ID d'événement Windows 5143 – Microsoft-Windows-Security-Auditing : L'objet de partage réseau a été accédé

Commencez par examiner les détails spécifiques de l'ID d'événement 5143 pour comprendre le modèle d'accès et identifier la source.

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 le journal en cliquant sur Filtrer le journal actuel dans le volet Actions
4. Entrez 5143 dans le champ ID d'événements et cliquez sur OK
5. Double-cliquez sur une entrée récente de l'ID d'événement 5143 pour voir les détails
6. Examinez les champs clés dans la description de l'événement:
   • Sujet: Compte utilisateur et SID faisant la demande
   • Objet: Nom du partage et informations sur le serveur
   • Informations sur le processus: Application initiant l'accès
   • Informations réseau: Adresse IP source et port
   • Informations sur la demande d'accès: Permissions demandées et masque d'accès
7. Notez l'horodatage et corrélez avec l'activité de l'utilisateur ou les processus système
8. Vérifiez si l'accès a réussi en recherchant des indicateurs de succès/échec correspondants

Utilisez PowerShell pour analyser les modèles d'ID d'événement 5143 et identifier les comportements d'accès inhabituels ou les sources à haute fréquence.

1. Ouvrez PowerShell en tant qu'administrateur
2. Interrogez les entrées récentes de l'ID d'événement 5143 :

   Get-WinEvent -FilterHashtable @{LogName='Security'; Id=5143} -MaxEvents 100 | Format-Table TimeCreated, Id, LevelDisplayName, Message -Wrap

3. Analysez les modèles d'accès par compte utilisateur :

   $events = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=5143} -MaxEvents 1000
   $events | ForEach-Object {
       $xml = [xml]$_.ToXml()
       [PSCustomObject]@{
           TimeCreated = $_.TimeCreated
           UserName = $xml.Event.EventData.Data | Where-Object {$_.Name -eq 'SubjectUserName'} | Select-Object -ExpandProperty '#text'
           ShareName = $xml.Event.EventData.Data | Where-Object {$_.Name -eq 'ObjectName'} | Select-Object -ExpandProperty '#text'
           SourceIP = $xml.Event.EventData.Data | Where-Object {$_.Name -eq 'IpAddress'} | Select-Object -ExpandProperty '#text'
       }
   } | Group-Object UserName | Sort-Object Count -Descending

4. Identifiez les partages les plus accédés :

   $events | ForEach-Object {
       $xml = [xml]$_.ToXml()
       $xml.Event.EventData.Data | Where-Object {$_.Name -eq 'ObjectName'} | Select-Object -ExpandProperty '#text'
   } | Group-Object | Sort-Object Count -Descending | Select-Object -First 10

5. Filtrez les événements par plage horaire spécifique :

   $startTime = (Get-Date).AddHours(-24)
   $endTime = Get-Date
   Get-WinEvent -FilterHashtable @{LogName='Security'; Id=5143; StartTime=$startTime; EndTime=$endTime}

6. Exportez les résultats en CSV pour une analyse plus approfondie :

   $events | Export-Csv -Path "C:\Temp\ShareAccess_5143.csv" -NoTypeInformation

Configurez correctement l'audit d'accès aux objets pour garantir que l'ID d'événement 5143 est généré avec des niveaux de détail appropriés.

1. Ouvrez Stratégie de sécurité locale en exécutant secpol.msc ou utilisez la gestion des stratégies de groupe pour les environnements de domaine
2. Accédez à Paramètres de sécurité → Stratégies locales → Stratégie d'audit
3. Double-cliquez sur Audit de l'accès aux objets
4. Activez l'audit pour Succès et Échec
5. Pour un contrôle plus granulaire, utilisez la stratégie d'audit avancée :

   auditpol /set /subcategory:"File Share" /success:enable /failure:enable

6. Vérifiez les paramètres d'audit actuels :

   auditpol /get /subcategory:"File Share"

7. Configurez l'audit de partage spécifique à l'aide de PowerShell :

   # Activer l'audit sur un partage spécifique
   $shareName = "SharedDocs"
   $share = Get-SmbShare -Name $shareName
   Set-SmbShare -Name $shareName -FolderEnumerationMode AccessBased

8. Configurez les listes de contrôle d'accès système (SACL) pour un audit détaillé de l'accès aux fichiers :

   # Configurer SACL pour un dossier partagé
   $folderPath = "C:\SharedDocs"
   $auditRule = New-Object System.Security.AccessControl.FileSystemAuditRule("Everyone", "FullControl", "ContainerInherit,ObjectInherit", "None", "Success,Failure")
   $acl = Get-Acl $folderPath
   $acl.SetAuditRule($auditRule)
   Set-Acl -Path $folderPath -AclObject $acl

9. Testez la configuration en accédant au partage et en vérifiant la génération de l'ID d'événement 5143

