Investigation de Logs Windows avec PowerShell

🎯 Pourquoi analyser les logs Windows en SOC ?

Les trois piliers de l'investigation de logs

1. Identification : Savoir quels Event IDs surveiller selon le contexte d'attaque
2. Corrélation : Regrouper les événements pour détecter des patterns (spray vs brute-force)
3. Action : Transformer l'analyse en décision opérationnelle (bloquer, alerter, investiguer)

🔍 Au-delà du 4625 : comprendre l'écosystème des Event IDs

Cartographie des Event IDs par scénario d'attaque

Décoder les Sub Status : la clé du triage

Le champ Sub Status de l'Event ID 4625 indique pourquoi la connexion a échoué. C'est ce champ qui permet de différencier une erreur utilisateur d'une attaque ciblée.

TimeCreated : 2025-08-19 14:33:12
Id          : 4625
Level       : Information
Message     : Échec de connexion d'un compte.

    Sujet :
        ID de sécurité : ANONYMOUS LOGON
        
    Informations sur le compte :
        Nom du compte : j.doe
        Domaine       : CORP
        
    Informations sur l'échec :
        Raison        : Mot de passe incorrect
        Statut        : 0xC000006A
        Sous-état     : 0xC000006A
        
    Informations réseau :
        Adresse réseau source : 185.220.101.42
        Port source           : 49152
        
    Informations sur le processus :
        Nom du processus appelant : -
        Type d'ouverture de session : 3 (Network)

⚙️ Collecte efficace : éviter le "gros CSV" qui plante

Le problème du débutant

L'erreur classique de l'analyste junior : exporter tout le journal Security en CSV.

# ❌ NE JAMAIS FAIRE ÇA
Get-WinEvent -LogName Security | Export-Csv C:\logs.csv

La bonne approche : filtrer AVANT de collecter

PowerShell permet de filtrer directement au niveau du moteur d'événements Windows avec -FilterHashtable. C'est 10 à 100 fois plus rapide qu'un filtrage après collecte.

# ✅ Filtrage efficace au niveau du moteur Windows Event Log
$filter = @{
    LogName   = 'Security'
    Id        = 4625                              # Échecs de connexion uniquement
    StartTime = (Get-Date).AddHours(-24)          # Dernières 24h
}

$events = Get-WinEvent -FilterHashtable $filter -ErrorAction SilentlyContinue

Write-Host "✅ $($events.Count) événements récupérés en quelques secondes"

Collecte multi-Event IDs pour analyse avancée

# Collecter plusieurs types d'événements d'authentification
$eventIds = 4625, 4648, 4771, 4776

$allEvents = foreach ($id in $eventIds) {
    $filter = @{
        LogName   = 'Security'
        Id        = $id
        StartTime = (Get-Date).AddHours(-24)
    }
    Get-WinEvent -FilterHashtable $filter -ErrorAction SilentlyContinue
}

Write-Host "📊 Total événements collectés : $($allEvents.Count)"

💻 Parsing : extraire les données enfouies dans le Message

Le problème : données non structurées

Contrairement aux logs Apache (format tabulaire), les Event Logs Windows stockent les informations dans un champ Message en texte libre. Il faut utiliser des regex pour extraire les valeurs.

Message : Échec de connexion d'un compte.
    Sujet :
        ID de sécurité : ANONYMOUS LOGON
    Informations sur le compte :
        Nom du compte : j.doe
        Domaine : CORP
    [...]

Construction d'un parser robuste

On utilise des regex avec captures nommées pour extraire chaque champ pertinent. La syntaxe (?s).*champ:\s+([^\r\n]+) permet de capturer jusqu'au retour à la ligne.

$parsed = foreach ($event in $events) {
    $msg = $event.Message
    
    # Extraction avec regex non-greedy
    [PSCustomObject]@{
        Timestamp     = $event.TimeCreated
        EventID       = $event.Id
        Account       = if ($msg -match 'Nom du compte\s*:\s*([^\r\n]+)') { $matches[1].Trim() } else { 'N/A' }
        Domain        = if ($msg -match 'Domaine\s*:\s*([^\r\n]+)') { $matches[1].Trim() } else { 'N/A' }
        SourceIP      = if ($msg -match 'Adresse réseau source\s*:\s*([^\r\n]+)') { $matches[1].Trim() } else { 'N/A' }
        LogonType     = if ($msg -match "Type d'ouverture de session\s*:\s*(\d+)") { $matches[1] } else { 'N/A' }
        Status        = if ($msg -match 'Statut\s*:\s*(0x[0-9A-F]+)') { $matches[1] } else { 'N/A' }
        SubStatus     = if ($msg -match 'Sous-état\s*:\s*(0x[0-9A-F]+)') { $matches[1] } else { 'N/A' }
        Workstation   = if ($msg -match 'Nom de la station de travail\s*:\s*([^\r\n]+)') { $matches[1].Trim() } else { 'N/A' }
    }
}

