ID d'événement Windows 4624 – Microsoft-Windows-Security-Auditing : Un compte s'est connecté avec succès

Ouvrez Observateur d'événements et naviguez vers Journaux Windows → Sécurité pour examiner les détails de l'ID d'événement 4624.

1. Appuyez sur Win + R, tapez eventvwr.msc, et appuyez sur Entrée
2. Développez Journaux Windows et cliquez sur Sécurité
3. Dans le volet Actions, cliquez sur Filtrer le journal actuel
4. Entrez 4624 dans le champ ID d'événements et cliquez sur OK
5. Double-cliquez sur n'importe quel événement 4624 pour voir des informations détaillées

Champs clés à examiner :

• Sujet : Compte qui a demandé la connexion
• Nouvelle connexion : Compte qui a été authentifié
• Type de connexion : Méthode d'authentification (2=Interactif, 3=Réseau, 5=Service, etc.)
• Processus de connexion : Package d'authentification utilisé
• Adresse réseau source : Adresse IP du système source
• Nom de la station de travail : Nom de l'ordinateur initiant la connexion

Utilisez PowerShell pour interroger et analyser les événements d'ID 4624 avec des capacités de filtrage avancées.

# Obtenez les événements de connexion réussis récents
Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4624} -MaxEvents 50 | 
    Select-Object TimeCreated, Id, LevelDisplayName, Message

Filtrer par types de connexion spécifiques :

# Filtrer uniquement pour les connexions interactives (Type 2)
$Events = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4624}
$Events | Where-Object {
    ([xml]$_.ToXml()).Event.EventData.Data | 
    Where-Object {$_.Name -eq 'LogonType' -and $_.'#text' -eq '2'}
} | Select-Object TimeCreated, Message

Extraire des champs de données d'événement spécifiques :

# Analyser les données d'événement en objets personnalisés
$LogonEvents = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4624} -MaxEvents 100
$LogonEvents | ForEach-Object {
    $xml = [xml]$_.ToXml()
    $eventData = $xml.Event.EventData.Data
    [PSCustomObject]@{
        TimeCreated = $_.TimeCreated
        TargetUserName = ($eventData | Where-Object {$_.Name -eq 'TargetUserName'}).'#text'
        LogonType = ($eventData | Where-Object {$_.Name -eq 'LogonType'}).'#text'
        IpAddress = ($eventData | Where-Object {$_.Name -eq 'IpAddress'}).'#text'
        WorkstationName = ($eventData | Where-Object {$_.Name -eq 'WorkstationName'}).'#text'
    }
} | Format-Table -AutoSize

Optimisez les paramètres de la stratégie d'audit pour capturer les événements de connexion les plus pertinents tout en gérant le volume des journaux.

Vérifiez les paramètres actuels de la stratégie d'audit :

# Afficher les paramètres actuels d'audit de connexion
auditpol /get /subcategory:"Logon"

Configurez les stratégies d'audit via la stratégie de groupe :

1. Ouvrez la Console de gestion des stratégies de groupe (gpmc.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 Stratégies d'audit → Connexion/Déconnexion
4. Configurez Audit de connexion sur Succès (et éventuellement Échec)

Définissez les stratégies d'audit via la ligne de commande :

# Activer l'audit de succès et d'échec pour les événements de connexion
auditpol /set /subcategory:"Logon" /success:enable /failure:enable

Configurez la taille et la rétention du journal de sécurité :

1. Ouvrez le Observateur d'événements → Journaux Windows → Sécurité
2. Cliquez avec le bouton droit sur Sécurité et sélectionnez Propriétés
3. Définissez la Taille maximale du journal à une valeur appropriée (par exemple, 1 Go)
4. Choisissez la méthode de rétention : Archiver le journal lorsqu'il est plein ou Écraser les événements si nécessaire

Créez des solutions de surveillance automatisées pour suivre les modèles de connexion suspects et générer des alertes pour les incidents de sécurité.

Créez un script PowerShell pour une surveillance continue :

# Surveiller les modèles de connexion inhabituels
$StartTime = (Get-Date).AddHours(-1)
$SuspiciousLogons = Get-WinEvent -FilterHashtable @{
    LogName='Security'
    Id=4624
    StartTime=$StartTime
} | ForEach-Object {
    $xml = [xml]$_.ToXml()
    $eventData = $xml.Event.EventData.Data
    $logonType = ($eventData | Where-Object {$_.Name -eq 'LogonType'}).'#text'
    $ipAddress = ($eventData | Where-Object {$_.Name -eq 'IpAddress'}).'#text'
    $userName = ($eventData | Where-Object {$_.Name -eq 'TargetUserName'}).'#text'
    
    # Signaler les modèles suspects
    if ($logonType -eq '3' -and $ipAddress -notmatch '^(10\.|192\.168\.|172\.(1[6-9]|2[0-9]|3[01])\.)') {
        [PSCustomObject]@{
            Time = $_.TimeCreated
            User = $userName
            Type = $logonType
            SourceIP = $ipAddress
            Suspicious = 'Connexion Réseau Externe'
        }
    }
} | Where-Object {$_.Suspicious}

if ($SuspiciousLogons) {
    $SuspiciousLogons | Format-Table
    # Envoyer un email d'alerte ou écrire dans le système de surveillance
}

Configurer le Planificateur de tâches Windows pour une exécution automatisée :

1. Ouvrez Planificateur de tâches (taskschd.msc)
2. Cliquez sur Créer une tâche de base dans le volet Actions
3. Nommer la tâche "Moniteur d'événements de connexion" et définir le déclencheur approprié (par exemple, toutes les 15 minutes)
4. Définir l'action pour démarrer PowerShell avec votre script de surveillance
5. Configurer la tâche pour s'exécuter avec les autorisations appropriées

Utilisez le Transfert d'événements Windows pour une collecte centralisée :

# Configurer l'abonnement de transfert d'événements
wecutil cs subscription.xml

# Exemple de contenu XML d'abonnement :
# <Subscription xmlns="http://schemas.microsoft.com/2006/03/windows/events/subscription">
#   <SubscriptionId>LogonEvents</SubscriptionId>
#   <Query><![CDATA[<QueryList><Query Id="0"><Select Path="Security">*[System[EventID=4624]]</Select></Query></QueryList>]]></Query>
# </Subscription>

Effectuez une analyse médico-légale complète en corrélant l'ID d'événement 4624 avec les événements de sécurité associés pour l'enquête sur les incidents.

Corrélez avec les événements de déconnexion (4634) pour suivre la durée de la session :

# Trouver les paires de connexion/déconnexion correspondantes
$LogonEvents = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4624} -MaxEvents 100
$LogoffEvents = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4634} -MaxEvents 100

