Windows Server 2025 - Guide Pratique Cybersecurite

%SystemDrive%\\inetpub\\logs\\LogFiles\\

C:\\inetpub\\logs\\LogFiles\\W3SVC1\\   (Site par défaut)
C:\\inetpub\\logs\\LogFiles\\W3SVC2\\   (Second site)

# ProxyLogon/ProxyShell detection
$exploitPatterns = @{
    ProxyLogon = "/owa/auth/x.js"
    ProxyShell = "/autodiscover/autodiscover.json"
    ProxyNotShell = "/autodiscover/autodiscover.json.*@.*Powershell"
}

$exploitAttempts = foreach($pattern in $exploitPatterns.GetEnumerator()) {
    $logs | Where-Object { $_."cs-uri-stem" -match $pattern.Value } |
        Select-Object @{N="ExploitType";E={$pattern.Key}}, DateTime, "c-ip", "cs-uri-stem", "sc-status"
}

Emplacement par défaut : %SystemRoot%\\System32\\DNS\\DNS.log
Format : Texte avec champs délimités par espaces
Taille maximale : Configurable (500MB par défaut)

Canal : Microsoft-Windows-DNSServer/Analytical
Format : EVTX
Emplacement : %SystemRoot%\\System32\\Winevt\\Logs\\Microsoft-Windows-DNSServer%4Analytical.evtx

# Analyse des événements de zone transfer
$zoneTransfers = Get-WinEvent -FilterHashtable @{
    LogName = 'DNS Server'
    ID = @(6001, 6002, 6003)  # Zone transfer events
} | ForEach-Object {
    $xml = [xml]$_.ToXml()
    [PSCustomObject]@{
        TimeCreated = $_.TimeCreated
        EventID = $_.Id
        ZoneName = $xml.Event.EventData.Data[0].'#text'
        RequestingServer = $xml.Event.EventData.Data[1].'#text'
        TransferType = $xml.Event.EventData.Data[2].'#text'
        Result = $xml.Event.EventData.Data[3].'#text'
    }
}

# Vérification des serveurs autorisés
$authorizedServers = @("192.168.1.10", "192.168.1.11")
$unauthorizedTransfers = $zoneTransfers | Where-Object {
    $_.RequestingServer -notin $authorizedServers
}

Disposez-vous d'un kit de forensique prêt à l'emploi en cas de compromission ?

4. Analyse des Logs Active Directory Domain Services

4.1 Sources de Logs AD DS

Active Directory génère des événements dans plusieurs canaux :

Security Log : Événements d'authentification et d'autorisation Pour approfondir, consultez Anti-Forensics.

Emplacement : %SystemRoot%\\System32\\Winevt\\Logs\\Security.evtx
Taille par défaut : 128MB (augmenter à 4GB minimum pour forensics)
Events critiques : 4624-4625 (Logon), 4720-4733 (Gestion comptes), 4768-4771 (Kerberos)

Directory Service Log : Opérations LDAP et réplication

Emplacement : %SystemRoot%\\System32\\Winevt\\Logs\\Directory Service.evtx
Events critiques : 1644 (LDAP searches), 2889 (LDAP signing), 1102 (Audit log cleared)

AD Database (NTDS.dit) : Base de données Active Directory

Emplacement : %SystemRoot%\\NTDS\\ntds.dit
Transaction logs : %SystemRoot%\\NTDS\\edb*.log
Checkpoint : %SystemRoot%\\NTDS\\edb.chk

4.2 Événements Critiques pour l'Investigation

4.3 Analyse de la Réplication et DCSync

# Events de réplication suspects
$dcSyncEvents = Get-WinEvent -FilterHashtable @{
    LogName = 'Security'
    ID = @(4662, 4624)  # DS Access et Logon events
} | Where-Object {
    $_.Message -match "ms-DS-Replication-Get-Changes" -or
    $_.Message -match "ms-DS-Replication-Get-Changes-All" -or
    $_.Message -match "1131f6aa-9c07-11d1-f79f-00c04fc2dcd2" -or
    $_.Message -match "1131f6ad-9c07-11d1-f79f-00c04fc2dcd2"
}

# Analyse détaillée des droits de réplication
$replicationRights = Get-ADObject -Filter * -Properties nTSecurityDescriptor |
    ForEach-Object {
        $acl = $_.nTSecurityDescriptor
        $aces = $acl.Access | Where-Object {
            $_.ActiveDirectoryRights -match "ExtendedRight" -and
            ($_.ObjectType -eq "1131f6aa-9c07-11d1-f79f-00c04fc2dcd2" -or
             $_.ObjectType -eq "1131f6ad-9c07-11d1-f79f-00c04fc2dcd2")
        }
        if ($aces) {
            [PSCustomObject]@{
                ObjectDN = $_.DistinguishedName
                Permissions = $aces | ForEach-Object {
                    "$($_.IdentityReference) - $($_.ActiveDirectoryRights)"
                }
            }
        }
    }

