ID d'événement Windows 4670 – Sécurité : Permissions de l'objet modifiées

Commencez par examiner les entrées spécifiques de l'ID d'événement 4670 pour comprendre quelles autorisations ont été modifiées et par qui.

1. Ouvrez Observateur d'événements → Journaux Windows → Sécurité
2. Filtrez pour l'ID d'événement 4670 en utilisant l'option de filtre
3. Double-cliquez sur les événements 4670 récents pour voir les informations détaillées
4. Examinez les champs clés suivants :
   • Sujet : Compte qui a effectué la modification
   • Objet : Fichier, dossier ou clé de registre cible
   • Informations sur le processus : Application qui a initié la modification
   • Informations sur la demande d'accès : Autorisations spécifiques modifiées
5. Utilisez PowerShell pour interroger plusieurs événements efficacement :

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

Recherchez des motifs dans le timing, les comptes utilisateurs ou les objets cibles qui pourraient indiquer des modifications non autorisées.

Utilisez PowerShell pour extraire et analyser les détails des changements de permission à partir des journaux d'événements ID 4670.

1. Créez un script PowerShell pour analyser les détails de l'événement ID 4670 :

# Obtenez les événements détaillés 4670 des dernières 24 heures
$Events = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4670; StartTime=(Get-Date).AddDays(-1)}

foreach ($Event in $Events) {
    $XML = [xml]$Event.ToXml()
    $EventData = $XML.Event.EventData.Data
    
    Write-Host "Heure: $($Event.TimeCreated)"
    Write-Host "Sujet: $($EventData | Where-Object {$_.Name -eq 'SubjectUserName'} | Select-Object -ExpandProperty '#text')"
    Write-Host "Objet: $($EventData | Where-Object {$_.Name -eq 'ObjectName'} | Select-Object -ExpandProperty '#text')"
    Write-Host "Processus: $($EventData | Where-Object {$_.Name -eq 'ProcessName'} | Select-Object -ExpandProperty '#text')"
    Write-Host "---"
}

2. Exportez les résultats en CSV pour une analyse plus approfondie :

$Results = @()
foreach ($Event in $Events) {
    $XML = [xml]$Event.ToXml()
    $EventData = $XML.Event.EventData.Data
    
    $Results += [PSCustomObject]@{
        TimeCreated = $Event.TimeCreated
        SubjectUser = ($EventData | Where-Object {$_.Name -eq 'SubjectUserName'}).'#text'
        ObjectName = ($EventData | Where-Object {$_.Name -eq 'ObjectName'}).'#text'
        ProcessName = ($EventData | Where-Object {$_.Name -eq 'ProcessName'}).'#text'
    }
}
$Results | Export-Csv -Path "C:\Temp\Event4670_Analysis.csv" -NoTypeInformation

Cette méthode aide à identifier les changements de permission en masse ou les motifs suspects à travers plusieurs objets.

Assurez-vous de configurer correctement la politique d'audit pour capturer tous les événements pertinents de changement de permission.

1. Ouvrez Group Policy Management Console ou exécutez gpedit.msc pour la politique locale
2. Accédez à Configuration de l'ordinateur → Paramètres Windows → Paramètres de sécurité → Configuration avancée de la politique d'audit
3. Développez Accès aux objets et configurez ces politiques:
   • Audit du système de fichiers: Activer Succès et Échec
   • Audit du registre: Activer Succès et Échec
   • Audit de la manipulation des poignées: Activer Succès
4. Appliquez la politique et forcez une mise à jour:

gpupdate /force

5. Vérifiez les paramètres d'audit en utilisant auditpol:

auditpol /get /category:"Object Access"

6. Pour des objets spécifiques, configurez l'audit SACL:

# Exemple: Activer l'audit sur un dossier spécifique
$Path = "C:\ImportantData"
$ACL = Get-Acl $Path
$AccessRule = New-Object System.Security.AccessControl.FileSystemAuditRule("Everyone", "ChangePermissions", "ContainerInherit,ObjectInherit", "None", "Success,Failure")
$ACL.SetAuditRule($AccessRule)
Set-Acl $Path $ACL

Configurez le transfert d'événements Windows pour surveiller de manière centralisée l'ID d'événement 4670 dans votre environnement.

1. Configurez le serveur collecteur en activant le service Windows Event Collector :

Start-Service Wecsvc
Set-Service Wecsvc -StartupType Automatic

2. Créez un fichier XML d'abonnement personnalisé pour l'ID d'événement 4670 :

<?xml version="1.0" encoding="UTF-8"?>
<Subscription xmlns="http://schemas.microsoft.com/2006/03/windows/events/subscription">
    <SubscriptionId>PermissionChanges</SubscriptionId>
    <SubscriptionType>SourceInitiated</SubscriptionType>
    <Description>Surveiller les changements de permission via l'ID d'événement 4670</Description>
    <Enabled>true</Enabled>
    <Uri>http://schemas.microsoft.com/wbem/wsman/1/windows/EventLog</Uri>
    <ConfigurationMode>Custom</ConfigurationMode>
    <Query>
        <![CDATA[
        <QueryList>
            <Query Id="0">
                <Select Path="Security">*[System[EventID=4670]]</Select>
            </Query>
        </QueryList>
        ]]>
    </Query>
