Cấm địa chỉ IP dựa trên X số lần thử đăng nhập không thành công?

Có thể cấm địa chỉ IP sau X lần thử đăng nhập không thành công vào Windows Server không? Không phải cho một tài khoản cụ thể, mà tôi biết làm thế nào, nhưng cho toàn bộ máy.

Chúng tôi bị ảnh hưởng nặng nề bởi các cuộc tấn công vũ phu cố gắng đoán tên người dùng, vì vậy điều này thực sự sẽ giúp giảm tải cho máy chủ.

Bạn có thể làm điều này với powershell và trình quản lý tác vụ. Đây có thể không phải là giải pháp hoàn hảo, nhưng nó hoạt động khá tốt và tôi có khoảng 100 địa chỉ IP bị chặn trong hai tháng. Tôi đã viết tập lệnh, chọn từ các sự kiện được chỉ định của EventLog ("lỗi kiểm toán"). Nếu có nhiều lần đăng nhập thất bại từ bất kỳ địa chỉ IP nào, thì nó sẽ được thêm vào quy tắc tường lửa (được tạo thủ công) có tên "BlockAttackers", chặn mọi lưu lượng truy cập đến các địa chỉ IP được chỉ định.

Tập lệnh PS1:

$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

Tạo tác vụ trong trình lập lịch biểu và đặt kích hoạt thành sự kiện 4625 (đăng nhập windows bao gồm các dịch vụ đầu cuối). Nhưng bạn có thể đặt kích hoạt để chạy, ví dụ hai lần mỗi giờ để tránh tải máy chủ không cần thiết.

và sau khi kích hoạt chạy tập lệnh powershell. Bạn cũng phải đặt các đặc quyền cao hơn để chạy tập lệnh này, nếu không nó sẽ thất bại với ngoại lệ bảo mật.

Bạn cũng có thể liên kết tập lệnh này với các sự kiện bảo mật khác.

Tôi biết câu hỏi này đã cũ nhưng đây thực sự là bài đăng trên diễn đàn đầu tiên tôi tình cờ thấy khi tôi bắt đầu cố gắng thực hiện chính xác điều này một vài tuần trước. Tôi đã quản lý để đưa ra một kịch bản hoạt động sẽ phân tích các bản ghi sự kiện 24 giờ trở lại chỉ cho các mục nhật ký sự kiện đăng nhập xấu, lấy các mục có hơn 10 thông tin đăng nhập xấu, sau đó đưa chúng vào danh sách bộ lọc ipsec bằng cách sử dụng lệnh Netsh. Sau đó, tôi đã viết một tệp bó với dòng này powershell .\*scriptname.ps1*và tạo một tác vụ theo lịch trình để chạy tệp bó mỗi 24 giờ (vì một số lý do, nó sẽ không thực thi trực tiếp).

$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}

Tôi biết rằng kịch bản này có thể không hiệu quả nhưng khi tôi bắt đầu thực hiện nó, tôi hoàn toàn không có kinh nghiệm về powershell, vì vậy khả năng tối ưu hóa các kịch bản của tôi khiến tôi rất mong muốn. Tuy nhiên, mặc dù thực tế này, tôi nghĩ rằng tôi sẽ chia sẻ điều này với bất cứ ai có thể sử dụng nó.

Tôi cảm ơn Remunda vì đã cho tôi ý tưởng ban đầu, poster đó là tác phẩm khiến tôi bật ý tưởng sử dụng powershell để tìm kiếm nhật ký sự kiện.

Kịch bản này được xây dựng dựa trên câu trả lời của Remunda và đi xa hơn một chút https://serverfault.com/a/397637/155102 Nó chiếm quy tắc "BlockAttackers" chưa có bất kỳ IP nào được nhập (trả về "*" dưới dạng chuỗi). Nó cũng viết một bình luận vào một tệp nhật ký để cho bạn biết khi IP được thêm vào quy tắc.