Write-Host "✅ Parsing terminé : $($parsed.Count) événements structurés"

Nettoyage des données : éliminer le bruit

Avant toute analyse, il faut filtrer les faux positifs courants.

# Éliminer le bruit commun
$cleaned = $parsed | Where-Object {
    $_.SourceIP -ne '-' -and              # Pas d'IP = événement local
    $_.SourceIP -ne '127.0.0.1' -and      # Localhost
    $_.SourceIP -ne '::1' -and            # IPv6 localhost
    $_.SourceIP -notlike '169.254.*' -and # APIPA (auto-config IP)
    $_.Account -ne '-' -and               # Comptes vides
    $_.Account -notlike '*$'              # Comptes machine (se terminent par $)
}

$removedNoise = $parsed.Count - $cleaned.Count
Write-Host "🧹 $removedNoise événements de bruit supprimés"

🚨 Détection d'attaques : comprendre les signatures

Les trois patterns d'attaque par authentification

Implémentation de la détection

# Regroupement par IP source
$grouped = $cleaned | Group-Object SourceIP

# Analyse de chaque IP pour détecter les patterns
$threats = foreach ($ipGroup in $grouped) {
    $ip = $ipGroup.Name
    $events = $ipGroup.Group
    
    # Compter les comptes uniques ciblés
    $uniqueAccounts = ($events.Account | Sort-Object -Unique)
    $accountCount = $uniqueAccounts.Count
    $totalAttempts = $events.Count
    
    # Calculer la moyenne d'échecs par compte
    $avgAttemptsPerAccount = if ($accountCount -gt 0) { 
        [math]::Round($totalAttempts / $accountCount, 1) 
    } else { 0 }
    
    # Classification de la menace
    $threatType = if ($accountCount -gt 10 -and $avgAttemptsPerAccount -lt 3) {
        'Credential Stuffing'
    } elseif ($accountCount -gt 5 -and $avgAttemptsPerAccount -lt 5) {
        'Password Spray'
    } elseif ($accountCount -le 3 -and $totalAttempts -gt 30) {
        'Brute-Force'
    } else {
        'Low Priority'
    }
    
    # Identifier le Sub Status le plus fréquent
    $topSubStatus = ($events.SubStatus | Group-Object | Sort-Object -Descending Count | Select-Object -First 1).Name
    
    [PSCustomObject]@{
        SourceIP              = $ip
        TotalAttempts         = $totalAttempts
        UniqueAccounts        = $accountCount
        AvgAttemptsPerAccount = $avgAttemptsPerAccount
        ThreatType            = $threatType
        TopSubStatus          = $topSubStatus
        FirstSeen             = ($events.Timestamp | Measure-Object -Minimum).Minimum
        LastSeen              = ($events.Timestamp | Measure-Object -Maximum).Maximum
        Duration              = (($events.Timestamp | Measure-Object -Maximum).Maximum - ($events.Timestamp | Measure-Object -Minimum).Minimum).TotalMinutes
        TopTargetedAccounts   = ($uniqueAccounts | Select-Object -First 5) -join ', '
    }
}

# Filtrer uniquement les menaces réelles (pas le bruit)
$realThreats = $threats | Where-Object { $_.ThreatType -ne 'Low Priority' } | Sort-Object -Descending TotalAttempts

Write-Host "🚨 $($realThreats.Count) menaces détectées"
$realThreats | Format-Table -AutoSize

🌐 Enrichissement OSINT : contextualiser les IPs

Pourquoi enrichir ?

Une IP seule ne donne aucun contexte. L'enrichissement permet de répondre à :

• 📍 Où se trouve l'attaquant ? (géolocalisation)
• 🏢 Qui est le propriétaire ? (ISP, hébergeur)
• 🚨 Réputation : Cette IP est-elle déjà connue pour des activités malveillantes ?
• 🔍 Infrastructure : Quels services expose-t-elle ? (Shodan)

Sources d'enrichissement gratuites et payantes

Implémentation de l'enrichissement

