IP-Adresse basierend auf X Anzahl fehlgeschlagener Anmeldeversuche sperren?

Ist es möglich, eine IP-Adresse nach x erfolglosen Anmeldeversuchen auf einem Windows Server zu sperren? Nicht auf ein bestimmtes Konto, von dem ich weiß, wie es geht, sondern auf die gesamte Maschine.

Wir werden ziemlich hart von Brute-Force-Angriffen getroffen, bei denen versucht wird, Benutzernamen zu erraten. Dies würde wirklich helfen, den Server etwas zu entlasten.

Sie können dies mit dem Powershell- und Task-Manager tun. Es ist wahrscheinlich keine perfekte Lösung, aber es funktioniert ganz gut und ich habe ungefähr 100 gesperrte IP-Adressen in zwei Monaten. Ich habe ein Skript geschrieben, das von EventLog angegebene Ereignisse auswählt ("audit failure"). Wenn es von einer IP-Adresse aus viele fehlgeschlagene Anmeldungen gibt, wird sie der (manuell erstellten) Firewall-Regel "BlockAttackers" hinzugefügt, die den Datenverkehr zu angegebenen IP-Adressen blockiert.

PS1-Skript:

$DT = [DateTime]::Now.AddDays(-1) # check only last 24 hours

$l = Get-EventLog -LogName 'Security' -InstanceId 4625 -After $DT | Select-Object @{n='IpAddress';e={$_.ReplacementStrings[-2]} } # select Ip addresses that has audit failure 
$g = $l | group-object -property IpAddress  | where {$_.Count -gt 20} | Select -property Name # get ip adresses, that have more than 20 wrong logins

$fw = New-Object -ComObject hnetcfg.fwpolicy2 # get firewall object

$ar = $fw.rules | where {$_.name -eq 'BlockAttackers'} # get firewall rule named 'BlockAttackers' (must be created manually)

$arRemote = $ar.RemoteAddresses -split(',') #split the existing IPs into an array so we can easily search for existing IPs

$w = $g | where {$_.Name.Length -gt 1 -and  !($arRemote -contains $_.Name + '/255.255.255.255') } # get ip addresses that are not already in firewal rule. Include the subnet mask which is automatically added to the firewall remote IP declaration.

$w| %{$ar.remoteaddresses += ',' + $_.Name} # add IPs to firewall rule

Erstellen Sie eine Aufgabe im Scheduler und setzen Sie den Auslöser auf Ereignis 4625 (Windows-Anmeldung einschließlich Terminaldienste). Sie können den Trigger jedoch so einstellen, dass er z. B. zweimal pro Stunde ausgeführt wird, um ein unnötiges Laden des Servers zu vermeiden.

und nach dem Trigger ein Powershell-Skript ausführen. Sie müssen auch höhere Berechtigungen festlegen, um dieses Skript auszuführen. Andernfalls schlägt die Ausführung mit einer Sicherheitsausnahme fehl.

Sie können dieses Skript auch an andere Sicherheitsereignisse binden.

Ich weiß, dass diese Frage alt ist, aber es war tatsächlich der erste Forumsbeitrag, auf den ich gestoßen bin, als ich vor ein paar Wochen versuchte, genau dasselbe zu tun. Ich habe es geschafft, ein funktionierendes Skript zu entwickeln, das die Ereignisprotokolle 24 Stunden später auf Einträge mit ungültigen Anmeldungsereignissen analysiert, die Einträge mit mehr als 10 ungültigen Anmeldungen auflistet und sie dann mithilfe von in eine IPSec-Filterliste einfügt Befehl netsh. Dann habe ich eine Batch-Datei mit dieser Zeile geschrieben powershell .\*scriptname.ps1*und eine geplante Task erstellt, um die Batch-Datei alle 24 Stunden auszuführen (aus irgendeinem Grund würde sie nicht direkt ausgeführt).

$DATE = [DateTime]::Now.AddDays(-1)

$EVS = Get-EventLog Security -InstanceId 529 -after $DATE

$EVS | select-string -inputobject {$_.message} -pattern "Source Network Address:(.)*\.*\.*\.*"  -allmatches | foreach-object {$_.Matches} | foreach-object {$_.Value} | foreach-object {$_.replace("Source Network Address:", "")} | group-object -property $_ | where-object {$_.count -gt 10} | select-object -property name | format-list | out-file c:\rdpblock.txt 

get-content -path c:\rdpblock.txt | foreach-object {$_.replace("Name :", "")} | out-file c:\rdpblockcleaned.txt 

get-content -path c:\rdpblockcleaned.txt | select-object -unique | out-file c:\rdpblocknospaces.txt

$RDPIP = get-content -path c:\rdpblocknospaces.txt | select-object -skip 1

$RDPIP | foreach-object {$_.replace("     ", "")} | foreach-object {netsh ipsec static add filter filterlist=RDP_BLOCK srcaddr=$($_) dstaddr=any}

Ich weiß, dass dieses Skript wahrscheinlich ineffizient ist, aber als ich anfing, daran zu arbeiten, hatte ich absolut keine Erfahrung mit Powershell. Daher lässt meine Fähigkeit, Skripte zu optimieren, sehr zu wünschen übrig. Trotzdem dachte ich, ich würde das mit jedem teilen, der es benutzen könnte.

Ich danke Remunda für die anfängliche Idee, dieses Poster hat mich auf die Idee gebracht, mit Powershell die Ereignisprotokolle zu durchsuchen.

Dieses Skript basiert auf Remunda Antwort und geht ein wenig weiter https://serverfault.com/a/397637/155102 Es erklärt die „BlockAttackers“ haben in der Regel keine eingegeben IPs noch (was ein „*“ als String zurückgibt). Außerdem wird ein Kommentar in eine Protokolldatei geschrieben, um Sie darüber zu informieren, wann die IP der Regel hinzugefügt wurde.