Một mẹo hay là tạo quy tắc "BlockAttackers" chặn các địa chỉ IP NHƯNG làm cho nó bị vô hiệu hóa lúc đầu. Sau đó, chạy tập lệnh này một lần theo cách thủ công để nó có thể điền vào trường "RemoteAddresses" với các địa chỉ IP thực tế cần được chặn. Hãy xem các địa chỉ IP đó để đảm bảo không có gì quan trọng được thêm vào và sau đó kích hoạt quy tắc tường lửa. Thêm quy tắc này vào tường lửa của bạn như mô tả lại.

Git cho kịch bản này

#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'}
}

Tôi không thể tin vào câu trả lời này, nhưng https://serverfault.com/users/7200/evan-anderson đã đề cập đến dự án của mình http://opensource.wellbury.com/projects/windows_sshd_block/newest-release/

Nói chung, không nên để người khác kiểm soát các quy tắc tường lửa của bạn. Về cơ bản đó là những gì bạn đang yêu cầu ở đây.

Đây là một chủ đề cũ. Tôi đã sử dụng kịch bản được cung cấp bởi kevinmicke trong 2014-2015. Sau đó, nó chỉ dừng hoạt động. Vì vậy, tôi đã phải chỉnh sửa nó một chút để chấp nhận xác thực Windows Network Security không để lại địa chỉ IP trong nhật ký bảo mật. Ngoài ra, vì tôi không chạy FTP thường xuyên nên tôi đã xóa phần đó vì nó gây ra lỗi vì không có thư mục nhật ký. Thay đổi chính là trong nguồn của các sự kiện RDP.

    $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
        }
    }

Kịch bản trên sẽ hoạt động trên Windows 2012. Nếu bạn vẫn đang sử dụng Remote Desktop với xác thực cấp độ truy cập mạng trên Windows 2008 thì bạn có thể cần thực hiện thủ thuật sau. Windows 2008 không có địa chỉ IP trong nhật ký bảo mật và dường như không có chúng trong nhật ký Microsoft-Windows-RemoteDesktopService-RdpCoreTS. Vì vậy, tôi đã phải thực sự sử dụng 2 nhật ký - khớp các sự kiện từ nhật ký bảo mật đến các lần truy cập thành công vào cổng 3389 trong nhật ký tường lửa. Đây là một công việc đoán, nhưng nó dường như đang phát hiện các cuộc tấn công mật khẩu. Đây là phần thu thập các IP vi phạm:

    $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

LƯU Ý: Đừng quên bật nhật ký tường lửa. CHÚ THÍCH 2: Tôi không phải là chuyên gia về quyền hạn nên sẽ rất tuyệt nếu một số chuyên gia có thể sửa / cải thiện mã của tôi.

Tôi đang sử dụng ts_block miễn phí.

Về cơ bản, đây là một "chương trình VBScript hoạt động như một sự kiện chìm WMI để nhận các sự kiện được Windows ghi lại để đáp ứng với các đăng nhập Terminal Services không hợp lệ."

Có vẻ như hoạt động hoàn hảo, và kịch bản là đơn giản nếu bạn cần sửa đổi nó. Bạn có thể cho phép nó ghi nhật ký các lần thử và sau đó cấm dựa trên số lần thử được phép của bạn và / hoặc bạn có thể mã tên đăng nhập cứng mà bạn không muốn cấp quyền truy cập.

Tôi đã bị bắt gặp khi vô tình thêm cùng một tên hai lần và dịch vụ chỉ đi vào một vòng lặp vô tận khởi động lại sau mỗi 1500ms, nhưng rất dễ sửa / sửa nếu bạn ổn với vbs.

Cài đặt hiện tại của tôi chỉ là một lần thử lại và bạn bị cấm trong 2 ngày, với các thông tin đăng nhập như 'quản trị viên' 'Quản trị viên' 'Quản trị viên' 'khách' v.v ... tự động bị cấm. Có nên đơn giản để thay đổi thành ip?