$enriched = foreach ($threat in $realThreats) {
    $ip = $threat.SourceIP
    
    Write-Host "🔍 Enrichissement de $ip..." -NoNewline
    
    # Rate limiting : 1.5 secondes entre chaque requête (40 req/min pour ip-api)
    Start-Sleep -Milliseconds 1500
    
    try {
        # Géolocalisation
        $geo = Invoke-RestMethod -Uri "http://ip-api.com/json/$ip" -TimeoutSec 5
        
        # AbuseIPDB (nécessite une clé API gratuite)
        $abuseHeaders = @{
            'Key' = 'VOTRE_CLE_API_ABUSEIPDB'
            'Accept' = 'application/json'
        }
        $abuse = Invoke-RestMethod -Uri "https://api.abuseipdb.com/api/v2/check?ipAddress=$ip" -Headers $abuseHeaders -TimeoutSec 5
        
        $threat | Add-Member -NotePropertyName Country -NotePropertyValue $geo.country -PassThru |
                 Add-Member -NotePropertyName City -NotePropertyValue $geo.city -PassThru |
                 Add-Member -NotePropertyName ISP -NotePropertyValue $geo.isp -PassThru |
                 Add-Member -NotePropertyName ASN -NotePropertyValue $geo.as -PassThru |
                 Add-Member -NotePropertyName Latitude -NotePropertyValue $geo.lat -PassThru |
                 Add-Member -NotePropertyName Longitude -NotePropertyValue $geo.lon -PassThru |
                 Add-Member -NotePropertyName AbuseScore -NotePropertyValue $abuse.data.abuseConfidenceScore -PassThru
        
        Write-Host " ✅ $($geo.country) - Score: $($abuse.data.abuseConfidenceScore)%"
        
    } catch {
        Write-Host " ⚠️ Échec" -ForegroundColor Yellow
        $threat | Add-Member -NotePropertyName Country -NotePropertyValue 'Unknown' -PassThru
    }
}

# Tri par score d'abus décroissant
$enriched = $enriched | Sort-Object -Descending AbuseScore

📊 Visualisation : carte interactive et heatmap

Pourquoi visualiser ?

Un tableau de 50 IPs est difficile à interpréter. Une carte permet de :

• Identifier les zones géographiques d'où proviennent les attaques
• Détecter les patterns de clustering (même hébergeur, même pays)
• Communiquer efficacement avec le management (impact visuel)

Génération d'une carte Leaflet avec clustering

# Conversion en JSON pour injection dans le HTML
$mapData = $enriched | Select-Object SourceIP, Latitude, Longitude, Country, City, ISP, TotalAttempts, UniqueAccounts, ThreatType, AbuseScore | ConvertTo-Json -Compress

$htmlReport = @"



    
    
    
    
    
    



📥 Exporter CSV






"@

$reportPath = "C:\Temp\rapport_intrusions_windows.html"
$htmlReport | Out-File -FilePath $reportPath -Encoding UTF8
Write-Host "✅ Rapport HTML généré : $reportPath"
Start-Process $reportPath

🛡️ Remédiation : du détection à l'action

Philosophie de la réponse à incident

Matrice de décision : action selon le contexte

Implémentation : playbook automatisé