Ein guter Tipp ist, die "BlockAttackers" -Regel zu erstellen, die die IP-Adressen blockiert, sie jedoch zunächst deaktiviert. Führen Sie dieses Skript dann einmal manuell aus, damit es das Feld "RemoteAddresses" mit den tatsächlichen IP-Adressen auffüllt, die blockiert werden sollen. Sehen Sie sich diese IP-Adressen an, um sicherzustellen, dass nichts Kritisches hinzugefügt wurde, und aktivieren Sie dann die Firewall-Regel. Fügen Sie diese Regel wie beschrieben zu Ihrer Firewall hinzu.

Der Git für dieses Skript

#Checks for IP addresses that used incorrect password more than 10 times
#within 24 hours and blocks them using a firewall rule 'BlockAttackers'

#Check only last 24 hours
$DT = [DateTime]::Now.AddHours(-24)

#Select Ip addresses that has audit failure
$l = Get-EventLog -LogName 'Security' -InstanceId 4625 -After $DT | Select-Object @{n='IpAddress';e={$_.ReplacementStrings[-2]} }

#Get ip adresses, that have more than 10 wrong logins
$g = $l | group-object -property IpAddress | where {$_.Count -gt 10} | Select -property Name

#Get firewall object
$fw = New-Object -ComObject hnetcfg.fwpolicy2

#Get firewall rule named 'BlockAttackers' (must be created manually)
$ar = $fw.rules | where {$_.name -eq 'BlockAttackers'}

#Split the existing IPs into an array so we can search it for existing IPs
$arRemote = $ar.RemoteAddresses -split(',')

#Only collect IPs that aren't already in the firewall rule
$w = $g | where {$_.Name.Length -gt 1 -and !($arRemote -contains $_.Name + '/255.255.255.255') }

#Add the new IPs to firewall rule
$w| %{
  if ($ar.RemoteAddresses -eq '*') {
    $ar.remoteaddresses = $_.Name
  }else{
    $ar.remoteaddresses += ',' + $_.Name
  }
}

#Write to logfile
if ($w.length -gt 1) {
  $w| %{(Get-Date).ToString() + ' ' + $_.Name >> '.\blocked.txt'}
}

Ich kann diese Antwort nicht würdigen, aber https://serverfault.com/users/7200/evan-anderson hat sein Projekt erwähnt http://opensource.wellbury.com/projects/windows_sshd_block/newest-release/

Im Allgemeinen ist es keine gute Idee, Ihre Firewall-Regeln von einer anderen Person steuern zu lassen. Das ist im Grunde das, wonach du hier fragst.

Dies ist ein alter Thread. Ich habe das Skript von KevinMicke in den Jahren 2014-2015 verwendet. Dann hat es einfach aufgehört zu funktionieren. Daher musste ich es ein wenig bearbeiten, um es an die Windows-Netzwerksicherheitsauthentifizierung anzupassen, bei der keine IP-Adressen im Sicherheitsprotokoll verbleiben. Da ich kein reguläres FTP habe, habe ich diesen Teil entfernt, da er Fehler verursachte, da es keinen Protokollordner gab. Die Hauptänderung betrifft die Quelle von RDP-Ereignissen.

    $current_date_utc = (Get-Date).ToUniversalTime()

    # Set number of failed login attempts after which an IP address will be blocked
    $int_block_limit = 10

    # Time window during which to check the Security log, which is currently set to check only the last 24 hours
    $dat_time_window = [DateTime]::Now.AddDays(-1)

    $arr_new_bad_ips_all = (get-winevent -filterhashtable @{ logname='Microsoft-Windows-RemoteDesktopServices-RdpCoreTS/Operational'; starttime=$dat_time_window; id=140 }).message |
        % { if ($_ -match "of (.+) failed") { $Matches[1] }} |
        Group-Object |
        Where {$_.Count -ge $int_block_limit} |
        Select -property Name

    # Sort the array, selecting only unique IPs (in case one IP shows up in both the Security and FTP logs)
    $arr_new_bad_ips_all = $arr_new_bad_ips_all | Foreach-Object { [string]$_.Name } | Select-Object -unique

    # Get firewall object
    $firewall = New-Object -comobject hnetcfg.fwpolicy2

    # Get all firewall rules matching "BlockAttackers*"
    $arr_firewall_rules = $firewall.Rules | Where {$_.Name -like 'BlockAttackers*'}

    # If no "BlockAttackers*" firewall rule exists yet, create one and set it to a variable
    if ($arr_firewall_rules -eq $null) {
        $str_new_rule_name = "BlockAttackers (Created " + $current_date_utc.ToString("yyyy-MM-dd HH:mm:ss") + " UTC)"
        netsh advfirewall firewall add rule dir=in action=block name=$str_new_rule_name description="Rule automatically created." enable=yes remoteip="0.0.0.0" | Out-Null
        $arr_firewall_rules = $firewall.Rules | Where {$_.Name -like 'BlockAttackers*'}
    }

    # Split the existing IPs from current "BlockAttackers*" firewall rule(s) into an array so we can easily search them
    $arr_existing_bad_ips = @()
    foreach ($rule in $arr_firewall_rules) {
        $arr_existing_bad_ips += $rule.RemoteAddresses -split(',')
    }

    # Clean subnet masks off of IPs that are currently blocked by the firewall rule(s)
    $arr_existing_bad_ips_without_masks = $arr_existing_bad_ips | ForEach-Object {$_ -replace "/.*", ""}

    # Select IP addresses to add to the firewall, but only ones that...
    $arr_new_bad_ips_for_firewall = $arr_new_bad_ips_all | Where {
        # contain an IP address (i.e. aren't blank or a dash, which the Security log has for systems that failed FTP logins)
        $_.Length -gt 6 -and
        # aren't already in the firewall rule(s)
        !($arr_existing_bad_ips_without_masks -contains $_) -and
        # aren't the local loopback
        !($_.StartsWith('127.0.0.1')) -and
        # aren't part of the local subnet
        !($_.StartsWith('192.168.')) -and
        !($_.StartsWith('0.0.'))
    }

    # If there are IPs to block, do the following...
    if ($arr_new_bad_ips_for_firewall -ne $null) {
        # Write date and time to script-specific log file
        [DateTime]::Now | Out-File -Append -Encoding utf8 C:\Security\blockattackers.txt
        # Write newly-blocked IP addresses to log file
        $arr_new_bad_ips_for_firewall | Out-File -Append -Encoding utf8 C:\Security\blockattackers.txt

        # Boolean to make sure the new IPs are only added on one rule
        $bln_added_to_rule = 0

        # Array to hold bad IPs from each rule one at a time, so we can count to make sure adding the new ones won't exceed 1000 IPs
        $arr_existing_bad_ips_current_rule = @()

        # For each "BlockAttackers*" rule in the firewall, do the following...
        foreach ($rule in $arr_firewall_rules) {
            if ($bln_added_to_rule -ne 1) {
                # Split the existing IPs from the current rule into an array so we can easily count them
                $arr_existing_bad_ips_current_rule = $rule.RemoteAddresses -split(',')

                # If the number of IPs to add is less than 1000 minus the current number of IPs in the rule, add them to this rule
                if ($arr_new_bad_ips_for_firewall.Count -le (1000 - $arr_existing_bad_ips_current_rule.Count)) {
                    # Add new IPs to firewall rule
                    $arr_new_bad_ips_for_firewall | %{$rule.RemoteAddresses += ',' + $_}

                    # Write which rule the IPs were added to to log file
                    echo "New IP addresses above added to Windows Firewall rule:" $rule.Name | Out-File -Append -Encoding utf8 C:\Security\blockattackers.txt

                    # Set boolean so any other rules are skipped when adding IPs
                    $bln_added_to_rule = 1
                }
            }
        }

        # If there wasn't room in any other "BlockAttackers*" firewall rule, create a new one and add the IPs to it
        if ($bln_added_to_rule -ne 1) {
            $str_new_rule_name = "BlockAttackers (Created " + $current_date_utc.ToString("yyyy-MM-dd HH:mm:ss") + " UTC)"
            netsh advfirewall firewall add rule dir=in action=block name=$str_new_rule_name description="Rule automatically created." enable=yes remoteip="0.0.0.0" | Out-Null
            $new_rule = $firewall.rules | Where {$_.Name -eq $str_new_rule_name}

            # Add new IPs to firewall rule
            $arr_new_bad_ips_for_firewall | %{$new_rule.RemoteAddresses += ',' + $_}

            # Write which rule the IPs were added to to log file
            echo "New IP addresses above added to newly created Windows Firewall rule:" $new_rule.Name | Out-File -Append -Encoding utf8 C:\Security\blockattackers.txt
        }
    }

