Renforcement EDR contre les tueurs de logiciels malveillants en 2026

Commencez par configurer les paramètres de protection contre les altérations les plus forts dans Microsoft Defender pour Endpoint. Cela empêche les logiciels malveillants de désactiver vos services de sécurité par manipulation du registre ou arrêt de service.

Accédez au portail Microsoft Defender à l'adresse security.microsoft.com et connectez-vous avec votre compte d'administrateur de sécurité. Allez à Endpoints > Configuration management > Endpoint security policies.

# Vérifier l'état actuel de la protection contre les altérations
Get-MpPreference | Select-Object DisableTamperProtection

# Activer la protection contre les altérations via PowerShell (nécessite admin)
Set-MpPreference -DisableTamperProtection $false

# Vérifier que le paramètre a pris effet
Get-MpComputerStatus | Select-Object TamperProtectionSource

Dans le portail, créez une nouvelle politique Antivirus ciblant vos points de terminaison critiques. Réglez Protection contre les altérations sur Activé et Niveau de protection cloud sur Élevé. Cela garantit des mises à jour de protection en temps réel et empêche les altérations locales.

Vérification : Exécutez Get-MpComputerStatus et confirmez que TamperProtectionSource affiche "ATP" (géré par le cloud).

Les règles de réduction de la surface d'attaque (ASR) fournissent un blocage comportemental contre les techniques de malware courantes utilisées par les tueurs d'EDR comme BlackSanta. Configurez ces règles pour empêcher le vol d'identifiants, l'injection de processus et la manipulation de services.

Dans le portail Defender, accédez à Endpoints > Configuration management > Attack surface reduction. Créez une nouvelle politique avec ces règles critiques :

# Configurer les règles ASR via PowerShell
$ASRRules = @{
    # Bloquer le vol d'identifiants du sous-système de sécurité locale de Windows
    "9e6c4e1f-7d60-472f-ba1a-a39ef669e4b2" = "Enabled"
    # Bloquer les créations de processus provenant de commandes PSExec et WMI
    "d1e49aac-8f56-4280-b9ba-993a6d77406c" = "Enabled"
    # Bloquer les processus non fiables et non signés qui s'exécutent depuis l'USB
    "b2b3f03d-6a65-4f7b-a9c7-1c7ef74a9ba4" = "Enabled"
    # Bloquer l'exécution de fichiers exécutables à moins qu'ils ne répondent aux critères de prévalence, d'âge ou de liste de confiance
    "01443614-cd74-433a-b99e-2ecdc07bfc25" = "Enabled"
    # Bloquer le lancement de contenu exécutable téléchargé par JavaScript ou VBScript
    "d3e037e1-3eb8-44c8-a917-57927947596d" = "Enabled"
}

# Appliquer les règles ASR
foreach ($rule in $ASRRules.GetEnumerator()) {
    Set-MpPreference -AttackSurfaceReductionRules_Ids $rule.Key -AttackSurfaceReductionRules_Actions $rule.Value
}

# Vérifier que les règles ASR sont actives
Get-MpPreference | Select-Object AttackSurfaceReductionRules_Ids, AttackSurfaceReductionRules_Actions

Réglez le mode de politique sur Block pour les environnements de production. Pour les tests, utilisez d'abord le mode Audit pour identifier les faux positifs potentiels.

Vérification : Vérifiez les événements ASR dans le Visualiseur d'événements Windows sous Applications and Services Logs > Microsoft > Windows > Windows Defender > Operational.

Configurez la surveillance comportementale pour détecter et bloquer les techniques de tueur EDR en temps réel. Cela implique de configurer des règles de détection personnalisées et d'activer des fonctionnalités avancées de protection cloud.

Dans le portail Defender, allez à Hunting > Custom detection rules et créez une nouvelle règle ciblant les tentatives de manipulation EDR :

