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 pour voir les informations détaillées
4. Vérifiez le champ Raison de l'échec pour la description spécifique de l'erreur
5. Notez le code Sous-état pour identifier le type exact d'échec :
   • 0xC0000064 - L'utilisateur spécifié n'existe pas
   • 0xC000006A - La valeur fournie comme mot de passe actuel n'est pas correcte
   • 0xC0000072 - Le compte référencé est actuellement désactivé
   • 0xC0000193 - Le compte référencé a expiré
   • 0xC0000234 - Le compte référencé est actuellement verrouillé
6. Examinez le Type de connexion pour comprendre la méthode d'authentification :
   • Type 2 - Interactive (connexion console)
   • Type 3 - Réseau (accès aux ressources partagées)
   • Type 10 - RemoteInteractive (RDP/Services Terminal)
7. Vérifiez Adresse réseau source pour identifier l'origine des tentatives échouées

PowerShell offre des capacités puissantes de filtrage et d'analyse pour enquêter sur les événements 4625 sur plusieurs systèmes.

1. Interroger les tentatives de connexion échouées récentes :

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

2. Filtrer les connexions échouées par compte utilisateur spécifique :

   Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4625} | Where-Object {$_.Message -like "*TargetUserName*"} | Select-Object TimeCreated, Message

3. Identifier les attaques potentielles par force brute en comptant les échecs par IP source :

   $Events = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4625; StartTime=(Get-Date).AddHours(-24)}
   $Events | ForEach-Object {
       $XML = [xml]$_.ToXml()
       [PSCustomObject]@{
           Time = $_.TimeCreated
           Account = $XML.Event.EventData.Data | Where-Object {$_.Name -eq 'TargetUserName'} | Select-Object -ExpandProperty '#text'
           SourceIP = $XML.Event.EventData.Data | Where-Object {$_.Name -eq 'IpAddress'} | Select-Object -ExpandProperty '#text'
           FailureReason = $XML.Event.EventData.Data | Where-Object {$_.Name -eq 'SubStatus'} | Select-Object -ExpandProperty '#text'
       }
   } | Group-Object SourceIP | Sort-Object Count -Descending

4. Exporter les événements de connexion échouée pour une analyse plus approfondie :

   Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4625; StartTime=(Get-Date).AddDays(-7)} | Export-Csv -Path "C:\Temp\FailedLogons.csv" -NoTypeInformation

5. Vérifier les modèles de verrouillage de compte :

   Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4625} | Where-Object {$_.Message -like "*0xC0000234*"} | Select-Object TimeCreated, Message

Assurez-vous de configurer correctement la politique d'audit pour capturer tous les événements de connexion échoués pertinents et améliorer la surveillance de la sécurité.

1. Vérifiez les paramètres actuels de la politique d'audit :

   auditpol /get /category:"Logon/Logoff"

2. Activez l'audit détaillé des échecs de connexion :

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

3. Configurez la stratégie de groupe pour les paramètres d'audit à l'échelle du domaine :
   • Ouvrez Group Policy Management Console
   • Accédez à Computer Configuration → Policies → Windows Settings → Security Settings → Advanced Audit Policy Configuration
   • Développez Audit Policies → Logon/Logoff
   • Configurez Audit Logon sur Success and Failure
   • Configurez Audit Account Lockout sur Success and Failure
4. Vérifiez l'application de la politique d'audit :

   gpresult /h C:\Temp\GPResult.html
   # Review Applied Group Policy Objects section

5. Testez la politique d'audit en générant une connexion échouée contrôlée :

   # From command prompt (will fail intentionally)
   runas /user:nonexistentuser cmd

6. Configurez la taille du journal de sécurité pour gérer le volume accru d'événements :
   • Ouvrez Event Viewer → Windows Logs → Security
   • Cliquez avec le bouton droit sur Security → Properties
   • Définissez Maximum log size sur au moins 100 Mo
   • Configurez When maximum log size is reached sur Archive the log automatically

