ID d'événement Windows 4625 – Microsoft-Windows-Security-Auditing : Échec de la connexion d'un compte

Commencez par examiner les détails spécifiques de l'échec dans le Visualiseur d'événements pour comprendre le contexte de l'échec d'authentification.

1. Ouvrez Visualiseur d'événements → Journaux Windows → Sécurité
2. Filtrez pour l'ID d'événement 4625 en utilisant Filtrer le journal actuel → IDs d'événements : 4625
3. Double-cliquez sur un événement 4625 récent pour voir les informations détaillées
4. Concentrez-vous sur ces champs critiques :
   • Nom du compte : Le compte qui a échoué à l'authentification
   • Raison de l'échec : Code d'erreur spécifique (0xC000006A = mauvais mot de passe, 0xC0000072 = compte désactivé)
   • Type de connexion : Méthode d'authentification (2=Interactive, 3=Réseau, 10=RemoteInteractive)
   • Adresse réseau source : Adresse IP de la tentative d'authentification
   • Nom de la station de travail : Nom de l'ordinateur d'où provient la tentative
5. Recoupez le code de sous-état avec la documentation Microsoft pour des raisons précises d'échec
6. Notez le modèle de timestamp pour identifier les séquences d'attaque potentielles

Utilisez PowerShell pour analyser les événements 4625 de manière programmatique et identifier les schémas suspects ou les échecs fréquents.

1. Interroger les échecs de connexion récents avec des informations détaillées :

   Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4625} -MaxEvents 100 | 
   Select-Object TimeCreated, @{Name='Account';Expression={$_.Properties[5].Value}}, 
   @{Name='SourceIP';Expression={$_.Properties[19].Value}}, 
   @{Name='FailureReason';Expression={$_.Properties[8].Value}} | 
   Format-Table -AutoSize

2. Identifier les comptes avec plusieurs échecs au cours des dernières 24 heures :

   $Events = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4625; StartTime=(Get-Date).AddDays(-1)}
   $FailuresByAccount = $Events | Group-Object {$_.Properties[5].Value} | 
   Sort-Object Count -Descending
   $FailuresByAccount | Select-Object Name, Count | Format-Table

3. Analyser les adresses IP sources pour identifier les sources potentielles d'attaque :

   $Events | Group-Object {$_.Properties[19].Value} | 
   Where-Object {$_.Count -gt 10} | 
   Sort-Object Count -Descending | 
   Select-Object Name, Count

4. Exporter l'analyse détaillée des échecs en CSV pour une enquête plus approfondie :

   Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4625; StartTime=(Get-Date).AddHours(-4)} | 
   ForEach-Object {
       [PSCustomObject]@{
           TimeCreated = $_.TimeCreated
           Account = $_.Properties[5].Value
           Domain = $_.Properties[6].Value
           SourceIP = $_.Properties[19].Value
           Workstation = $_.Properties[13].Value
           LogonType = $_.Properties[10].Value
           FailureReason = $_.Properties[8].Value
           SubStatus = $_.Properties[9].Value
       }
   } | Export-Csv -Path "C:\Temp\LogonFailures.csv" -NoTypeInformation

Optimisez les paramètres de la politique d'audit et mettez en œuvre une surveillance automatisée pour la détection proactive des incidents de sécurité.

1. Vérifiez la configuration actuelle de la politique d'audit :

   auditpol /get /category:"Logon/Logoff"

2. Activez l'audit détaillé des connexions si ce n'est pas déjà configuré :

   auditpol /set /subcategory:"Logon" /success:enable /failure:enable
   auditpol /set /subcategory:"Account Lockout" /success:enable /failure:enable

3. Configurez la taille du journal de sécurité pour gérer l'augmentation du volume d'événements :
   • Ouvrez Observateur d'événements → Journaux Windows → Sécurité
   • Cliquez avec le bouton droit sur Sécurité → Propriétés
   • Définissez la Taille maximale du journal à au moins 100 Mo pour les systèmes occupés
   • Configurez Archiver le journal lorsqu'il est plein pour la rétention