Configurez la surveillance et le filtrage automatisés pour l'ID d'événement 5143 afin de gérer les environnements à fort volume et de détecter les incidents de sécurité.

1. Créez une vue personnalisée dans l'Observateur d'événements pour une surveillance ciblée:
   • Dans l'Observateur d'événements, cliquez avec le bouton droit sur Vues personnalisées et sélectionnez Créer une vue personnalisée
   • Sélectionnez Par journal et choisissez Sécurité
   • Entrez 5143 dans le champ ID d'événements
   • Ajoutez des filtres supplémentaires comme des utilisateurs spécifiques ou des plages horaires
   • Enregistrez la vue avec un nom descriptif comme "Surveillance d'accès partagé"
2. Configurez le transfert d'événements Windows (WEF) pour la journalisation centralisée:

   # Sur le serveur collecteur
   wecutil qc /q
   # Créer un abonnement pour l'ID d'événement 5143
   wecutil cs ShareAccessSubscription.xml

3. Configurez un script de surveillance basé sur PowerShell:

   # Surveiller les modèles d'accès partagé suspects
   $suspiciousIPs = @("192.168.1.100", "10.0.0.50")
   $events = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=5143} -MaxEvents 50
   
   foreach ($event in $events) {
       $xml = [xml]$event.ToXml()
       $sourceIP = $xml.Event.EventData.Data | Where-Object {$_.Name -eq 'IpAddress'} | Select-Object -ExpandProperty '#text'
       
       if ($sourceIP -in $suspiciousIPs) {
           Write-Warning "Accès suspect depuis $sourceIP à $($event.TimeCreated)"
           # Envoyer une alerte ou enregistrer dans le SIEM
       }
   }

4. Configurez le Planificateur de tâches pour la surveillance automatisée:

   # Créer une tâche planifiée pour exécuter le script de surveillance
   $action = New-ScheduledTaskAction -Execute "PowerShell.exe" -Argument "-File C:\Scripts\MonitorShareAccess.ps1"
   $trigger = New-ScheduledTaskTrigger -Once -At (Get-Date) -RepetitionInterval (New-TimeSpan -Minutes 15)
   $principal = New-ScheduledTaskPrincipal -UserId "SYSTEM" -LogonType ServiceAccount
   Register-ScheduledTask -TaskName "ShareAccessMonitor" -Action $action -Trigger $trigger -Principal $principal

5. Implémentez la rotation et l'archivage des journaux:

   # Configurer la taille et la rétention du journal de sécurité
   Limit-EventLog -LogName Security -MaximumSize 512MB -OverflowAction OverwriteAsNeeded

Effectuer une analyse médico-légale détaillée de l'ID d'événement 5143 pour les enquêtes de sécurité et les rapports de conformité.

1. Exporter les journaux de sécurité pour une analyse hors ligne:

   # Exporter le journal de sécurité avec l'ID d'événement 5143 au format EVTX
   wevtutil epl Security C:\Forensics\Security_5143_$(Get-Date -Format 'yyyyMMdd').evtx "/q:*[System[(EventID=5143)]]"
   
   # Convertir en CSV pour les outils d'analyse
   Get-WinEvent -Path "C:\Forensics\Security_5143_*.evtx" | Export-Csv -Path "C:\Forensics\ShareAccess_Analysis.csv" -NoTypeInformation

2. Corréler avec d'autres événements de sécurité pour une chronologie complète:

   # Corréler l'ID d'événement 5143 avec les événements de connexion (4624, 4625)
   $timeWindow = (Get-Date).AddHours(-2)
   $shareEvents = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=5143; StartTime=$timeWindow}
   $logonEvents = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4624,4625; StartTime=$timeWindow}
   
   # Créer une chronologie de corrélation
   $correlatedEvents = @()
   foreach ($shareEvent in $shareEvents) {
       $xml = [xml]$shareEvent.ToXml()
       $userName = $xml.Event.EventData.Data | Where-Object {$_.Name -eq 'SubjectUserName'} | Select-Object -ExpandProperty '#text'
       $sourceIP = $xml.Event.EventData.Data | Where-Object {$_.Name -eq 'IpAddress'} | Select-Object -ExpandProperty '#text'
       
       $relatedLogon = $logonEvents | Where-Object {
           $logonXml = [xml]$_.ToXml()
           $logonUser = $logonXml.Event.EventData.Data | Where-Object {$_.Name -eq 'TargetUserName'} | Select-Object -ExpandProperty '#text'
           $logonIP = $logonXml.Event.EventData.Data | Where-Object {$_.Name -eq 'IpAddress'} | Select-Object -ExpandProperty '#text'
           
           $logonUser -eq $userName -and $logonIP -eq $sourceIP -and 
           [Math]::Abs(($_.TimeCreated - $shareEvent.TimeCreated).TotalMinutes) -lt 30
       }
       
       if ($relatedLogon) {
           $correlatedEvents += [PSCustomObject]@{
               ShareAccessTime = $shareEvent.TimeCreated
               LogonTime = $relatedLogon.TimeCreated
               UserName = $userName
               SourceIP = $sourceIP
               ShareName = $xml.Event.EventData.Data | Where-Object {$_.Name -eq 'ObjectName'} | Select-Object -ExpandProperty '#text'
           }
       }
   }

