Gestion de la politique de sécurité
Notes de cours : Gestion de la politique de sécurité
1. Les stratégies par défaut
Définition
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.
Les deux GPO par défaut
1.1 Default Domain Policy
- Emplacement : Liée à la racine du domaine
- Portée : S'applique à tous les utilisateurs et ordinateurs du domaine
- Paramètres principaux :
- Stratégie de mot de passe
- Longueur minimale : 7 caractères (par défaut)
- Historique : 24 mots de passe mémorisés
- Durée de vie maximale : 42 jours
- Durée de vie minimale : 1 jour
- Complexité requise : Activée
- Stratégie de verrouillage de compte
- Seuil de verrouillage : Non défini par défaut
- Durée de verrouillage : Non applicable
- Réinitialisation du compteur : Non applicable
- Stratégie Kerberos
- Durée de vie maximale du ticket utilisateur : 10 heures
- Durée de vie maximale de renouvellement : 7 jours
- Tolérance de synchronisation d'horloge : 5 minutes
- Stratégie de mot de passe
1.2 Default Domain Controllers Policy
- Emplacement : Liée à l'OU "Domain Controllers"
- Portée : S'applique uniquement aux contrôleurs de domaine
- Paramètres principaux :
- Droits d'utilisateurs
- Autoriser l'ouverture de session locale
- Accéder à cet ordinateur à partir du réseau
- Sauvegarder des fichiers et des répertoires
- Restaurer des fichiers et des répertoires
- Options de sécurité
- Audit des accès
- Signature LDAP
- Chiffrement ou signature de canal sécurisé
- Droits d'utilisateurs
Ordre de traitement des GPO
- GPO locale de l'ordinateur (LGPO)
- GPO du site
- GPO du domaine (Default Domain Policy)
- GPO de l'OU (de la plus haute à la plus basse dans la hiérarchie)
Règle : Le dernier appliqué gagne (Last Write Wins), sauf si "Appliqué" ou "Aucun remplacement" est configuré.
Bonnes pratiques
✅ À faire :
- Ne jamais modifier directement les GPO par défaut
- Créer des GPO personnalisées pour les modifications
- Documenter toute modification apportée
- Effectuer des sauvegardes régulières des GPO
- Tester les modifications dans un environnement de test
❌ À éviter :
- Supprimer les GPO par défaut
- Désactiver complètement Default Domain Policy
- Appliquer des paramètres non-sécurité dans ces GPO
- Modifier les permissions par défaut sans documentation
Visualisation des GPO par défaut
Outils :
- Console GPMC (Group Policy Management Console)
gpmc.msc
- PowerShell :
Get-GPO -Name "Default Domain Policy"
Get-GPOReport -Name "Default Domain Policy" -ReportType HTML -Path "C:\Rapport.html"
Restauration des paramètres par défaut
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.
Syntaxe et options
1. Restaurer uniquement la Default Domain Policy
dcgpofix /target:domain
- Restaure Default Domain Policy aux paramètres par défaut
- Affecte les stratégies de mot de passe, verrouillage de compte, Kerberos
- N'affecte PAS la Default Domain Controllers Policy
2. Restaurer uniquement la Default Domain Controllers Policy
dcgpofix /target:dc
- Restaure Default Domain Controllers Policy aux paramètres par défaut
- Affecte les droits d'utilisateurs et options de sécurité des DC
- N'affecte PAS la Default Domain Policy
3. Restaurer les deux GPO simultanément
dcgpofix /target:both
- Restaure les deux GPO par défaut en une seule commande
- Équivalent à exécuter
/target:domainpuis/target:dc
Bonnes pratiques
AVANT d'exécuter dcgpofix
1. 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
- Noter toutes les modifications apportées aux GPO par défaut
- Créer une checklist de reconfiguration
- Valider avec l'équipe avant de procéder
3. Tester dans un environnement de test si possible
- Lab ou domaine de test
- Vérifier l'impact avant la production
APRÈS l'exécution
1. Forcer la réplication AD
repadmin /syncall /AdeP
2. Forcer la mise à jour des GPO sur les clients
gpupdate /force
3. Vérifier l'application
gpresult /h gpresult.html
4. Reconfigurer les paramètres personnalisés
- Suivre la documentation préparée
- Tester progressivement
- Valider avec les utilisateurs
2. Les stratégies d'audit
2.1 Introduction
Qu'est-ce que l'audit de sécurité ?
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 :
- La détection d'activités suspectes
- La conformité réglementaire
- L'investigation après incident
- L'analyse des comportements utilisateurs
Types d'audit
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é :
- Granularité supérieure
- Réduction du bruit dans les journaux
- Ciblage précis des événements importants
- Meilleure performance système
Exemples de sous-catégories utiles :
- Audit de la validation des informations d'identification
- Audit des opérations sur les comptes d'utilisateurs
- Audit de l'activité des comptes sensibles
- Audit du service d'authentification Kerberos
- Audit de la gestion des autorisations
Configuration de l'audit via GPO
Étapes de configuration :
- Ouvrir GPMC (
gpmc.msc) - Créer ou modifier une GPO
- Naviguer vers les stratégies d'audit
- Configurer les catégories nécessaires :
- Réussite : Enregistre les tentatives réussies
- Échec : Enregistre les tentatives échouées
- Réussite et Échec : Enregistre les deux
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 | ✓ | ✓ |
Consultation des journaux d'audit
Observateur d'événements (eventvwr.msc)
- Journaux Windows > Sécurité
- Filtrage par ID d'événement
- Création de vues personnalisées
- Exportation pour analyse
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
Événements de sécurité importants
| 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 |
Taille et gestion des journaux
Configuration de la taille des journaux :
- Observateur d'événements > Clic droit sur "Sécurité" > Propriétés
- Paramètres recommandés :
- Taille maximale : 1 Go minimum (plus pour les DC)
- Comportement à saturation : Remplacer les événements si nécessaire
- Pour les environnements critiques : Archiver automatiquement
Archivage automatique via tâche planifiée :
wevtutil epl Security "C:\Archives\Security_$(Get-Date -Format 'yyyyMMdd').evtx"
2.2 Auditer les accès aux dossiers partagés
Objectif
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.
Prérequis
- Le système de fichiers doit être NTFS
- L'audit d'accès aux objets doit être activé via GPO
- La SACL (System Access Control List) doit être configurée sur les dossiers
Étape 1 : Activer l'audit d'accès aux objets
Via GPO :
- Créer ou modifier une GPO
- Naviguer vers :
- Configuration ordinateur > Stratégies > Paramètres Windows > Paramètres de sécurité > Stratégies locales > Stratégie d'audit
- Double-cliquer sur "Auditer l'accès aux objets"
- Cocher :
- ☑ Réussite
- ☑ Échec
- Appliquer et OK
Ou via l'audit avancé (recommandé) :
- Configuration ordinateur > Stratégies > Paramètres Windows > Paramètres de sécurité > Configuration avancée de la stratégie d'audit > Accès aux objets
- Activer :
- "Audit du système de fichiers"
- "Audit du partage de fichiers"
Étape 2 : Configurer la SACL sur le dossier
Méthode graphique :
- Clic droit sur le dossier > Propriétés
- Onglet Sécurité > Bouton Avancé
- Onglet Audit > Bouton Ajouter
- Cliquer sur "Sélectionner un principal"
- Entrer le groupe ou l'utilisateur à auditer (ex: "Tout le monde")
- Sélectionner le type : Réussite, Échec, ou Tous
- Choisir les actions à auditer :
- ☑ Traverser le dossier / Exécuter le fichier
- ☑ Afficher le contenu du dossier / Lire les données
- ☑ Lire les attributs
- ☑ Créer des fichiers / Écrire des données
- ☑ Créer des dossiers / Ajouter des données
- ☑ Écrire les attributs
- ☑ Supprimer les sous-dossiers et les fichiers
- ☑ Supprimer
- ☑ Modifier les autorisations
- ☑ Prendre possession
- Cocher "Appliquer ces entrées d'audit aux objets et/ou conteneurs de ce conteneur uniquement"
- Appliquer et OK
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 $acl
Actions auditables recommandées
Pour 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
Étape 3 : Consulter les événements d'audit
É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 :
- Ouvrir l'Observateur d'événements
- Journaux Windows > Sécurité
- Volet de droite > Filtrer le journal actuel
- ID d'événements : 4663, 5140, 5145
- Ou créer une vue personnalisée
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" -NoTypeInformation
Analyse et alertes
Scénarios à surveiller :
- Accès hors heures ouvrables → Activité suspecte potentielle
- Accès massifs à de nombreux fichiers → Possibilité d'exfiltration de données
- Échecs d'accès répétés → Tentative d'accès non autorisé
- Modifications de permissions → Élévation de privilèges non autorisée
- Suppressions massives → Ransomware ou sabotage
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"
}
Bonnes pratiques
✅ 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)
Impact sur les performances
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
3. Gestion de la sécurité
3.1 Stratégie de mot de passe affinée à l'aide de l'interface graphique
Définition et contexte
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 :
- Des exigences plus strictes pour les administrateurs
- Des règles différentes pour des départements spécifiques
- Des politiques adaptées aux comptes de service
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.
- Exemple : Administrateurs = mots de passe de 15 caractères, Utilisateurs = 10 caractères
Prérequis
| Élément | Exigence |
|---|---|
| Niveau fonctionnel du domaine | Windows Server 2008 minimum |
| Permissions | Administrateurs du domaine |
| Outil | Centre d'administration Active Directory (ADAC) |
Paramètres configurables dans une PSO
| 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é :
- PSO appliquée directement à l'utilisateur (priorité absolue)
- PSO du groupe avec la précédence la plus faible
- Default Domain Policy si aucune PSO ne s'applique
Création d'une PSO via Centre d'administration AD
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.exe
2. Naviguer vers le conteneur des PSO
Domaine (local) > System > Password Settings Container
3. Créer une nouvelle PSO
Volet de droite > Tâches > Nouveau > Paramètres de mot de passe
4. 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 minutes
Exemple 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 minutes
5. Appliquer la PSO à un groupe ou utilisateur
Section "S'applique directement à" > Cliquer sur "Ajouter"
Rechercher le groupe : "Admins du domaine"
OK
6. Enregistrer
Cliquer sur OK pour créer la PSO
Vérification de la PSO effective pour un utilisateur
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'applique
Mé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éation d'une PSO
Création d'une PSO via PowerShell
# 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"
Vérification de la PSO effective pour un utilisateur
Via ADAC :
- Ouvrir le Centre d'administration Active Directory
- Rechercher l'utilisateur
- Double-cliquer sur l'utilisateur > Onglet Extensions
- Vérifier la section "Paramètres de mot de passe résultants"
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}
}
Gestion et modification des PSO
Modifier une PSO existante :
- Ouvrir ADAC > Password Settings Container
- Double-cliquer sur la PSO
- Modifier les paramètres
- OK
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"
Scénarios d'utilisation recommandés
| 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
Dépannage
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
3.2 Création et importation d'un modèle de sécurité
Qu'est-ce qu'un modèle de sécurité ?
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é :
- ✓ Standardiser la configuration de sécurité
- ✓ Déployer des paramètres cohérents sur plusieurs systèmes
- ✓ Faciliter l'audit de conformité
- ✓ Sauvegarder et restaurer des configurations
Contenu 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 |
Méthode 1 : Création via la console MMC (Interface graphique)
Étape 1 : Ouvrir une console MMC vierge
Windows + R
Taper : mmc
Appuyer sur Entrée
Dans la console MMC :
Fichier > Ajouter/Supprimer un composant logiciel enfichable
Étape 2 : Ajouter le composant Modèles de sécurité
Dans la liste des composants disponibles :
- Sélectionner "Modèles de sécurité"
- Cliquer sur "Ajouter >"
- Cliquer sur "OK"
Étape 3 : Créer un nouveau modèle
Développer "Modèles de sécurité" dans le volet de gauche
Clic droit sur : C:\Windows\security\templates
Sélectionner : Nouveau modèle
Configuration du nouveau modèle :
Nom du modèle : Serveur_Membre_Securise
Description : Configuration de sécurité renforcée pour serveurs membres
Cliquer sur : OK
Étape 4 : Configurer les paramètres de sécurité
Dé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 :
- Mode de démarrage (Automatique, Manuel, Désactivé)
- Permissions d'accès
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
Étape 5 : Enregistrement du modèle
Le modèle est automatiquement sauvegardé dans :
C:\Windows\security\templates\Serveur_Membre_Securise.inf
Vérification :
Explorateur de fichiers > C:\Windows\security\templates
Vérifier la présence du fichier .inf
Méthode 2 : Création manuelle du fichier .inf
Cré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
Exportation de la configuration actuelle vers un modèle
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`
Modèles de sécurité prédéfinis Windows
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 |
Bonnes pratiques
✅ 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
Cas d'usage pratiques
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
3.3 Comparaison des paramètres en cours et du modèle
Méthode 1 : Configuration et analyse de la sécurité (MMC)
Étape 1 : Ouvrir une console MMC
Windows + R
Taper : mmc
Appuyer sur Entrée
Étape 2 : Ajouter le composant logiciel enfichable
Dans 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
Étape 3 : Créer ou ouvrir une base de données
Clic droit sur "Configuration et analyse de la sécurité"
Sélectionner : Ouvrir la base de données
Dans la boîte de dialogue :
Nom de la nouvelle base : analyse_serveur.sdb
Cliquer sur : Ouvrir
Note : Si la base n'existe pas, elle sera créée automatiquement.
Étape 4 : Importer un modèle de sécurité
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
Étape 5 : Analyser l'ordinateur
Clic droit sur "Configuration et analyse de la sécurité"
Sélectionner : Analyser l'ordinateur maintenant
Configuration de l'analyse :
Chemin du fichier journal : C:\Analyse\analyse_securite.log
Cliquer sur : OK
Attendre la fin de l'analyse (peut prendre quelques minutes selon la configuration)
Étape 6 : Examiner les résultats
Développer l'arborescence dans le volet de gauche pour voir les différentes sections analysées.
Symboles utilisés dans l'analyse
| 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 |
Exemple de vue des résultats
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
Étape 7 : Afficher les détails d'un paramètre non conforme
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 :
- La valeur actuelle ne correspond pas au modèle
- Une action corrective est nécessaire
Étape 8 : Exporter les résultats
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
Enregistrer
Le fichier contiendra :
- Liste de tous les paramètres analysés
- État de conformité (conforme / non conforme)
- Valeurs actuelles vs valeurs recommandées
Étape 9 : Appliquer la configuration (OPTIONNEL)
⚠️ 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 maintenant
Confirmation :
Chemin du journal : C:\Logs\configuration.log
Cliquer sur : OK
⚠️ Avertissements importants :
- Cette action modifie immédiatement la configuration du système
- Peut affecter la disponibilité de certains services
- Peut nécessiter un redémarrage
- TOUJOURS tester sur un environnement de test avant production
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é
Méthode 2 : Utilisation de secedit.exe (ligne de commande)
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" /verbose
Paramè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'analyse
2. 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.
Méthode 3 : Utilisation de PowerShell
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.ps1
Script 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=53353
Avantages :
- Interface graphique intuitive
- Baselines préconfigurées (Windows Server, Office, SQL Server, etc.)
- Support des standards (CIS, DISA STIG)
- Génération de documentation automatique
Interprétation des résultats et actions correctives
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 :
- Identifier : Lister tous les écarts avec croix rouge
- Prioriser : Classer par gravité (critique > élevée > moyenne)
- Analyser : Déterminer si l'écart est :
- Non intentionnel → À corriger
- Exigence métier → À documenter comme exception
- Dérive de configuration → À corriger et investiguer la cause
- Tester : Appliquer les corrections dans un environnement de test
- Déployer : Appliquer via GPO ou configuration locale
- Vérifier : Ré-analyser pour confirmer la conformité
- Documenter : Consigner les changements et exceptions
Automatisation de la surveillance continue
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é
Configuration via PowerShell
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 1
Contourner UAC pour des applications spécifiques (Tâches planifiées)
Certaines 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 $principal
Lancer la tâche :
Start-ScheduledTask -TaskName "MonApp_Elevee"
⚠️ Attention : N'utiliser que pour des applications de confiance et documenter la raison.
Logs et événements UAC
Journal des événements :
- Applications and Services Logs > Microsoft > Windows > UAC > Operational
É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 |
Bonnes pratiques
✅ Recommandations :
- Toujours activer UAC sauf dans des cas très spécifiques et documentés
- Utiliser le bureau sécurisé pour toutes les invites
- Former les utilisateurs à reconnaître les invites UAC légitimes
- Limiter les comptes administrateurs : privilégier les utilisateurs standards
- Auditer les événements d'élévation pour détecter les abus
- Utiliser AppLocker en complément pour un contrôle granulaire
❌ À éviter :
- Désactiver UAC pour "faciliter" le travail (réduit drastiquement la sécurité)
- Donner des droits administrateurs à tous les utilisateurs
- Ignorer les invites UAC sans les lire
- Configurer "Élever sans invite" pour les administrateurs (sauf environnements contrôlés)
Impact de la désactivation d'UAC
Conséquences de la désactivation :
- ❌ Toutes les applications s'exécutent avec privilèges complets
- ❌ Pas de protection contre l'élévation silencieuse
- ❌ Certaines fonctionnalités Windows peuvent ne plus fonctionner (Windows Store, Modern Apps)
- ❌ Non-conformité à de nombreux standards de sécurité (PCI-DSS, HIPAA, etc.)
- ❌ Augmentation significative du risque de compromission
Si UAC doit être désactivé (très rare) :
- Compenser avec d'autres contrôles (AppLocker, antivirus renforcé)
- Limiter aux machines isolées (hors réseau de production)
- Documenter et obtenir approbation formelle
- Audit régulier de ces machines
4.2 Utilisation d'AppLocker
Qu'est-ce qu'AppLocker ?
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 :
- Empêcher l'exécution de logiciels malveillants
- Bloquer les applications non autorisées
- Contrôler l'exécution de scripts
- Réduire le risque d'infections par ransomware
- Conformité aux politiques d'entreprise
Avantages d'AppLocker par rapport aux SRP
| 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 |
Prérequis
Éditions Windows supportées :
- ✅ Windows 10/11 Entreprise
- ✅ Windows 10/11 Éducation
- ✅ Windows Server 2008 R2 et ultérieures
- ❌ Windows 10/11 Familiale et Professionnel (AppLocker non disponible)
Service requis :
- Identité de l'application (Application Identity) doit être démarré
- Type de démarrage : Automatique
- État : En cours d'exécution
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
Types de règles AppLocker
AppLocker permet de créer des règles pour cinq collections :
1. Exécutables (.exe, .com)
Contrôle les applications traditionnelles
Exemples : notepad.exe, chrome.exe, malware.exe
2. Scripts Windows (.ps1, .bat, .cmd, .vbs, .js)
Contrôle les scripts exécutables
Exemples : script.ps1, install.bat, virus.vbs
3. Programmes d'installation Windows (.msi, .msp, .mst)
Contrôle les packages d'installation
Exemples : Office.msi, update.msp
4. DLL (.dll, .ocx)
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
5. Applications empaquetées et programmes d'installation d'application empaquetée (Packaged apps)
Contrôle les applications du Microsoft Store
Exemples : applications UWP, applications APPX
Conditions de règles
AppLocker peut créer des règles basées sur trois conditions principales :
1. Règles d'éditeur (Recommandé)
Basées sur la signature numérique de l'application
Avantages :
- ✅ Résiste aux mises à jour (signature reste la même)
- ✅ Facile à gérer
- ✅ Peut cibler un éditeur, un produit ou une version spécifique
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.
2. Règles de chemin d'accès
Basées sur l'emplacement du fichier
Avantages :
- ✅ Fonctionne pour les applications non signées
- ✅ Facile à comprendre
Inconvénients :
- ❌ Sensible aux déplacements de fichiers
- ❌ Peut être contourné si l'utilisateur a accès en écriture au dossier
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.
3. Règles de hachage
Basées sur l'empreinte numérique du fichier
Avantages :
- ✅ Identification unique du fichier
- ✅ Ne peut pas être contourné
- ✅ Fonctionne pour les applications non signées
Inconvénients :
- ❌ Doit être mis à jour à chaque version de l'application
- ❌ Lourd à gérer pour de nombreux fichiers
Usage recommandé :
- Autoriser/bloquer une version spécifique d'un fichier
- Exceptions pour des fichiers particuliers
Exemple :
Hash SHA256 : A8F3D9C2E5B1... (unique pour ce fichier précis)
Règles par défaut
AppLocker propose des règles par défaut qui autorisent l'exécution de Windows et des programmes installés.
Génération automatique :
- Ouvrir la GPO > AppLocker > Collection (ex: Exécutables)
- Clic droit > Créer des règles par défaut automatiquement
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.
Configuration d'AppLocker via GPO
Étapes complètes :
Étape 1 : Créer ou modifier une GPO
gpmc.msc > Clic droit sur une OU > Créer un objet GPO
Nom : GPO_AppLocker_Restrictions
Étape 2 : Accéder aux paramètres AppLocker
Modifier la GPO > Configuration ordinateur > Stratégies > Paramètres Windows > Paramètres de sécurité > Stratégies de contrôle d'application > AppLocker
Étape 3 : Configurer les propriétés AppLocker
Clic droit sur AppLocker > Propriétés
Onglet Application :
- Cocher les collections à activer :
- ☑ Exécutables
- ☑ Scripts Windows
- ☑ Programmes d'installation Windows
- ☐ DLL (décoché sauf besoin spécifique)
- ☑ Applications empaquetées
Pour chaque collection cochée :
- Sélectionner : Configuré
- Choisir le mode :
- Audit uniquement : Enregistre les blocages sans les appliquer (recommandé initialement)
- Appliquer les règles : Bloque réellement les applications
Étape 4 : Créer des règles
Exemple 1 : Bloquer l'accès à cmd.exe pour les utilisateurs standard
- Exécutables > Clic droit > Créer une règle
- Permissions : Refuser
- Utilisateur ou groupe : Utilisateurs (BUILTIN\Users)
- Conditions : Chemin d'accès
- Chemin :
%SYSTEM32%\cmd.exe - Nom : Bloquer CMD pour utilisateurs standards
- Description : "Empêche l'exécution de l'invite de commandes pour les non-admins"
- Créer
Exemple 2 : Autoriser uniquement les applications Microsoft
- Exécutables > Créer une règle
- Permissions : Autoriser
- Utilisateur ou groupe : Tous
- Conditions : Éditeur
- Parcourir > Sélectionner un fichier signé Microsoft (ex: C:\Windows\notepad.exe)
- Curseur de granularité : Déplacer vers le haut jusqu'à "Éditeur" uniquement
Éditeur : O=MICROSOFT CORPORATION, L=REDMOND, S=WASHINGTON, C=US
- Nom : Autoriser applications Microsoft
- Créer
Exemple 3 : Bloquer un malware spécifique par hash
- Exécutables > Créer une règle
- Permissions : Refuser
- Utilisateur ou groupe : Tous
- Conditions : Hachage de fichier
- Parcourir > Sélectionner le fichier malveillant (si disponible en quarantaine)
- Nom : Bloquer malware XYZ
- Créer
Étape 5 : Créer des exceptions
Les exceptions permettent d'affiner les règles.
Scénario : Autoriser tous les exécutables dans C:\Program Files SAUF une application spécifique.
- Créer la règle principale : Autoriser
C:\Program Files\* - Dans cette règle, onglet Exceptions
- Ajouter une exception :
- Type : Chemin
- Chemin :
C:\Program Files\ApplicationBloquee\*
Résultat : Tout autorisé dans Program Files sauf ApplicationBloquee.
Étape 6 : Démarrer le service Identité de l'application
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 : Automatique
Ou via script (à déployer sur les postes) :
Set-Service -Name AppIDSvc -StartupType Automatic
Start-Service -Name AppIDSvc
Étape 7 : Lier la GPO et tester
- Lier la GPO à l'OU des postes de travail
- Sur un poste client :
gpupdate /force - Vérifier l'application des règles :
Get-AppLockerPolicy -Effective -Xml | Out-File C:\EffectivePolicy.xml
notepad C:\EffectivePolicy.xml
Mode Audit (Recommandé avant déploiement)
Pourquoi utiliser le mode Audit ?
- Identifier les applications légitimes qui seraient bloquées
- Éviter de perturber la productivité des utilisateurs
- Affiner les règles avant l'application réelle
Configuration :
- AppLocker > Propriétés
- Pour chaque collection : Sélectionner Audit uniquement
- Laisser tourner pendant 1-2 semaines
Analyser les journaux :
Observateur d'événements > Journaux des applications et services > Microsoft > Windows > AppLocker
Journaux par collection :
- EXE and DLL : Événements pour exécutables et DLL
- MSI and Script : Événements pour installateurs et scripts
- Packaged app-Deployment : Événements pour applications empaquetées
É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" -NoTypeInformation
Analyse des résultats :
- Identifier les applications légitimes fréquemment bloquées
- Créer des règles d'exception pour ces applications
- Vérifier qu'aucune application critique n'est impactée
- Passer en mode "Appliquer les règles" après validation
Création de règles AppLocker via PowerShell
Avantages :
- Automatisation du déploiement
- Gestion en masse de règles
- Intégration dans des scripts de configuration
Exemples de commandes :
1. Créer une règle d'éditeur
# 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
2. Créer une règle de chemin
# 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
3. Créer une règle de hachage
# 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
4. Générer automatiquement des règles basées sur un dossier
# 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
5. Exporter et importer des stratégies
# 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"
6. Vérifier les règles appliquées
# 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
- Créer une règle d'autorisation pour BUILTIN\Administrateurs
Scénario 2 : Autoriser uniquement les applications du Microsoft Store
Objectif : Environnement verrouillé pour postes publics
Configuration :
- Applications empaquetées > Créer les règles par défaut
- Exécutables > Créer une règle
- Autoriser : %WINDIR%*
- Autoriser : %PROGRAMFILES%\WindowsApps*
- Refuser : * (pour tout le reste)
Scénario 3 : Bloquer les ransomwares connus
Objectif : Protection contre les variantes de ransomware
Configuration :
- Maintenir une liste de hashes de ransomware connus
- Créer des règles de hash pour chaque variante
- Automatiser avec un script de mise à jour hebdomadaire
# 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
}
Scénario 4 : Autoriser une application métier non signée
Objectif : Permettre l'exécution d'une application développée en interne
Configuration :
- Exécutables > Créer une règle
- Permissions : Autoriser
- Groupe : Groupe_Utilisateurs_AppMetier
- Condition : Chemin
- Chemin :
C:\Applications\AppMetier\*
⚠️ Sécurité : S'assurer que les utilisateurs n'ont pas de droits d'écriture sur ce dossier.
Dépannage AppLocker
Problème 1 : Les règles ne s'appliquent pas
Vérifications :
- Le service "Identité de l'application" est-il démarré ?
Get-Service AppIDSvc
Start-Service AppIDSvc
- La GPO est-elle bien liée et appliquée ?
gpresult /h gpresult.html
- Les règles sont-elles configurées en mode "Appliquer" et non "Audit" ?
Get-AppLockerPolicy -Effective
- Forcer la mise à jour des stratégies
gpupdate /force
Problème 2 : Une application légitime est bloquée
Solution immédiate :
- Identifier l'application dans les journaux AppLocker
- Créer une exception temporaire via règle de chemin
- Planifier une règle d'éditeur permanente
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
Surveillance et rapports
Requêtes PowerShell utiles
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 -AutoSize
2. 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 -AutoSize
3. 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"
}
Intégration avec d'autres technologies
AppLocker + Windows Defender Application Control (WDAC)
- AppLocker : Contrôle au niveau utilisateur
- WDAC : Contrôle au niveau noyau (plus profond)
- Utiliser ensemble pour une défense en profondeur
AppLocker + Antivirus
- AppLocker bloque les exécutions non autorisées
- Antivirus détecte et supprime les malwares
- Complémentaires, pas redondants
AppLocker + Pare-feu
- AppLocker : Empêche l'exécution
- Pare-feu : Empêche la communication réseau
- Exemple : Bloquer une backdoor même si elle arrive à s'exécuter
Bonnes pratiques
✅ Recommandations :
- Commencer en mode Audit pendant 2-4 semaines minimum
- Utiliser des règles d'éditeur en priorité (plus robustes)
- Créer des exceptions plutôt que des règles trop complexes
- Documenter chaque règle et sa justification
- Tester sur un groupe pilote avant déploiement global
- Surveiller les journaux régulièrement
- Former les utilisateurs sur les raisons des blocages
- Établir un processus d'approbation d'applications
- Ne pas activer les règles DLL sauf exigence spécifique
- Automatiser la génération de rapports
❌ À éviter :
- Déployer directement en mode "Appliquer" sans audit préalable
- Créer trop de règles de hash (difficiles à maintenir)
- Bloquer des applications sans alternative
- Ignorer les demandes d'exception des utilisateurs
- Oublier de démarrer le service "Identité de l'application"
- Utiliser uniquement des règles de chemin (facilement contournables)
- Ne pas surveiller les journaux AppLocker
Limites d'AppLocker
Ce qu'AppLocker NE fait PAS :
- ❌ Ne protège pas contre les exploits de vulnérabilités
- ❌ Ne remplace pas un antivirus
- ❌ Ne peut pas bloquer les macros Office (utiliser les paramètres Office)
- ❌ Ne protège pas contre les attaques fileless
- ❌ Peut être contourné par des techniques avancées (si l'attaquant a des privilèges admin)
Solutions complémentaires :
- Windows Defender Application Control (WDAC) pour une protection plus profonde
- Attack Surface Reduction (ASR) rules
- Exploit Protection
- Controlled Folder Access (protection ransomware)
6. Mise en place de la délégation
Introduction à la délégation
Qu'est-ce que la délégation ?
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.
Pourquoi déléguer ?
Avantages :
- ✅ Réduction des risques : Moins de comptes avec privilèges complets
- ✅ Distribution des responsabilités : Le help desk peut réinitialiser les mots de passe sans accès complet à AD
- ✅ Efficacité opérationnelle : Les tâches courantes ne nécessitent pas un administrateur de domaine
- ✅ Conformité : Respect des normes de sécurité (ISO 27001, SOC 2)
- ✅ Audit : Traçabilité des actions (qui fait quoi)
Scénarios courants :
- Support niveau 1 : Réinitialisation de mots de passe
- Support niveau 2 : Activation/désactivation de comptes
- Gestionnaires RH : Création d'utilisateurs dans leur département
- Administrateurs de sites : Gestion des ordinateurs de leur site
- Gestionnaires d'impression : Administration des imprimantes
Méthodes de délégation
1. Assistant Délégation de contrôle (Recommandé pour les débutants)
- Interface graphique intuitive
- Tâches courantes prédéfinies
- Accessible depuis Users and Computers
2. Attribution manuelle d'ACL (Pour les besoins avancés)
- Contrôle granulaire total
- Utilisation de l'onglet "Sécurité" avancé
- Nécessite une bonne compréhension des permissions AD
3. Utilisation de groupes intégrés
- Account Operators
- Server Operators
- Print Operators
- Backup Operators
- ⚠️ Attention : Ces groupes ont parfois plus de privilèges que nécessaire
4. Rôles RBAC (Role-Based Access Control) via PowerShell
- Création de groupes par rôle
- Attribution de permissions via scripts
- Facilite la gestion à grande échelle
6.1 Délégation dans Active Directory
Préparation de la délégation
Étape 1 : Planification
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 |
Étape 2 : Créer les groupes de délégation
# 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"
Étape 3 : Ajouter les utilisateurs aux groupes
# 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
- Activer les fonctionnalités avancées
- Menu Affichage > Cocher Fonctionnalités avancées
- Sélectionner l'OU source et destination
- Les utilisateurs pourront déplacer des objets DEPUIS et VERS ces OU
- Exemple : OU=Employees et toutes ses sous-OU
- Lancer l'assistant de délégation
- Clic droit sur l'OU (ex: OU=Employees)
- Déléguer le contrôle...
- Sélectionner les utilisateurs ou groupes
- Ajouter...
- Entrer :
GRP_Support_N2 - OK
- Suivant
- Sélectionner la tâche personnalisée
- ☑ Créer une tâche personnalisée à déléguer
- Suivant
- Type d'objet Active Directory
- ☑ Objets Utilisateur uniquement
- Suivant
- Permissions à accorder
- Dans la liste "Permissions", cocher :
- ☐ Général
- ☑ Spécifique à une propriété
- Faire défiler et cocher :
- ☑ Lire toutes les propriétés
- ☑ Écrire toutes les propriétés (nécessaire pour mettre à jour le distinguished name)
- Suivant
- Terminer
- Dans la liste "Permissions", cocher :
- Répéter pour l'OU de destination
- Si les utilisateurs doivent être déplacés vers une autre OU spécifique, répéter l'opération sur cette OU également
Méthode 2 : Attribution manuelle d'ACL (Avancée)
Via 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 permissions
Vérifier les permissions accordées :
dsacls "OU=Employees,DC=entreprise,DC=local"
Méthode 3 : PowerShell
# 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 Green
Test de la délégation
Tester avec un compte membre du groupe délégué :
- Ouvrir une session en tant qu'utilisateur membre de GRP_Support_N2
- Ouvrir Active Directory Users and Computers
- Essayer de déplacer un utilisateur :
- Clic droit sur un utilisateur dans OU=Employees
- Déplacer...
- Sélectionner une OU de destination
- OK
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
- Lancer l'assistant sur l'OU concernée
- Clic droit sur OU=Employees
- Déléguer le contrôle...
- Sélectionner le groupe
- Ajouter... >
GRP_Support_N2 - Suivant
- Ajouter... >
- Sélectionner les tâches à déléguer
- ☑ Créer, supprimer et gérer les comptes d'utilisateur
- Décocher "Créer, supprimer et gérer..."
- Descendre dans la liste et cocher uniquement :
- ☑ Activer/désactiver, supprimer et réinitialiser les mots de passe des comptes d'utilisateur
- Suivant
- Terminer
Méthode 2 : Permissions spécifiques (Plus granulaire)
Via l'interface graphique :
- Activer les fonctionnalités avancées
- ADUC > Affichage > Fonctionnalités avancées
- Accéder aux propriétés de l'OU
- Clic droit sur OU=Employees > Propriétés
- Onglet Sécurité > Avancé
- Ajouter une nouvelle entrée
- Ajouter
- Sélectionner un principal >
GRP_Support_N2> OK
- Configurer les permissions
- Type : Autoriser
- S'applique à : Objets Utilisateur descendants
- Dans la liste des permissions, cocher :
- ☑ Lire toutes les propriétés
- ☑ Écrire userAccountControl (permet d'activer/désactiver)
- OK > Appliquer > OK
Méthode 3 : PowerShell
# 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 Green
Test de la délégation
Via interface graphique :
- Se connecter avec un compte membre de GRP_Support_N2
- Ouvrir ADUC
- Clic droit sur un utilisateur > Désactiver le compte
- Vérifier que l'opération réussit
- Clic droit > Activer le compte
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
6.1.3 Réinitialisation de mot de passe
Objectif : Permettre au help desk de réinitialiser les mots de passe utilisateurs (tâche la plus fréquente).
Méthode 1 : Assistant Délégation de contrôle
Étapes :
- Lancer l'assistant
- ADUC > Clic droit sur OU=Employees
- Déléguer le contrôle...
- Sélectionner le groupe
- Ajouter... >
GRP_Support_N1 - Suivant
- Ajouter... >
- Sélectionner la tâche courante
- ☑ Réinitialiser les mots de passe utilisateur et forcer la modification du mot de passe à la prochaine ouverture de session
- Suivant
- Terminer
Méthode 2 : PowerShell (Recommandé pour automatisation)
# 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 Green
Vérifier les permissions accordées
Via 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 -AutoSize
Test de la délégation
Via interface graphique :
- Se connecter avec un compte membre de GRP_Support_N1
- Ouvrir ADUC
- Clic droit sur un utilisateur > Réinitialiser le mot de passe...
- Entrer le nouveau mot de passe
- ☑ L'utilisateur doit changer le mot de passe à la prochaine ouverture de session
- OK
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 Green
Script de réinitialisation pour le help desk
Cré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.msc
OU
Gestionnaire de serveur > Outils > Gestion de l'impression
Étape 2 : Déléguer la gestion d'une imprimante spécifique
Permissions sur une imprimante :
- Développer le serveur d'impression
- Serveurs d'impression > [NomServeur] > Imprimantes
- Propriétés de l'imprimante
- Clic droit sur l'imprimante > Propriétés
- Onglet Sécurité
- Ajouter le groupe de délégation
- Ajouter...
- Entrer :
GRP_Admin_Impression - OK
- Accorder les permissions
- Sélectionner
GRP_Admin_Impression - Cocher les permissions nécessaires :
- ☐ Imprimer
- ☑ Gérer cette imprimante (pour configuration complète)
- ☑ Gérer les documents (pour gérer les travaux)
- Appliquer > OK
- Sélectionner
Étape 3 : Déléguer la gestion du serveur d'impression complet
Permissions sur le serveur :
- Propriétés du serveur d'impression
- Dans la console Gestion de l'impression
- Clic droit sur le serveur > Propriétés
- Onglet Sécurité
- Ajouter le groupe
- Ajouter... >
GRP_Admin_Impression> OK
- Ajouter... >
- Définir les permissions
- Cocher :
- ☑ Gérer les imprimantes (permet de créer, modifier, supprimer des imprimantes)
- ☑ Gérer les documents (permet de gérer tous les travaux)
- Appliquer > OK
- Cocher :
Étape 4 : Déléguer via les groupes locaux (Alternative)
Sur 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 :
- Gérer les imprimantes du serveur
- Gérer les pilotes d'imprimante
- Partager des imprimantes
- ❌ Ne permet PAS d'administrer le serveur lui-même
Délégation via PowerShell
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 Green
Fonction 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"
Test de la délégation
Tester avec un compte membre du groupe délégué :
- Se connecter avec le compte délégué
- Ouvrir la Gestion de l'impression
- Tenter de :
- Mettre en pause/reprendre une imprimante
- Modifier les propriétés d'une imprimante
- Annuler un travail d'impression d'un autre utilisateur
- Créer un nouveau partage d'imprimante
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 $cred
Gestion des travaux d'impression
Script 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
- Tester avant de déployer
- Créer un environnement de test
- Valider avec les utilisateurs finaux
- Vérifier qu'aucune permission excessive n'est accordée
- Auditer régulièrement
# 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
- Séparer les rôles
- Support N1 : Reset MDP uniquement
- Support N2 : Reset MDP + activation/désactivation
- RH : Création d'utilisateurs dans leur département uniquement
- Admins locaux : Gestion des ordinateurs de leur site
- Utiliser des OU dédiées
- Créer des OU par département/site
- Déléguer la gestion sur ces OU spécifiques
- Évite les délégations trop larges
- Former les utilisateurs délégués
- Expliquer les limites de leurs permissions
- Documenter les procédures
- Établir un processus d'escalade
❌ À éviter :
- Ajouter des utilisateurs au groupe "Admins du domaine" pour faciliter la gestion
- Déléguer des permissions sur la racine du domaine
- Utiliser des comptes utilisateurs individuels dans les ACL
- Oublier de documenter les délégations
- Ne jamais auditer les permissions accordées
- Accorder des permissions "Contrôle total" quand des permissions spécifiques suffisent
Audit et surveillance des délégations
Script d'audit complet
# 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
Conclusion des notes de cours
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 :
- ✅ Stratégies par défaut - Compréhension et gestion des GPO de base
- ✅ Audit de sécurité - Configuration et analyse des journaux d'événements
- ✅ Gestion avancée - PSO, modèles de sécurité, comparaison de configurations
- ✅ UAC et AppLocker - Contrôle d'accès et d'exécution des applications
- ✅ Délégation - Distribution sécurisée des responsabilités administratives
Points clés à retenir :
- La sécurité est un processus continu, pas une destination
- Le principe du moindre privilège doit guider toutes les décisions
- L'audit et la surveillance sont essentiels pour détecter les anomalies
- La documentation est cruciale pour la maintenabilité