ID d'événement Windows 4764 – Microsoft-Windows-Security-Auditing : Membre du groupe ajouté

Commencez par examiner les détails spécifiques de l'événement pour comprendre quel changement d'appartenance à un groupe a eu lieu et qui l'a initié.

1. Ouvrez Observateur d'événements en appuyant sur Win + R, en tapant eventvwr.msc, et en appuyant sur Entrée
2. Accédez à Journaux Windows → Sécurité
3. Filtrez pour l'ID d'événement 4764 en cliquant avec le bouton droit sur le journal Sécurité et en sélectionnant Filtrer le journal actuel
4. Entrez 4764 dans le champ ID d'événements et cliquez sur OK
5. Double-cliquez sur un événement 4764 pour voir des informations détaillées incluant :
   • Sujet : Qui a effectué l'action (nom du compte et SID)
   • Membre : Quel utilisateur a été ajouté au groupe
   • Groupe : Nom du groupe cible et SID
   • Privilèges : Privilèges de sécurité utilisés pour l'opération
6. Notez l'horodatage et corrélez avec d'autres activités administratives
7. Vérifiez la section Informations sur le processus pour identifier quelle application ou outil a été utilisé

Utilisez PowerShell pour rechercher et analyser efficacement les occurrences de l'ID d'événement 4764 dans votre environnement.

1. Ouvrez PowerShell en tant qu'administrateur
2. Interrogez les ajouts récents de membres de groupe :

   Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4764} -MaxEvents 50 | Select-Object TimeCreated, Id, @{Name='Message';Expression={$_.Message.Split('`n')[0..10] -join '`n'}}

3. Filtrez les événements pour des groupes spécifiques (remplacez 'Domain Admins' par votre groupe cible) :

   Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4764} | Where-Object {$_.Message -like '*Domain Admins*'} | Select-Object TimeCreated, @{Name='Details';Expression={$_.Message}}

4. Extrayez des données structurées des événements :

   $Events = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4764} -MaxEvents 100
   foreach ($Event in $Events) {
       $XML = [xml]$Event.ToXml()
       $EventData = $XML.Event.EventData.Data
       [PSCustomObject]@{
           TimeCreated = $Event.TimeCreated
           SubjectUserName = ($EventData | Where-Object {$_.Name -eq 'SubjectUserName'}).'#text'
           MemberName = ($EventData | Where-Object {$_.Name -eq 'MemberName'}).'#text'
           GroupName = ($EventData | Where-Object {$_.Name -eq 'GroupName'}).'#text'
       }
   }

5. Exportez les résultats pour analyse :

   Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4764} -MaxEvents 1000 | Export-Csv -Path "C:\Temp\GroupMembershipChanges.csv" -NoTypeInformation

Assurez-vous de configurer correctement la politique d'audit pour capturer tous les changements d'appartenance aux groupes de manière cohérente.

1. Ouvrez Group Policy Management Console ou Local Group Policy Editor (gpedit.msc)
2. Accédez à Configuration de l'ordinateur → Stratégies → Paramètres Windows → Paramètres de sécurité → Configuration avancée de la stratégie d'audit
3. Développez Gestion des comptes et localisez Audit de la gestion des groupes de sécurité
4. Configurez la politique sur Succès et Échec pour une journalisation complète
5. Vérifiez les paramètres d'audit actuels via PowerShell :

   auditpol /get /category:"Account Management" /subcategory:"Security Group Management"

6. Appliquez les paramètres immédiatement en utilisant :

   gpupdate /force

7. Testez la configuration en ajoutant un utilisateur test à un groupe et en vérifiant que l'ID d'événement 4764 apparaît
8. Pour les environnements de domaine, configurez cette politique au niveau de l'OU des contrôleurs de domaine
9. Surveillez les changements de politique d'audit en utilisant l'ID d'événement 4719 pour détecter les modifications non autorisées

Configurez une surveillance proactive pour détecter et répondre aux changements critiques d'appartenance à des groupes en temps réel.

1. Créez un script PowerShell pour une surveillance continue :

   # Monitor-GroupChanges.ps1
   $SensitiveGroups = @('Domain Admins', 'Enterprise Admins', 'Schema Admins', 'Administrators')
   $LastCheck = (Get-Date).AddMinutes(-5)
   
   while ($true) {
       $Events = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4764; StartTime=$LastCheck} -ErrorAction SilentlyContinue
       
       foreach ($Event in $Events) {
           $XML = [xml]$Event.ToXml()
           $GroupName = ($XML.Event.EventData.Data | Where-Object {$_.Name -eq 'GroupName'}).'#text'
           
           if ($SensitiveGroups -contains $GroupName) {
               # Envoyer une alerte - personnaliser la méthode de notification
               Write-Host "ALERTE : Utilisateur ajouté à $GroupName à $($Event.TimeCreated)" -ForegroundColor Red
               # Ajouter une notification par email, intégration SIEM, etc.
           }
       }
       
       $LastCheck = Get-Date
       Start-Sleep -Seconds 300  # Vérifier toutes les 5 minutes
   }