3. Générer des rapports de conformité:

   # Créer un rapport d'accès détaillé pour la conformité
   $reportData = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=5143} -MaxEvents 10000 | ForEach-Object {
       $xml = [xml]$_.ToXml()
       [PSCustomObject]@{
           Timestamp = $_.TimeCreated
           EventID = $_.Id
           UserName = $xml.Event.EventData.Data | Where-Object {$_.Name -eq 'SubjectUserName'} | Select-Object -ExpandProperty '#text'
           UserDomain = $xml.Event.EventData.Data | Where-Object {$_.Name -eq 'SubjectDomainName'} | Select-Object -ExpandProperty '#text'
           ShareName = $xml.Event.EventData.Data | Where-Object {$_.Name -eq 'ObjectName'} | Select-Object -ExpandProperty '#text'
           SourceIP = $xml.Event.EventData.Data | Where-Object {$_.Name -eq 'IpAddress'} | Select-Object -ExpandProperty '#text'
           AccessMask = $xml.Event.EventData.Data | Where-Object {$_.Name -eq 'AccessMask'} | Select-Object -ExpandProperty '#text'
           ProcessName = $xml.Event.EventData.Data | Where-Object {$_.Name -eq 'ProcessName'} | Select-Object -ExpandProperty '#text'
       }
   }
   
   # Exporter au format compatible Excel
   $reportData | Export-Csv -Path "C:\Reports\ShareAccess_Compliance_$(Get-Date -Format 'yyyyMMdd').csv" -NoTypeInformation

4. Analyser les modèles d'accès pour la détection d'anomalies:

   # Détecter des modèles d'accès inhabituels
   $baselineHours = 24 * 7  # Baseline d'une semaine
   $baselineEvents = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=5143; StartTime=(Get-Date).AddHours(-$baselineHours)}
   
   # Calculer la fréquence d'accès normale par utilisateur
   $userBaseline = $baselineEvents | ForEach-Object {
       $xml = [xml]$_.ToXml()
       $xml.Event.EventData.Data | Where-Object {$_.Name -eq 'SubjectUserName'} | Select-Object -ExpandProperty '#text'
   } | Group-Object | ForEach-Object {
       [PSCustomObject]@{
           UserName = $_.Name
           AverageAccessPerHour = $_.Count / $baselineHours
       }
   }
   
   # Comparer l'heure actuelle avec la baseline
   $currentHourEvents = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=5143; StartTime=(Get-Date).AddHours(-1)}
   $currentHourAccess = $currentHourEvents | ForEach-Object {
       $xml = [xml]$_.ToXml()
       $xml.Event.EventData.Data | Where-Object {$_.Name -eq 'SubjectUserName'} | Select-Object -ExpandProperty '#text'
   } | Group-Object
   
   foreach ($user in $currentHourAccess) {
       $baseline = $userBaseline | Where-Object {$_.UserName -eq $user.Name}
       if ($baseline -and $user.Count -gt ($baseline.AverageAccessPerHour * 3)) {
           Write-Warning "Accès anormal détecté pour l'utilisateur $($user.Name): $($user.Count) accès dans la dernière heure (baseline: $([math]::Round($baseline.AverageAccessPerHour, 2)))"
       }
   }

5. Intégrer avec SIEM ou des outils de sécurité:

   # Envoyer des événements de haute priorité à SIEM via syslog
   function Send-SyslogMessage {
       param($Message, $Server, $Port = 514)
       $udpClient = New-Object System.Net.Sockets.UdpClient
       $bytes = [System.Text.Encoding]::UTF8.GetBytes($Message)
       $udpClient.Send($bytes, $bytes.Length, $Server, $Port)
       $udpClient.Close()
   }
   
   # Surveiller les accès en dehors des heures de travail
   $afterHoursEvents = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=5143; StartTime=(Get-Date).AddHours(-1)} | Where-Object {
       $hour = $_.TimeCreated.Hour
       $hour -lt 7 -or $hour -gt 19  # En dehors de 7h à 19h
   }
   
   foreach ($event in $afterHoursEvents) {
       $xml = [xml]$event.ToXml()
       $message = "ALERTE: Accès au partage en dehors des heures par $($xml.Event.EventData.Data | Where-Object {$_.Name -eq 'SubjectUserName'} | Select-Object -ExpandProperty '#text') à $($event.TimeCreated)"
       Send-SyslogMessage -Message $message -Server "siem.company.com"
   }