// Requête KQL personnalisée pour détecter la falsification du service EDR
DeviceProcessEvents
| where Timestamp > ago(1h)
| where ProcessCommandLine has_any("sc stop", "sc delete", "sc config", "net stop", "taskkill")
| where ProcessCommandLine has_any("windefend", "sense", "csagent", "csfalconservice", "crowdstrike")
| where InitiatingProcessFileName !in ("services.exe", "svchost.exe")
| project Timestamp, DeviceName, ProcessCommandLine, InitiatingProcessFileName, InitiatingProcessCommandLine
| summarize EventCount = count() by DeviceName, ProcessCommandLine
| where EventCount >= 1

Activez les paramètres de protection cloud avancée via PowerShell :

# Activer la protection cloud avancée
Set-MpPreference -MAPSReporting Advanced
Set-MpPreference -SubmitSamplesConsent SendAllSamples
Set-MpPreference -CloudBlockLevel HighPlus
Set-MpPreference -CloudExtendedTimeout 50

# Activer la surveillance comportementale
Set-MpPreference -DisableBehaviorMonitoring $false
Set-MpPreference -DisableRealtimeMonitoring $false
Set-MpPreference -DisableIOAVProtection $false

# Vérifier les paramètres
Get-MpPreference | Select-Object MAPSReporting, CloudBlockLevel, DisableBehaviorMonitoring

Configurez la règle de détection personnalisée pour déclencher des alertes et des actions de réponse automatique lorsque la falsification EDR est détectée.

Vérification : Testez la règle en exécutant une commande bénigne comme sc query windefend et confirmez que l'alerte apparaît dans la file d'attente des incidents du portail Defender.

Si vous utilisez CrowdStrike Falcon en parallèle ou à la place de Defender, mettez en œuvre un renforcement de la protection du capteur pour empêcher les logiciels malveillants de désactiver l'agent Falcon.

Accédez à la console CrowdStrike Falcon et naviguez vers Configuration > Politiques de mise à jour des capteurs. Créez une nouvelle politique avec ces paramètres de renforcement :

# Vérifier l'état du capteur Falcon (Linux/macOS)
sudo /opt/CrowdStrike/falconctl -g --cid
sudo /opt/CrowdStrike/falconctl -g --aid

# Activer la protection contre la falsification du capteur
sudo /opt/CrowdStrike/falconctl -s --feature=TamperProtection --value=true

# Configurer la surveillance comportementale avancée
sudo /opt/CrowdStrike/falconctl -s --feature=BehavioralProtection --value=true
sudo /opt/CrowdStrike/falconctl -s --feature=MachineLearning --value=true

# Vérifier la configuration
sudo /opt/CrowdStrike/falconctl -g --feature

Pour les points de terminaison Windows, configurez Falcon via la console de gestion :

# Vérification du capteur Falcon Windows
$FalconService = Get-Service -Name "CSFalconService" -ErrorAction SilentlyContinue
if ($FalconService) {
    Write-Host "Statut Falcon : $($FalconService.Status)"
    Get-ItemProperty -Path "HKLM:\SYSTEM\CrowdStrike\{9b03c1d9-3138-44ed-9fae-d9f4c034b88d}\{16e0423f-7058-48c9-a204-725362b67639}\Default" -Name "CID"
}

# Vérifier les clés de registre de protection contre la falsification
Get-ItemProperty -Path "HKLM:\SOFTWARE\CrowdStrike\*" -Name "*Tamper*" -ErrorAction SilentlyContinue

Dans la console Falcon, activez Protection contre la falsification du capteur, Surveillance de l'exécution basée sur des scripts et Surveillance des processus suspects dans vos politiques de prévention.

Vérification : Essayez d'arrêter le service CrowdStrike manuellement - cela devrait être bloqué et générer une alerte dans la console Falcon.

Implémentez l'isolation des processus pour empêcher les logiciels malveillants d'accéder aux espaces mémoire des services de sécurité et restreindre les privilèges qui pourraient être utilisés pour désactiver les outils EDR.