Loại gây nghiện đi vào và xem những sinh vật nào đã bị cấm qua đêm ...

Bạn có nghĩa là đăng nhập vào máy chủ / tên miền hoặc đăng nhập vào một trang web đang chạy trên máy chủ? Nếu bạn có nghĩa là đăng nhập vào máy chủ / tên miền thì câu trả lời là không. Windows không có khái niệm chặn địa chỉ IP dựa trên các lần đăng nhập thất bại vì địa chỉ ip không phải là thực thể bảo mật. Có thể có các công cụ của bên thứ ba có thể làm điều này, nhưng tôi không biết về bất kỳ công cụ nào vì tôi chưa bao giờ nhìn vào nó.

Nếu có một máy chủ web đang bị tấn công, bạn có thể cài đặt tiện ích mở rộng hạn chế IP động . Nếu điều này là để xác thực tiêu chuẩn cho máy chủ thì bạn sẽ có thể thực hiện cách ly miền và máy chủ , điều này sẽ giới hạn phạm vi tấn công vào các máy tính gia nhập miền và có thể được đặt thành chỉ cho phép các nỗ lực từ các hệ thống bạn cần có quyền truy cập vào máy chủ. Trong các cửa sổ, việc ngăn chặn các cuộc tấn công vũ phu là đặt chính sách khóa tài khoản thành cài đặt như 10 phút và chính sách mật khẩu xấu thành 3 lần thử - điều này có nghĩa là tài khoản bị tấn công sẽ khóa trong 10 phút sau 3 lần thử. Các kết nối IP không thể khóa theo mặc định trong các cửa sổ. (Ngoài ra, tôi cũng tò mò về việc phải mất bao nhiêu lần đăng nhập mỗi giây để tác động đến hệ thống)

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

Nếu những gì bạn muốn là một giải pháp vượt trội (Cài đặt & hoàn thành), bạn có thể tìm thấy một công cụ miễn phí tại đây và có lẽ nên tiếp tục đọc điều này:

Phiên bản hiện tại: 1.2 (Hồ sơ khách hàng .NET Framework 4.0) -> Tải xuống phiên bản hiện tại của EvlWatcher (miễn phí cho sử dụng cá nhân và thương mại)

Mới trong 1.2 (thông tin thêm trong tài liệu):

• Bảng điều khiển quản lý
• Mẫu dịch vụ WCF
• Danh sách đen
• Tự động chuyển sang danh sách đen sau 3 lần đình công (mỗi mặc định)

Đối với các máy chủ cũ hơn (.NET Framework 2.0)

-> Tải xuống phiên bản rút gọn của EvlWatcher (miễn phí cho sử dụng cá nhân và thương mại)

Sử dụng tập lệnh tuyệt vời của Remunda làm điểm khởi đầu, tôi đã thêm một điều quan trọng còn thiếu: chặn địa chỉ IP khỏi các lần đăng nhập FTP không thành công . Windows Server không đăng nhập địa chỉ IP vào Nhật ký bảo mật khi ai đó không đăng nhập qua FTP mà thay vào đó, đặt "Địa chỉ mạng nguồn" thành dấu gạch ngang. FTP là một vectơ tấn công rất phổ biến cho các cuộc tấn công vũ phu, vì vậy tôi đã thêm vào tập lệnh của anh ấy khả năng quét nhật ký FTP của ngày hiện tại để tìm nhiều lỗi đăng nhập và cũng chặn các địa chỉ IP đó.

Cập nhật 2014/02/07: Khi tôi thực hiện một số điều chỉnh để xử lý tất cả các nhật ký FTP cũ của mình, tôi nhận ra khi chúng có số lượng lớn các lần thử (50.000+), các mảng mà nó tạo ra sẽ rất lớn và khiến quá trình xử lý cực kỳ chậm. Kể từ đó tôi đã viết lại nó để làm cho nó hiệu quả hơn nhiều khi xử lý nhật ký FTP.

