Comment détecter et bloquer les attaques par force brute sur Windows Server avec PowerShell

Tout d'abord, assurez-vous que Windows enregistre les tentatives d'authentification échouées. Ouvrez la Console de gestion des stratégies de groupe et accédez aux paramètres de la stratégie d'audit.

gpedit.msc

Accédez à Configuration de l'ordinateur > Paramètres Windows > Paramètres de sécurité > Stratégies locales > Stratégie d'audit. Activez Audit des événements de connexion pour les réussites et les échecs.

Alternativement, configurez cela via PowerShell :

auditpol /set /category:"Logon/Logoff" /success:enable /failure:enable

Appliquez les modifications immédiatement :

gpupdate /force

Vérification : Vérifiez que l'ID d'événement 4625 apparaît dans le journal des événements de sécurité après une tentative RDP échouée :

Get-WinEvent -FilterHashtable @{LogName='Security'; ID=4625} -MaxEvents 5

Créez une règle de pare-feu désactivée que votre script PowerShell remplira avec des adresses IP malveillantes. Cette approche empêche de bloquer accidentellement tout le trafic.

Ouvrez le Pare-feu Windows Defender avec sécurité avancée en tant qu'administrateur :

wf.msc

Créez une nouvelle règle entrante via PowerShell :

New-NetFirewallRule -DisplayName "BlockAttackers" -Direction Inbound -Protocol TCP -Action Block -Enabled False -RemoteAddress "127.0.0.1"

La règle commence désactivée avec une adresse IP de remplacement. Votre script mettra à jour le champ RemoteAddress avec les IP des attaquants réels.

Vérification : Confirmez que la règle existe mais est désactivée :

Get-NetFirewallRule -DisplayName "BlockAttackers" | Select-Object DisplayName, Enabled, Direction

Créez le script PowerShell principal qui analyse les entrées Event ID 4625 et identifie les modèles de force brute. Enregistrez-le sous C:\Scripts\RDP_BruteForce_Detection.ps1 :

# Script de détection et de blocage de force brute RDP
param(
    [int]$Hours = 1,
    [int]$AttackThreshold = 5
)

# Obtenez les tentatives de connexion RDP échouées des dernières heures spécifiées
$FailedLogons = Get-WinEvent -FilterHashtable @{
    LogName='Security'
    ID=4625
    StartTime=(Get-Date).AddHours(-$Hours)
} -ErrorAction SilentlyContinue | ForEach-Object {
    $EventXml = ([xml]$_.ToXml()).Event
    [PSCustomObject]@{
        UserName = ($EventXml.EventData.Data | Where-Object { $_.Name -eq 'TargetUserName' }).'#text'
        IpAddress = ($EventXml.EventData.Data | Where-Object { $_.Name -eq 'IpAddress' }).'#text'
        EventDate = [DateTime]$EventXml.System.TimeCreated.SystemTime
        LogonType = ($EventXml.EventData.Data | Where-Object { $_.Name -eq 'LogonType' }).'#text'
    }
}

# Filtrer pour les tentatives RDP (LogonType 10) et regrouper par IP
$AttackerIPs = $FailedLogons | Where-Object { 
    $_.LogonType -eq '10' -and 
    $_.IpAddress -ne '-' -and 
    $_.IpAddress -ne '127.0.0.1' 
} | Group-Object IpAddress | Where-Object { $_.Count -ge $AttackThreshold }

if ($AttackerIPs) {
    Write-Host "Trouvé $($AttackerIPs.Count) adresses IP attaquantes :" -ForegroundColor Red
    $AttackerIPs | ForEach-Object {
        Write-Host "  $($_.Name): $($_.Count) tentatives échouées" -ForegroundColor Yellow
    }
    return $AttackerIPs.Name
} else {
    Write-Host "Aucune attaque de force brute détectée dans les dernières $Hours heure(s)" -ForegroundColor Green
    return @()
}

Créez d'abord le répertoire Scripts :

New-Item -Path "C:\Scripts" -ItemType Directory -Force

Vérification : Testez le script manuellement :

C:\Scripts\RDP_BruteForce_Detection.ps1 -Hours 24 -AttackThreshold 3

Construisez le script qui convertit les IPs attaquantes individuelles en sous-réseaux /16 et met à jour la règle du pare-feu. Enregistrez sous C:\Scripts\Block_Attackers.ps1 :

# Script de blocage des attaquants avec conversion de sous-réseau
param(
    [string[]]$AttackerIPs,
    [string]$RuleName = "BlockAttackers"
)

if (-not $AttackerIPs -or $AttackerIPs.Count -eq 0) {
    Write-Host "Aucune IP à bloquer" -ForegroundColor Green
    return
}