Das obige Skript funktioniert unter Windows 2012. Wenn Sie unter Windows 2008 immer noch Remotedesktop mit Authentifizierung auf Netzwerkzugriffsebene verwenden, müssen Sie möglicherweise den folgenden Trick ausführen. Windows 2008 hat keine IP-Adressen im Sicherheitsprotokoll und scheint diese auch nicht im Microsoft-Windows-RemoteDesktopServices-RdpCoreTS-Protokoll zu haben. Also musste ich eigentlich 2 Protokolle verwenden - Ereignisse aus dem Sicherheitsprotokoll mit erfolgreichen Zugriffsversuchen auf Port 3389 im Firewall-Protokoll abgleichen. Dies ist eine Vermutung, aber es scheint, Kennwortangriffe zu erkennen. Hier ist der Teil, der verletzende IPs sammelt:

    $current_date_utc = (Get-Date).ToUniversalTime()

    # Set number of failed login attempts after which an IP address will be blocked
    $int_block_limit = 10

    $dat_time_window = [DateTime]::Now.AddDays(-1)

    $logfn = (netsh advfirewall show allprofiles | Select-String Filename | select-object -unique | % { $_ -replace "%systemroot%",$env:systemroot }).substring(10).trimstart().trimend()

    $badevts = Get-EventLog -LogName 'Security' -InstanceId 4625 -After $dat_time_window | foreach-object { [datetime]$_.TimeWritten } | sort-object

    $fwlog = Select-String -Path $logfn -Pattern "ALLOW TCP" |
        % {
            if ($_ -match "(201.-..-..) (.+) ALLOW TCP (.+) (.+) (.+) 3389") 
            {
                new-object psobject -property @{ 
                  dt = $Matches[1] + ' ' + $Matches[2]
                  ip = $Matches[3]
                }
            }
        }

    $ipa = @()
    $j = 0

    for ($i=0; $i -lt $fwlog.Count; $i++)
    {
        $conn = ([datetime]$fwlog[$i].dt).ticks
        while (($j -lt $badevts.Count) -and (($badevts[$j]).ticks -lt $conn)) { $j++ }
        if ($j -ge $badevts.Count) { break }
        if ((($badevts[$j]).ticks - $conn) -le 30000000) { $ipa += ,($fwlog[$i].ip) }
    }

    $arr_new_bad_ips_all = $ipa |
        Group-Object |
        Where {$_.Count -ge $int_block_limit} |
        Select -property Name

HINWEIS: Vergessen Sie nicht, die Firewall-Protokolle zu aktivieren. ANMERKUNG 2: Ich bin kein Powershell-Experte, daher wäre es schön, wenn einige Gurus meinen Code korrigieren / verbessern könnten.

Ich benutze ts_block kostenlos.

Grundsätzlich handelt es sich um ein "VBScript-Programm, das als WMI-Ereignissenke fungiert, um Ereignisse zu empfangen, die von Windows als Reaktion auf ungültige Terminaldiensteanmeldungen protokolliert wurden."

Scheint perfekt zu funktionieren und das Skript ist unkompliziert, wenn Sie es modifizieren müssen. Sie können entweder zulassen, dass Versuche protokolliert und dann basierend auf der Anzahl der zulässigen Versuche gesperrt werden, und / oder Sie können Anmeldenamen, auf die Sie keinen Zugriff gewähren möchten, fest codieren.