</Subscription>

3. Créez l'abonnement en utilisant wecutil :

wecutil cs C:\Path\To\PermissionChanges.xml

4. Configurez les ordinateurs sources pour transférer les événements :

# Exécuter sur les ordinateurs sources
winrm quickconfig
wecutil qc

5. Surveillez le journal des événements transférés :

Get-WinEvent -LogName "ForwardedEvents" | Where-Object {$_.Id -eq 4670} | Select-Object TimeCreated, MachineName, Message

Cette approche centralisée permet une surveillance à l'échelle de l'entreprise des changements de permission et prend en charge les flux de travail d'alerte automatisés.

Effectuez une analyse médico-légale approfondie en corrélant l'ID d'événement 4670 avec les événements de sécurité et les activités système connexes.

1. Créez une requête de corrélation complète pour identifier les modèles de changement de permission suspects :

# Script de corrélation avancée pour l'analyse des changements de permission
$StartTime = (Get-Date).AddDays(-7)
$EndTime = Get-Date

# Obtenez tous les changements de permission (4670) et les événements connexes
$PermissionChanges = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4670; StartTime=$StartTime; EndTime=$EndTime}
$ObjectAccess = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4663; StartTime=$StartTime; EndTime=$EndTime}
$LogonEvents = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4624,4625; StartTime=$StartTime; EndTime=$EndTime}

# Analysez les changements de permission par utilisateur
$UserActivity = @{}
foreach ($Event in $PermissionChanges) {
    $XML = [xml]$Event.ToXml()
    $User = ($XML.Event.EventData.Data | Where-Object {$_.Name -eq 'SubjectUserName'}).'#text'
    $Object = ($XML.Event.EventData.Data | Where-Object {$_.Name -eq 'ObjectName'}).'#text'
    
    if (-not $UserActivity[$User]) {
        $UserActivity[$User] = @()
    }
    $UserActivity[$User] += @{
        Time = $Event.TimeCreated
        Object = $Object
        EventId = $Event.Id
    }
}

# Identifiez les utilisateurs avec des changements de permission excessifs
$SuspiciousUsers = $UserActivity.GetEnumerator() | Where-Object {$_.Value.Count -gt 10} | Sort-Object {$_.Value.Count} -Descending
Write-Host "Utilisateurs avec une activité de changement de permission élevée :"
$SuspiciousUsers | ForEach-Object { Write-Host "$($_.Key): $($_.Value.Count) changements" }

2. Vérifiez les changements de permission suivis d'un accès immédiat à l'objet :

# Corrélez les changements de permission avec les tentatives d'accès ultérieures
foreach ($PermChange in $PermissionChanges) {
    $ChangeTime = $PermChange.TimeCreated
    $XML = [xml]$PermChange.ToXml()
    $ObjectName = ($XML.Event.EventData.Data | Where-Object {$_.Name -eq 'ObjectName'}).'#text'
    
    # Recherchez les tentatives d'accès dans les 5 minutes suivant le changement de permission
    $RelatedAccess = $ObjectAccess | Where-Object {
        $_.TimeCreated -gt $ChangeTime -and 
        $_.TimeCreated -lt $ChangeTime.AddMinutes(5) -and
        $_.Message -like "*$ObjectName*"
    }
    
    if ($RelatedAccess) {
        Write-Host "Escalade de privilèges potentielle détectée :"
        Write-Host "Permission modifiée : $ChangeTime sur $ObjectName"
        Write-Host "Suivi par des tentatives d'accès : $($RelatedAccess.Count)"
    }
}

3. Générez un rapport de sécurité complet :

# Créez un rapport médico-légal détaillé
$Report = @"
RAPPORT D'ANALYSE DE SÉCURITÉ - ID D'ÉVÉNEMENT 4670
Généré : $(Get-Date)

RÉSUMÉ :
Total des changements de permission : $($PermissionChanges.Count)
Utilisateurs uniques impliqués : $($UserActivity.Keys.Count)
Plage de temps : $StartTime à $EndTime

UTILISATEURS LES PLUS ACTIFS :
$($SuspiciousUsers | ForEach-Object { "$($_.Key): $($_.Value.Count) changements" } | Out-String)

RECOMMANDATIONS :
1. Examiner les comptes avec des niveaux d'activité élevés
2. Valider la justification commerciale pour les changements en masse
3. Mettre en œuvre une surveillance supplémentaire pour les utilisateurs signalés
4. Envisager de mettre en œuvre des flux de travail d'approbation pour les objets sensibles
"@

$Report | Out-File -FilePath "C:\Temp\Security_Analysis_$(Get-Date -Format 'yyyyMMdd_HHmmss').txt"