# Convertir les IPs en sous-réseaux /16 pour une protection plus large
$Subnets = @()
foreach ($IP in $AttackerIPs) {
    if ($IP -match '^(\d+\.\d+)\.(\d+)\.(\d+)$') {
        $Subnet = "$($matches[1]).0.0/16"
        if ($Subnets -notcontains $Subnet) {
            $Subnets += $Subnet
            Write-Host "Conversion de $IP en sous-réseau $Subnet" -ForegroundColor Cyan
        }
    }
}

# Obtenir les adresses bloquées existantes de la règle du pare-feu
$ExistingRule = Get-NetFirewallRule -DisplayName $RuleName -ErrorAction SilentlyContinue
if ($ExistingRule) {
    $ExistingAddresses = (Get-NetFirewallAddressFilter -AssociatedNetFirewallRule $ExistingRule).RemoteAddress
    
    # Combiner les sous-réseaux existants et nouveaux, supprimer les doublons
    $AllSubnets = ($ExistingAddresses + $Subnets) | Where-Object { $_ -ne "127.0.0.1" } | Sort-Object -Unique
    
    # Mettre à jour la règle du pare-feu avec tous les sous-réseaux
    Set-NetFirewallRule -DisplayName $RuleName -RemoteAddress $AllSubnets
    
    # Activer la règle maintenant qu'elle a des adresses IP valides
    Set-NetFirewallRule -DisplayName $RuleName -Enabled True
    
    Write-Host "Règle du pare-feu mise à jour avec $($AllSubnets.Count) sous-réseaux bloqués" -ForegroundColor Green
    Write-Host "Sous-réseaux bloqués : $($AllSubnets -join ', ')" -ForegroundColor Yellow
    
    # Enregistrer l'action dans le journal des événements
    Write-EventLog -LogName Application -Source "RDC Brute Force Prevention Script" -EventId 1001 -EntryType Information -Message "Sous-réseaux bloqués : $($AllSubnets -join ', ')"
} else {
    Write-Host "Règle du pare-feu '$RuleName' non trouvée" -ForegroundColor Red
}

Enregistrez la source d'événements personnalisée pour la journalisation :

New-EventLog -LogName Application -Source "RDC Brute Force Prevention Script" -ErrorAction SilentlyContinue

Vérification : Testez le script de blocage avec une IP de test :

C:\Scripts\Block_Attackers.ps1 -AttackerIPs @("192.168.1.100")

Créez un script de nettoyage qui efface les IP bloquées toutes les 24 heures pour éviter le blocage permanent des adresses IP dynamiques. Enregistrez sous C:\Scripts\Clear_Blocked_IPs.ps1 :

# Script de nettoyage des IP bloquées - S'exécute quotidiennement à minuit
param(
    [string]$RuleName = "BlockAttackers"
)

# Réinitialiser la règle de pare-feu à une IP de remplacement et la désactiver
Set-NetFirewallRule -DisplayName $RuleName -RemoteAddress "127.0.0.1" -Enabled False

# Journaliser l'action de nettoyage
Write-EventLog -LogName Application -Source "RDC Brute Force Prevention Script" -EventId 1002 -EntryType Information -Message "Effacé toutes les IP bloquées de la règle de pare-feu à $(Get-Date)"

Write-Host "Effacé toutes les IP bloquées de la règle de pare-feu '$RuleName'" -ForegroundColor Green

Créez le script maître qui combine détection et blocage. Enregistrez sous C:\Scripts\RDP_Protection_Master.ps1 :

# Script maître de protection RDP
$AttackerIPs = & "C:\Scripts\RDP_BruteForce_Detection.ps1" -Hours 1 -AttackThreshold 5

if ($AttackerIPs -and $AttackerIPs.Count -gt 0) {
    & "C:\Scripts\Block_Attackers.ps1" -AttackerIPs $AttackerIPs
}

# Vérifier s'il est minuit (dans les 5 minutes) et effacer les règles
$CurrentTime = Get-Date
if ($CurrentTime.Hour -eq 0 -and $CurrentTime.Minute -lt 5) {
    & "C:\Scripts\Clear_Blocked_IPs.ps1"
}

Vérification : Testez le flux de travail complet :

C:\Scripts\RDP_Protection_Master.ps1

Configurez une tâche planifiée pour exécuter le script de protection toutes les 5 minutes. Utilisez PowerShell pour créer la tâche de manière programmatique :

# Créer une tâche planifiée pour la protection RDP
$TaskName = "RDP_BruteForce_Protection"
$ScriptPath = "C:\Scripts\RDP_Protection_Master.ps1"