Ich wurde erwischt, als ich versehentlich zweimal den gleichen Namen hinzufügte und der Dienst in eine Endlosschleife überging, die alle 1500 ms neu gestartet wurde, aber sehr einfach zu reparieren / modifizieren ist, wenn Sie mit vbs einverstanden sind.

Meine aktuellen Einstellungen sind nur eine Wiederholung und Sie sind für 2 Tage gesperrt, wobei Anmeldungen wie "admin", "Admin", "Administrator", "Gast" usw. automatisch gesperrt werden. Sollte es unkompliziert sein, auf ip zu wechseln?

Irgendwie macht es süchtig, nachzusehen, welche Tiere über Nacht gesperrt wurden ...

Meinen Sie damit die Anmeldung am Server / in der Domäne oder die Anmeldung an einer Website, die auf dem Server ausgeführt wird? Wenn Sie sich auf dem Server / in der Domäne anmelden möchten, lautet die Antwort "Nein". Windows hat kein Konzept zum Blockieren von IP-Adressen basierend auf fehlgeschlagenen Anmeldeversuchen, da IP-Adressen keine Sicherheitseinheiten sind. Möglicherweise gibt es Tools von Drittanbietern, die dies tun können, mir sind jedoch keine bekannt, da ich mich noch nie darum gekümmert habe.

Wenn ein Webserver angegriffen wird, können Sie die Erweiterung für dynamische IP-Beschränkungen installieren . Wenn dies für die Standardauthentifizierung gegenüber dem Server vorgesehen ist, sollten Sie in der Lage sein, Domänen- und Serverisolierungen zu implementieren, die den Umfang der Angriffe auf Domänencomputer einschränken. Außerdem können Sie festlegen, dass nur Versuche von den Systemen zugelassen werden, auf die Sie Zugriff haben müssen der Server. In Windows besteht die Verhinderung von Brute-Force-Angriffen darin, die Kontosperrungsrichtlinie auf 10 Minuten und die Richtlinie für ungültige Kennwörter auf 3 Versuche festzulegen. Dies bedeutet, dass das angegriffene Konto nach 3 Versuchen für 10 Minuten gesperrt wird. IP-Verbindungen können in Windows standardmäßig nicht gesperrt werden. (Nebenbei bin ich auch gespannt, wie viele Anmeldeversuche pro Sekunde erforderlich sind, um das System zu beeinflussen.)

http://nerderies.blogspot.co.at/2012/12/automatically-banning-ips-with-windows.html

Wenn Sie eine sofort einsatzbereite Lösung wünschen (Installieren und fertig), finden Sie hier ein kostenloses Tool, das Sie wahrscheinlich weiterlesen sollten:

Aktuelle Version: 1.2 (.NET Framework 4.0 Client Profile) -> Laden Sie die aktuelle Version von EvlWatcher herunter (kostenlos für den persönlichen und kommerziellen Gebrauch)

Neu in 1.2 (mehr Infos in der Dokumentation):

• Managementkonsole
• WCF-Dienstmuster
• Schwarze Liste
• Automatisches Verschieben auf die Blacklist nach 3 Treffern (Standardeinstellung)

Für ältere Server (.NET Framework 2.0)

-> Download der reduzierten Version von EvlWatcher (kostenlos für den persönlichen und kommerziellen Gebrauch)

Mit dem großartigen Skript von remunda als Ausgangspunkt habe ich eine wichtige Sache hinzugefügt, die fehlte: das Blockieren von IP-Adressen für fehlgeschlagene FTP-Anmeldungen . Windows Server protokolliert die IP-Adresse nicht im Sicherheitsprotokoll, wenn sich jemand nicht über FTP anmeldet, sondern setzt die "Quellnetzwerkadresse" auf einen Bindestrich. FTP ist ein sehr verbreiteter Angriffsvektor für Brute-Force-Angriffe. Daher habe ich seinem Skript die Möglichkeit hinzugefügt, die FTP-Protokolle des aktuellen Tages auf mehrere Anmeldefehler zu scannen und diese IP-Adressen ebenfalls zu blockieren.

Update 2014/02/07: Als ich einige Anpassungen an dieser Funktion vorgenommen habe, um alle meine alten FTP-Protokolle zu verarbeiten, wurde mir klar, dass die von ihr erstellten Arrays bei einer immensen Anzahl von Versuchen (über 50.000) sehr groß und die Verarbeitung unglaublich langsam sein würden. Ich habe es seitdem umgeschrieben, um es viel effizienter bei der Verarbeitung von FTP-Protokollen zu machen.

Ich habe auch herausgefunden, dass es ein beliebiges festes Limit von 1000 gibt, wie viele IPs in einer Windows-Firewall-Regel enthalten sein können. Aufgrund dieser Begrenzung musste ich automatisch eine neue Regel erstellen, wenn die letzte voll ist. Das erledigt es jetzt und erstellt auch die anfängliche Firewall-Regel (falls Sie keine eigene erstellen), sodass das einzige Setup darin besteht, sie dem Scheduler hinzuzufügen, damit sie ausgeführt wird, wenn ein Ereignis 4625 auftritt.

Hier ist der Code, der sowohl unter Windows Server 2008 R2 als auch unter Windows 7 getestet wurde:

# This Windows Powershell script will automatically block IP addresses that attempt to login to the system
# and fail the number of times set below with the $int_block_limit variable or more. Is scans both the Security
# log, which covers Remote Desktop and other attempts, as well as the current day's FTP log. If the $int_block_limit
# limit is hit on either of those logs (separately, not combined), then the IP address will be added to the
# firewall rule.
#
# The script will automatically create a firewall rule named "BlockAttackers (Created yyyy-MM-dd HH:mm:ss UTC)" using
# the current time if one with a name that includes "BlockAttackers" doesn't already exist. Because there's a hard
# limit of 1000 entries (IP addresses) you can block per rule, it will also create similarly-named rules once that
# limit is reached for the latest one.
#
# I recommend setting the script to run as a scheduled task triggered by event 4625 login audit failures from the
# Security log, or alternatively you could set it to run after some amount of time (i.e. every 10 minutes).
#
# Authors:
# Majority of script written by serverfault.com user kevinmicke
# Windows Security Log portion written by serverfault.com user remunda, which provided the starting point for kevinmicke
#
# Details: https://serverfault.com/questions/233222/ban-ip-address-based-on-x-number-of-unsuccessful-login-attempts