4.4 Timeline Reconstruction

La reconstruction de timeline est cruciale pour comprendre la progression d'une attaque. Voici un framework complet d'agrégation multi-sources :

# Agrégation multi-sources pour timeline
$timeline = @()

# Events AD
$adEvents = Get-WinEvent -FilterHashtable @{
    LogName = @('Security', 'System', 'Application', 'Directory Service')
    StartTime = (Get-Date).AddDays(-7)
} | Select-Object TimeCreated, LogName, Id, Message

# Logs IIS
$iisLogs = Get-ChildItem "C:\\inetpub\\logs\\LogFiles\\W3SVC*\\*.log" |
    Where-Object { $_.LastWriteTime -gt (Get-Date).AddDays(-7) } |
    ForEach-Object {
        Get-Content $_.FullName | Where-Object { $_ -notmatch "^#" } |
        ConvertFrom-Csv -Delimiter " " -Header @("date","time","s-ip","cs-method","cs-uri-stem","cs-uri-query","s-port","cs-username","c-ip","cs-User-Agent","cs-Referer","sc-status","sc-substatus","sc-win32-status","time-taken") |
        ForEach-Object {
            [PSCustomObject]@{
                TimeCreated = [DateTime]::Parse($_.date + " " + $_.time)
                Source = "IIS"
                Details = "$($_.c-ip) - $($_.cs-method) $($_.cs-uri-stem) - $($_.sc-status)"
            }
        }
    }

# Logs DNS
$dnsLogs = Get-Content "C:\\Windows\\System32\\DNS\\DNS.log" -ErrorAction SilentlyContinue |
    Where-Object { $_ -match "^\\d{1,2}/\\d{1,2}/\\d{4}" } |
    ForEach-Object {
        if ($_ -match "^(\\S+)\\s+(\\S+).+\\[(\\S+)\\].+Query.+for\\s+(.+)") {
            [PSCustomObject]@{
                TimeCreated = [DateTime]::Parse($matches[1] + " " + $matches[2])
                Source = "DNS"
                Details = "$($matches[3]) queried $($matches[4])"
            }
        }
    }

# Consolidation et tri chronologique
$timeline = $adEvents + $iisLogs + $dnsLogs |
    Sort-Object TimeCreated |
    Select-Object TimeCreated, Source, @{N="Event";E={
        if ($_.Id) { "EventID: $($_.Id)" }
        elseif ($_.Details) { $_.Details }
        else { $_.Message -replace "\`r\`n", " " | ForEach-Object { $_.Substring(0, [Math]::Min($_.Length, 100)) } }
    }}

# Export pour analyse
$timeline | Export-Csv -Path "C:\\Forensics\\Timeline_$(Get-Date -Format 'yyyyMMdd_HHmmss').csv" -NoTypeInformation

5. Techniques de Corrélation Avancées

5.1 Corrélation Multi-Sources

La corrélation entre différentes sources de logs permet d'identifier des patterns d'attaque complexes. Voici une fonction avancée de corrélation temporelle :

# Fonction de corrélation temporelle
function Find-CorrelatedEvents {
    param(
        [DateTime]$ReferenceTime,
        [Int]$WindowSeconds = 60,
        [String[]]$LogNames = @('Security', 'System', 'Application')
    )

    $startTime = $ReferenceTime.AddSeconds(-$WindowSeconds)
    $endTime = $ReferenceTime.AddSeconds($WindowSeconds)

    $correlatedEvents = @{}

    # Windows Events
    $correlatedEvents['WindowsEvents'] = Get-WinEvent -FilterHashtable @{
        LogName = $LogNames
        StartTime = $startTime
        EndTime = $endTime
    } -ErrorAction SilentlyContinue

    # IIS Logs
    $iisPath = "C:\\inetpub\\logs\\LogFiles\\W3SVC1\\*.log"
    $correlatedEvents['IISLogs'] = Get-Content $iisPath -ErrorAction SilentlyContinue |
        Where-Object {
            $_ -notmatch "^#" -and
            $_ -match "^(\\S+)\\s+(\\S+)"
        } | ForEach-Object {
            $fields = $_ -split '\\s+'
            $logTime = [DateTime]::Parse($fields[0] + " " + $fields[1])
            if ($logTime -ge $startTime -and $logTime -le $endTime) {
                $_
            }
        }

    # DNS Logs
    $dnsPath = "C:\\Windows\\System32\\DNS\\DNS.log"
    $correlatedEvents['DNSLogs'] = Get-Content $dnsPath -ErrorAction SilentlyContinue |
        Where-Object {
            $_ -match "^(\\d{1,2}/\\d{1,2}/\\d{4})\\s+(\\S+)"
        } | ForEach-Object {
            if ($_ -match "^(\\S+)\\s+(\\S+)") {
                $logTime = [DateTime]::Parse($matches[1] + " " + $matches[2])
                if ($logTime -ge $startTime -and $logTime -le $endTime) {
                    $_
                }
            }
        }

    return $correlatedEvents
}