Tôi cũng phát hiện ra rằng có giới hạn cứng tùy ý là 1000 cho số lượng IP có thể có trong một quy tắc Tường lửa của Windows. Do giới hạn đó, tôi cần nó để tự động tạo quy tắc mới khi quy tắc mới nhất lấp đầy. Bây giờ nó thực hiện điều đó và cũng tạo quy tắc tường lửa ban đầu (nếu bạn không tự tạo) để thiết lập duy nhất phải làm là thêm nó vào Trình lập lịch biểu để chạy khi có sự kiện 4625.

Đây là mã đã được thử nghiệm trên cả Windows Server 2008 R2 và Windows 7:

# 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
    }
}

Kịch bản của remuda , được chỉnh sửa bởi kevinmicke (7 tháng 2 lúc 21:59) đã không kiểm tra kênh điều khiển của FTP, có thư mục riêng trên hệ thống của tôi (Windows Server 2008 R2). Ngoài ra, những 530 11001điều chưa được công nhận, dường như xuất hiện khi tin tặc chỉ cố gắng truy cập vào kênh điều khiển. Vì vậy, tôi đã nối thêm một số dòng trong tập lệnh để kiểm tra thư mục FTP-log thứ hai:

# Tập lệnh Windows Powershell này sẽ tự động chặn các địa chỉ IP cố gắng đăng nhập vào hệ thống
# và không thành công số lần được đặt bên dưới với biến $ int_block_limit trở lên. Là quét cả Bảo mật
# log, bao gồm Remote Desktop và các nỗ lực khác, cũng như nhật ký FTP của ngày hiện tại. Nếu $ int_block_limit
# giới hạn được nhấn vào một trong hai nhật ký đó (riêng rẽ, không được kết hợp), sau đó địa chỉ IP sẽ được thêm vào
# quy tắc tường lửa.
#
# Tập lệnh sẽ tự động tạo quy tắc tường lửa có tên "BlockAttackers (Tạo yyyy-MM-dd HH: mm: ss UTC)" bằng cách sử dụng
# thời điểm hiện tại nếu một tên có "BlockAttackers" không tồn tại. Bởi vì có một khó khăn
# giới hạn 1000 mục (địa chỉ IP) bạn có thể chặn theo quy tắc, nó cũng sẽ tạo quy tắc có tên tương tự một lần
# giới hạn đạt được cho cái mới nhất.
#
# Tôi khuyên bạn nên đặt tập lệnh để chạy dưới dạng tác vụ theo lịch được kích hoạt bởi sự kiện kiểm toán đăng nhập sự kiện 4625 từ
# Nhật ký bảo mật hoặc cách khác là bạn có thể đặt nó chạy sau một khoảng thời gian (tức là cứ sau 10 phút).
#
# Tác giả:
# Đa số các tập lệnh được viết bởi người dùng serverfault.com kevinmicke
# Phần Nhật ký bảo mật của Windows được viết bởi remunda của serverfault.com, nơi cung cấp điểm khởi đầu cho kevinmicke
# Kiểm tra kênh điều khiển của FTP được thêm bởi người dùng serverfault.com Uwe Martens
#
# Chi tiết: https://serverfault.com/questions/233222/ban-ip-address-basing-on-x-number-of-unsuccessful-login-attvor


# Đặt số lần thử đăng nhập thất bại sau đó địa chỉ IP sẽ bị chặn
$ int_block_limit = 3

# Cửa sổ thời gian để kiểm tra Nhật ký bảo mật, hiện được đặt để chỉ kiểm tra trong 24 giờ qua
$ dat_time_window = [DateTime] :: Now.AddDays (-1)

# Chọn từ Nhật ký bảo mật tất cả các địa chỉ IP có nhiều hơn $ int_block_limit lỗi kiểm toán (sự kiện 4625) trong $ dat_time_window
$ Array_new_bad_ips_security_log = @ ()
$ Array_new_bad_ips_security_log = Get-EventLog -LogName 'Bảo mật' -InstanceId 4625 -Sau khi $ dat_time_window |
    Chọn-Object @ {n = 'IpAddress'; e = {$ _. AlternativeStrings [-2]}} |
    IpAddress nhóm-Object -property |
    Trong đó {$ _. Đếm -ge $ int_block_limit} |
    Chọn tên -perperty

