Les stratégies de sécurité par défaut sont des objets de stratégie de groupe (GPO) automatiquement créés lors de la promotion d'un serveur en contrôleur de domaine Active Directory. Elles établissent la configuration de sécurité de base pour le domaine.
Règle : Le dernier appliqué gagne (Last Write Wins), sauf si "Appliqué" ou "Aucun remplacement" est configuré.
✅ À faire :
❌ À éviter :
Outils :
gpmc.mscGet-GPO -Name "Default Domain Policy"
Get-GPOReport -Name "Default Domain Policy" -ReportType HTML -Path "C:\Rapport.html"Si une GPO par défaut est compromise :
dcgpofix /target:domain
dcgpofix /target:dc
dcgpofix /target:both⚠️ Attention : Cette commande restaure les paramètres d'usine et supprime toutes les modifications.
dcgpofix /target:domaindcgpofix /target:dcdcgpofix /target:both/target:domain puis /target:dc1. Sauvegarder les GPO actuelles
# Exporter Default Domain Policy Backup-GPO -Name "Default Domain Policy" -Path "C:\GPO_Backups" # Exporter Default Domain Controllers Policy Backup-GPO -Name "Default Domain Controllers Policy" -Path "C:\GPO_Backups" # Générer un rapport HTML Get-GPOReport -Name "Default Domain Policy" -ReportType HTML -Path "C:\GPO_Reports\DDP_$(Get-Date -Format 'yyyyMMdd').html" Get-GPOReport -Name "Default Domain Controllers Policy" -ReportType HTML -Path "C:\GPO_Reports\DDCP_$(Get-Date -Format 'yyyyMMdd').html"2. Documenter les paramètres personnalisés
3. Tester dans un environnement de test si possible
1. Forcer la réplication AD
repadmin /syncall /AdeP2. Forcer la mise à jour des GPO sur les clients
gpupdate /force3. Vérifier l'application
gpresult /h gpresult.html4. Reconfigurer les paramètres personnalisés
L'audit de sécurité est le processus d'enregistrement des événements de sécurité qui se produisent sur un système ou un réseau. Ces événements sont consignés dans les journaux Windows pour permettre :
1. Audit de base (9 catégories principales) Accessible via : Configuration ordinateur > Stratégies > Paramètres Windows > Paramètres de sécurité > Stratégies locales > Stratégie d'audit
| Catégorie | Description | Exemples d'événements |
|---|---|---|
| Événements de connexion de compte | Audit des authentifications sur les contrôleurs de domaine | Connexion Kerberos, NTLM |
| Gestion des comptes | Audit des modifications de comptes | Création, suppression, modification d'utilisateurs |
| Accès au service d'annuaire | Audit des accès à Active Directory | Lecture/modification d'objets AD |
| Événements d'ouverture de session | Audit des connexions locales | Ouverture/fermeture de session |
| Accès aux objets | Audit des accès aux ressources | Fichiers, imprimantes, registre |
| Modifications de stratégie | Audit des changements de stratégies | Modifications de GPO, droits utilisateurs |
| Utilisation des privilèges | Audit de l'utilisation de droits sensibles | Prise de propriété, sauvegarde |
| Suivi des processus | Audit du lancement de programmes | Création de processus |
| Événements système | Audit des événements système | Démarrage, arrêt, modifications horaires |
2. Audit avancé (54 sous-catégories) Accessible via : Configuration ordinateur > Stratégies > Paramètres Windows > Paramètres de sécurité > Configuration avancée de la stratégie d'audit
Avantages de l'audit avancé :
Exemples de sous-catégories utiles :
Étapes de configuration :
gpmc.msc)Exemple de configuration recommandée :
| Catégorie | Réussite | Échec |
|---|---|---|
| Événements de connexion de compte | ✓ | ✓ |
| Gestion des comptes | ✓ | ✓ |
| Événements d'ouverture de session | ✓ | ✓ |
| Accès aux objets | ✓ | ✓ |
| Modifications de stratégie | ✓ | ✓ |
Observateur d'événements (eventvwr.msc)
PowerShell :
# Afficher les derniers événements de sécurité
Get-WinEvent -LogName Security -MaxEvents 100
# Filtrer par ID d'événement
Get-WinEvent -FilterHashtable @{LogName='Security'; ID=4624}
# Exporter vers CSV
Get-WinEvent -LogName Security -MaxEvents 1000 |
Select-Object TimeCreated, Id, Message |
Export-Csv -Path "C:\audit.csv" -NoTypeInformation| ID | Description | Catégorie |
|---|---|---|
| 4624 | Ouverture de session réussie | Connexion |
| 4625 | Échec d'ouverture de session | Connexion |
| 4634 | Fermeture de session | Connexion |
| 4648 | Tentative de connexion avec informations d'identification explicites | Connexion |
| 4672 | Privilèges spéciaux attribués à une nouvelle connexion | Privilèges |
| 4720 | Compte utilisateur créé | Gestion comptes |
| 4726 | Compte utilisateur supprimé | Gestion comptes |
| 4740 | Compte utilisateur verrouillé | Gestion comptes |
| 4768 | Ticket TGT Kerberos demandé | Authentification |
| 4776 | Tentative de validation d'informations d'identification | Authentification |
Configuration de la taille des journaux :
Archivage automatique via tâche planifiée :
wevtutil epl Security "C:\Archives\Security_$(Get-Date -Format 'yyyyMMdd').evtx"
Surveiller qui accède aux fichiers et dossiers partagés, quelles actions sont effectuées (lecture, modification, suppression) et détecter les accès non autorisés.
Via GPO :
Ou via l'audit avancé (recommandé) :
Méthode graphique :
Méthode PowerShell :
# Définir le chemin du dossier
$folderPath = "C:\Partages\Confidential"
# Obtenir l'ACL actuelle
$acl = Get-Acl -Path $folderPath -Audit
# Créer une règle d'audit pour "Tout le monde"
$auditRule = New-Object System.Security.AccessControl.FileSystemAuditRule(
"Tout le monde", # Principal
"ReadAndExecute, Write, Delete", # Droits à auditer
"ContainerInherit, ObjectInherit", # Héritage
"None", # Propagation
"Success, Failure" # Type d'audit
)
# Ajouter la règle d'audit
$acl.AddAuditRule($auditRule)
# Appliquer la nouvelle ACL
Set-Acl -Path $folderPath -AclObject $aclPour les dossiers sensibles (finance, RH, direction)
✓ Lire les données
✓ Écrire les données
✓ Supprimer
✓ Modifier les autorisations
✓ Prendre possession
Pour les dossiers partagés généraux :
✓ Écrire les données
✓ Supprimer
✓ Modifier les autorisations
Événements générés dans le journal Sécurité :
| ID événement | Description | Informations contenues |
|--------------|-------------|------------------------|
| **4656** | Demande d'un handle vers un objet | Qui, quand, quel objet, quel accès demandé |
| **4663** | Tentative d'accès à un objet | Action effectuée (lecture, écriture, suppression) |
| **5140** | Accès à un partage réseau | Nom du partage, utilisateur, adresse IP |
| **5145** | Vérification si l'objet peut être supprimé | Nom du fichier, utilisateur |
Exemple d'événement 4663 :
```
Type d'accès : Écriture de données
Nom du fichier : \\SRV01\Partages\Confidential\Budget2025.xlsx
Nom du compte : jdupont
Domaine : ENTREPRISE
ID de connexion : 0x3E7
Processus : C:\Windows\explorer.exe
Adresse IP source : 192.168.1.50
Filtrage dans l'Observateur d'événements :
Requête PowerShell pour analyser les accès :
# Rechercher tous les accès à un dossier spécifique
Get-WinEvent -FilterHashtable @{
LogName='Security'
ID=4663
} | Where-Object {
$_.Message -like "*Budget2025.xlsx*"
} | Select-Object TimeCreated, @{
Name='Utilisateur'
Expression={$_.Properties[1].Value}
}, @{
Name='Action'
Expression={$_.Properties[8].Value}
}
# Exporter vers Excel pour analyse
Get-WinEvent -FilterHashtable @{
LogName='Security'
ID=4663
StartTime=(Get-Date).AddDays(-7)
} | Select-Object TimeCreated, Message |
Export-Csv -Path "C:\Audit_Acces_7jours.csv" -NoTypeInformationScénarios à surveiller :
Script de surveillance automatique :
# Surveiller les accès échoués répétés
$events = Get-WinEvent -FilterHashtable @{
LogName='Security'
ID=4656
StartTime=(Get-Date).AddMinutes(-15)
} | Where-Object {$_.Message -like "*Échec*"}
if ($events.Count -gt 10) {
Send-MailMessage -To "admin@entreprise.local" `
-From "audit@entreprise.local" `
-Subject "ALERTE: Tentatives d'accès échouées multiples" `
-Body "Plus de 10 tentatives d'accès échouées détectées" `
-SmtpServer "smtp.entreprise.local"
}
✅ Recommandations :
- Auditer uniquement les dossiers sensibles (réduire le bruit)
- Activer l'audit sur "Réussite" ET "Échec"
- Augmenter la taille du journal de sécurité sur les serveurs de fichiers
- Mettre en place une solution SIEM pour l'analyse centralisée
- Archiver les journaux régulièrement
- Établir une baseline des accès normaux
- Documenter les accès légitimes d'administrateurs
❌ À éviter :
- Auditer tous les dossiers (surcharge des journaux)
- Ignorer les alertes d'audit
- Ne pas archiver les journaux
- Auditer uniquement les réussites (manque les tentatives malveillantes)
Considérations :
- L'audit génère des entrées dans les journaux → I/O disque
- Plus d'actions auditées = plus de charge
- Privilégier l'audit avancé pour réduire le bruit
- Tester l'impact avant déploiement en production
Recommandation de taille de journal :
- Serveur de fichiers standard : 1-2 Go
- Serveur de fichiers critique : 4-8 Go
- Avec archivage automatique quotidien
Historique: Avant Windows Server 2008, une seule stratégie de mot de passe pouvait être appliquée à l'ensemble du domaine via la Default Domain Policy. Impossible d'avoir :
Solution :
Les PSO (Password Settings Objects) ou stratégies de mot de passe affinées permettent d'appliquer différentes politiques de mots de passe à différents utilisateurs ou groupes au sein d'un même domaine.
| Élément | Exigence |
|---|---|
| Niveau fonctionnel du domaine | Windows Server 2008 minimum |
| Permissions | Administrateurs du domaine |
| Outil | Centre d'administration Active Directory (ADAC) |
| Paramètre | Description | Exemple |
|---|---|---|
| Nom | Identifiant unique de la PSO | PSO_Administrateurs |
| Précédence | Priorité (1 = plus haute) | 10 |
| Longueur minimale | Nombre de caractères minimum | 15 |
| Historique | Nombre de mots de passe mémorisés | 24 |
| Durée de vie maximale | Âge maximum avant changement | 60 jours |
| Durée de vie minimale | Temps minimum entre changements | 2 jours |
| Complexité | Exiger majuscules + minuscules + chiffres + symboles | Activé |
| Chiffrement réversible | Stocker avec chiffrement réversible | Désactivé ⚠️ |
| Seuil de verrouillage | Nombre de tentatives avant verrouillage | 3 |
| Durée de verrouillage | Temps de verrouillage du compte | 30 min |
| Réinitialiser le compteur après | Temps avant reset du compteur | 30 min |
¶ Ordre de précédence des PSO
Règle : Plus le chiffre de précédence est PETIT, plus la priorité est HAUTE
Exemple de résolution :
Utilisateur : Jean Dupont
Membre de : Groupe "Admins" → PSO_Admins (Précédence = 10)
Membre de : Groupe "Direction" → PSO_Direction (Précédence = 5)
Résultat : PSO_Direction s'applique (5 < 10)Ordre de priorité :
Procédure complète :
1. Ouvrir le Centre d'administration Active Directory
Menu Démarrer > Outils d'administration > Centre d'administration Active Directory
OU commande : dsac.exe2. Naviguer vers le conteneur des PSO
Domaine (local) > System > Password Settings Container3. Créer une nouvelle PSO
Volet de droite > Tâches > Nouveau > Paramètres de mot de passe4. Configurer la PSO
Exemple 1 : PSO pour administrateurs (stricte)
Nom : PSO_Administrateurs
Précédence : 10
PARAMÈTRES DE MOT DE PASSE :
☑ Longueur minimale : 15 caractères
☑ Historique : 24 mots de passe
☑ Durée de vie maximale : 60 jours
☑ Durée de vie minimale : 2 jours
☑ Complexité requise : Activée
☐ Chiffrement réversible : Désactivé
PARAMÈTRES DE VERROUILLAGE :
☑ Seuil de verrouillage : 3 tentatives
☑ Durée de verrouillage : 30 minutes
☑ Réinitialiser le compteur après : 30 minutesExemple 2 : PSO pour utilisateurs standards (normale)
Nom : PSO_Utilisateurs_Standards
Précédence : 20
PARAMÈTRES DE MOT DE PASSE :
☑ Longueur minimale : 10 caractères
☑ Historique : 12 mots de passe
☑ Durée de vie maximale : 90 jours
☑ Durée de vie minimale : 1 jour
☑ Complexité requise : Activée
☐ Chiffrement réversible : Désactivé
PARAMÈTRES DE VERROUILLAGE :
☑ Seuil de verrouillage : 5 tentatives
☑ Durée de verrouillage : 15 minutes
☑ Réinitialiser le compteur après : 15 minutes5. Appliquer la PSO à un groupe ou utilisateur
Section "S'applique directement à" > Cliquer sur "Ajouter"
Rechercher le groupe : "Admins du domaine"
OK6. Enregistrer
Cliquer sur OK pour créer la PSO
Méthode 1 : Via ADAC
1. Rechercher l'utilisateur dans ADAC
2. Double-cliquer sur l'utilisateur
3. Onglet "Extensions"
4. Section "Paramètres de mot de passe résultants"Méthode 2 : Via PowerShell
# Vérifier quelle PSO s'applique à un utilisateur
Get-ADUserResultantPasswordPolicy -Identity "jdupont"
# Si retourne $null → Default Domain Policy s'appliqueMéthode 3 : Lister toutes les PSO appliquées à un utilisateur
# Voir les PSO liées aux groupes dont l'utilisateur est membre
Get-ADUser "jdupont" -Properties memberOf |
Select-Object -ExpandProperty memberOf |
ForEach-Object {
Get-ADFineGrainedPasswordPolicySubject -Identity $_
}# Créer une PSO pour les administrateurs
New-ADFineGrainedPasswordPolicy `
-Name "PSO_Administrateurs" `
-Precedence 10 `
-ComplexityEnabled $true `
-Description "Politique stricte pour les administrateurs" `
-DisplayName "PSO Administrateurs" `
-LockoutDuration "00:30:00" `
-LockoutObservationWindow "00:30:00" `
-LockoutThreshold 3 `
-MaxPasswordAge "60.00:00:00" `
-MinPasswordAge "2.00:00:00" `
-MinPasswordLength 15 `
-PasswordHistoryCount 24 `
-ReversibleEncryptionEnabled $false
# Appliquer la PSO au groupe des administrateurs du domaine
Add-ADFineGrainedPasswordPolicySubject `
-Identity "PSO_Administrateurs" `
-Subjects "Admins du domaine"
# Vérifier la PSO
Get-ADFineGrainedPasswordPolicy -Identity "PSO_Administrateurs"Via ADAC :
Via PowerShell :
# Vérifier la PSO appliquée à un utilisateur spécifique
Get-ADUserResultantPasswordPolicy -Identity "jdupont"
# Si retourne $null, la Default Domain Policy s'applique
# Lister tous les utilisateurs avec leur PSO effective
Get-ADUser -Filter * -Properties msDS-ResultantPSO |
Select-Object Name, SamAccountName, @{
Name='PSO'
Expression={(Get-ADObject $_.'"msDS-ResultantPSO"' -Properties DisplayName).DisplayName}
}Modifier une PSO existante :
Via PowerShell :
# Modifier la longueur minimale du mot de passe
Set-ADFineGrainedPasswordPolicy `
-Identity "PSO_Administrateurs" `
-MinPasswordLength 20
# Ajouter un utilisateur supplémentaire à une PSO
Add-ADFineGrainedPasswordPolicySubject `
-Identity "PSO_Administrateurs" `
-Subjects "pdupuis"Supprimer une PSO :
Remove-ADFineGrainedPasswordPolicy -Identity "PSO_Ancienne"
| Groupe cible | Longueur min | Complexité | Durée max | Verrouillage |
|--------------|--------------|------------|-----------|--------------|
| **Administrateurs de domaine** | 15-20 car. | Activée | 60 jours | 3 tentatives |
| **Administrateurs locaux** | 14 car. | Activée | 90 jours | 3 tentatives |
| **Comptes de service** | 25 car. | Activée | 365 jours | Désactivé |
| **Utilisateurs privilégiés** | 12 car. | Activée | 60 jours | 5 tentatives |
| **Utilisateurs standards** | 10 car. | Activée | 90 jours | 5 tentatives |
| **Invités/Externes** | 12 car. | Activée | 30 jours | 3 tentatives |
Bonnes pratiques
✅ Recommandations :
- Utiliser une **précédence cohérente** (ex: 10, 20, 30...)
- Appliquer les PSO aux **groupes** plutôt qu'aux utilisateurs individuels
- Documenter chaque PSO et sa raison d'être
- Tester les PSO sur un groupe pilote avant déploiement
- Ne jamais utiliser le chiffrement réversible (sauf exigence spécifique)
- Utiliser des valeurs de verrouillage raisonnables (éviter les dénis de service)
❌ À éviter :
- Créer trop de PSO (complexité de gestion)
- Appliquer directement aux utilisateurs (privilégier les groupes)
- Définir des durées de vie trop courtes (frustration utilisateurs)
- Oublier de documenter les changements
Problème : La PSO ne s'applique pas
- Vérifier le niveau fonctionnel du domaine
- Vérifier que l'utilisateur est membre du groupe cible
- Vérifier la précédence (une autre PSO peut avoir priorité)
- Attendre la réplication AD (jusqu'à 15 minutes)
- Forcer une mise à jour : `gpupdate /force`
Problème : Conflit entre plusieurs PSO
- Utiliser `Get-ADUserResultantPasswordPolicy` pour identifier la PSO effective
- Ajuster les valeurs de précédence
Un modèle de sécurité est un fichier texte (extension .inf) qui contient une configuration de sécurité standardisée pouvant être appliquée à des ordinateurs ou importée dans des GPO.
Objectifs d'un modèle de sécurité :
Un modèle peut inclure les sections suivantes :
| Section | Description | Exemples de paramètres |
|---|---|---|
| [System Access] | Stratégies de compte | Longueur mot de passe, verrouillage |
| [Event Audit] | Stratégies d'audit | Audit des connexions, accès objets |
| [Registry Values] | Valeurs du registre | Paramètres de sécurité réseau |
| [Privilege Rights] | Attribution de droits | Ouverture de session, arrêt système |
| [Service General Setting] | Configuration des services | Mode de démarrage, permissions |
| [Group Membership] | Appartenance aux groupes | Groupes locaux |
| [File Security] | Permissions sur fichiers | ACL sur dossiers système |
| [Registry Keys] | Permissions sur clés registre | ACL sur clés sensibles |
Windows + R
Taper : mmc
Appuyer sur EntréeDans la console MMC :
Fichier > Ajouter/Supprimer un composant logiciel enfichableDans la liste des composants disponibles :
- Sélectionner "Modèles de sécurité"
- Cliquer sur "Ajouter >"
- Cliquer sur "OK"Développer "Modèles de sécurité" dans le volet de gauche
Clic droit sur : C:\Windows\security\templates
Sélectionner : Nouveau modèleConfiguration du nouveau modèle :
Nom du modèle : Serveur_Membre_Securise
Description : Configuration de sécurité renforcée pour serveurs membres
Cliquer sur : OKDévelopper le modèle créé et configurer chaque section selon vos besoins.
A) Stratégies de compte > Stratégie de mot de passe
Double-cliquer sur chaque paramètre pour l'activer et le configurer.
Exemple de configuration :
☑ Longueur minimale du mot de passe : 12 caractères
☑ Durée de vie maximale du mot de passe : 90 jours
☑ Durée de vie minimale du mot de passe : 2 jours
☑ Conserver l'historique des mots de passe : 24 mots de passe
☑ Le mot de passe doit respecter des exigences de complexité : Activée
☐ Stocker les mots de passe en utilisant un chiffrement réversible : Désactivée
B) Stratégies locales > Stratégie d'audit
Exemple de configuration :
☑ Auditer les événements d'ouverture de session : Réussite, Échec
☑ Auditer la gestion des comptes : Réussite, Échec
☑ Auditer l'accès aux objets : Réussite, Échec
☑ Auditer les modifications de stratégie : Réussite
☑ Auditer les événements de connexion de compte : Réussite, Échec
☐ Auditer le suivi des processus : Aucun audit
C) Stratégies locales > Attribution des droits utilisateur
Exemple de configuration :
| Droit utilisateur | Groupes/Utilisateurs autorisés |
|---|---|
| Autoriser l'ouverture de session locale | Administrateurs, Utilisateurs |
| Refuser l'accès à cet ordinateur à partir du réseau | Invité |
| Arrêter le système | Administrateurs |
| Sauvegarder des fichiers et des répertoires | Administrateurs |
| Restaurer des fichiers et des répertoires | Administrateurs |
Pour configurer :
Double-cliquer sur le droit à modifier
Cocher "Définir ces paramètres de stratégie dans le modèle"
Ajouter utilisateur ou groupe
OK
D) Stratégies locales > Options de sécurité
Exemple de configuration :
☑ Comptes : État du compte Administrateur : Désactivé
☑ Accès réseau : Ne pas autoriser l'énumération anonyme des comptes SAM : Activé
☑ Ouverture de session interactive : Ne pas afficher le dernier nom d'utilisateur : Activé
☑ Sécurité réseau : Niveau d'authentification LAN Manager : Envoyer NTLMv2 uniquement
☑ Accès réseau : Ne pas autoriser le stockage de mots de passe : Activé
E) Journal des événements
Exemple de configuration :
| Paramètre | Valeur recommandée |
|---|---|
| Taille maximale du journal de sécurité | 2048 Ko (2 Go) |
| Taille maximale du journal d'application | 1024 Ko |
| Taille maximale du journal système | 1024 Ko |
| Méthode de rétention | Remplacer les événements si nécessaire |
F) Services système
Double-cliquer sur un service pour définir :
Exemple : Désactiver les services inutiles
Telnet : Désactivé
FTP Publishing Service : Désactivé
SNMP Trap : Manuel
RemoteRegistry : DésactivéServices à laisser actifs :
Windows Firewall : Automatique
Windows Update : Automatique
DNS Client : Automatique
Le modèle est automatiquement sauvegardé dans :
C:\Windows\security\templates\Serveur_Membre_Securise.infVérification :
Explorateur de fichiers > C:\Windows\security\templates
Vérifier la présence du fichier .infCréer un fichier texte et le renommer avec l'extension .inf
Exemple de structure d'un modèle personnalisé :
[Unicode]
Unicode=yes
[Version]
signature="$CHICAGO$"
Revision=1
[System Access]
MinimumPasswordAge = 2
MaximumPasswordAge = 90
MinimumPasswordLength = 12
PasswordComplexity = 1
PasswordHistorySize = 24
LockoutBadCount = 5
ResetLockoutCount = 30
LockoutDuration = 30
RequireLogonToChangePassword = 0
ClearTextPassword = 0
[Event Audit]
AuditSystemEvents = 3
AuditLogonEvents = 3
AuditObjectAccess = 3
AuditPrivilegeUse = 2
AuditPolicyChange = 3
AuditAccountManage = 3
AuditProcessTracking = 0
AuditDSAccess = 3
AuditAccountLogon = 3
[Registry Values]
MACHINE\System\CurrentControlSet\Control\Lsa\RestrictAnonymous=4,1
MACHINE\System\CurrentControlSet\Control\Lsa\NoLMHash=4,1
MACHINE\System\CurrentControlSet\Services\LanManServer\Parameters\EnableSecuritySignature=4,1
[Privilege Rights]
SeNetworkLogonRight = *S-1-5-32-544,*S-1-5-32-545
SeInteractiveLogonRight = *S-1-5-32-544,*S-1-5-32-545
SeRemoteInteractiveLogonRight = *S-1-5-32-544
SeDenyNetworkLogonRight = *S-1-5-32-546
[Service General Setting]
"Telnet",2,""
"RemoteRegistry",4,""
```
**Légende des valeurs :**
- **Event Audit** : 0=Aucun audit, 1=Réussite, 2=Échec, 3=Réussite et Échec
- **Service** : 2=Automatique, 3=Manuel, 4=Désactivé
- **SID** : *S-1-5-32-544 = Administrateurs, *S-1-5-32-545 = Utilisateurs, *S-1-5-32-546 = Invités
Méthode 1 : Via secedit.exe (command line)
REM Exporter la configuration de sécurité actuelle
secedit /export /cfg "C:\Export_Config_Actuelle.inf" /db secedit.sdb
REM Afficher le contenu du fichier exporté
notepad "C:\Export_Config_Actuelle.inf"
Méthode 2 : Via MMC Configuration et analyse de la sécurité
1. Ajouter le composant "Configuration et analyse de la sécurité"
2. Clic droit > Ouvrir la base de données
3. Créer une nouvelle base : `analyse.sdb`
4. Importer un modèle de référence
5. Clic droit > Analyser l'ordinateur maintenant
6. Clic droit > Exporter la stratégie
7. Enregistrer le fichier `.inf`
Windows Server inclut des modèles de sécurité de base dans :
C:\Windows\security\templates\
| Modèle | Description | Usage |
|--------|-------------|-------|
| **DC security.inf** | Paramètres par défaut des contrôleurs de domaine | Référence pour DC |
| **Setup security.inf** | Configuration initiale de Windows | Restauration des paramètres d'usine |
| **hisecdc.inf** | Sécurité renforcée pour DC | Environnements haute sécurité |
| **hisecws.inf** | Sécurité renforcée pour stations de travail | Postes de travail sensibles |
| **securedc.inf** | Sécurité accrue pour DC | Bon compromis sécurité/compatibilité |
| **securews.inf** | Sécurité accrue pour stations | Postes standards |
✅ Recommandations :
- Tester les modèles dans un environnement de test avant production
- Documenter chaque paramètre du modèle et sa justification
- Versionner les modèles (ex: Serveur_Securise_v1.2.inf)
- Sauvegarder les modèles dans un emplacement centralisé
- Utiliser des modèles différents selon les rôles (DC, serveurs membres, postes clients)
- Combiner avec d'autres mécanismes (AppLocker, BitLocker, etc.)
❌ À éviter:
- Importer un modèle sans l'avoir examiné
- Appliquer des modèles trop restrictifs sans test (risque de blocage)
- Modifier directement les modèles prédéfinis Windows
- Oublier de documenter les changements
Scénario 1 : Standardisation de serveurs de fichiers
1. Créer un modèle `Serveur_Fichiers_Standard.inf`
2. Configurer :
- Audit avancé des accès fichiers
- Désactivation des services inutiles
- Renforcement des paramètres réseau
3. Importer dans une GPO liée à l'OU "Serveurs de fichiers"
Scénario 2 : Conformité réglementaire (HIPAA, PCI-DSS)
1. Obtenir le modèle de conformité (ex: CIS Benchmarks)
2. Adapter aux besoins de l'organisation
3. Valider avec l'équipe sécurité
4. Déployer via GPO avec suivi d'application
Scénario 3 : Récupération après incident
1. Avant incident : Exporter la configuration de référence
2. Après compromission : Analyser les écarts
3. Réappliquer le modèle de référence pour restaurer la configuration
Windows + R
Taper : mmc
Appuyer sur EntréeDans la console MMC :
Fichier > Ajouter/Supprimer un composant logiciel enfichable
Dans la liste :
Sélectionner : Configuration et analyse de la sécurité
Cliquer sur : Ajouter >
Cliquer sur : OK
Clic droit sur "Configuration et analyse de la sécurité"
Sélectionner : Ouvrir la base de donnéesDans la boîte de dialogue :
Nom de la nouvelle base : analyse_serveur.sdb
Cliquer sur : OuvrirNote : Si la base n'existe pas, elle sera créée automatiquement.
Sélectionner le modèle de référence :
Exemple : Serveur_Membre_Securise.inf
☑ Cocher : Effacer cette base de données avant d'importer
(pour une analyse propre, sans données précédentes)
Cliquer sur : Ouvrir
Cliquer sur : OK
Clic droit sur "Configuration et analyse de la sécurité"
Sélectionner : Analyser l'ordinateur maintenantConfiguration de l'analyse :
Chemin du fichier journal : C:\Analyse\analyse_securite.log
Cliquer sur : OKAttendre la fin de l'analyse (peut prendre quelques minutes selon la configuration)
Développer l'arborescence dans le volet de gauche pour voir les différentes sections analysées.
| Symbole | Signification | Action requise |
|---|---|---|
| ✅ Coche verte | Paramètre conforme au modèle | Aucune action |
| ❌ Croix rouge | Paramètre DIFFÉRENT du modèle | À corriger |
| ⚠️ Point d'exclamation | Paramètre non défini dans le modèle | À évaluer |
| ❓ Point d'interrogation | Erreur lors de l'analyse | À investiguer |
Configuration et analyse de la sécurité
│
├─ Stratégies de compte
│ │
│ ├─ Stratégie de mot de passe
│ │ ├─ ✅ Longueur minimale du mot de passe : 12 caractères
│ │ ├─ ❌ Durée de vie maximale : 42 jours (devrait être 90 jours)
│ │ └─ ✅ Complexité requise : Activée
│ │
│ └─ Stratégie de verrouillage de compte
│ ├─ ❌ Seuil de verrouillage : 0 tentatives (devrait être 5)
│ └─ ⚠️ Durée de verrouillage : Non défini dans le modèle
│
├─ Stratégies locales
│ │
│ ├─ Stratégie d'audit
│ │ ├─ ✅ Auditer ouverture de session : Réussite, Échec
│ │ └─ ❌ Auditer accès aux objets : Aucun (devrait être Réussite, Échec)
│ │
│ ├─ Attribution des droits utilisateur
│ │ ├─ ✅ Ouverture de session locale : Administrateurs, Utilisateurs
│ │ └─ ❌ Arrêter le système : Tout le monde (devrait être Administrateurs uniquement)
│ │
│ └─ Options de sécurité
│ ├─ ✅ Compte Administrateur : Désactivé
│ └─ ❌ Partages accessibles anonymement : COMCFG, IPC$ (devrait être vide)
│
├─ Journal des événements
│ ├─ ✅ Taille journal de sécurité : 2048 Ko
│ └─ ✅ Méthode de rétention : Remplacer si nécessaire
│
└─ Services système
├─ ❌ Telnet : Manuel (devrait être Désactivé)
└─ ✅ Windows Firewall : Automatique
Pour examiner un écart :
Double-cliquer sur un paramètre marqué d'une croix rouge ❌Fenêtre de propriétés affichant :
┌─────────────────────────────────────────────┐
│ Propriétés du paramètre │
├─────────────────────────────────────────────┤
│ │
│ Paramètre de l'ordinateur : │
│ Valeur actuelle = 42 jours │
│ │
│ Paramètre de la base de données : │
│ Valeur recommandée = 90 jours │
│ │
│ Dernière analyse : │
│ Date : 12/11/2025 14:30:25 │
│ │
└─────────────────────────────────────────────┘Interprétation :
Pour créer un rapport :
Clic droit sur une section (ou sur la racine pour tout exporter)
Sélectionner : Exporter la liste...
Choisir l'emplacement : C:\Rapports\Analyse_Conformite.txt
EnregistrerLe fichier contiendra :
⚠️ ATTENTION : Cette étape applique automatiquement TOUS les paramètres du modèle à l'ordinateur.
Procédure
Clic droit sur "Configuration et analyse de la sécurité"
Sélectionner : Configurer l'ordinateur maintenantConfirmation :
Chemin du journal : C:\Logs\configuration.log
Cliquer sur : OK⚠️ Avertissements importants :
Après application :
Vérifier le fichier journal pour détecter d'éventuelles erreurs
Redémarrer l'ordinateur si nécessaire
Ré-analyser pour confirmer la conformité
Commandes principales :
1. Analyser la configuration de sécurité
secedit /analyze /db analyse.sdb /cfg "C:\Templates\Serveur_Securise.inf" /log "C:\Logs\analyse.log" /verboseParamètres :
/analyze : Lance l'analyse/db : Base de données à utiliser (créée si inexistante)/cfg : Fichier de modèle de référence (.inf)/log : Fichier journal de l'analyse/verbose : Affiche les détails pendant l'analyse2. Exporter la configuration actuelle
secedit /export /cfg "C:\Export\config_actuelle.inf" /db export.sdb /log "C:\Logs\export.log"3. Appliquer un modèle de sécurité
secedit /configure /db configuration.sdb /cfg "C:\Templates\Serveur_Securise.inf" /log "C:\Logs\configuration.log" /verbose⚠️ Attention : Cette commande applique immédiatement la configuration.
4. Comparer deux fichiers .inf manuellement Une fois exporté, vous pouvez comparer deux fichiers .inf avec :
fc "C:\Export\config_actuelle.inf" "C:\Templates\Serveur_Securise.inf" > "C:\Comparaison\differences.txt"5. Consulter le journal d'analyse
notepad "C:\Logs\analyse.log"
```
**Format du journal :**
```
Configuration de la stratégie de sécurité dans la base de données C:\analyse.sdb...
Durée de vie maximale du mot de passe
Paramètre de l'ordinateur = 42
Paramètre de la base de données = 90
État = Valeur différente
Seuil de verrouillage du compte
Paramètre de l'ordinateur = 0
Paramètre de la base de données = 5
État = Valeur différente
Longueur minimale du mot de passe
Paramètre de l'ordinateur = 12
Paramètre de la base de données = 12
État = Correspond
Tâche terminée. Consultez le fichier journal pour obtenir plus de détails.
Script d'analyse automatisée :
# Script : Analyser-SecuriteServeur.ps1
# Description : Compare la configuration actuelle avec un modèle de référence
# Paramètres
$modele = "C:\Templates\Serveur_Securise.inf"
$baseDB = "C:\Analyse\analyse_$(Get-Date -Format 'yyyyMMdd_HHmmss').sdb"
$journal = "C:\Logs\analyse_$(Get-Date -Format 'yyyyMMdd_HHmmss').log"
$export = "C:\Export\config_actuelle_$(Get-Date -Format 'yyyyMMdd_HHmmss').inf"
# Créer les répertoires si nécessaire
New-Item -ItemType Directory -Path "C:\Analyse", "C:\Logs", "C:\Export" -Force -ErrorAction SilentlyContinue
# Exporter la configuration actuelle
Write-Host "Exportation de la configuration actuelle..." -ForegroundColor Cyan
secedit /export /cfg $export /db "$baseDB.export" /log "$journal.export" | Out-Null
# Analyser par rapport au modèle
Write-Host "Analyse de la conformité au modèle de sécurité..." -ForegroundColor Cyan
secedit /analyze /db $baseDB /cfg $modele /log $journal /verbose | Out-Null
# Extraire les non-conformités du journal
Write-Host "`nNon-conformités détectées :" -ForegroundColor Yellow
Get-Content $journal | Where-Object {
$_ -like "*Valeur différente*" -or $_ -like "*État = *"
} | ForEach-Object {
Write-Host $_ -ForegroundColor Red
}
# Afficher le résumé
Write-Host "`n=== Résumé de l'analyse ===" -ForegroundColor Green
Write-Host "Modèle de référence : $modele"
Write-Host "Configuration exportée : $export"
Write-Host "Base de données : $baseDB"
Write-Host "Journal complet : $journal"
Write-Host "`nConsultez le journal pour les détails complets."Exécution du script :
.\Analyser-SecuriteServeur.ps1Script pour comparer deux configurations :
# Script : Comparer-Configurations.ps1
param(
[string]$Config1 = "C:\Export\config_avant.inf",
[string]$Config2 = "C:\Export\config_apres.inf"
)
Write-Host "Comparaison de :" -ForegroundColor Cyan
Write-Host " Fichier 1 : $Config1"
Write-Host " Fichier 2 : $Config2"
Write-Host ""
$contenu1 = Get-Content $Config1
$contenu2 = Get-Content $Config2
$differences = Compare-Object -ReferenceObject $contenu1 -DifferenceObject $contenu2
if ($differences) {
Write-Host "Différences trouvées :" -ForegroundColor Yellow
$differences | ForEach-Object {
if ($_.SideIndicator -eq "<=") {
Write-Host "- Seulement dans $Config1 : $($_.InputObject)" -ForegroundColor Red
} else {
Write-Host "+ Seulement dans $Config2 : $($_.InputObject)" -ForegroundColor Green
}
}
} else {
Write-Host "Aucune différence trouvée. Les configurations sont identiques." -ForegroundColor Green
}
```
---
#### **Méthode 4 : Security Compliance Manager (SCM)**
**Présentation :**
Microsoft Security Compliance Manager est un outil gratuit qui permet de :
- Comparer les configurations aux baselines Microsoft
- Créer des baselines personnalisées
- Exporter vers des GPO ou des fichiers .inf
- Générer des rapports de conformité
**Téléchargement :**
```
https://www.microsoft.com/en-us/download/details.aspx?id=53353Avantages :
Tableau de décision :
| Écart détecté | Gravité | Action recommandée |
|---|---|---|
| Mot de passe trop court | 🔴 Critique | Appliquer immédiatement via GPO |
| Audit désactivé | 🟠 Élevée | Activer l'audit, examiner les journaux |
| Service inutile actif | 🟡 Moyenne | Désactiver le service |
| Permission trop permissive | 🔴 Critique | Restreindre les permissions |
| Verrouillage de compte désactivé | 🟠 Élevée | Activer le verrouillage (seuil : 5) |
| Paramètre documenté comme exception | 🟢 Info | Aucune action, documenter |
Processus de remédiation :
Script de surveillance hebdomadaire :
# Script : Audit-Securite-Hebdomadaire.ps1
# Planification : Tâche planifiée chaque lundi à 08h00
param(
[string]$modele = "C:\Standards\Serveur_Standard.inf",
[string]$rapportEmail = "securite@entreprise.local",
[string]$smtpServer = "smtp.entreprise.local"
)
$date = Get-Date -Format "yyyy-MM-dd"
$baseDB = "C:\Audit\analyse_$date.sdb"
$journal = "C:\Audit\analyse_$date.log"
$rapport = "C:\Audit\rapport_$date.html"
# Analyse
secedit /analyze /db $baseDB /cfg $modele /log $journal /quiet
# Vérifier les non-conformités
$nonConformites = Get-Content $journal | Where-Object {$_ -like "*Valeur différente*"}
if ($nonConformites.Count -gt 0) {
# Générer un rapport HTML
$html = @"
<html>
<head><title>Rapport d'audit de sécurité - $date</title></head>
<body>
<h1>Rapport d'audit de sécurité</h1>
<p>Date : $date</p>
<p>Serveur : $env:COMPUTERNAME</p>
<h2>Non-conformités détectées : $($nonConformites.Count)</h2>
<pre>$($nonConformites -join "`n")</pre>
</body>
</html>
"@
$html | Out-File $rapport
# Envoyer par email
Send-MailMessage -To $rapportEmail `
-From "audit@entreprise.local" `
-Subject "⚠️ Non-conformités de sécurité détectées sur $env:COMPUTERNAME" `
-Body "Consultez le rapport en pièce jointe." `
-Attachments $rapport `
-SmtpServer $smtpServer
}Création de la tâche planifiée :
$action = New-ScheduledTaskAction -Execute "PowerShell.exe" -Argument "-File C:\Scripts\Audit-Securite-Hebdomadaire.ps1"
$trigger = New-ScheduledTaskTrigger -Weekly -DaysOfWeek Monday -At 8am
Register-ScheduledTask -TaskName "Audit Sécurité Hebdomadaire" -Action $action -Trigger $trigger -User "SYSTEM" -RunLevel Highest
```
---
#### **Bonnes pratiques**
✅ **Recommandations :**
- **Analyser régulièrement** : Planifier des audits hebdomadaires ou mensuels
- **Documenter les exceptions** : Toute déviation du modèle doit être justifiée et approuvée
- **Versionner les modèles** : Conserver l'historique des modifications
- **Tester avant correction** : Ne jamais appliquer des changements en production sans test
- **Archiver les rapports** : Conserver les journaux d'analyse pour l'historique de conformité
- **Automatiser** : Utiliser des scripts pour la surveillance continue
❌ **À éviter :**
- Ignorer les écarts sans les analyser
- Appliquer automatiquement les corrections sans validation
- Utiliser un modèle obsolète comme référence
- Ne pas documenter les raisons des écarts autorisés
- Analyser sans agir sur les résultats
---
#### **Cas d'usage pratiques**
**Scénario 1 : Audit de conformité réglementaire**
```
Objectif : Prouver la conformité aux standards CIS Benchmarks
1. Télécharger le modèle CIS pour Windows Server 2022
2. Analyser tous les serveurs avec ce modèle
3. Générer des rapports pour l'auditeur
4. Corriger les écarts critiques
5. Documenter les exceptions validées par le RSSI
```
**Scénario 2 : Détection de dérives de configuration**
```
Objectif : Identifier les changements non autorisés
1. Exporter la configuration de référence approuvée
2. Chaque semaine, analyser par rapport à cette baseline
3. Alerter l'équipe sécurité en cas d'écart
4. Investiguer la cause du changement
5. Corriger ou valider l'exception
```
**Scénario 3 : Préparation à un audit externe**
```
Objectif : S'assurer de la conformité avant l'audit
1. 3 mois avant l'audit : Analyse initiale et correction des écarts majeurs
2. 1 mois avant : Ré-analyse et correction des écarts mineurs
3. 1 semaine avant : Analyse finale et génération des rapports
4. Pendant l'audit : Fournir les rapports d'analyse comme preuves
```
---
## **4. Paramétrage de l'User Access Control**
### **4.1 Introduction**
#### **Qu'est-ce que l'UAC ?**
L'**User Access Control (UAC)** est un mécanisme de sécurité introduit avec Windows Vista qui vise à limiter l'impact des logiciels malveillants et des erreurs utilisateur en contrôlant l'élévation des privilèges.
#### **Problème résolu par l'UAC**
**Avant l'UAC (Windows XP et antérieurs) :**
- Les utilisateurs travaillaient souvent avec des comptes administrateurs
- Les applications s'exécutaient avec tous les privilèges de l'utilisateur
- Un malware pouvait compromettre le système sans avertissement
- Aucune distinction entre tâches ordinaires et tâches administratives
**Avec l'UAC :**
- Séparation des privilèges : même les administrateurs fonctionnent avec un jeton utilisateur standard
- Les actions sensibles nécessitent une élévation explicite
- Invite de consentement pour les opérations administratives
- Réduction de la surface d'attaque
#### **Principe de fonctionnement**
**Tokens de sécurité :**
1. **Token standard** : Privilèges limités pour les opérations quotidiennes
2. **Token administrateur** : Tous les privilèges, utilisé uniquement après élévation
**Processus d'élévation :**
```
1. Application demande des privilèges administratifs
↓
2. UAC détecte la demande d'élévation
↓
3. Passage au bureau sécurisé (secure desktop)
↓
4. Affichage de l'invite UAC
↓
5. Utilisateur approuve ou refuse
↓
6. Si approuvé : l'application s'exécute avec le token administrateur
```
#### **Types d'invites UAC**
| Couleur | Type | Description |
|---------|------|-------------|
| 🔴 **Rouge** | Bloquer | Application bloquée par la stratégie (non signée, blacklistée) |
| 🟡 **Jaune/Orange** | Avertissement | Application non signée ou signature non vérifiable |
| 🔵 **Bleu** | Approuvé | Application signée par un éditeur de confiance |
| 🟢 **Vert** | Windows | Composant Windows authentique |
#### **Niveaux UAC dans Windows**
Accessible via : Panneau de configuration > Comptes d'utilisateurs > Modifier les paramètres de contrôle de compte d'utilisateur
**Niveau 4 - Toujours m'avertir (Maximum)** ☑️ Recommandé pour les environnements sensibles
- Notifie à chaque tentative de modification par une application
- Notifie lors de modifications des paramètres Windows
- Bureau sécurisé activé
**Niveau 3 - Me prévenir uniquement lorsque des applications tentent de modifier mon ordinateur (Par défaut)** ☑️ Recommandé pour la plupart des utilisateurs
- Notifie uniquement pour les applications (pas pour les paramètres Windows)
- Bureau sécurisé activé
- Équilibre sécurité/productivité
**Niveau 2 - Me prévenir uniquement lorsque des applications tentent de modifier mon ordinateur (sans obscurcir le bureau)**
- Même que niveau 3 mais sans bureau sécurisé
- ⚠️ Moins sécurisé (malware peut simuler l'interface UAC)
**Niveau 1 - Ne jamais m'avertir (Désactivé)** ❌ Déconseillé
- UAC complètement désactivé
- Aucune protection contre l'élévation non autorisée
- Équivalent à Windows XP
#### **Bureau sécurisé (Secure Desktop)**
**Qu'est-ce que c'est ?**
Le bureau sécurisé est un environnement isolé où seuls les processus système de confiance peuvent s'exécuter. Quand l'invite UAC s'affiche :
- L'écran s'assombrit
- Toutes les autres applications sont suspendues
- Impossible pour un malware de cliquer sur "Oui" à votre place
**Sécurité apportée :**
- Protection contre les attaques par injection de clavier
- Empêche les clics automatisés (clickjacking)
- Isole l'invite UAC des applications potentiellement malveillantes
#### **Configuration UAC via GPO**
**Emplacement dans la GPO :**
```
Configuration ordinateur > Stratégies > Paramètres Windows > Paramètres de sécurité > Stratégies locales > Options de sécurité
```
**Paramètres UAC disponibles :**
| Paramètre | Description | Valeurs possibles | Recommandation |
|-----------|-------------|-------------------|----------------|
| **Contrôle de compte d'utilisateur : comportement de l'invite d'élévation pour les administrateurs** | Contrôle le type d'invite pour les admins | - Élever sans invite<br>- Demander le consentement sur le bureau sécurisé<br>- Demander les informations d'identification sur le bureau sécurisé | Demander le consentement sur le bureau sécurisé |
| **Contrôle de compte d'utilisateur : comportement de l'invite d'élévation pour les utilisateurs standard** | Contrôle le type d'invite pour les utilisateurs | - Refuser automatiquement<br>- Demander les informations d'identification sur le bureau sécurisé<br>- Demander les informations d'identification | Demander les informations d'identification sur le bureau sécurisé |
| **Contrôle de compte d'utilisateur : détecter les installations d'applications et demander une élévation** | Demande élévation pour les installateurs | Activé / Désactivé | Activé |
| **Contrôle de compte d'utilisateur : exécuter tous les administrateurs en mode Approbation d'administrateur** | Active/désactive UAC globalement | Activé / Désactivé | Activé |
| **Contrôle de compte d'utilisateur : passer au bureau sécurisé lors d'une demande d'élévation** | Utilise le secure desktop | Activé / Désactivé | Activé |
| **Contrôle de compte d'utilisateur : virtualiser les échecs d'écriture de fichiers et de Registre vers des emplacements par utilisateur** | Redirige les écritures non autorisées | Activé / Désactivé | Activé |
| **Contrôle de compte d'utilisateur : élever uniquement les applications exécutables signées et validées** | Vérifie la signature numérique | Activé / Désactivé | Facultatif (peut bloquer scripts légitimes) |
| **Contrôle de compte d'utilisateur : élever uniquement les applications UIAccess installées à des emplacements sécurisés** | Restreint les applications UI Automation | Activé / Désactivé | Activé |
#### **Configuration recommandée pour différents environnements**
**Environnement standard (bureautique) :**
```
Comportement pour administrateurs : Demander le consentement sur bureau sécurisé
Comportement pour utilisateurs : Demander les informations d'identification sur bureau sécurisé
Détecter installations : Activé
Mode Approbation : Activé
Bureau sécurisé : Activé
Virtualisation : Activé
```
**Environnement haute sécurité (finance, santé) :**
```
Comportement pour administrateurs : Demander les informations d'identification sur bureau sécurisé
Comportement pour utilisateurs : Refuser automatiquement
Détecter installations : Activé
Mode Approbation : Activé
Bureau sécurisé : Activé
Virtualisation : Activé
Élever uniquement apps signées : Activé
```
**Environnement développement/test :**
```
Comportement pour administrateurs : Élever sans invite (sur machines de dev uniquement)
Comportement pour utilisateurs : Demander les informations d'identification
Détecter installations : Activé
Mode Approbation : Activé
Bureau sécurisé : Désactivé (pour faciliter le debug)
Virtualisation : DésactivéVérifier l'état actuel de l'UAC :
# Vérifier si UAC est activé
$uacEnabled = (Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System").EnableLUA
if ($uacEnabled -eq 1) {
Write-Host "UAC est activé" -ForegroundColor Green
} else {
Write-Host "UAC est désactivé" -ForegroundColor Red
}
# Afficher tous les paramètres UAC
Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System" | Select-Object Enable*, Consent*, Prompt*Modifier les paramètres UAC (nécessite admin) :
# Activer UAC
Set-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System" -Name "EnableLUA" -Value 1
# Demander consentement sur bureau sécurisé pour les admins
Set-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System" -Name "ConsentPromptBehaviorAdmin" -Value 2
# Demander identifiants pour les utilisateurs standards
Set-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System" -Name "ConsentPromptBehaviorUser" -Value 1
# Activer le bureau sécurisé
Set-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System" -Name "PromptOnSecureDesktop" -Value 1Certaines applications légitimes nécessitent des privilèges élevés sans interaction utilisateur.
Méthode : Créer une tâche planifiée avec privilèges élevés
# Créer une tâche qui lance une application avec élévation automatique
$action = New-ScheduledTaskAction -Execute "C:\Program Files\MonApp\app.exe"
$trigger = New-ScheduledTaskTrigger -AtLogOn
$principal = New-ScheduledTaskPrincipal -UserId "DOMAIN\user" -RunLevel Highest
Register-ScheduledTask -TaskName "MonApp_Elevee" -Action $action -Trigger $trigger -Principal $principalLancer la tâche :
Start-ScheduledTask -TaskName "MonApp_Elevee"⚠️ Attention : N'utiliser que pour des applications de confiance et documenter la raison.
Journal des événements :
Événements importants :
| ID | Description |
|---|---|
| 4688 | Nouveau processus créé (inclut le niveau d'élévation) |
| 4624 | Connexion réussie (Type 2 = élévation UAC) |
| 5376 | Sauvegarde des informations d'identification |
✅ Recommandations :
❌ À éviter :
Conséquences de la désactivation :
Si UAC doit être désactivé (très rare) :
AppLocker est une fonctionnalité de contrôle d'application introduite dans Windows 7/Server 2008 R2 qui permet aux administrateurs de spécifier quelles applications peuvent s'exécuter dans l'environnement. C'est l'évolution des stratégies de restriction logicielle (Software Restriction Policies).
Objectifs :
| Caractéristique | SRP (anciennes versions) | AppLocker |
|---|---|---|
| Granularité | Limitée | Très fine (éditeur, chemin, hash) |
| Exceptions | Difficiles à gérer | Faciles avec règles d'exception |
| Audit | Basique | Complet (mode audit avant blocage) |
| Gestion | Complexe | Interface intuitive |
| Performance | Impact parfois élevé | Optimisé |
| Règles par défaut | Aucune | Générées automatiquement |
Éditions Windows supportées :
Service requis :
Activation du service via GPO :
Configuration ordinateur > Stratégies > Paramètres Windows > Paramètres de sécurité > Services système > Identité de l'application
- Mode de démarrage : Automatique
AppLocker permet de créer des règles pour cinq collections :
Contrôle les applications traditionnelles
Exemples : notepad.exe, chrome.exe, malware.exe
Contrôle les scripts exécutables
Exemples : script.ps1, install.bat, virus.vbs
Contrôle les packages d'installation
Exemples : Office.msi, update.msp
Contrôle les bibliothèques dynamiques
⚠️ Impact sur les performances : Active le blocage des DLL non autorisées
Recommandation : N'activer que si nécessaire
Contrôle les applications du Microsoft Store
Exemples : applications UWP, applications APPX
AppLocker peut créer des règles basées sur trois conditions principales :
Basées sur la signature numérique de l'application
Avantages :
Niveaux de granularité :
Éditeur : Microsoft Corporation
↓
Nom du produit : Windows
↓
Nom du fichier : notepad.exe
↓
Version du fichier : >= 10.0.0.0
Exemple :
Autoriser toutes les applications signées par "Microsoft Corporation"
Autoriser uniquement "Google Chrome" version 100.0 et ultérieures
Bloquer "Adobe Flash Player" de "Adobe Inc."
Limitation : Ne fonctionne que pour les applications signées numériquement.
Basées sur l'emplacement du fichier
Avantages :
Inconvénients :
Variables d'environnement utilisables :
%WINDIR% → C:\Windows
%SYSTEM32% → C:\Windows\System32
%PROGRAMFILES% → C:\Program Files
%OSDRIVE% → C:\
Exemples :
Autoriser : %PROGRAMFILES%\MonApplication\*
Bloquer : C:\Temp\*
Autoriser : %USERPROFILE%\Documents\Scripts\Approuvés\*
⚠️ Sécurité : Ne jamais autoriser %TEMP% ou dossiers avec droits d'écriture utilisateur.
Basées sur l'empreinte numérique du fichier
Avantages :
Inconvénients :
Usage recommandé :
Exemple :
Hash SHA256 : A8F3D9C2E5B1... (unique pour ce fichier précis)
AppLocker propose des règles par défaut qui autorisent l'exécution de Windows et des programmes installés.
Génération automatique :
Règles générées :
Pour les exécutables :
1. (Tous) %PROGRAMFILES%\* → Autorisé
2. (Tous) %WINDIR%\* → Autorisé
3. (BUILTIN\Administrateurs) * → Autorisé
Pour les scripts :
1. (Tous) %PROGRAMFILES%\* → Autorisé
2. (Tous) %WINDIR%\* → Autorisé
3. (BUILTIN\Administrateurs) * → Autorisé
⚠️ Important : Ces règles sont un point de départ mais peuvent être trop permissives selon vos besoins.
Étapes complètes :
gpmc.msc > Clic droit sur une OU > Créer un objet GPO
Nom : GPO_AppLocker_Restrictions
Modifier la GPO > Configuration ordinateur > Stratégies > Paramètres Windows > Paramètres de sécurité > Stratégies de contrôle d'application > AppLocker
Clic droit sur AppLocker > Propriétés
Onglet Application :
Pour chaque collection cochée :
Exemple 1 : Bloquer l'accès à cmd.exe pour les utilisateurs standard
%SYSTEM32%\cmd.exeExemple 2 : Autoriser uniquement les applications Microsoft
Éditeur : O=MICROSOFT CORPORATION, L=REDMOND, S=WASHINGTON, C=USExemple 3 : Bloquer un malware spécifique par hash
Les exceptions permettent d'affiner les règles.
Scénario : Autoriser tous les exécutables dans C:\Program Files SAUF une application spécifique.
C:\Program Files\*C:\Program Files\ApplicationBloquee\*Résultat : Tout autorisé dans Program Files sauf ApplicationBloquee.
Via GPO :
Configuration ordinateur > Stratégies > Paramètres Windows > Paramètres de sécurité > Services système > Identité de l'application
Double-cliquer > Définir ce mode de démarrage de service : AutomatiqueOu via script (à déployer sur les postes) :
Set-Service -Name AppIDSvc -StartupType Automatic
Start-Service -Name AppIDSvcgpupdate /forceGet-AppLockerPolicy -Effective -Xml | Out-File C:\EffectivePolicy.xml
notepad C:\EffectivePolicy.xml
Pourquoi utiliser le mode Audit ?
Configuration :
Analyser les journaux :
Observateur d'événements > Journaux des applications et services > Microsoft > Windows > AppLockerJournaux par collection :
Événements importants :
| ID | Niveau | Description |
|---|---|---|
| 8002 | Avertissement | L'exécution a été AUTORISÉE (en mode audit, serait bloquée en mode Appliqué) |
| 8003 | Avertissement | L'exécution a été AUTORISÉE (règle explicite) |
| 8004 | Erreur | L'exécution a été BLOQUÉE |
**Requête PowerShell pour analyser les blocages:
# Requête PowerShell pour analyser les blocages potentiels
Get-WinEvent -LogName "Microsoft-Windows-AppLocker/EXE and DLL" -MaxEvents 1000 |
Where-Object {$_.Id -eq 8002 -or $_.Id -eq 8004} |
Select-Object TimeCreated, Id, @{
Name='Application'
Expression={
if ($_.Message -match "([A-Z]:\\[^\\]+(?:\\[^\\]+)*\\[^\\]+\.\w+)") {
$matches[1]
}
}
}, @{
Name='Utilisateur'
Expression={$_.UserId}
} |
Group-Object Application |
Sort-Object Count -Descending |
Select-Object Count, Name |
Format-Table -AutoSize
# Exporter vers CSV pour analyse Excel
Get-WinEvent -LogName "Microsoft-Windows-AppLocker/EXE and DLL" -MaxEvents 5000 |
Where-Object {$_.Id -eq 8002} |
Select-Object TimeCreated, Message |
Export-Csv -Path "C:\AppLocker_Audit.csv" -NoTypeInformationAnalyse des résultats :
Avantages :
Exemples de commandes :
# Créer une règle autorisant tous les exécutables signés par Microsoft
$rule = New-AppLockerPolicy -RuleType Publisher `
-PublisherName "O=MICROSOFT CORPORATION, L=REDMOND, S=WASHINGTON, C=US" `
-ProductName "*" `
-BinaryName "*" `
-User "Everyone" `
-Action Allow `
-RuleNamePrefix "Microsoft_Apps"
# Ajouter la règle à la politique existante
Set-AppLockerPolicy -PolicyObject $rule -Merge
# Bloquer cmd.exe pour les utilisateurs $rule = New-AppLockerPolicy -RuleType Path `
-Path "%SYSTEM32%\cmd.exe" `
-User "BUILTIN\Users" `
-Action Deny `
-RuleNamePrefix "Block_CMD" Set-AppLockerPolicy -PolicyObject $rule -Merge
# Bloquer un fichier spécifique par son hash
$filePath = "C:\Malware\suspect.exe"
$rule = New-AppLockerPolicy -RuleType Hash `
-SourcePath $filePath `
-User "Everyone" `
-Action Deny `
-RuleNamePrefix "Block_Malware"
Set-AppLockerPolicy -PolicyObject $rule -Merge
# Créer des règles pour tous les exécutables d'un dossier
$folder = "C:\Program Files\MonApplication"
$rules = Get-ChildItem -Path $folder -Filter *.exe -Recurse |
ForEach-Object {
New-AppLockerPolicy -RuleType Publisher -SourcePath $_.FullName -User "Everyone" -Action Allow
}
# Fusionner toutes les règles
$policy = New-Object Microsoft.Security.ApplicationId.PolicyManagement.PolicyModel.AppLockerPolicy
foreach ($rule in $rules) {
$policy.Merge($rule)
}
Set-AppLockerPolicy -PolicyObject $policy -Merge
# Exporter la politique actuelle
Get-AppLockerPolicy -Effective -Xml | Out-File "C:\AppLocker_Policy.xml"
# Importer une politique depuis un fichier XML
Set-AppLockerPolicy -XmlPolicy "C:\AppLocker_Policy.xml"
# Afficher toutes les règles effectives
Get-AppLockerPolicy -Effective | Select-Object -ExpandProperty RuleCollections
# Tester si un fichier serait bloqué
Test-AppLockerPolicy -Path "C:\Program Files\Chrome\chrome.exe" -User "DOMAIN\jdupont"
```
---
Exception : Autoriser les administrateurs
Objectif : Environnement verrouillé pour postes publics
Configuration :
Objectif : Protection contre les variantes de ransomware
Configuration :
# Script de mise à jour automatique des règles anti-ransomware
$hashList = Get-Content "\\Serveur\Partage\Ransomware_Hashes.txt"
foreach ($hash in $hashList) {
$rule = New-AppLockerPolicy -RuleType Hash `
-HashValue $hash `
-User "Everyone" `
-Action Deny `
-RuleNamePrefix "Block_Ransomware"
Set-AppLockerPolicy -PolicyObject $rule -Merge
}Objectif : Permettre l'exécution d'une application développée en interne
Configuration :
C:\Applications\AppMetier\*⚠️ Sécurité : S'assurer que les utilisateurs n'ont pas de droits d'écriture sur ce dossier.
Vérifications :
Get-Service AppIDSvc
Start-Service AppIDSvc
gpresult /h gpresult.html
Get-AppLockerPolicy -Effective
gpupdate /forceSolution immédiate :
PowerShell pour exception rapide :
# Autoriser temporairement une application
$appPath = "C:\Program Files\AppBloquee\app.exe"
$rule = New-AppLockerPolicy -RuleType Path `
-Path $appPath `
-User "Everyone" `
-Action Allow `
-RuleNamePrefix "Exception_Temporaire"
Set-AppLockerPolicy -PolicyObject $rule -Merge
```
##### **Problème 3 : Impact sur les performances**
**Causes courantes :**
- Règles DLL activées (très gourmand en ressources)
- Trop de règles de hash
- Règles avec caractères génériques complexes
**Solutions :**
1. Désactiver les règles DLL si non nécessaires
2. Consolider les règles (utiliser des règles d'éditeur plutôt que de hash)
3. Optimiser les règles de chemin
##### **Problème 4 : Les administrateurs sont également bloqués**
**Cause :** Les règles de refus ont priorité sur les règles d'autorisation
**Solution :**
```
Au lieu de : Refuser * pour Utilisateurs
Utiliser : Refuser [application spécifique] pour Utilisateurs
ET : Autoriser * pour Administrateurs
1. Applications les plus bloquées cette semaine
Get-WinEvent -LogName "Microsoft-Windows-AppLocker/EXE and DLL" -MaxEvents 10000 |
Where-Object {$_.Id -eq 8004 -and $_.TimeCreated -gt (Get-Date).AddDays(-7)} |
Select-Object @{
Name='Application'
Expression={
if ($_.Message -match "\\([^\\]+\.exe)") {$matches[1]}
}
} |
Group-Object Application |
Sort-Object Count -Descending |
Select-Object -First 10 Count, Name |
Format-Table -AutoSize2. Utilisateurs impactés par les blocages
Get-WinEvent -LogName "Microsoft-Windows-AppLocker/EXE and DLL" |
Where-Object {$_.Id -eq 8004} |
Group-Object UserId |
Sort-Object Count -Descending |
Format-Table Count, Name -AutoSize3. Rapport quotidien automatisé
# Script : AppLocker-RapportQuotidien.ps1
$date = Get-Date -Format "yyyy-MM-dd"
$rapport = "C:\Rapports\AppLocker_$date.html"
$blocages = Get-WinEvent -LogName "Microsoft-Windows-AppLocker/EXE and DLL" -MaxEvents 1000 |
Where-Object {$_.Id -eq 8004 -and $_.TimeCreated -gt (Get-Date).AddDays(-1)}
$html = @"
<html>
<head><title>Rapport AppLocker - $date</title></head>
<body>
<h1>Rapport quotidien AppLocker</h1>
<p>Date : $date</p>
<p>Nombre de blocages : $($blocages.Count)</p>
<h2>Applications bloquées</h2>
<table border='1'>
<tr><th>Heure</th><th>Utilisateur</th><th>Application</th></tr>
$(
$blocages | Select-Object -First 20 | ForEach-Object {
"<tr><td>$($_.TimeCreated)</td><td>$($_.UserId)</td><td>$($_.Message)</td></tr>"
}
)
</table>
</body>
</html>
"@
$html | Out-File $rapport
# Envoyer par email si des blocages détectés
if ($blocages.Count -gt 0) {
Send-MailMessage -To "admin@entreprise.local" `
-From "applocker@entreprise.local" `
-Subject "Rapport AppLocker - $($blocages.Count) blocages" `
-Body "Consultez le rapport en pièce jointe" `
-Attachments $rapport `
-SmtpServer "smtp.entreprise.local"
}
✅ Recommandations :
❌ À éviter :
Ce qu'AppLocker NE fait PAS :
Solutions complémentaires :
La délégation de contrôle dans Active Directory est le processus d'attribution de permissions administratives spécifiques à des utilisateurs ou groupes, leur permettant d'effectuer certaines tâches sans leur donner tous les privilèges d'administration.
Principe du moindre privilège : Accorder uniquement les permissions nécessaires pour accomplir une tâche spécifique, rien de plus.
Avantages :
Scénarios courants :
1. Assistant Délégation de contrôle (Recommandé pour les débutants)
2. Attribution manuelle d'ACL (Pour les besoins avancés)
3. Utilisation de groupes intégrés
4. Rôles RBAC (Role-Based Access Control) via PowerShell
Définir les rôles et responsabilités :
| Rôle | Tâches autorisées | Groupe AD correspondant |
|---|---|---|
| Support Niveau 1 | Réinitialiser mots de passe, Déverrouiller comptes | GRP_Support_N1 |
| Support Niveau 2 | Niveau 1 + Activer/désactiver comptes, Déplacer utilisateurs | GRP_Support_N2 |
| RH | Créer utilisateurs dans OU=Employees, Modifier attributs (téléphone, bureau) | GRP_RH_Admins |
| Admins Sites | Gérer les ordinateurs de leur site | GRP_Admin_Site_Montreal |
| Admins Impression | Gérer les files d'attente d'impression | GRP_Admin_Impression |
# Créer les groupes de sécurité pour la délégation
New-ADGroup -Name "GRP_Support_N1" `
-GroupCategory Security `
-GroupScope Global `
-Description "Groupe de délégation - Support Niveau 1 (reset MDP)" `
-Path "OU=Groupes_Delegation,DC=entreprise,DC=local"
New-ADGroup -Name "GRP_Support_N2" `
-GroupCategory Security `
-GroupScope Global `
-Description "Groupe de délégation - Support Niveau 2 (gestion comptes)" `
-Path "OU=Groupes_Delegation,DC=entreprise,DC=local"
New-ADGroup -Name "GRP_RH_Admins" `
-GroupCategory Security `
-GroupScope Global `
-Description "Groupe de délégation - RH (création utilisateurs)" `
-Path "OU=Groupes_Delegation,DC=entreprise,DC=local"
# Ajouter des membres au groupe Support N1
Add-ADGroupMember -Identity "GRP_Support_N1" -Members "jdupont","mtremblay","slavoie"
# Vérifier les membres
Get-ADGroupMember -Identity "GRP_Support_N1"
```
---
#### **6.1.1 Déplacement d'utilisateur**
**Objectif :** Permettre au support de déplacer des utilisateurs entre les OU sans être administrateur de domaine.
##### **Méthode 1 : Assistant Délégation de contrôle**
**Étapes détaillées :**
1. **Ouvrir Active Directory Users and Computers**
```
dsa.msc
GRP_Support_N2Via ADSI Edit ou dsacls :
REM Accorder la permission de déplacement sur l'OU Employees
dsacls "OU=Employees,DC=entreprise,DC=local" /G "ENTREPRISE\GRP_Support_N2:LCRP;user"
REM Explications des permissions :
REM L = List contents
REM C = Create child
REM R = Read property
REM P = Read permissionsVérifier les permissions accordées :
dsacls "OU=Employees,DC=entreprise,DC=local"
# Importer le module Active Directory
Import-Module ActiveDirectory
# Définir les variables
$ouPath = "OU=Employees,DC=entreprise,DC=local"
$delegatedGroup = "GRP_Support_N2"
$domain = "entreprise"
# Obtenir le SID du groupe délégué
$groupSID = (Get-ADGroup $delegatedGroup).SID
# Obtenir l'ACL actuelle de l'OU
$acl = Get-Acl -Path "AD:$ouPath"
# Créer une règle d'accès pour lire et écrire toutes les propriétés des objets utilisateur
$userGuid = [GUID]"bf967aba-0de6-11d0-a285-00aa003049e2" # GUID pour les objets User
$ace = New-Object System.DirectoryServices.ActiveDirectoryAccessRule(
$groupSID, # Identity
[System.DirectoryServices.ActiveDirectoryRights]::ReadProperty -bor
[System.DirectoryServices.ActiveDirectoryRights]::WriteProperty, # Rights
[System.Security.AccessControl.AccessControlType]::Allow, # Type
$userGuid, # ObjectType (User objects)
[System.DirectoryServices.ActiveDirectorySecurityInheritance]::Descendents, # InheritanceType
$userGuid # InheritedObjectType
)
# Ajouter la règle à l'ACL
$acl.AddAccessRule($ace)
# Appliquer l'ACL modifiée
Set-Acl -Path "AD:$ouPath" -AclObject $acl
Write-Host "Délégation appliquée avec succès pour $delegatedGroup sur $ouPath" -ForegroundColor GreenTester avec un compte membre du groupe délégué :
Vérification par script :
# Se connecter avec les informations d'identification du support
$cred = Get-Credential ENTREPRISE\jdupont
# Tenter de déplacer un utilisateur
Move-ADObject -Identity "CN=Test User,OU=Employees,DC=entreprise,DC=local" `
-TargetPath "OU=Anciens,DC=entreprise,DC=local" `
-Credential $cred
```
---
#### **6.1.2 Activation de comptes utilisateurs**
**Objectif :** Permettre au support d'activer et désactiver des comptes utilisateurs.
##### **Méthode 1 : Assistant Délégation de contrôle (Tâche courante)**
**Étapes :**
1. **Ouvrir Active Directory Users and Computers**
```
dsa.msc
GRP_Support_N2Via l'interface graphique :
GRP_Support_N2 > OK# Script : Deleguer-ActivationComptes.ps1
param(
[string]$OUPath = "OU=Employees,DC=entreprise,DC=local",
[string]$GroupName = "GRP_Support_N2"
)
# Obtenir le SID du groupe
$groupSID = (Get-ADGroup $GroupName).SID
# Obtenir l'ACL de l'OU
$acl = Get-Acl -Path "AD:$OUPath"
# GUID pour les objets User
$userGuid = [GUID]"bf967aba-0de6-11d0-a285-00aa003049e2"
# GUID pour l'attribut userAccountControl
$userAccountControlGuid = [GUID]"bf967a68-0de6-11d0-a285-00aa003049e2"
# Créer la règle d'accès pour écrire userAccountControl
$ace = New-Object System.DirectoryServices.ActiveDirectoryAccessRule(
$groupSID,
[System.DirectoryServices.ActiveDirectoryRights]::WriteProperty,
[System.Security.AccessControl.AccessControlType]::Allow,
$userAccountControlGuid, # Écrire userAccountControl
[System.DirectoryServices.ActiveDirectorySecurityInheritance]::Descendents,
$userGuid # Sur les objets User
)
$acl.AddAccessRule($ace)
# Ajouter également la lecture (nécessaire pour voir les utilisateurs)
$aceRead = New-Object System.DirectoryServices.ActiveDirectoryAccessRule(
$groupSID,
[System.DirectoryServices.ActiveDirectoryRights]::ReadProperty,
[System.Security.AccessControl.AccessControlType]::Allow,
[System.DirectoryServices.ActiveDirectorySecurityInheritance]::Descendents,
$userGuid
)
$acl.AddAccessRule($aceRead)
# Appliquer l'ACL
Set-Acl -Path "AD:$OUPath" -AclObject $acl
Write-Host "Délégation d'activation/désactivation de comptes appliquée avec succès !" -ForegroundColor GreenVia interface graphique :
Via PowerShell :
# Tester avec les informations d'identification déléguées
$cred = Get-Credential ENTREPRISE\support_user
# Désactiver un compte
Disable-ADAccount -Identity "testuser" -Credential $cred
# Vérifier l'état
Get-ADUser "testuser" -Properties Enabled | Select-Object Name, Enabled
# Réactiver le compte
Enable-ADAccount -Identity "testuser" -Credential $cred
Objectif : Permettre au help desk de réinitialiser les mots de passe utilisateurs (tâche la plus fréquente).
Étapes :
GRP_Support_N1
# Script : Deleguer-ResetPassword.ps1
param(
[string]$OUPath = "OU=Employees,DC=entreprise,DC=local",
[string]$GroupName = "GRP_Support_N1"
)
Import-Module ActiveDirectory
# Obtenir le SID du groupe délégué
$groupSID = (Get-ADGroup $GroupName).SID
# Obtenir l'ACL actuelle
$acl = Get-Acl -Path "AD:$OUPath"
# GUID pour les objets User
$userGuid = [GUID]"bf967aba-0de6-11d0-a285-00aa003049e2"
# GUID pour l'attribut pwdLastSet (force password change)
$pwdLastSetGuid = [GUID]"bf967a0a-0de6-11d0-a285-00aa003049e2"
# GUID pour l'attribut lockoutTime (unlock account)
$lockoutTimeGuid = [GUID]"28630ebf-41d5-11d1-a9c1-0000f80367c1"
# Permission 1 : Reset password (extended right)
$extendedRight = [GUID]"00299570-246d-11d0-a768-00aa006e0529" # Reset Password
$ace1 = New-Object System.DirectoryServices.ActiveDirectoryAccessRule(
$groupSID,
[System.DirectoryServices.ActiveDirectoryRights]::ExtendedRight,
[System.Security.AccessControl.AccessControlType]::Allow,
$extendedRight, # Reset Password
[System.DirectoryServices.ActiveDirectorySecurityInheritance]::Descendents,
$userGuid # User objects
)
# Permission 2 : Write pwdLastSet (force change at next logon)
$ace2 = New-Object System.DirectoryServices.ActiveDirectoryAccessRule(
$groupSID,
[System.DirectoryServices.ActiveDirectoryRights]::WriteProperty,
[System.Security.AccessControl.AccessControlType]::Allow,
$pwdLastSetGuid,
[System.DirectoryServices.ActiveDirectorySecurityInheritance]::Descendents,
$userGuid
)
# Permission 3 : Write lockoutTime (unlock account)
$ace3 = New-Object System.DirectoryServices.ActiveDirectoryAccessRule(
$groupSID,
[System.DirectoryServices.ActiveDirectoryRights]::WriteProperty,
[System.Security.AccessControl.AccessControlType]::Allow,
$lockoutTimeGuid,
[System.DirectoryServices.ActiveDirectorySecurityInheritance]::Descendents,
$userGuid
)
# Ajouter toutes les règles
$acl.AddAccessRule($ace1)
$acl.AddAccessRule($ace2)
$acl.AddAccessRule($ace3)
# Appliquer
Set-Acl -Path "AD:$OUPath" -AclObject $acl
Write-Host "Délégation de réinitialisation de mot de passe appliquée avec succès !" -ForegroundColor GreenVia dsacls :
dsacls "OU=Employees,DC=entreprise,DC=local" | findstr /I "GRP_Support_N1"Via PowerShell :
(Get-Acl "AD:OU=Employees,DC=entreprise,DC=local").Access |
Where-Object {$_.IdentityReference -like "*GRP_Support_N1*"} |
Select-Object IdentityReference, ActiveDirectoryRights, AccessControlType |
Format-Table -AutoSizeVia interface graphique :
Via PowerShell :
# Tester la réinitialisation avec les credentials du support
$cred = Get-Credential ENTREPRISE\support_user
# Réinitialiser le mot de passe
$newPassword = ConvertTo-SecureString "NouveauP@ssw0rd!" -AsPlainText -Force
Set-ADAccountPassword -Identity "testuser" `
-NewPassword $newPassword `
-Reset `
-Credential $cred
# Forcer le changement au prochain logon
Set-ADUser -Identity "testuser" `
-ChangePasswordAtLogon $true `
-Credential $cred
Write-Host "Mot de passe réinitialisé avec succès" -ForegroundColor GreenCréer un script simple que le help desk peut utiliser :
# Script : ResetUserPassword.ps1
# Usage : .\ResetUserPassword.ps1 -Username "jdupont"
param(
[Parameter(Mandatory=$true)]
[string]$Username
)
Import-Module ActiveDirectory
try {
# Vérifier que l'utilisateur existe
$user = Get-ADUser -Identity $Username -ErrorAction Stop
# Générer un mot de passe temporaire
$tempPassword = "Temp" + (Get-Random -Minimum 1000 -Maximum 9999) + "!"
$securePassword = ConvertTo-SecureString $tempPassword -AsPlainText -Force
# Réinitialiser le mot de passe
Set-ADAccountPassword -Identity $Username -NewPassword $securePassword -Reset
# Forcer le changement au prochain logon
Set-ADUser -Identity $Username -ChangePasswordAtLogon $true
# Déverrouiller le compte si verrouillé
Unlock-ADAccount -Identity $Username
Write-Host "=====================================" -ForegroundColor Green
Write-Host "Mot de passe réinitialisé avec succès !" -ForegroundColor Green
Write-Host "Utilisateur : $Username" -ForegroundColor Cyan
Write-Host "Mot de passe temporaire : $tempPassword" -ForegroundColor Yellow
Write-Host "L'utilisateur devra changer son mot de passe à la prochaine connexion" -ForegroundColor Cyan
Write-Host "=====================================" -ForegroundColor Green
} catch {
Write-Host "Erreur : $_" -ForegroundColor Red
}
```
---
### **6.2 Délégation du serveur d'impression**
**Objectif :** Permettre à une équipe de gérer les imprimantes et les travaux d'impression sans être administrateurs du serveur.
#### **Niveaux de permissions d'imprimante**
| Permission | Capacités |
|------------|-----------|
| **Imprimer** | Envoyer des documents à l'imprimante |
| **Gérer les documents** | Mettre en pause, reprendre, annuler les travaux d'impression de tous les utilisateurs |
| **Gérer cette imprimante** | Modifier les propriétés, partager, gérer les permissions, supprimer l'imprimante |
#### **Délégation via l'interface graphique**
##### **Étape 1 : Ouvrir la console Gestion de l'impression**
```
printmanagement.mscOU
Gestionnaire de serveur > Outils > Gestion de l'impression
Permissions sur une imprimante :
GRP_Admin_ImpressionGRP_Admin_ImpressionPermissions sur le serveur :
GRP_Admin_Impression > OKSur le serveur d'impression :
# Ajouter le groupe de domaine au groupe local "Print Operators"
Add-LocalGroupMember -Group "Print Operators" -Member "ENTREPRISE\GRP_Admin_Impression"
# Vérifier
Get-LocalGroupMember -Group "Print Operators"Permissions accordées par le groupe Print Operators :
Script pour déléguer toutes les imprimantes d'un serveur :
# Script : Deleguer-Imprimantes.ps1
param(
[string]$PrintServer = "SRV-PRINT01",
[string]$DelegatedGroup = "ENTREPRISE\GRP_Admin_Impression"
)
# Obtenir toutes les imprimantes
$printers = Get-Printer -ComputerName $PrintServer
foreach ($printer in $printers) {
Write-Host "Configuration de $($printer.Name)..." -ForegroundColor Cyan
# Définir les permissions (nécessite le module PowerShell de gestion d'impression)
Set-PrinterPermission -PrinterName $printer.Name `
-ComputerName $PrintServer `
-AccountName $DelegatedGroup `
-AccessRight ManagePrinter
Write-Host " ✓ Permissions accordées" -ForegroundColor Green
}
Write-Host "Délégation terminée pour $($printers.Count) imprimantes" -ForegroundColor GreenFonction personnalisée pour gérer les permissions WMI :
# Fonction pour définir les permissions sur une imprimante via WMI
function Set-PrinterACL {
param(
[string]$PrinterName,
[string]$ComputerName,
[string]$TrusteeName,
[string]$Permission = "ManagePrinter" # ManagePrinter, ManageDocuments, Print
)
# Convertir le nom du trustee en SID
$objUser = New-Object System.Security.Principal.NTAccount($TrusteeName)
$strSID = $objUser.Translate([System.Security.Principal.SecurityIdentifier])
# Connexion WMI
$printer = Get-WmiObject -Class Win32_Printer -ComputerName $ComputerName -Filter "Name='$PrinterName'"
if ($printer) {
# Obtenir le Security Descriptor
$SD = $printer.GetSecurityDescriptor().Descriptor
# Créer une nouvelle ACE (Access Control Entry)
$Trustee = ([WMIClass] "Win32_Trustee").CreateInstance()
$Trustee.Domain = $objUser.Translate([System.Security.Principal.NTAccount]).Value.Split('\')[0]
$Trustee.Name = $objUser.Translate([System.Security.Principal.NTAccount]).Value.Split('\')[1]
$Trustee.SIDString = $strSID.Value
$ACE = ([WMIClass] "Win32_ACE").CreateInstance()
$ACE.AccessMask = 983052 # ManagePrinter (0x000F000C)
$ACE.AceFlags = 0
$ACE.AceType = 0 # Access Allowed
$ACE.Trustee = $Trustee
# Ajouter l'ACE au SD
$SD.DACL += $ACE
# Appliquer le nouveau SD
$printer.SetSecurityDescriptor($SD)
Write-Host "Permissions appliquées sur $PrinterName pour $TrusteeName" -ForegroundColor Green
} else {
Write-Host "Imprimante $PrinterName introuvable" -ForegroundColor Red
}
}
# Utilisation
Set-PrinterACL -PrinterName "Imprimante_RH" `
-ComputerName "SRV-PRINT01" `
-TrusteeName "ENTREPRISE\GRP_Admin_Impression"Tester avec un compte membre du groupe délégué :
Via PowerShell :
# Tester avec les credentials du groupe délégué
$cred = Get-Credential ENTREPRISE\admin_impression
# Lister les imprimantes
Get-Printer -ComputerName "SRV-PRINT01" -Credential $cred
# Mettre en pause une imprimante
Set-Printer -Name "Imprimante_RH" -ComputerName "SRV-PRINT01" -PrinterStatus Paused -Credential $cred
# Reprendre l'impression
Set-Printer -Name "Imprimante_RH" -ComputerName "SRV-PRINT01" -PrinterStatus Normal -Credential $credScript pour les administrateurs d'impression :
# Script : Gerer-Travaux-Impression.ps1
param(
[string]$PrinterName,
[string]$ComputerName = $env:COMPUTERNAME
)
# Lister tous les travaux en attente
$jobs = Get-PrintJob -PrinterName $PrinterName -ComputerName $ComputerName
Write-Host "=====================================" -ForegroundColor Cyan
Write-Host "Travaux d'impression sur $PrinterName" -ForegroundColor Cyan
Write-Host "=====================================" -ForegroundColor Cyan
$jobs | ForEach-Object {
Write-Host "ID: $($_.Id) | Utilisateur: $($_.UserName) | Document: $($_.DocumentName) | Pages: $($_.TotalPages) | État: $($_.JobStatus)"
}
# Menu interactif
do {
Write-Host "`nActions disponibles :" -ForegroundColor Yellow
Write-Host "1. Mettre en pause un travail"
Write-Host "2. Reprendre un travail"
Write-Host "3. Annuler un travail"
Write-Host "4. Annuler TOUS les travaux"
Write-Host "5. Actualiser la liste"
Write-Host "Q. Quitter"
$choice = Read-Host "Votre choix"
switch ($choice) {
"1" {
$jobId = Read-Host "ID du travail à mettre en pause"
Suspend-PrintJob -ID $jobId -PrinterName $PrinterName -ComputerName $ComputerName
Write-Host "Travail $jobId mis en pause" -ForegroundColor Green
}
"2" {
$jobId = Read-Host "ID du travail à reprendre"
Resume-PrintJob -ID $jobId -PrinterName $PrinterName -ComputerName $ComputerName
Write-Host "Travail $jobId repris" -ForegroundColor Green
}
"3" {
$jobId = Read-Host "ID du travail à annuler"
Remove-PrintJob -ID $jobId -PrinterName $PrinterName -ComputerName $ComputerName
Write-Host "Travail $jobId annulé" -ForegroundColor Green
}
"4" {
$confirm = Read-Host "Êtes-vous sûr de vouloir annuler TOUS les travaux ? (O/N)"
if ($confirm -eq "O") {
Get-PrintJob -PrinterName $PrinterName -ComputerName $ComputerName | Remove-PrintJob
Write-Host "Tous les travaux annulés" -ForegroundColor Green
}
}
"5" {
$jobs = Get-PrintJob -PrinterName $PrinterName -ComputerName $ComputerName
$jobs | Format-Table -AutoSize
}
}
} while ($choice -ne "Q")
```
---
### **Bonnes pratiques de délégation**
✅ **Recommandations générales :**
1. **Principe du moindre privilège**
- N'accorder que les permissions strictement nécessaires
- Préférer plusieurs groupes de délégation spécialisés plutôt qu'un groupe avec trop de droits
2. **Utiliser des groupes, jamais des utilisateurs individuels**
- Facilite la gestion
- Permet l'audit
- Simplifie les changements de personnel
3. **Documenter toutes les délégations**
```
Créer un fichier Excel avec :
- Nom du groupe
- Permissions accordées
- OU/objets concernés
- Date de création
- Justification métier
- Responsable
# Script d'audit des délégations
$ouPath = "OU=Employees,DC=entreprise,DC=local"
$acl = Get-Acl "AD:$ouPath"
$acl.Access | Where-Object {
$_.IdentityReference -notlike "*BUILTIN*" -and
$_.IdentityReference -notlike "*NT AUTHORITY*" -and
$_.IdentityReference -notlike "*Admins du domaine*"
} | Select-Object IdentityReference, ActiveDirectoryRights, AccessControlType |
Export-Csv "C:\Audit\Delegations_$(Get-Date -Format 'yyyyMMdd').csv" -NoTypeInformation
❌ À éviter :
# Script : Audit-Delegations-AD.ps1
# Génère un rapport des délégations non-standard dans Active Directory
param(
[string]$Domain = (Get-ADDomain).DistinguishedName,
[string]$ReportPath = "C:\Rapports\Delegations_AD_$(Get-Date -Format 'yyyyMMdd_HHmmss').html"
)
Import-Module ActiveDirectory
# Groupes à exclure de l'audit (groupes système normaux)
$excludedGroups = @(
"Admins du domaine",
"Administrateurs de l'entreprise",
"Administrateurs du schéma",
"Administrateurs",
"BUILTIN",
"NT AUTHORITY"
)
# Fonction pour obtenir les délégations sur une OU
function Get-OUDelegations {
param([string]$OUPath)
$acl = Get-Acl "AD:$OUPath"
$delegations = @()
foreach ($access in $acl.Access) {
# Filtrer les groupes système
$excluded = $false
foreach ($excludedGroup in $excludedGroups) {
if ($access.IdentityReference -like "*$excludedGroup*") {
$excluded = $true
break
}
}
if (-not $excluded) {
$delegations += [PSCustomObject]@{
OU = $OUPath
Identité = $access.IdentityReference
Permissions = $access.ActiveDirectoryRights
Type = $access.AccessControlType
Héritage = $access.InheritanceType
}
}
}
return $delegations
}
# Parcourir toutes les OU
Write-Host "Analyse des délégations en cours..." -ForegroundColor Cyan
$allOUs = Get-ADOrganizationalUnit -Filter * -SearchBase $Domain
$allDelegations = @()
foreach ($ou in $allOUs) {
$delegations = Get-OUDelegations -OUPath $ou.DistinguishedName
if ($delegations.Count -gt 0) {
$allDelegations += $delegations
}
}
# Générer le rapport HTML
$html = @"
<html>
<head>
<title>Rapport de délégations Active Directory</title>
<style>
body { font-family: Arial, sans-serif; }
h1 { color: #0078D4; }
table { border-collapse: collapse; width: 100%; }
th { background-color: #0078D4; color: white; padding: 10px; text-align: left; }
td { border: 1px solid #ddd; padding: 8px; }
tr:nth-child(even) { background-color: #f2f2f2; }
</style>
</head>
<body>
<h1>Rapport de délégations Active Directory</h1>
<p>Date : $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')</p>
<p>Domaine : $Domain</p>
<p>Nombre total de délégations non-standard : $($allDelegations.Count)</p>
<h2>Détails des délégations</h2>
<table>
<tr>
<th>OU</th>
<th>Identité</th>
<th>Permissions</th>
<th>Type</th>
<th>Héritage</th>
</tr>
$(
$allDelegations | ForEach-Object {
"<tr>
<td>$($_.OU)</td>
<td>$($_.Identité)</td>
<td>$($_.Permissions)</td>
<td>$($_.Type)</td>
<td>$($_.Héritage)</td>
</tr>"
}
)
</table>
</body>
</html>
"@
$html | Out-File $ReportPath
Write-Host "Rapport généré : $ReportPath" -ForegroundColor Green
# Ouvrir le rapport
Start-Process $ReportPath
Ce courst couvre les aspects essentiels de la gestion de la politique de sécurité dans un environnement Windows Server avec Active Directory. Les sujets abordés incluent :
Points clés à retenir :