# Set number of failed login attempts after which an IP address will be blocked
$int_block_limit = 10

# Time window during which to check the Security log, which is currently set to check only the last 24 hours
$dat_time_window = [DateTime]::Now.AddDays(-1)

# Select from the Security log all IP addresses that have more than $int_block_limit audit failures (event 4625) within $dat_time_window
$arr_new_bad_ips_security_log = @()
$arr_new_bad_ips_security_log = Get-EventLog -LogName 'Security' -InstanceId 4625 -After $dat_time_window |
    Select-Object @{n='IpAddress';e={$_.ReplacementStrings[-2]}} |
    Group-Object -property IpAddress |
    Where {$_.Count -ge $int_block_limit} |
    Select -property Name

# Get current time UTC to figure out filename for current FTP log
$current_date_utc = (Get-Date).ToUniversalTime()

# Set path to today's FTP log file
$str_log_file_name = "C:\inetpub\logs\LogFiles\FTPSVC2\u_ex" + $current_date_utc.ToString("yyMMdd") + ".log"

# Search today's FTP log file for "530 1326" to find lines that contain IPs of systems that failed to log in,
# get just the IP from each line, group the IPs by IP to count the attempts from each one, and select only the
# IPs that have $int_block_limit or more bad logins today
$arr_new_bad_ips_ftp = @()
$arr_new_bad_ips_ftp = Select-String $str_log_file_name -pattern "530 1326" |
    ForEach-Object {$_.Line.Substring(20,15) -replace " .*", ""} |
    Group |
    Where {$_.Count -ge $int_block_limit} |
    Select -property Name

# Concatenate the two arrays of IPs (one from Security log, one from FTP log)
$arr_new_bad_ips_all = @()
# $arr_new_bad_ips_all = @($arr_new_bad_ips_security_log) + @($arr_new_bad_ips_ftp_over_limit)
$arr_new_bad_ips_all = @($arr_new_bad_ips_security_log) + @($arr_new_bad_ips_ftp)

# Sort the array, selecting only unique IPs (in case one IP shows up in both the Security and FTP logs)
$arr_new_bad_ips_all_sorted = @()
$arr_new_bad_ips_all_sorted = $arr_new_bad_ips_all |
    Foreach-Object { [string]$_.Name } |
    Select-Object -unique

# Get firewall object
$firewall = New-Object -comobject hnetcfg.fwpolicy2

# Get all firewall rules matching "BlockAttackers*"
$arr_firewall_rules = $firewall.Rules | Where {$_.Name -like 'BlockAttackers*'}

# If no "BlockAttackers*" firewall rule exists yet, create one and set it to a variable
if ($arr_firewall_rules -eq $null) {
    $str_new_rule_name = "BlockAttackers (Created " + $current_date_utc.ToString("yyyy-MM-dd HH:mm:ss") + " UTC)"
    netsh advfirewall firewall add rule dir=in action=block name=$str_new_rule_name description="Rule automatically created by BlockAttackers Powershell script written by Kevin Micke." enable=yes remoteip="0.0.0.0" | Out-Null
    $arr_firewall_rules = $firewall.Rules | Where {$_.Name -like 'BlockAttackers*'}
}

# Split the existing IPs from current "BlockAttackers*" firewall rule(s) into an array so we can easily search them
$arr_existing_bad_ips = @()
foreach ($rule in $arr_firewall_rules) {
    $arr_existing_bad_ips += $rule.RemoteAddresses -split(',')
}

# Clean subnet masks off of IPs that are currently blocked by the firewall rule(s)
$arr_existing_bad_ips_without_masks = @()
$arr_existing_bad_ips_without_masks = $arr_existing_bad_ips | ForEach-Object {$_ -replace "/.*", ""}

# Select IP addresses to add to the firewall, but only ones that...
$arr_new_bad_ips_for_firewall = @()
$arr_new_bad_ips_for_firewall = $arr_new_bad_ips_all_sorted | Where {
    # contain an IP address (i.e. aren't blank or a dash, which the Security log has for systems that failed FTP logins)
    $_.Length -gt 6 -and
    # aren't already in the firewall rule(s)
    !($arr_existing_bad_ips_without_masks -contains $_) -and
    # aren't the local loopback
    !($_.StartsWith('127.0.0.1')) -and
    # aren't part of the local subnet
    !($_.StartsWith('192.168.')) -and
    !($_.StartsWith('10.0.'))
}