$SessionAnalysis = foreach ($logon in $LogonEvents) {
    $logonXml = [xml]$logon.ToXml()
    $logonData = $logonXml.Event.EventData.Data
    $logonId = ($logonData | Where-Object {$_.Name -eq 'TargetLogonId'}).'#text'
    $userName = ($logonData | Where-Object {$_.Name -eq 'TargetUserName'}).'#text'
    
    $matchingLogoff = $LogoffEvents | Where-Object {
        $logoffXml = [xml]$_.ToXml()
        $logoffData = $logoffXml.Event.EventData.Data
        $logoffId = ($logoffData | Where-Object {$_.Name -eq 'TargetLogonId'}).'#text'
        $logoffId -eq $logonId
    } | Select-Object -First 1
    
    [PSCustomObject]@{
        User = $userName
        LogonTime = $logon.TimeCreated
        LogoffTime = if ($matchingLogoff) { $matchingLogoff.TimeCreated } else { 'Still Active' }
        SessionDuration = if ($matchingLogoff) { 
            New-TimeSpan -Start $logon.TimeCreated -End $matchingLogoff.TimeCreated 
        } else { 'Ongoing' }
        LogonId = $logonId
    }
}

$SessionAnalysis | Format-Table -AutoSize

Analysez les modèles d'authentification et détectez les anomalies :

# Détecter les heures ou fréquences de connexion inhabituelles
$TimeWindow = (Get-Date).AddDays(-7)
$RecentLogons = Get-WinEvent -FilterHashtable @{
    LogName='Security'
    Id=4624
    StartTime=$TimeWindow
}

# Grouper par utilisateur et analyser les modèles
$UserPatterns = $RecentLogons | ForEach-Object {
    $xml = [xml]$_.ToXml()
    $eventData = $xml.Event.EventData.Data
    [PSCustomObject]@{
        User = ($eventData | Where-Object {$_.Name -eq 'TargetUserName'}).'#text'
        Time = $_.TimeCreated
        Hour = $_.TimeCreated.Hour
        DayOfWeek = $_.TimeCreated.DayOfWeek
        LogonType = ($eventData | Where-Object {$_.Name -eq 'LogonType'}).'#text'
        SourceIP = ($eventData | Where-Object {$_.Name -eq 'IpAddress'}).'#text'
    }
} | Group-Object User

# Identifier les utilisateurs avec des modèles inhabituels
foreach ($userGroup in $UserPatterns) {
    $user = $userGroup.Name
    $logons = $userGroup.Group
    
    # Vérifier l'activité hors heures (avant 6h ou après 22h)
    $offHoursLogons = $logons | Where-Object {$_.Hour -lt 6 -or $_.Hour -gt 22}
    
    if ($offHoursLogons) {
        Write-Host "ALERTE : L'utilisateur $user a des connexions hors heures :" -ForegroundColor Red
        $offHoursLogons | Format-Table Time, LogonType, SourceIP
    }
}

Exporter un rapport médico-légal complet :

# Générer un rapport médico-légal détaillé
$ForensicReport = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4624} -MaxEvents 1000 | 
ForEach-Object {
    $xml = [xml]$_.ToXml()
    $eventData = $xml.Event.EventData.Data
    [PSCustomObject]@{
        EventTime = $_.TimeCreated
        EventID = $_.Id
        SubjectUserName = ($eventData | Where-Object {$_.Name -eq 'SubjectUserName'}).'#text'
        TargetUserName = ($eventData | Where-Object {$_.Name -eq 'TargetUserName'}).'#text'
        LogonType = ($eventData | Where-Object {$_.Name -eq 'LogonType'}).'#text'
        LogonProcessName = ($eventData | Where-Object {$_.Name -eq 'LogonProcessName'}).'#text'
        AuthenticationPackageName = ($eventData | Where-Object {$_.Name -eq 'AuthenticationPackageName'}).'#text'
        WorkstationName = ($eventData | Where-Object {$_.Name -eq 'WorkstationName'}).'#text'
        SourceNetworkAddress = ($eventData | Where-Object {$_.Name -eq 'IpAddress'}).'#text'
        SourcePort = ($eventData | Where-Object {$_.Name -eq 'IpPort'}).'#text'
    }
}

$ForensicReport | Export-Csv -Path "C:\Forensics\Logon_Analysis_$(Get-Date -Format 'yyyyMMdd_HHmmss').csv" -NoTypeInformation