Configurez des systèmes de détection automatisés pour identifier et répondre aux modèles de tentatives de connexion échouées suspectes en temps réel.

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

   # Enregistrer sous Monitor-FailedLogons.ps1
   param(
       [int]$ThresholdCount = 5,
       [int]$TimeWindowMinutes = 10
   )
   
   $StartTime = (Get-Date).AddMinutes(-$TimeWindowMinutes)
   $FailedLogons = Get-WinEvent -FilterHashtable @{
       LogName='Security'
       Id=4625
       StartTime=$StartTime
   } -ErrorAction SilentlyContinue
   
   if ($FailedLogons) {
       $GroupedByIP = $FailedLogons | ForEach-Object {
           $XML = [xml]$_.ToXml()
           [PSCustomObject]@{
               SourceIP = $XML.Event.EventData.Data | Where-Object {$_.Name -eq 'IpAddress'} | Select-Object -ExpandProperty '#text'
               Account = $XML.Event.EventData.Data | Where-Object {$_.Name -eq 'TargetUserName'} | Select-Object -ExpandProperty '#text'
           }
       } | Group-Object SourceIP
       
       foreach ($Group in $GroupedByIP) {
           if ($Group.Count -ge $ThresholdCount) {
               Write-Warning "ALERTE : $($Group.Count) tentatives de connexion échouées depuis $($Group.Name) dans les dernières $TimeWindowMinutes minutes"
               # Ajouter une notification par email ou une intégration SIEM ici
           }
       }
   }

2. Planifiez le script de surveillance à l'aide du Planificateur de tâches :

   $Action = New-ScheduledTaskAction -Execute "PowerShell.exe" -Argument "-File C:\Scripts\Monitor-FailedLogons.ps1"
   $Trigger = New-ScheduledTaskTrigger -RepetitionInterval (New-TimeSpan -Minutes 5) -RepetitionDuration (New-TimeSpan -Days 365) -At (Get-Date)
   $Settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -StartWhenAvailable
   Register-ScheduledTask -TaskName "Monitor Failed Logons" -Action $Action -Trigger $Trigger -Settings $Settings -RunLevel Highest

3. Configurez le transfert d'événements Windows pour une surveillance centralisée :
   • Sur le serveur collecteur, activez WinRM :

     winrm quickconfig -y
     wecutil qc

   • Créez un fichier de configuration d'abonnement :

     <?xml version="1.0" encoding="UTF-8"?>
     <Subscription xmlns="http://schemas.microsoft.com/2006/03/windows/events/subscription">
         <SubscriptionId>FailedLogons</SubscriptionId>
         <SubscriptionType>SourceInitiated</SubscriptionType>
         <Description>Transférer l'ID d'événement 4625 des ordinateurs du domaine</Description>
         <Enabled>true</Enabled>
         <Uri>http://schemas.microsoft.com/wbem/wsman/1/windows/EventLog</Uri>
         <Query><![CDATA[<QueryList><Query Id="0"><Select Path="Security">*[System[(EventID=4625)]]</Select></Query></QueryList>]]></Query>
     </Subscription>

   • Créez l'abonnement :

     wecutil cs C:\Config\FailedLogons.xml

4. Intégrez avec Microsoft Sentinel ou un SIEM tiers :
   • Installez l'agent Azure Monitor sur les contrôleurs de domaine
   • Configurez le connecteur de données des événements de sécurité dans Sentinel
   • Créez des règles d'analyse pour la détection des tentatives de connexion échouées

Effectuer une analyse médico-légale approfondie des événements de connexion échoués pour identifier les schémas d'attaque et mettre en œuvre des contre-mesures ciblées.

1. Extraire des données médico-légales détaillées en utilisant des techniques avancées de PowerShell:

   # Script d'analyse avancée 4625
   $Events = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4625; StartTime=(Get-Date).AddDays(-1)}
   $DetailedAnalysis = foreach ($Event in $Events) {
       $XML = [xml]$Event.ToXml()
       $EventData = @{}
       $XML.Event.EventData.Data | ForEach-Object {
           $EventData[$_.Name] = $_.'#text'
       }
       
       [PSCustomObject]@{
           TimeCreated = $Event.TimeCreated
           TargetUserName = $EventData.TargetUserName
           TargetDomainName = $EventData.TargetDomainName
           WorkstationName = $EventData.WorkstationName
           IpAddress = $EventData.IpAddress
           IpPort = $EventData.IpPort
           LogonType = $EventData.LogonType
           LogonProcessName = $EventData.LogonProcessName
           AuthenticationPackageName = $EventData.AuthenticationPackageName
           FailureReason = $EventData.FailureReason
           Status = $EventData.Status
           SubStatus = $EventData.SubStatus
           ProcessName = $EventData.ProcessName
           KeyLength = $EventData.KeyLength
       }
   }
   
   # Analyser les schémas d'attaque
   $DetailedAnalysis | Group-Object IpAddress | Sort-Object Count -Descending | Select-Object Name, Count, @{n='UniqueAccounts';e={($_.Group | Select-Object -Unique TargetUserName).Count}}