# Exemple d'utilisation pour investigation d'incident
$suspiciousLogin = Get-WinEvent -FilterHashtable @{LogName='Security'; ID=4624} |
    Where-Object { $_.Message -match "NTLM" } |
    Select-Object -First 1

$correlated = Find-CorrelatedEvents -ReferenceTime $suspiciousLogin.TimeCreated -WindowSeconds 300

5.2 Analyse Comportementale et Détection d'Anomalies

function Detect-AnomalousActivity {
    param(
        [String]$BaselinePath = "C:\\Forensics\\Baseline.json",
        [Int]$ThresholdMultiplier = 3
    )

    # Chargement de la baseline
    if (Test-Path $BaselinePath) {
        $baseline = Get-Content $BaselinePath | ConvertFrom-Json
    } else {
        # Création de baseline
        $baseline = @{
            AverageLoginsPerHour = 50
            CommonServiceAccounts = @('svc_backup', 'svc_sql', 'svc_web')
            NormalDNSQueryRate = 1000
            CommonWebPaths = @('/default.aspx', '/api/health', '/login')
        }
    }

    # Analyse des activités courantes
    $currentHour = (Get-Date).AddHours(-1)

    # Analyse des logons
    $recentLogons = Get-WinEvent -FilterHashtable @{
        LogName = 'Security'
        ID = 4624
        StartTime = $currentHour
    } | Measure-Object

    if ($recentLogons.Count -gt ($baseline.AverageLoginsPerHour * $ThresholdMultiplier)) {
        Write-Warning "Anomalie détectée : Nombre de logons anormal ($($recentLogons.Count) vs baseline $($baseline.AverageLoginsPerHour))"
    }

    # Analyse des comptes de service
    $serviceAccountLogons = Get-WinEvent -FilterHashtable @{
        LogName = 'Security'
        ID = 4624
        StartTime = $currentHour
    } | Where-Object {
        $xml = [xml]$_.ToXml()
        $targetUser = $xml.Event.EventData.Data | Where-Object {$_.Name -eq 'TargetUserName'} | Select-Object -ExpandProperty '#text'
        $targetUser -like "svc_*" -and $targetUser -notin $baseline.CommonServiceAccounts
    }

    if ($serviceAccountLogons) {
        Write-Warning "Anomalie détectée : Utilisation de compte de service non référencé"
        $serviceAccountLogons | ForEach-Object {
            $xml = [xml]$_.ToXml()
            $targetUser = $xml.Event.EventData.Data | Where-Object {$_.Name -eq 'TargetUserName'} | Select-Object -ExpandProperty '#text'
            Write-Warning "  - Compte suspect : $targetUser"
        }
    }
}

5.3 Reconstruction de Chaîne d'Attaque (Kill Chain)

L'analyse selon le modèle Cyber Kill Chain permet de reconstituer les phases d'une attaque complexee. Le script suivant implémente une détection automatique des 7 phases :

6. Outils et Automatisation

6.1 Script Principal d'Extraction Forensique

6.2 Analyse Automatisée avec SIGMA Rules

L'implémentation de règles SIGMA permet une détection standardisée des patterns d'attaque connus. Voici un framework d'intégration SIGMA pour Windows : Pour approfondir, consultez Comparatif Outils DFIR.