2. Configurez le Planificateur de tâches Windows pour exécuter le script de surveillance :

   $Action = New-ScheduledTaskAction -Execute "PowerShell.exe" -Argument "-File C:\Scripts\Monitor-GroupChanges.ps1"
   $Trigger = New-ScheduledTaskTrigger -AtStartup
   $Principal = New-ScheduledTaskPrincipal -UserId "SYSTEM" -LogonType ServiceAccount
   Register-ScheduledTask -TaskName "GroupMembershipMonitor" -Action $Action -Trigger $Trigger -Principal $Principal

3. Configurez les abonnements au journal des événements pour une collecte centralisée :

   <Subscription xmlns="http://schemas.microsoft.com/2006/03/windows/events/subscription">
       <SubscriptionId>GroupMembershipChanges</SubscriptionId>
       <Query>
           <![CDATA[
           <QueryList>
               <Query Id="0">
                   <Select Path="Security">*[System[EventID=4764]]</Select>
               </Query>
           </QueryList>
           ]]>
       </Query>
   </Subscription>

4. Configurez l'intégration SIEM en utilisant le transfert d'événements Windows ou l'envoi direct de journaux

Effectuer une analyse médico-légale détaillée pour enquêter sur les changements suspects d'appartenance à des groupes et établir des chronologies complètes des attaques.

1. Collecter les événements liés pour une analyse complète:

   # Collecter tous les événements de gestion de groupe
   $StartTime = (Get-Date).AddDays(-7)
   $GroupEvents = @(4728, 4729, 4732, 4733, 4756, 4757, 4764, 4765)
   
   $AllEvents = foreach ($EventId in $GroupEvents) {
       Get-WinEvent -FilterHashtable @{LogName='Security'; Id=$EventId; StartTime=$StartTime} -ErrorAction SilentlyContinue
   }
   
   $AllEvents | Sort-Object TimeCreated | Export-Csv -Path "C:\Temp\GroupManagementTimeline.csv" -NoTypeInformation

2. Corréler avec les événements de connexion pour établir le contexte utilisateur:

   # Trouver les sessions de connexion liées aux changements de groupe
   $LogonEvents = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4624; StartTime=$StartTime}
   $GroupChangeEvents = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4764; StartTime=$StartTime}
   
   foreach ($GroupEvent in $GroupChangeEvents) {
       $XML = [xml]$GroupEvent.ToXml()
       $LogonId = ($XML.Event.EventData.Data | Where-Object {$_.Name -eq 'SubjectLogonId'}).'#text'
       
       $RelatedLogon = $LogonEvents | Where-Object {
           $LogonXML = [xml]$_.ToXml()
           ($LogonXML.Event.EventData.Data | Where-Object {$_.Name -eq 'TargetLogonId'}).'#text' -eq $LogonId
       } | Select-Object -First 1
       
       if ($RelatedLogon) {
           Write-Host "Changement de groupe à $($GroupEvent.TimeCreated) lié à la connexion à $($RelatedLogon.TimeCreated)"
       }
   }

3. Analyser le contexte d'exécution des processus:

   # Extraire les informations de processus des événements
   Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4764} -MaxEvents 100 | ForEach-Object {
       $XML = [xml]$_.ToXml()
       $ProcessName = ($XML.Event.EventData.Data | Where-Object {$_.Name -eq 'ProcessName'}).'#text'
       $ProcessId = ($XML.Event.EventData.Data | Where-Object {$_.Name -eq 'ProcessId'}).'#text'
       
       [PSCustomObject]@{
           TimeCreated = $_.TimeCreated
           ProcessName = $ProcessName
           ProcessId = $ProcessId
           GroupName = ($XML.Event.EventData.Data | Where-Object {$_.Name -eq 'GroupName'}).'#text'
       }
   } | Group-Object ProcessName | Sort-Object Count -Descending

4. Générer un rapport médico-légal complet:

   # Créer un rapport d'analyse détaillé
   $Report = @"
   Rapport d'analyse des changements d'appartenance à des groupes
   Généré: $(Get-Date)
   
   Résumé des changements (7 derniers jours):
   "@
   
   $GroupStats = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4764; StartTime=(Get-Date).AddDays(-7)} | 
       Group-Object @{Expression={([xml]$_.ToXml()).Event.EventData.Data | Where-Object {$_.Name -eq 'GroupName'} | Select-Object -ExpandProperty '#text'}} | 
       Sort-Object Count -Descending
   
   foreach ($Stat in $GroupStats) {
       $Report += "`n$($Stat.Name): $($Stat.Count) ajouts"
   }
   
   $Report | Out-File -FilePath "C:\Temp\GroupChangeAnalysis.txt"