2. Corréler avec d'autres événements de sécurité pour une analyse chronologique:

   # Corréler 4625 avec les connexions réussies (4624) et les verrouillages de compte (4740)
   $TimeRange = @{StartTime=(Get-Date).AddHours(-2); EndTime=Get-Date}
   $FailedLogons = Get-WinEvent -FilterHashtable (@{LogName='Security'; Id=4625} + $TimeRange)
   $SuccessfulLogons = Get-WinEvent -FilterHashtable (@{LogName='Security'; Id=4624} + $TimeRange)
   $AccountLockouts = Get-WinEvent -FilterHashtable (@{LogName='Security'; Id=4740} + $TimeRange)
   
   # Créer une chronologie des événements
   $AllEvents = @($FailedLogons + $SuccessfulLogons + $AccountLockouts) | Sort-Object TimeCreated
   $AllEvents | Select-Object TimeCreated, Id, @{n='EventType';e={switch($_.Id){4625{'Failed Logon'};4624{'Successful Logon'};4740{'Account Lockout'}}}}, Message

3. Mettre en œuvre la vérification de la réputation des adresses IP:

   # Vérifier les IP suspectes avec le renseignement sur les menaces
   $SuspiciousIPs = $DetailedAnalysis | Group-Object IpAddress | Where-Object {$_.Count -gt 10} | Select-Object -ExpandProperty Name
   
   foreach ($IP in $SuspiciousIPs) {
       if ($IP -and $IP -ne '-' -and $IP -ne '::1' -and $IP -ne '127.0.0.1') {
           try {
               $GeoLocation = Invoke-RestMethod -Uri "http://ip-api.com/json/$IP" -TimeoutSec 5
               Write-Host "IP: $IP - Country: $($GeoLocation.country) - ISP: $($GeoLocation.isp)" -ForegroundColor Yellow
           } catch {
               Write-Host "IP: $IP - Geolocation lookup failed" -ForegroundColor Red
           }
       }
   }

4. Générer un rapport de sécurité complet:

   # Générer un rapport de sécurité détaillé
   $Report = @"
   === Rapport d'analyse des connexions échouées ===
   Généré: $(Get-Date)
   Plage de temps: Dernières 24 heures
   
   Résumé:
   - Total des connexions échouées: $($DetailedAnalysis.Count)
   - IP sources uniques: $(($DetailedAnalysis | Select-Object -Unique IpAddress).Count)
   - Comptes cibles uniques: $(($DetailedAnalysis | Select-Object -Unique TargetUserName).Count)
   
   Top 10 des IP sources par tentatives échouées:
   $($DetailedAnalysis | Group-Object IpAddress | Sort-Object Count -Descending | Select-Object -First 10 | Format-Table Name, Count -AutoSize | Out-String)
   
   Top 10 des comptes ciblés:
   $($DetailedAnalysis | Group-Object TargetUserName | Sort-Object Count -Descending | Select-Object -First 10 | Format-Table Name, Count -AutoSize | Out-String)
   
   Répartition des raisons d'échec:
   $($DetailedAnalysis | Group-Object SubStatus | Sort-Object Count -Descending | Format-Table Name, Count -AutoSize | Out-String)
   "@
   
   $Report | Out-File -FilePath "C:\Temp\FailedLogonReport_$(Get-Date -Format 'yyyyMMdd_HHmm').txt"

5. Mettre en œuvre des actions de réponse automatisées:

   # Réponse automatisée pour les scénarios à haut risque
   $HighRiskIPs = $DetailedAnalysis | Group-Object IpAddress | Where-Object {$_.Count -gt 20}
   
   foreach ($RiskIP in $HighRiskIPs) {
       if ($RiskIP.Name -and $RiskIP.Name -notmatch '^(192\.168\.|10\.|172\.(1[6-9]|2[0-9]|3[01])\.)') {
           Write-Warning "IP à haut risque détectée: $($RiskIP.Name) avec $($RiskIP.Count) tentatives échouées"
           
           # Ajouter une règle de pare-feu Windows pour bloquer l'IP
           try {
               New-NetFirewallRule -DisplayName "Block Brute Force IP $($RiskIP.Name)" -Direction Inbound -RemoteAddress $RiskIP.Name -Action Block -Protocol TCP
               Write-Host "Règle de pare-feu créée pour bloquer $($RiskIP.Name)" -ForegroundColor Green
           } catch {
               Write-Error "Échec de la création de la règle de pare-feu pour $($RiskIP.Name): $($_.Exception.Message)"
           }
       }
   }