# Définir l'action
$Action = New-ScheduledTaskAction -Execute "PowerShell.exe" -Argument "-WindowStyle Hidden -ExecutionPolicy Bypass -File `"$ScriptPath`""

# Définir le déclencheur (toutes les 5 minutes)
$Trigger = New-ScheduledTaskTrigger -Once -At (Get-Date) -RepetitionInterval (New-TimeSpan -Minutes 5) -RepetitionDuration (New-TimeSpan -Days 365)

# Définir les paramètres de la tâche
$Settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -StartWhenAvailable -RunOnlyIfNetworkAvailable

# Créer la tâche
Register-ScheduledTask -TaskName $TaskName -Action $Action -Trigger $Trigger -Settings $Settings -User "SYSTEM" -RunLevel Highest -Force

Vérifiez que la tâche a été créée et est en cours d'exécution :

Get-ScheduledTask -TaskName "RDP_BruteForce_Protection" | Select-Object TaskName, State, LastRunTime

Démarrez la tâche manuellement pour tester :

Start-ScheduledTask -TaskName "RDP_BruteForce_Protection"

Vérification : Vérifiez l'historique des tâches et les journaux d'événements :

# Vérifiez l'historique d'exécution des tâches
Get-WinEvent -FilterHashtable @{LogName='Microsoft-Windows-TaskScheduler/Operational'; ID=200} -MaxEvents 5

# Vérifiez nos entrées de journal d'événements personnalisées
Get-WinEvent -FilterHashtable @{LogName='Application'; ProviderName='RDC Brute Force Prevention Script'} -MaxEvents 10

Effectuez des tests complets pour vous assurer que le système fonctionne correctement sans bloquer le trafic légitime.

Tout d'abord, simulez une attaque par force brute en générant des événements de connexion échoués (utilisez un compte de test) :

# Générer des événements de connexion échoués pour le test (exécuter depuis une autre machine)
for ($i = 1; $i -le 10; $i++) {
    try {
        $cred = Get-Credential -UserName "testuser" -Message "Entrez un mauvais mot de passe"
        Enter-PSSession -ComputerName "YourServerIP" -Credential $cred
    } catch {
        Write-Host "Tentative échouée $i" -ForegroundColor Red
    }
    Start-Sleep -Seconds 2
}

Surveillez la détection en temps réel :

# Surveiller les nouvelles entrées Event ID 4625
Get-WinEvent -FilterHashtable @{LogName='Security'; ID=4625; StartTime=(Get-Date).AddMinutes(-10)} | 
    Select-Object TimeCreated, @{Name='SourceIP';Expression={([xml]$_.ToXml()).Event.EventData.Data | Where-Object {$_.Name -eq 'IpAddress'} | Select-Object -ExpandProperty '#text'}}

Vérifiez que la règle de pare-feu est remplie et activée :

# Vérifier l'état de la règle de pare-feu
$Rule = Get-NetFirewallRule -DisplayName "BlockAttackers"
$Addresses = Get-NetFirewallAddressFilter -AssociatedNetFirewallRule $Rule

Write-Host "Règle activée : $($Rule.Enabled)" -ForegroundColor $(if($Rule.Enabled){'Green'}else{'Red'})
Write-Host "Adresses bloquées : $($Addresses.RemoteAddress -join ', ')" -ForegroundColor Yellow

Testez la connectivité depuis une plage d'IP bloquée (si possible) :

# Depuis le serveur, tester si la règle bloque réellement
Test-NetConnection -ComputerName "localhost" -Port 3389 -InformationLevel Detailed

Vérification : Vérifiez l'état complet du système :

# Vérification complète de l'état du système
Write-Host "=== État de la protection contre la force brute RDP ===" -ForegroundColor Cyan
Write-Host "Tâche planifiée : $(if((Get-ScheduledTask -TaskName 'RDP_BruteForce_Protection').State -eq 'Ready'){'En cours'}else{'Non en cours'})" -ForegroundColor Green
Write-Host "Règle de pare-feu : $(if((Get-NetFirewallRule -DisplayName 'BlockAttackers').Enabled){'Activée'}else{'Désactivée'})" -ForegroundColor Green
Write-Host "Journalisation des événements : $(if((auditpol /get /category:'Logon/Logoff' | Select-String 'Failure.*Success').Count -gt 0){'Activée'}else{'Désactivée'})" -ForegroundColor Green
Write-Host "Blocages récents : $((Get-WinEvent -FilterHashtable @{LogName='Application'; ProviderName='RDC Brute Force Prevention Script'} -MaxEvents 5 -ErrorAction SilentlyContinue).Count)" -ForegroundColor Yellow