# Nhận UTC thời gian hiện tại để tìm ra tên tệp cho nhật ký FTP hiện tại
$ current_date_utc = (Ngày nhận) .ToUniversalTime ()

# Đặt đường dẫn đến tệp nhật ký Kênh điều khiển FTP ngày nay
$ str_log_file_name_control_channel = "C: \ inetpub \ log \ LogFiles \ FTPSVC \ u_ex" + $ current_date_utc.ToString ("yyMMdd") + ".log"

# Tìm kiếm tệp nhật ký Kênh Điều khiển FTP ngày hôm nay cho "530 1" để tìm các dòng chứa IP của các hệ thống không đăng nhập được,
# chỉ nhận IP từ mỗi dòng, nhóm IP theo IP để đếm số lần thử từ mỗi dòng và chỉ chọn
# IP có $ int_block_limit hoặc nhiều thông tin đăng nhập xấu hiện nay
$ Array_new_bad_ips_ftp_control_channel = @ ()
$ Array_new_bad_ips_ftp_control_channel = Chọn chuỗi $ str_log_file_name_control_channel -potype "530 1" |
    ForEach-Object {$ _. Line.Sub chuỗi (20,15) -replace ". *", ""} |
    Nhóm |
    Trong đó {$ _. Đếm -ge $ int_block_limit} |
    Chọn tên -perperty

# Đặt đường dẫn đến tệp nhật ký FTP ngày nay
$ str_log_file_name = "C: \ inetpub \ log \ LogFiles \ FTPSVC * \ u_ex" + $ current_date_utc.ToString ("yyMMdd") + ".log"

# Tìm kiếm tệp nhật ký FTP ngày hôm nay cho "530 1" để tìm các dòng chứa IP của các hệ thống không đăng nhập được,
# chỉ nhận IP từ mỗi dòng, nhóm IP theo IP để đếm số lần thử từ mỗi dòng và chỉ chọn
# IP có $ int_block_limit hoặc nhiều thông tin đăng nhập xấu hiện nay
# Trong FTPSVC * phải được thêm ID của máy chủ FTP thay vì * hoặc chỉ cần lấy đúng thư mục nhật ký
$ Array_new_bad_ips_ftp = @ ()
$ Array_new_bad_ips_ftp = Chọn-Chuỗi $ str_log_file_name -potype "530 1" |
    ForEach-Object {$ _. Line.Sub chuỗi (20,15) -replace ". *", ""} |
    Nhóm |
    Trong đó {$ _. Đếm -ge $ int_block_limit} |
    Chọn tên -perperty

# Nối hai mảng IP (một từ Nhật ký bảo mật, một từ nhật ký FTP)
$ Array_new_bad_ips_all = @ ()
# $ Array_new_bad_ips_all = @ ($ Array_new_bad_ips_security_log) + @ ($ Array_new_bad_ips_ftp_over_limit)
$ Array_new_bad_ips_all = @ ($ Array_new_bad_ips_security_log) + @ ($ Array_new_bad_ips_ftp_control_channel) + @ ($ Array_new_bad_ips_ftp)

# Sắp xếp mảng, chỉ chọn các IP duy nhất (trong trường hợp một IP hiển thị trong cả nhật ký Bảo mật và FTP)
$ Array_new_bad_ips_all_sortic = @ ()
$ Array_new_bad_ips_all_sortic = $ Array_new_bad_ips_all |
    Foreach-Object {[chuỗi] $ _. Name} |
    Chọn-Object -unique

# Nhận đối tượng tường lửa
$ tường lửa = Đối tượng mới -comobject hnetcfg.fwpolicy2