Activez Windows Defender Application Guard et configurez l'isolation des processus :

# Activer Windows Defender Application Guard
Enable-WindowsOptionalFeature -Online -FeatureName "Windows-Defender-ApplicationGuard" -All

# Configurer les politiques d'atténuation des processus
Set-ProcessMitigation -System -Enable DEP,SEHOP,ForceRelocateImages,RequireInfo
Set-ProcessMitigation -Name "windefend.exe" -Enable CFG,StrictCFG,SuppressExports
Set-ProcessMitigation -Name "MsSense.exe" -Enable CFG,StrictCFG,SuppressExports

# Vérifier les paramètres d'atténuation
Get-ProcessMitigation -System
Get-ProcessMitigation -Name "windefend.exe"

Configurez le contrôle de compte utilisateur (UAC) pour une sécurité maximale et implémentez un accès au moindre privilège :

# Définir l'UAC au niveau le plus élevé
Set-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System" -Name "ConsentPromptBehaviorAdmin" -Value 2
Set-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System" -Name "ConsentPromptBehaviorUser" -Value 3
Set-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System" -Name "EnableLUA" -Value 1

# Restreindre les privilèges de débogage
secedit /export /cfg C:\temp\current_policy.inf
# Modifier le fichier de politique pour supprimer SeDebugPrivilege des comptes non essentiels
secedit /configure /db C:\temp\policy.sdb /cfg C:\temp\modified_policy.inf

Créez une stratégie de groupe pour empêcher les modifications non autorisées des services :

# Configurer le durcissement des services via le registre
$ServiceHardeningKeys = @(
    "HKLM:\SYSTEM\CurrentControlSet\Services\WinDefend",
    "HKLM:\SYSTEM\CurrentControlSet\Services\Sense",
    "HKLM:\SYSTEM\CurrentControlSet\Services\CSFalconService"
)

foreach ($key in $ServiceHardeningKeys) {
    if (Test-Path $key) {
        # Définir le service pour démarrage automatique et empêcher la modification
        Set-ItemProperty -Path $key -Name "Start" -Value 2
        Set-ItemProperty -Path $key -Name "Type" -Value 32
        
        # Définir des permissions restrictives
        $acl = Get-Acl $key
        $acl.SetAccessRuleProtection($true, $false)
        Set-Acl -Path $key -AclObject $acl
    }
}

Vérification : Utilisez Process Monitor pour confirmer que les processus non privilégiés ne peuvent pas accéder à la mémoire des services de sécurité ou aux clés de registre.

Configurez vos solutions EDR pour exploiter les flux de renseignements sur les menaces en temps réel afin d'identifier et de bloquer les signatures et comportements connus des tueurs d'EDR avant qu'ils ne s'exécutent.

Dans Microsoft Defender, activez l'intégration des renseignements sur les menaces :

# Activer Microsoft Defender Threat Intelligence
Set-MpPreference -SignatureScheduleDay Everyday
Set-MpPreference -SignatureScheduleTime 120  # 2 AM
Set-MpPreference -SignatureUpdateInterval 1   # Toutes les heures

# Configurer la protection fournie par le cloud
Set-MpPreference -MAPSReporting Advanced
Set-MpPreference -CloudBlockLevel HighPlus

# Activer la protection réseau
Set-MpPreference -EnableNetworkProtection Enabled

# Vérifier les paramètres de renseignement sur les menaces
Get-MpComputerStatus | Select-Object AntivirusSignatureLastUpdated, NISSignatureLastUpdated

Créez des indicateurs de compromission (IOC) personnalisés pour les tueurs d'EDR connus :