4. Créez une tâche planifiée pour la surveillance automatisée des échecs :

   $Action = New-ScheduledTaskAction -Execute "PowerShell.exe" -Argument "-File C:\Scripts\MonitorLogonFailures.ps1"
   $Trigger = New-ScheduledTaskTrigger -Daily -At "06:00"
   $Principal = New-ScheduledTaskPrincipal -UserId "SYSTEM" -LogonType ServiceAccount
   Register-ScheduledTask -TaskName "Monitor Logon Failures" -Action $Action -Trigger $Trigger -Principal $Principal

5. Mettez en œuvre une surveillance en temps réel avec Windows Event Forwarding (WEF) pour une collecte centralisée
6. Configurez des vues personnalisées dans l'Observateur d'événements pour une analyse rapide des échecs :
   • Créez Vues personnalisées → Créer une vue personnalisée
   • Filtrez par ID d'événement 4625 avec des codes de raison d'échec spécifiques
   • Enregistrez les vues pour différents types d'échecs (force brute, problèmes de compte, etc.)

Effectuer une enquête complète sur les incidents de sécurité lorsque les événements 4625 indiquent des attaques potentielles ou une compromission de compte.

1. Corréler les événements 4625 avec les événements de verrouillage de compte (4740):

   $StartTime = (Get-Date).AddHours(-2)
   $LockoutEvents = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4740; StartTime=$StartTime}
   $FailureEvents = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4625; StartTime=$StartTime}
   
   foreach ($Lockout in $LockoutEvents) {
       $Account = $Lockout.Properties[0].Value
       $RelatedFailures = $FailureEvents | Where-Object {$_.Properties[5].Value -eq $Account}
       Write-Host "Account $Account locked at $($Lockout.TimeCreated)"
       Write-Host "Related failures: $($RelatedFailures.Count)"
   }

2. Analyser les schémas d'authentification pour le compte affecté:

   $TargetAccount = "username"
   $Events = Get-WinEvent -FilterHashtable @{LogName='Security'; StartTime=(Get-Date).AddDays(-7)} | 
   Where-Object {($_.Id -eq 4624 -or $_.Id -eq 4625) -and $_.Properties[5].Value -eq $TargetAccount}
   
   $Events | Select-Object Id, TimeCreated, @{Name='Result';Expression={if($_.Id -eq 4624){"Success"}else{"Failure"}}}, 
   @{Name='SourceIP';Expression={$_.Properties[18].Value}} | 
   Sort-Object TimeCreated | Format-Table

3. Vérifier les connexions réussies immédiatement après les échecs (compromission potentielle):

   $Failures = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4625; StartTime=(Get-Date).AddHours(-1)}
   $Successes = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4624; StartTime=(Get-Date).AddHours(-1)}
   
   foreach ($Failure in $Failures) {
       $Account = $Failure.Properties[5].Value
       $FailureTime = $Failure.TimeCreated
       $SubsequentSuccess = $Successes | Where-Object {
           $_.Properties[5].Value -eq $Account -and 
           $_.TimeCreated -gt $FailureTime -and 
           $_.TimeCreated -lt $FailureTime.AddMinutes(10)
       }
       if ($SubsequentSuccess) {
           Write-Warning "Potential compromise: $Account failed at $FailureTime, succeeded at $($SubsequentSuccess.TimeCreated)"
       }
   }

4. Générer un rapport d'incident complet:

   $Report = @()
   $UniqueAccounts = (Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4625; StartTime=(Get-Date).AddDays(-1)} | 
       Group-Object {$_.Properties[5].Value}).Name
   
   foreach ($Account in $UniqueAccounts) {
       $AccountFailures = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4625; StartTime=(Get-Date).AddDays(-1)} | 
           Where-Object {$_.Properties[5].Value -eq $Account}
       
       $Report += [PSCustomObject]@{
           Account = $Account
           FailureCount = $AccountFailures.Count
           FirstFailure = ($AccountFailures | Sort-Object TimeCreated)[0].TimeCreated
           LastFailure = ($AccountFailures | Sort-Object TimeCreated -Descending)[0].TimeCreated
           UniqueSourceIPs = ($AccountFailures | Group-Object {$_.Properties[19].Value}).Count
           MostCommonFailure = ($AccountFailures | Group-Object {$_.Properties[8].Value} | Sort-Object Count -Descending)[0].Name
       }
   }
   
   $Report | Sort-Object FailureCount -Descending | Format-Table