# Implémentation de SIGMA rules pour Windows
function Test-SigmaRule {
    param(
        [String]$RulePath,
        [String]$EventLogPath
    )

    # Parsing de la règle SIGMA (format YAML simplifié)
    $rule = Get-Content $RulePath -Raw | ConvertFrom-Yaml

    $detection = $rule.detection
    $selection = $detection.selection

    # Construction de la requête
    $filter = @{
        Path = $EventLogPath
    }

    if ($selection.EventID) {
        $filter['ID'] = $selection.EventID
    }

    # Recherche des événements correspondants
    $matches = Get-WinEvent -FilterHashtable $filter -ErrorAction SilentlyContinue | Where-Object {
        $xml = [xml]$_.ToXml()
        $match = $true

        foreach ($criterion in $selection.Keys) {
            if ($criterion -ne 'EventID') {
                $value = $xml.Event.EventData.Data |
                    Where-Object {$_.Name -eq $criterion} |
                    Select-Object -ExpandProperty '#text'

                if ($value -notmatch $selection[$criterion]) {
                    $match = $false
                    break
                }
            }
        }
        $match
    }

    return [PSCustomObject]@{
        Rule = $rule.title
        Severity = $rule.level
        MatchCount = $matches.Count
        Matches = $matches
    }
}

7. Recommandations et Bonnes Pratiques

7.1 Configuration Préventive

Pour optimiser la capacité d'investigation forensique, les configurations suivantes sont recommandées :

7.2 Centralisation et Archivage

La mise en place d'une architecture de centralisation des logs est cruciale pour les grandes infrastructures. Windows Event Forwarding (WEF) permet la collecte centralisée sans infrastructure SIEM lourde :

# Configuration Windows Event Forwarding (WEF)
wecutil cs ForensicsSubscription.xml

7.3 Documentation et Rapport

La documentation rigoureuse est essentielle pour la validité légale de l'investigation. Un framework de génération de rapport forensique complet doit inclure :

• Informations du cas : Nom, numéro, examinateur, date, système analysé
• Chain of Custody : Hashes SHA-256 de tous les fichiers d'évidence
• Findings Summary : Résultats critiques, activités suspectes, timeline consolidée, IOCs
• Recommandations : Mesures correctives et préventives
• Annexes techniques : Logs complets, scripts utilisés, méthodologie détaillée

Questions frequentes

Pour approfondir, consultez les ressources officielles : SANS White Papers, NVD - NIST et ANSSI.

Nous avons entraîné un modèle spécialisé CyberSec-Assistant-3B pour assister les professionnels de la cybersécurité sur ce type de problématique.

Conclusion

L'analyse forensique des infrastructures Windows Server 2025 requiert une approche méthodologique rigoureuse combinant expertise technique approfondie et utilisation d'outils spécialisés. La corrélation entre les différentes sources de logs (IIS, DNS, AD DS) permet de reconstituer avec précision la chronologie des événements lors d'un incident de sécurité.

📌 Points Clés à Retenir :

1. Configuration préventive : Une configuration adéquate de l'audit et de la rétention des logs est essentielle pour disposer des données nécessaires lors d'une investigation.
2. Approche multi-sources : La corrélation entre IIS, DNS et AD DS révèle des patterns d'attaque invisibles lors de l'analyse isolée de chaque source.
3. Automatisation : L'utilisation de scripts PowerShell et de règles SIGMA permet d'automatiser la détection et d'accélérer le triage lors d'incidents majeurs.
4. Documentation rigoureuse : La traçabilité et la documentation détaillée sont cruciales pour la validité légale et la reproductibilité de l'investigation.
5. Évolution continue : Les techniques d'attaque évoluant constamment, la veille technologique et l'adaptation des méthodologies d'investigation sont indispensables.

Cette méthodologie, appliquée de manière systématique, permet aux équipes de sécurité de répondre efficacement aux incidents, d'identifier les vecteurs de compromission, et de mettre en place les mesures correctives appropriées pour renforcer la posture de sécurité de l'infrastructure.

Besoin d'une Investigation Forensique Windows Server ?

AYI NEDJIMI CONSULTANTS offre des services spécialisés d'investigation forensique pour infrastructures Windows Server : triage d'incidents, analyse approfondie, reconstruction chronologique, rapports conformes aux standards légaux.

Contactez nos Experts Forensics

Partager cet article

Twitter LinkedIn Copier le lien

Ayi NEDJIMI

Expert Cybersécurité & Intelligence Artificielle

Consultant et formateur spécialisé en tests d'intrusion, Active Directory, et développement de solutions IA. 15+ années d'expérience en sécurité offensive.

Articles connexes

Forensique Mémoire : Guide Pratique Volatility 3 en 2026

08/03/2026

Timeline Forensique : Reconstituer Pas à Pas une : Guide

08/03/2026

Forensique Cloud : Analyser les Logs CloudTrail, Azure

08/03/2026

Article précédent

Registry Forensics : Guide Expert Analyse Securite

Article suivant

Memory Forensics : Strategies de Detection et de Remediation

Commentaires

Aucun commentaire pour le moment. Soyez le premier à commenter !

Laisser un commentaire

Nom *

Email * (non publié)

Commentaire *

Publier