// Créer un IOC personnalisé pour les modèles de malware BlackSanta
let BlackSantaIOCs = datatable(IndicatorType: string, Indicator: string, Action: string)
[
    "FileSha256", "a1b2c3d4e5f6789012345678901234567890abcdef1234567890abcdef123456", "Block",
    "ProcessName", "edr_killer.exe", "Block",
    "CommandLine", "*sc stop windefend*", "Alert",
    "CommandLine", "*taskkill /f /im MsSense.exe*", "Block",
    "RegistryKey", "HKLM\\SOFTWARE\\Microsoft\\Windows Defender\\*", "Alert"
];
BlackSantaIOCs

Configurez des actions de réponse automatisées dans le portail Defender :

{
  "automationRules": [
    {
      "name": "Block EDR Killer Execution",
      "conditions": {
        "threatCategory": "Malware",
        "threatName": "*EDR*Killer*",
        "severity": "High"
      },
      "actions": [
        "isolateDevice",
        "quarantineFile",
        "collectInvestigationPackage"
      ]
    }
  ]
}

Pour CrowdStrike, configurez des règles IOA (Indicateur d'Attaque) personnalisées :

# Télécharger des règles IOA personnalisées via l'API Falcon
curl -X POST "https://api.crowdstrike.com/ioa/entities/rules/v1" \
  -H "Authorization: Bearer $FALCON_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "rules": [{
      "name": "EDR Service Tampering Detection",
      "pattern_severity": "high",
      "ruletype_id": "process_creation",
      "field_values": [{
        "name": "CommandLine",
        "type": "excludes",
        "values": ["*sc stop*windefend*", "*net stop*sense*"]
      }]
    }]
  }'

Vérification : Testez la détection des IOC en créant un fichier inoffensif avec un hachage connu mauvais et confirmez qu'il est immédiatement bloqué et mis en quarantaine.

Implémentez une journalisation complète pour détecter les tentatives de falsification d'EDR et assurez-vous d'avoir des preuves médico-légales de toute manipulation d'outil de sécurité.

Activez la journalisation avancée de Windows pour les événements de sécurité :

# Activer les politiques d'audit avancées
auditpol /set /subcategory:"Process Creation" /success:enable /failure:enable
auditpol /set /subcategory:"Process Termination" /success:enable /failure:enable
auditpol /set /subcategory:"Handle Manipulation" /success:enable /failure:enable
auditpol /set /subcategory:"Registry" /success:enable /failure:enable
auditpol /set /subcategory:"System Integrity" /success:enable /failure:enable

# Configurer l'audit de la ligne de commande
Set-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System\Audit" -Name "ProcessCreationIncludeCmdLine_Enabled" -Value 1

# Activer la journalisation PowerShell
Set-ItemProperty -Path "HKLM:\SOFTWARE\Policies\Microsoft\Windows\PowerShell\ModuleLogging" -Name "EnableModuleLogging" -Value 1
Set-ItemProperty -Path "HKLM:\SOFTWARE\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging" -Name "EnableScriptBlockLogging" -Value 1

# Vérifier les paramètres d'audit
auditpol /get /category:*

Configurer Sysmon pour une surveillance détaillée des processus :

<!-- Configuration Sysmon pour la protection EDR -->
<Sysmon schemaversion="4.82">
  <EventFiltering>
    <ProcessCreate onmatch="include">
      <CommandLine condition="contains">sc stop</CommandLine>
      <CommandLine condition="contains">sc delete</CommandLine>
      <CommandLine condition="contains">net stop</CommandLine>
      <CommandLine condition="contains">taskkill</CommandLine>
      <CommandLine condition="contains">windefend</CommandLine>
      <CommandLine condition="contains">sense</CommandLine>
      <CommandLine condition="contains">csagent</CommandLine>
    </ProcessCreate>
    <RegistryEvent onmatch="include">
      <TargetObject condition="contains">Windows Defender</TargetObject>
      <TargetObject condition="contains">CrowdStrike</TargetObject>
    </RegistryEvent>
  </EventFiltering>
</Sysmon>

Installer et configurer Sysmon :