Déployez des capacités de surveillance de niveau entreprise et de réponse automatisée pour la gestion d'événements 4625 à grande échelle.

1. Configurer le transfert d'événements Windows pour une collecte centralisée :

   # Sur le serveur collecteur
   wecutil qc /q
   wecutil cs subscription.xml
   
   # Créer subscription.xml avec filtrage d'événements 4625
   $SubscriptionXML = @"
   
       Security-Logon-Failures
       SourceInitiated
       Collecter les événements d'échec de connexion
       true
       http://schemas.microsoft.com/wbem/wsman/1/windows/EventLog
       Normal
       
               
                   *[System[(EventID=4625)]]
               
           
       ]]>
   
   "@
   $SubscriptionXML | Out-File -FilePath "C:\Temp\subscription.xml"

2. Créer un système d'alerte basé sur PowerShell :

   # Enregistrer sous MonitorLogonFailures.ps1
   param(
       [int]$ThresholdCount = 10,
       [int]$TimeWindowMinutes = 15
   )
   
   $StartTime = (Get-Date).AddMinutes(-$TimeWindowMinutes)
   $Events = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4625; StartTime=$StartTime}
   
   $AccountFailures = $Events | Group-Object {$_.Properties[5].Value} | 
       Where-Object {$_.Count -ge $ThresholdCount}
   
   if ($AccountFailures) {
       $AlertMessage = "Nombre élevé d'échecs de connexion détecté :`n"
       foreach ($Account in $AccountFailures) {
           $AlertMessage += "Compte : $($Account.Name) - Échecs : $($Account.Count)`n"
       }
       
       # Envoyer une alerte par email (configurer les paramètres SMTP)
       Send-MailMessage -To "security@company.com" -From "alerts@company.com" \
           -Subject "Alerte de sécurité : Échecs de connexion multiples" -Body $AlertMessage \
           -SmtpServer "smtp.company.com"
       
       # Enregistrer dans le journal des événements de l'application
       Write-EventLog -LogName Application -Source "Security Monitor" -EventId 1001 \
           -EntryType Warning -Message $AlertMessage
   }

3. Mettre en œuvre une réponse automatisée de verrouillage de compte :

   # Script de réponse automatisée
   $SuspiciousIPs = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4625; StartTime=(Get-Date).AddMinutes(-10)} | 
       Group-Object {$_.Properties[19].Value} | 
       Where-Object {$_.Count -gt 20} | 
       Select-Object -ExpandProperty Name
   
   foreach ($IP in $SuspiciousIPs) {
       if ($IP -ne "-" -and $IP -ne "127.0.0.1") {
           # Bloquer l'IP en utilisant le pare-feu Windows
           New-NetFirewallRule -DisplayName "Bloquer IP suspecte $IP" \
               -Direction Inbound -RemoteAddress $IP -Action Block
           
           Write-EventLog -LogName Application -Source "Security Monitor" -EventId 1002 \
               -EntryType Warning -Message "IP suspecte automatiquement bloquée : $IP"
       }
   }

4. Configurer des compteurs de performance personnalisés pour la surveillance :

   # Créer un compteur de performance personnalisé pour les échecs de connexion
   $CounterPath = "\Security Events\Logon Failures per Minute"
   typeperf $CounterPath -si 60 -o "C:\Logs\LogonFailures.csv"

5. Intégrer avec Microsoft Sentinel ou un SIEM tiers :
   • Configurer l'agent Azure Monitor pour le transfert de journaux
   • Créer des requêtes KQL pour la détection avancée de modèles
   • Configurer des playbooks automatisés pour la réponse aux incidents
   • Mettre en œuvre une détection d'anomalies basée sur l'apprentissage automatique