# If there are IPs to block, do the following...
if ($arr_new_bad_ips_for_firewall -ne $null) {
    # Write date and time to script-specific log file
    [DateTime]::Now | Out-File -Append -Encoding utf8 C:\blockattackers.txt
    # Write newly-blocked IP addresses to log file
    $arr_new_bad_ips_for_firewall | Out-File -Append -Encoding utf8 C:\blockattackers.txt

    # Boolean to make sure the new IPs are only added on one rule
    $bln_added_to_rule = 0

    # Array to hold bad IPs from each rule one at a time, so we can count to make sure adding the new ones won't exceed 1000 IPs
    $arr_existing_bad_ips_current_rule = @()

    # For each "BlockAttackers*" rule in the firewall, do the following...
    foreach ($rule in $arr_firewall_rules) {
        if ($bln_added_to_rule -ne 1) {
            # Split the existing IPs from the current rule into an array so we can easily count them
            $arr_existing_bad_ips_current_rule = $rule.RemoteAddresses -split(',')

            # If the number of IPs to add is less than 1000 minus the current number of IPs in the rule, add them to this rule
            if ($arr_new_bad_ips_for_firewall.Count -le (1000 - $arr_existing_bad_ips_current_rule.Count)) {
                # Add new IPs to firewall rule
                $arr_new_bad_ips_for_firewall | %{$rule.RemoteAddresses += ',' + $_}

                # Write which rule the IPs were added to to log file
                echo "New IP addresses above added to Windows Firewall rule:" $rule.Name | Out-File -Append -Encoding utf8 C:\blockattackers.txt

                # Set boolean so any other rules are skipped when adding IPs
                $bln_added_to_rule = 1
            }
        }
    }

    # If there wasn't room in any other "BlockAttackers*" firewall rule, create a new one and add the IPs to it
    if ($bln_added_to_rule -ne 1) {
        $str_new_rule_name = "BlockAttackers (Created " + $current_date_utc.ToString("yyyy-MM-dd HH:mm:ss") + " UTC)"
        netsh advfirewall firewall add rule dir=in action=block name=$str_new_rule_name description="Rule automatically created by BlockAttackers Powershell script written by Kevin Micke." enable=yes remoteip="0.0.0.0" | Out-Null
        $new_rule = $firewall.rules | Where {$_.Name -eq $str_new_rule_name}

        # Add new IPs to firewall rule
        $arr_new_bad_ips_for_firewall | %{$new_rule.RemoteAddresses += ',' + $_}

        # Write which rule the IPs were added to to log file
        echo "New IP addresses above added to newly created Windows Firewall rule:" $new_rule.Name | Out-File -Append -Encoding utf8 C:\blockattackers.txt
    }
}

Das von kevinmicke bearbeitete Skript von remuda (7. Februar um 21:59 Uhr) hat den Kontrollkanal des FTP nicht überprüft, der auf meinem System einen eigenen Ordner hat (Windows Server 2008 R2). Auch 530 11001haben -Events nicht erkannt worden, was zu erscheinen scheinen , wenn nur der Hacker den Zugriff auf den Steuerkanal versucht. Deshalb habe ich einige Zeilen im Skript angehängt, um einen zweiten FTP-Log-Ordner zu überprüfen:

# Dieses Windows Powershell-Skript blockiert automatisch IP-Adressen, die versuchen, sich beim System anzumelden
# und nicht so oft wie unten mit der Variablen $ int_block_limit oder mehr angegeben. Überprüft wird sowohl die Sicherheit
# log, das Remotedesktop und andere Versuche sowie das aktuelle FTP-Protokoll des Tages abdeckt. Wenn das $ int_block_limit
Wenn in einem dieser Protokolle das # -Limit erreicht ist (separat, nicht kombiniert), wird die IP-Adresse zu dem Protokoll hinzugefügt
# Firewall-Regel.
#
# Das Skript erstellt automatisch eine Firewall-Regel mit dem Namen "BlockAttackers (Created yyyy-MM-dd HH: mm: ss UTC)"
# die aktuelle Uhrzeit, wenn noch keine mit einem Namen vorhanden ist, der "BlockAttackers" enthält. Weil es eine harte gibt
# Beschränkung auf 1000 Einträge (IP-Adressen), die Sie pro Regel blockieren können. Sobald dies der Fall ist, werden auch Regeln mit ähnlichen Namen erstellt
Das # -Limit ist für die neueste Version erreicht.
#
# Ich empfehle, das Skript so einzurichten, dass es als geplante Aufgabe ausgeführt wird, die durch Fehler bei der Anmeldeprüfung von Ereignis 4625 ausgelöst wird
# Sicherheitsprotokoll, oder Sie können festlegen, dass es nach einiger Zeit (dh alle 10 Minuten) ausgeführt wird.
#
# Autoren:
# Die Mehrheit der Skripte wurde vom serverfault.com-Benutzer kevinmicke geschrieben
# Teil des Windows-Sicherheitsprotokolls, der vom serverfault.com-Benutzer remunda geschrieben wurde und den Ausgangspunkt für kevinmicke darstellte
# Überprüfung des vom serverfault.com-Benutzer Uwe Martens hinzugefügten FTP-Kontrollkanals
#
# Details: https://serverfault.com/questions/233222/ban-ip-address-based-on-x-number-of-unsuccessful-login-attempts


# Anzahl der fehlgeschlagenen Anmeldeversuche festlegen, nach denen eine IP-Adresse gesperrt wird
$ int_block_limit = 3

# Zeitfenster, in dem das Sicherheitsprotokoll überprüft werden soll. Derzeit werden nur die letzten 24 Stunden überprüft
$ dat_time_window = [DateTime] :: Now.AddDays (-1)

# Wählen Sie im Sicherheitsprotokoll alle IP-Adressen aus, bei denen mehr als $ int_block_limit Überwachungsfehler (Ereignis 4625) innerhalb von $ dat_time_window aufgetreten sind
$ arr_new_bad_ips_security_log = @ ()
$ arr_new_bad_ips_security_log = Get-EventLog -LogName 'Security' -InstanceId 4625 -Nach $ dat_time_window |
    Select-Object @ {n = 'IpAddress'; e = {$ _. ReplacementStrings [-2]}} |
    Gruppenobjekt-Eigenschaft IpAddress |
    Wobei {$ _. Count -ge $ int_block_limit} |
    Wählen Sie -property Name

# Holen Sie sich die aktuelle UTC-Zeit, um den Dateinamen für das aktuelle FTP-Protokoll zu ermitteln
$ current_date_utc = (Get-Date) .ToUniversalTime ()

# Legen Sie den Pfad zur heutigen FTP-Kontrollkanal-Protokolldatei fest
$ str_log_file_name_control_channel = "C: \ inetpub \ logs \ LogFiles \ FTPSVC \ u_ex" + $ current_date_utc.ToString ("yyMMdd") + ".log"