# Télécharger et installer Sysmon
Invoke-WebRequest -Uri "https://download.sysinternals.com/files/Sysmon.zip" -OutFile "C:\temp\Sysmon.zip"
Expand-Archive -Path "C:\temp\Sysmon.zip" -DestinationPath "C:\temp\Sysmon"

# Installer avec une configuration personnalisée
C:\temp\Sysmon\Sysmon64.exe -accepteula -i C:\temp\sysmon-config.xml

# Vérifier l'installation
Get-Service -Name "Sysmon64"
Get-WinEvent -LogName "Microsoft-Windows-Sysmon/Operational" -MaxEvents 5

Configurer le transfert de journaux vers votre SIEM :

# Configurer le transfert d'événements Windows
wecutil qc /q

# Créer une souscription pour les événements de sécurité
$SubscriptionXML = @"
<Subscription xmlns="http://schemas.microsoft.com/2006/03/windows/events/subscription">
    <SubscriptionId>EDR-Protection-Events</SubscriptionId>
    <SubscriptionType>SourceInitiated</SubscriptionType>
    <Description>Événements de détection de falsification EDR</Description>
    <Enabled>true</Enabled>
    <Uri>http://schemas.microsoft.com/wbem/wsman/1/windows/EventLog</Uri>
    <ConfigurationMode>Normal</ConfigurationMode>
    <Query>
        <![CDATA[
        <QueryList>
            <Query Id="0">
                <Select Path="Security">*[System[(EventID=4688 or EventID=4689)]]</Select>
                <Select Path="Microsoft-Windows-Sysmon/Operational">*[System[(EventID=1 or EventID=13)]]</Select>
            </Query>
        </QueryList>
        ]]>
    </Query>
</Subscription>
"@

$SubscriptionXML | Out-File -FilePath "C:\temp\edr-subscription.xml"
wecutil cs "C:\temp\edr-subscription.xml"

Vérification : Générez des événements de test en exécutant des commandes bénignes et confirmez qu'ils apparaissent à la fois dans le journal des événements Windows local et dans votre SIEM dans les 5 minutes.

Effectuez des tests complets pour vous assurer que vos mesures de durcissement EDR empêchent efficacement les logiciels malveillants de désactiver les outils de sécurité tout en maintenant la fonctionnalité du système.

Créez un environnement de test contrôlé et simulez des attaques de type EDR killer :

# Script de test pour valider la protection EDR (à exécuter dans un environnement de test isolé)
$TestResults = @()

# Test 1 : Tentative d'arrêt du service Windows Defender
try {
    Stop-Service -Name "WinDefend" -Force -ErrorAction Stop
    $TestResults += "ÉCHEC : Service Windows Defender arrêté"
} catch {
    $TestResults += "RÉUSSITE : Protection du service Windows Defender active"
}

# Test 2 : Tentative de désactivation de la protection en temps réel
try {
    Set-MpPreference -DisableRealtimeMonitoring $true -ErrorAction Stop
    $TestResults += "ÉCHEC : Protection en temps réel désactivée"
} catch {
    $TestResults += "RÉUSSITE : Protection contre la falsification de la protection en temps réel active"
}

# Test 3 : Tentative de modification des clés de registre
try {
    Set-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows Defender" -Name "DisableAntiSpyware" -Value 1 -ErrorAction Stop
    $TestResults += "ÉCHEC : Modification du registre réussie"
} catch {
    $TestResults += "RÉUSSITE : Protection du registre active"
}

# Test 4 : Tentative de tuer les processus de sécurité
try {
    Stop-Process -Name "MsSense" -Force -ErrorAction Stop
    $TestResults += "ÉCHEC : Processus de sécurité terminé"
} catch {
    $TestResults += "RÉUSSITE : Protection des processus active"
}

# Afficher les résultats
$TestResults | ForEach-Object { Write-Host $_ }