# Playbook de réponse automatisée
foreach ($threat in $enriched) {
    $ip = $threat.SourceIP
    $score = $threat.AbuseScore
    $type = $threat.ThreatType
    
    # NIVEAU 1 : Investigation (tous les cas)
    Write-Host "🔍 Investigation de $ip ($type, Score: $score%)"
    
    # NIVEAU 2 : Alerte si score modéré
    if ($score -gt 50 -and $score -le 75) {
        $alertBody = @"
🚨 ALERTE SOC - Tentative d'intrusion détectée

IP Source : $ip
Localisation : $($threat.City), $($threat.Country)
ISP : $($threat.ISP)
Score d'abus : $score%
Type d'attaque : $type
Tentatives : $($threat.TotalAttempts)
Comptes ciblés : $($threat.UniqueAccounts)

Comptes les plus ciblés : $($threat.TopTargetedAccounts)

Action recommandée : Investigation manuelle
"@
        
        # Envoi email
        Send-MailMessage `
            -To "soc@votreentreprise.com" `
            -From "noreply@votreentreprise.com" `
            -Subject "[SOC] Tentative d'intrusion - $ip" `
            -Body $alertBody `
            -SmtpServer "smtp.votreentreprise.com"
        
        Write-Host "📧 Alerte envoyée au SOC" -ForegroundColor Yellow
    }
    
    # NIVEAU 3 : Blocage temporaire si score élevé
    if ($score -gt 75 -and $score -le 90) {
        Write-Host "🚫 Blocage temporaire de $ip (24h)" -ForegroundColor Red
        
        # Exemple avec Windows Firewall
        $ruleName = "SOC_Block_$($ip -replace '\.','_')"
        New-NetFirewallRule `
            -DisplayName $ruleName `
            -Direction Inbound `
            -Action Block `
            -RemoteAddress $ip `
            -Description "Auto-blocked by SOC - Score: $score%" `
            -ErrorAction SilentlyContinue
        
        # Planifier la suppression après 24h
        $action = New-ScheduledTaskAction -Execute "powershell.exe" -Argument "-Command `"Remove-NetFirewallRule -DisplayName '$ruleName'`""
        $trigger = New-ScheduledTaskTrigger -Once -At (Get-Date).AddHours(24)
        Register-ScheduledTask -TaskName "SOC_Unblock_$($ip -replace '\.','_')" -Action $action -Trigger $trigger
    }
    
    # NIVEAU 4 : Blocage permanent si score critique
    if ($score -gt 90) {
        Write-Host "🔒 BLOCAGE PERMANENT de $ip" -ForegroundColor Red -BackgroundColor White
        
        # Ajout à une blacklist permanente
        $blacklistPath = "C:\SOC\blacklist.txt"
        Add-Content -Path $blacklistPath -Value "$ip`t$score`t$(Get-Date)`t$type"
        
        # Blocage firewall permanent
        $ruleName = "SOC_Permanent_Block_$($ip -replace '\.','_')"
        New-NetFirewallRule `
            -DisplayName $ruleName `
            -Direction Inbound `
            -Action Block `
            -RemoteAddress $ip `
            -Description "Permanent block - Score: $score% - $type" `
            -ErrorAction SilentlyContinue
    }
}

Write-Host "`n✅ Playbook de remédiation exécuté"

📋 Checklist de l'analyste SOC

Temps estimé par étape (100 IPs suspectes)

🚀 Aller plus loin : techniques avancées

1. Analyse temporelle : détecter les attaques distribuées

Les attaquants sophistiqués utilisent des botnets pour répartir les tentatives sur plusieurs IPs. Une analyse temporelle révèle ces coordinations.

# Regroupement par fenêtres de 5 minutes
$timeWindows = $parsed | Group-Object {
    $_.Timestamp.ToString("yyyy-MM-dd HH:") + ([Math]::Floor($_.Timestamp.Minute / 5) * 5)
}

# Détecter les pics d'activité
$spikes = $timeWindows | Where-Object { $_.Count -gt 50 } | Sort-Object -Descending Count
Write-Host "⚡ $($spikes.Count) pics d'activité détectés"

2. Analyse de User-Agent : détecter les outils d'attaque

Certains Event IDs (4648, 4771) contiennent des informations sur le processus ou le client utilisé.

# Extraction de patterns suspects dans les User-Agents / Process Names
$suspiciousTools = @('python', 'curl', 'hydra', 'nmap', 'metasploit', 'sqlmap', 'burp')

$toolDetection = $parsed | Where-Object {
    $msg = $_.Message
    $suspiciousTools | Where-Object { $msg -like "*$_*" }
}

if ($toolDetection) {
    Write-Host "🔧 Outils d'attaque détectés : $($toolDetection.Count) événements"
}

3. Corrélation avec d'autres sources

• Logs VPN : Les attaquants testent souvent plusieurs vecteurs (VPN + RDP)
• Logs Web : Corréler avec les logs Apache/IIS pour identifier les scans web → brute-force
• Threat Intelligence : Importer des feeds MISP/STIX pour comparer les IPs

4. Machine Learning : prédire les attaques

Avec des historiques de logs suffisants, il est possible d'entraîner un modèle de détection d'anomalies.

# Export pour analyse ML (Python/scikit-learn)
$mlDataset = $parsed | Select-Object `
    @{N='Hour';E={$_.Timestamp.Hour}},
    @{N='DayOfWeek';E={$_.Timestamp.DayOfWeek}},
    @{N='AttemptsPerIP';E={($parsed | Where-Object {$_.SourceIP -eq $_.SourceIP}).Count}},
    @{N='UniqueAccounts';E={(($parsed | Where-Object {$_.SourceIP -eq $_.SourceIP}).Account | Sort-Object -Unique).Count}},
    @{N='IsAttack';E={if ($_.ThreatType -ne 'Low Priority') {1} else {0}}}

$mlDataset | Export-Csv C:\SOC\ml_training_data.csv -NoTypeInformation

🎓 Conclusion : PowerShell, couteau suisse du SOC