Kerberos : extraire un AS-REQ d'une capture et casser la pré-authentification

L’authentification Kerberos commence par un échange où le client prouve son identité en chiffrant un horodatage avec une clé dérivée de son mot de passe. Ce message, l’AS-REQ, transite sur le réseau. Capturé, il fournit tout ce qu’il faut pour reconstruire un hash et tenter de retrouver le mot de passe hors ligne, sans jamais interagir avec le domaine.

L’échange à cibler

La première phase de Kerberos comporte deux messages :

AS-REQ (Authentication Service Request) : le client demande un ticket initial (TGT). Pour prouver son identité, il joint une pré-authentification (PA-DATA), un horodatage chiffré avec la clé dérivée du mot de passe de l’utilisateur (PA-ENC-TIMESTAMP).
AS-REP : la réponse du serveur d’authentification.

C’est l’AS-REQ et son horodatage chiffré qui nous intéressent : le déchiffrer correctement revient à connaître le mot de passe, donc un candidat qui reproduit le chiffré donné est le bon mot de passe.

Isoler Kerberos dans Wireshark

Ouvrir la capture et appliquer le filtre :

kerberos

Repérer un paquet AS-REQ. En déroulant as-req → req-body, trois informations sont à relever :

L’utilisateur : req-body → cname → cname-string, le login en clair.
Le domaine (realm) : req-body → realm, généralement en majuscules (CORP.LOCAL).
Le type de chiffrement : celui de la pré-authentification pA-ENC-TIMESTAMP. Un eTYPE-AES256-CTS-HMAC-SHA1-96 (18) indique de l’AES256, un (23) indiquerait du RC4.

L’horodatage chiffré (le cipher) se lit dans les padata de la pré-authentification.

Extraire en ligne de commande avec tshark

tshark récupère les champs sans passer par l’interface :

# Lister les logins présents dans les AS-REQ
tshark -r capture.pcapng -Y "kerberos.CNameString" -T fields -e kerberos.CNameString | sort -u
# -> j.martin

Assembler le hash

Le format Hashcat pour une pré-authentification Kerberos s’écrit sur une seule ligne :

$krb5pa$<etype>$<UTILISATEUR>$<DOMAINE>$<CIPHER>

Avec un etype 18 (AES256), l’utilisateur, le realm et le chiffré relevés dans la trame :

$krb5pa$18$j.martin$CORP.LOCAL$a1b2c3d4e5f60718293a4b5c6d7e8f90112233445566778899aabbccddeeff00

Le champ <etype> reprend le type de chiffrement lu dans la trame : 18 pour AES256, 23 pour RC4.

Casser avec Hashcat

Le mode dépend du type de chiffrement, un point souvent confondu :

etype 18 (AES256) : mode 19900.
etype 23 (RC4) : mode 7500.

Ici, en AES256 :

hashcat -m 19900 hash.txt rockyou.txt

Une correspondance dans le dictionnaire termine l’attaque :

$krb5pa$18$j.martin$CORP.LOCAL$a1b2c3...eeff00:<mot_de_passe_trouvé>

Status...........: Cracked
Hash.Mode........: 19900 (Kerberos 5, etype 18, Pre-Auth)

Le mot de passe apparaît après le :. La solidité de l’AES256 ne change rien : l’attaque ne casse pas le chiffrement, elle teste des mots de passe candidats jusqu’à reproduire le chiffré. Un mot de passe présent dans rockyou.txt tombe en quelques secondes.

Remédiation

Des mots de passe hors de portée d’un dictionnaire

L’attaque est une recherche par dictionnaire sur le mot de passe. Une politique imposant des mots de passe longs et non devinables la rend impraticable. Pour les comptes de service, privilégier des comptes gérés (gMSA) aux mots de passe aléatoires et longs.

Réduire l’exposition de la capture

Le hash n’est extractible que si l’on peut observer l’AS-REQ. Segmenter le réseau, chiffrer les liaisons et surveiller les captures non autorisées limite l’accès à ce trafic.

Surveiller les demandes anormales

Un volume inhabituel de demandes de tickets, ou des demandes pour de nombreux comptes depuis un même hôte, signale une collecte en vue d’un cassage. Les journaux Kerberos du contrôleur de domaine permettent cette détection.

À retenir

Un AS-REQ capturé porte un horodatage chiffré par la clé dérivée du mot de passe. En relevant l’utilisateur, le realm et le type de chiffrement dans Wireshark ou tshark, on reconstruit un hash $krb5pa$ que Hashcat casse hors ligne : mode 19900 pour l’AES256 (etype 18), 7500 pour le RC4 (etype 23). La robustesse de l’algorithme ne protège pas d’un mot de passe faible, seule sa complexité compte.