# Générer un rapport de synthèse
$PassCount = ($TestResults | Where-Object { $_ -like "RÉUSSITE:*" }).Count
$FailCount = ($TestResults | Where-Object { $_ -like "ÉCHEC:*" }).Count
Write-Host "\nRésumé : $PassCount tests réussis, $FailCount tests échoués"

Testez l'efficacité des règles ASR avec des attaques simulées :

# Tester les règles ASR avec le fichier de test EICAR
$EICARString = 'X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*'
$EICARString | Out-File -FilePath "C:\temp\eicar.txt" -Encoding ASCII

# Tentative d'exécution - devrait être bloquée
try {
    Start-Process -FilePath "C:\temp\eicar.txt" -ErrorAction Stop
    Write-Host "ÉCHEC : Fichier EICAR exécuté"
} catch {
    Write-Host "RÉUSSITE : Fichier EICAR bloqué par ASR"
}

# Vérifier les événements ASR
Get-WinEvent -LogName "Microsoft-Windows-Windows Defender/Operational" | 
    Where-Object { $_.Id -eq 1121 -or $_.Id -eq 1122 } | 
    Select-Object TimeCreated, Id, LevelDisplayName, Message | 
    Format-Table -AutoSize

Validez la surveillance comportementale avec une simulation d'injection de processus :

// Programme de test C# pour valider la protection des processus
using System;
using System.Diagnostics;
using System.Runtime.InteropServices;

class EDRTest
{
    [DllImport("kernel32.dll")]
    static extern IntPtr OpenProcess(uint dwDesiredAccess, bool bInheritHandle, int dwProcessId);
    
    static void Main()
    {
        try
        {
            // Tentative d'ouverture du processus Defender avec accès en écriture
            Process[] defenderProcesses = Process.GetProcessesByName("MsSense");
            if (defenderProcesses.Length > 0)
            {
                IntPtr handle = OpenProcess(0x001F0FFF, false, defenderProcesses[0].Id);
                if (handle != IntPtr.Zero)
                {
                    Console.WriteLine("ÉCHEC : Accès en écriture obtenu au processus Defender");
                }
                else
                {
                    Console.WriteLine("RÉUSSITE : Protection des processus empêchant l'accès");
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"RÉUSSITE : Exception capturée - {ex.Message}");
        }
    }
}

Compilez et exécutez le programme de test :

# Compiler le programme de test
Add-Type -TypeDefinition $CSharpCode -OutputAssembly "C:\temp\EDRTest.exe"

# Exécuter le test
Start-Process -FilePath "C:\temp\EDRTest.exe" -Wait -NoNewWindow

Créez un rapport de validation complet :

# Générer un rapport de validation du durcissement EDR
$Report = @"
Rapport de validation du durcissement EDR
Généré : $(Get-Date)

Statut de la protection contre la falsification :
$(Get-MpComputerStatus | Select-Object TamperProtectionSource, AntivirusEnabled | Format-List | Out-String)

Statut des règles ASR :
$(Get-MpPreference | Select-Object AttackSurfaceReductionRules_Ids | Format-List | Out-String)

Surveillance comportementale :
$(Get-MpPreference | Select-Object DisableBehaviorMonitoring, DisableRealtimeMonitoring | Format-List | Out-String)

Statut du service :
$(Get-Service -Name "WinDefend", "Sense" | Format-Table | Out-String)

Événements de sécurité récents :
$(Get-WinEvent -LogName "Microsoft-Windows-Windows Defender/Operational" -MaxEvents 10 | Format-Table | Out-String)
"@

$Report | Out-File -FilePath "C:\temp\EDR-Hardening-Report.txt"
Write-Host "Rapport de validation enregistré dans C:\temp\EDR-Hardening-Report.txt"

Vérification : Examinez le rapport de validation et confirmez que tous les mécanismes de protection critiques sont actifs et bloquent les attaques simulées. Tout échec indique des domaines nécessitant un durcissement supplémentaire.