# Durchsuchen Sie die Protokolldatei des heutigen FTP-Steuerkanals nach "530 1", um nach Zeilen zu suchen, die IP-Adressen von Systemen enthalten, die sich nicht anmelden konnten.
# Holen Sie sich nur die IP von jeder Zeile, gruppieren Sie die IPs nach IP, um die Versuche von jeder Zeile zu zählen, und wählen Sie nur die aus
# IPs, die heute mindestens $ int_block_limit haben
$ arr_new_bad_ips_ftp_control_channel = @ ()
$ arr_new_bad_ips_ftp_control_channel = Select-String $ str_log_file_name_control_channel -pattern "530 1" |
    ForEach-Object {$ _. Line.Substring (20,15) -replace ". *", ""} |
    Gruppe |
    Wobei {$ _. Count -ge $ int_block_limit} |
    Wählen Sie -property Name

# Legen Sie den Pfad zur heutigen FTP-Protokolldatei fest
$ str_log_file_name = "C: \ inetpub \ logs \ LogFiles \ FTPSVC * \ u_ex" + $ current_date_utc.ToString ("yyMMdd") + ".log"

# Durchsuchen Sie die heutige FTP-Protokolldatei nach "530 1", um nach Zeilen zu suchen, die IP-Adressen von Systemen enthalten, die sich nicht anmelden konnten.
# Holen Sie sich nur die IP von jeder Zeile, gruppieren Sie die IPs nach IP, um die Versuche von jeder Zeile zu zählen, und wählen Sie nur die aus
# IPs, die heute mindestens $ int_block_limit haben
# In FTPSVC * muss anstelle von * die ID des FTP-Servers eingegeben werden, oder es muss nur der richtige Log-Ordner ausgewählt werden
$ arr_new_bad_ips_ftp = @ ()
$ arr_new_bad_ips_ftp = Select-String $ str_log_file_name -pattern "530 1" |
    ForEach-Object {$ _. Line.Substring (20,15) -replace ". *", ""} |
    Gruppe |
    Wobei {$ _. Count -ge $ int_block_limit} |
    Wählen Sie -property Name

# Verketten Sie die beiden IP-Arrays (eines aus dem Sicherheitsprotokoll, eines aus dem FTP-Protokoll)
$ arr_new_bad_ips_all = @ ()
# $ arr_new_bad_ips_all = @ ($ arr_new_bad_ips_security_log) + @ ($ arr_new_bad_ips_ftp_over_limit)
$ arr_new_bad_ips_all = @ ($ arr_new_bad_ips_security_log) + @ ($ arr_new_bad_ips_ftp_control_channel) + @ ($ arr_new_bad_ips_ftp)

# Sortieren Sie das Array und wählen Sie nur eindeutige IP-Adressen aus (falls eine IP-Adresse sowohl im Sicherheits- als auch im FTP-Protokoll angezeigt wird).
$ arr_new_bad_ips_all_sorted = @ ()
$ arr_new_bad_ips_all_sorted = $ arr_new_bad_ips_all |
    Foreach-Object {[string] $ _. Name} |
    Select-Object-einzigartig

# Holen Sie sich ein Firewall-Objekt
$ firewall = New-Object -comobject hnetcfg.fwpolicy2

# Alle Firewall-Regeln abrufen, die mit "BlockAttackers *" übereinstimmen
$ arr_firewall_rules = $ firewall.Rules | Where {$ _. Name-like 'BlockAttackers *'}

# Wenn noch keine Firewall-Regel "BlockAttackers *" vorhanden ist, erstellen Sie eine und setzen Sie sie auf eine Variable
if ($ arr_firewall_rules -eq $ null) {
    $ str_new_rule_name = "BlockAttackers (Created" + $ current_date_utc.ToString ("JJJJ-MM-TT HH: MM: SS") + "UTC") "
    netsh advfirewall Firewall Regel hinzufügen dir = in Aktion = Blockname = $ str_new_rule_name description = "Regel automatisch erstellt." enable = yes remoteip = "0.0.0.0" | Out-Null
    $ arr_firewall_rules = $ firewall.Rules | Where {$ _. Name-like 'BlockAttackers *'}
}

# Teilen Sie die vorhandenen IP-Adressen der aktuellen "BlockAttackers *" - Firewall-Regeln in ein Array auf, damit wir sie problemlos durchsuchen können
$ arr_existing_bad_ips = @ ()
foreach ($ rule in $ arr_firewall_rules) {
    $ arr_existing_bad_ips + = $ rule.RemoteAddresses -split (',')
}

# Entfernen Sie Subnetzmasken von IP-Adressen, die derzeit von den Firewall-Regeln blockiert werden.
$ arr_existing_bad_ips_without_masks = @ ()
$ arr_existing_bad_ips_without_masks = $ arr_existing_bad_ips | Für jedes Objekt {$ _ -replace "/.*", ""}

# Geben Sie die IP-Adresse Ihres Servers (IPv4 und IPv6) in die Zeilen 115 und 116 ein.
# Wählen Sie IP-Adressen aus, die der Firewall hinzugefügt werden sollen, aber nur solche, die ...
$ arr_new_bad_ips_for_firewall = @ ()
$ arr_new_bad_ips_for_firewall = $ arr_new_bad_ips_all_sorted | Wo {
    # eine IP-Adresse enthalten (dh nicht leer oder ein Bindestrich, den das Sicherheitsprotokoll für Systeme enthält, bei denen FTP-Anmeldungen fehlgeschlagen sind)
    $ _. Länge -gt 6 -und
    # sind noch nicht in den Firewall-Regeln enthalten
    ! ($ arr_existing_bad_ips_without_masks -contains $ _) -und
    # ist nicht das lokale Loopback
    ! ($ _. StartsWith ('127.0.0.1')) -und
    # sind nicht Teil des lokalen Subnetzes
    ! ($ _. StartsWith ('192.168.')) -Und
    ! ($ _. StartsWith ('0.0.')) -Und
    ! ($ _. StartsWith ('10 .0. ')) -Und
    ! ($ _. StartsWith ('*. *. *. *')) -Und
    ! ($ _. StartsWith ('*: *: *: *: *: *'))
}