# Nhận tất cả các quy tắc tường lửa phù hợp với "BlockAttackers *"
$ Array_firewall_rules = $ tường lửa.Rules | Trong đó {$ _. Giống như tên 'BlockAttackers *'}

# Nếu chưa có quy tắc tường lửa "BlockAttackers *", hãy tạo một và đặt nó thành một biến
if ($ Array_firewall_rules -eq $ null) {
    $ str_new_rule_name = "BlockAttackers (Đã tạo" + $ current_date_utc.ToString ("yyyy-MM-dd HH: mm: ss") + "UTC)"
    tường lửa Netsh advfirewall thêm quy tắc dir = in action = block name = $ str_new_rule_name description = "Quy tắc được tạo tự động." enable = yes remoteip = "0.0.0.0" | Hết
    $ Array_firewall_rules = $ tường lửa.Rules | Trong đó {$ _. Giống như tên 'BlockAttackers *'}
}

# Tách các IP hiện tại khỏi (các) quy tắc tường lửa "BlockAttackers *" hiện tại thành một mảng để chúng ta có thể dễ dàng tìm kiếm chúng
$ Array_ex hiện_bad_ips = @ ()
foreach (quy tắc $ trong $ Array_firewall_rules) {
    $ Array_ex hiện_bad_ips + = $ rule.RemoteAddresses -split (',')
}

# Làm sạch mặt nạ mạng con khỏi các IP hiện bị chặn bởi (các) quy tắc tường lửa
$ Array_ex hiện_bad_ips_without_masks = @ ()
$ Array_ex hiện_bad_ips_without_masks = $ Array_ex hiện_bad_ips | ForEach-Object {$ _ -replace "/.*", ""}

# Nhập IP của máy chủ của bạn (IPv4 và IPv6) vào dòng 115 và 116.
# Chọn địa chỉ IP để thêm vào tường lửa, nhưng chỉ những địa chỉ ...
$ Array_new_bad_ips_for_firewall = @ ()
$ Array_new_bad_ips_for_firewall = $ Array_new_bad_ips_all_sort | Ở đâu {
    # chứa địa chỉ IP (nghĩa là không trống hoặc dấu gạch ngang, mà Nhật ký bảo mật dành cho các hệ thống đăng nhập FTP không thành công)
    $ _. Chiều dài -gt 6 -và
    # chưa có trong quy tắc tường lửa
    ! ($ Array_ex hiện_bad_ips_without_masks -contains $ _) -và
    # không phải là loopback cục bộ
    ! ($ _. Bắt đầu với ('127.0.0.1')) -và
    # không phải là một phần của mạng con cục bộ
    ! ($ _. Bắt đầu với ('192.168.')) -Và
    ! ($ _. Bắt đầu với ('0,0.')) -Và
    ! ($ _. Bắt đầu với ('10 .0. ')) -Và
    ! ($ _. Bắt đầu với ('*. *. *. *')) -Và
    ! ($ _. Bắt đầu với ('*: *: *: *: *: *'))
}