# Wenn IPs blockiert werden müssen, gehen Sie wie folgt vor ...
if ($ arr_new_bad_ips_for_firewall -ne $ null) {
    # Schreiben Sie Datum und Uhrzeit in die skriptspezifische Protokolldatei
    [DateTime] :: Now | Out-File -Append -Encoding utf8 C: \ inetpub \ logs \ LogFiles \ blockattackers.txt
    # Schreiben Sie neu blockierte IP-Adressen in die Protokolldatei
    $ arr_new_bad_ips_for_firewall | Out-File -Append -Encoding utf8 C: \ inetpub \ logs \ LogFiles \ blockattackers.txt

    # Boolescher Wert, um sicherzustellen, dass die neuen IP-Adressen nur für eine Regel hinzugefügt werden
    $ bln_added_to_rule = 0

    # Array, das jeweils eine ungültige IP-Adresse für jede Regel enthält. Wir können also sicherstellen, dass beim Hinzufügen der neuen IP-Adresse 1000 IP-Adressen nicht überschritten werden
    $ arr_existing_bad_ips_current_rule = @ ()

    # Führen Sie für jede "BlockAttackers *" - Regel in der Firewall die folgenden Schritte aus ...
    foreach ($ rule in $ arr_firewall_rules) {
        if ($ bln_added_to_rule -ne 1) {
            # Teilen Sie die vorhandenen IPs aus der aktuellen Regel in ein Array auf, damit wir sie problemlos zählen können
            $ arr_existing_bad_ips_current_rule = $ rule.RemoteAddresses -split (',')

            # Wenn die Anzahl der hinzuzufügenden IP-Adressen weniger als 1000 minus der aktuellen Anzahl der IP-Adressen in der Regel beträgt, fügen Sie sie dieser Regel hinzu
            if ($ arr_new_bad_ips_for_firewall.Count -le (1000 - $ arr_existing_bad_ips_current_rule.Count)) {
                # Fügen Sie der Firewall-Regel neue IP-Adressen hinzu
                $ arr_new_bad_ips_for_firewall | % {$ rule.RemoteAddresses + = ',' + $ _}

                # Schreiben Sie, zu welcher Regel die IPs zur Protokolldatei hinzugefügt wurden
                echo "Neue IP-Adressen oben zur Windows Firewall-Regel hinzugefügt:" $ rule.Name | Out-File -Append -Encoding utf8 C: \ inetpub \ logs \ LogFiles \ blockattackers.txt

                # Stellen Sie den Booleschen Wert so ein, dass andere Regeln beim Hinzufügen von IPs übersprungen werden
                $ bln_added_to_rule = 1
            }
        }
    }

    # Wenn in keiner anderen "BlockAttackers *" - Firewallregel Platz war, erstellen Sie eine neue und fügen Sie die IPs hinzu
    if ($ bln_added_to_rule -ne 1) {
        $ str_new_rule_name = "BlockAttackers (Created" + $ current_date_utc.ToString ("JJJJ-MM-TT HH: MM: SS") + "UTC") "
        netsh advfirewall Firewall Regel hinzufügen dir = in Aktion = Blockname = $ str_new_rule_name description = "Regel automatisch erstellt." enable = yes remoteip = "0.0.0.0" | Out-Null
        $ new_rule = $ firewall.rules | Wobei {$ _. Name -eq $ str_new_rule_name}

        # Fügen Sie der Firewall-Regel neue IP-Adressen hinzu
        $ arr_new_bad_ips_for_firewall | % {$ new_rule.RemoteAddresses + = ',' + $ _}

        # Schreiben Sie, zu welcher Regel die IPs zur Protokolldatei hinzugefügt wurden
        echo "Neue IP-Adressen wurden der neu erstellten Windows Firewall-Regel hinzugefügt:" $ new_rule.Name | Out-File -Append -Encoding utf8 C: \ inetpub \ logs \ LogFiles \ blockattackers.txt
    }
}

Der Name des FTP-Protokollordners FTPSVC*in Zeile 54 muss aus wichtigem Grund ausgefüllt werden. In den Zeilen 115 und 116 muss die IP Ihres Servers (IPv4 und IPv6) eingegeben werden, andernfalls kann die IP des eigenen Servers hundertmal zur Firewall-Regel hinzugefügt werden. Die Variable, die $int_block_limitich auf meinem Server auf 1 setze, sodass das Skript einen Hackerangriff blockiert, der innerhalb von zwei Sekunden ein 4625-Ereignis verursacht. Ich denke immer noch darüber nach, das Skript zusätzlich zu 4625-Ereignissen in einem Zeitraum von wenigen Minuten auszuführen. Natürlich wäre es auch möglich, die Skripte zu trennen und ein Skript die vom 4625-Ereignis ausgelösten 4625-Ereignisse und ein anderes Skript die Protokollordner des FTP-Servers regelmäßig alle 5 oder 10 Minuten überprüfen zu lassen, selbst bei separater Firewall-Regel und Protokolldatei.

Ich habe meine für SQL hinzugefügt

# Select from the Application log (SQL) all IP addresss that have more than $int_block_limit logon failure within $dat_time_window
$arr_new_bad_ips_SQL_log = @()
$arr_new_bad_ips_SQL_log = Get-EventLog -LogName 'Application' -After $dat_time_window |
    Where-Object{$_.EventID -eq 18456} |
    Select-Object @{n='CLIENT';e={$_.ReplacementStrings[-1]}} |
    Group-Object -property CLIENT |
    Where {$_.Count -ge $int_block_limit} |
    Select -property Name |
    {
        $_.Name = $_.Name.Replace(" [CLIENT: ", "");
        $_.Name = $_.Name.Replace("]", "");
        return $_;
    }

Dann müssen Sie das Array in ips_all einfügen

$arr_new_bad_ips_all = @($arr_new_bad_ips_SQL_log) + @($arr_new_bad_ips_security_log) + @($arr_new_bad_ips_ftp_control_channel) + @($arr_new_bad_ips_ftp)