# Nếu có IP để chặn, hãy làm như sau ...
if ($ Array_new_bad_ips_for_firewall -ne $ null) {
    # Viết ngày và giờ vào tệp nhật ký dành riêng cho tập lệnh
    [DateTime] :: Bây giờ | Out-File -Append -Encoding utf8 C: \ inetpub \ log \ LogFiles \ blockattackers.txt
    # Ghi địa chỉ IP mới bị chặn vào tệp nhật ký
    $ Array_new_bad_ips_for_firewall | Out-File -Append -Encoding utf8 C: \ inetpub \ log \ LogFiles \ blockattackers.txt

    # Boolean để đảm bảo IP mới chỉ được thêm vào theo một quy tắc
    $ bln_added_to_rule = 0

    # Mảng để giữ các IP xấu từ mỗi quy tắc một lần, vì vậy chúng tôi có thể đếm để đảm bảo thêm các IP mới sẽ không vượt quá 1000 IP
    $ Array_ex hiện_bad_ips_cản_rule = @ ()

    # Đối với mỗi quy tắc "BlockAttackers *" trong tường lửa, hãy làm như sau ...
    foreach (quy tắc $ trong $ Array_firewall_rules) {
        if ($ bln_added_to_rule -ne 1) {
            # Tách các IP hiện có từ quy tắc hiện tại thành một mảng để chúng ta có thể dễ dàng đếm chúng
            $ Array_ex hiện_bad_ips_cản_rule = $ rule.RemoteAddresses -split (',')

            # Nếu số lượng IP cần thêm ít hơn 1000 trừ số IP hiện tại trong quy tắc, hãy thêm chúng vào quy tắc này
            if ($ Array_new_bad_ips_for_firewall.Count -le (1000 - $ Array_ex hiện_bad_ips_cản_rule.Count)) {
                # Thêm IP mới vào quy tắc tường lửa
                $ Array_new_bad_ips_for_firewall | % {$ rule.RemoteAddresses + = ',' + $ _}

                # Viết quy tắc nào IP được thêm vào tệp nhật ký
                echo "Địa chỉ IP mới ở trên được thêm vào quy tắc Tường lửa của Windows:" $ rule.Name | Out-File -Append -Encoding utf8 C: \ inetpub \ log \ LogFiles \ blockattackers.txt

                # Đặt boolean để mọi quy tắc khác được bỏ qua khi thêm IP
                $ bln_added_to_rule = 1
            }
        }
    }

    # Nếu không có chỗ trong bất kỳ quy tắc tường lửa "BlockAttackers *" nào khác, hãy tạo một cái mới và thêm IP vào nó
    if ($ bln_added_to_rule -ne 1) {
        $ str_new_rule_name = "BlockAttackers (Đã tạo" + $ current_date_utc.ToString ("yyyy-MM-dd HH: mm: ss") + "UTC)"
        tường lửa Netsh advfirewall thêm quy tắc dir = in action = block name = $ str_new_rule_name description = "Quy tắc được tạo tự động." enable = yes remoteip = "0.0.0.0" | Hết
        $ new_rule = $ tường lửa.rules | Trong đó {$ _. Tên -eq $ str_new_rule_name}

        # Thêm IP mới vào quy tắc tường lửa
        $ Array_new_bad_ips_for_firewall | % {$ new_rule.RemoteAddresses + = ',' + $ _}

        # Viết quy tắc nào IP được thêm vào tệp nhật ký
        echo "Địa chỉ IP mới ở trên được thêm vào quy tắc Tường lửa Windows mới được tạo:" $ new_rule.Name | Out-File -Append -Encoding utf8 C: \ inetpub \ log \ LogFiles \ blockattackers.txt
    }
}

Tên của thư mục nhật ký của FTP FTPSVC*trên dòng 54 phải được hoàn thành có lý do. Trong dòng 115 và 116 phải được nhập IP của máy chủ của bạn (IPv4 và IPv6), nếu không, IP của máy chủ riêng có thể được thêm vào quy tắc tường lửa hàng trăm lần. Biến $int_block_limittôi đang đặt thành 1 tại máy chủ của mình, vì vậy tập lệnh đang chặn một cuộc tấn công của tin tặc gây ra sự kiện 4625 trong vòng hai giây. Tôi vẫn đang suy nghĩ về việc chạy kịch bản bổ sung để xảy ra 4625 sự kiện trong khoảng thời gian vài phút. Vì lý do, cũng có thể, để tách các tập lệnh và để một tập lệnh kiểm tra 4625 sự kiện được kích hoạt bởi sự kiện 4625 và một tập lệnh khác mà các thư mục nhật ký của FTP kiểm tra định kỳ cứ sau 5 hoặc 10 phút, ngay cả với quy tắc tường lửa riêng và tệp nhật ký.

Tôi đã thêm của tôi cho SQL

# 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 $_;
    }

Sau đó, bạn sẽ phải thêm mảng vào ips_all

$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)