असफल लॉगिन प्रयासों के एक्स नंबर के आधार पर प्रतिबंध आईपी पता?


47

क्या विंडोज सर्वर पर असफल लॉगिन प्रयासों के एक्स नंबर के बाद आईपी पते पर प्रतिबंध लगाना संभव है? किसी विशेष खाते के लिए नहीं, जो मुझे पता है कि कैसे करना है, लेकिन पूरी मशीन के लिए।

हम उपयोगकर्ता नाम का अनुमान लगाने की कोशिश कर रहे क्रूर बल के हमलों से बहुत मुश्किल हो जाते हैं, इसलिए यह वास्तव में सर्वर से कुछ लोड प्राप्त करने में मदद करेगा।


8
* nix में fial2ban है ... सुनिश्चित नहीं है कि कोई विंडोज समकक्ष / पोर्ट है या नहीं। fail2ban.org/wiki/index.php/Main_Page
क्रिस नावा

5
इवान एंडरसन से: serverfault.com/questions/43360/… ... फेल 2ब्बन की कार्यक्षमता का एक अच्छा समकक्ष दिखता है, लेकिन जैसा कि आपका सवाल पर्याप्त विशिष्ट नहीं है, मुझे नहीं पता कि आप आईपी पर प्रतिबंध लगाने की कोशिश कर रहे हैं या नहीं। एक होस्ट की गई वेबसाइट पर, आपके सर्वर (SSH के माध्यम से) या आपके डोमेन पर। क्लेरीफिकेशन एक लंबा रास्ता तय करेगा। इसके अतिरिक्त आप अपने फ़ायरवॉल पर सीमा को सीमित कर सकते हैं, लेकिन यह कार्यान्वयन-निर्भर है।

4
IP पर आधारित स्वचालित स्वचालित प्रतिबंध कितना उपयोगी है, इस बारे में पिछली चर्चा के लिए आप serverfault.com/questions/216995/… पर एक नज़र डाल सकते हैं ।
पीहर

1
यदि आप टर्मिनल सेवाओं के बारे में बात कर रहे हैं / दूरस्थ डेस्कटॉप पर एक नज़र है: serverfault.com/a/335976/7200
इवान एंडरसन

3
मैंने
जीथुब

जवाबों:


28

आप इसे शक्तियां और कार्य प्रबंधक के साथ कर सकते हैं। यह शायद सही समाधान नहीं है, लेकिन यह काफी अच्छी तरह से काम करता है और मेरे पास दो महीनों में लगभग 100 अवरुद्ध आईपी पते हैं। मैंने स्क्रिप्ट लिखी, जो कि EventLog निर्दिष्ट घटनाओं ("ऑडिट विफलता") से चुनें। यदि किसी भी आईपी पते से कई विफल लॉगिन हैं, तो इसे "ब्लॉकअटैकर" नाम के फ़ायरवॉल नियम (मैन्युअल रूप से बनाया गया) में जोड़ा जाता है जो निर्दिष्ट आईपी पते पर किसी भी यातायात को रोकता है।

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

शेड्यूलर में कार्य बनाएं और ईवेंट 4625 पर सेट करें (टर्मिनल सेवाओं सहित विंडोज़ लॉगिन)। लेकिन आप सर्वर पर अनावश्यक लोडिंग से बचने के लिए प्रति घंटे दो बार जैसे ट्रिगर को सेट कर सकते हैं।

शेड्यूलर ट्रिगर

और ट्रिगर चलाने के बाद पटकथा पटकथा। आपको इस स्क्रिप्ट को चलाने के लिए उच्च विशेषाधिकार भी निर्धारित करने होंगे, अन्यथा यह सुरक्षा अपवाद के साथ विफल हो जाएगा।

रनिंग पॉवरशेल स्क्रिप्ट

आप इस स्क्रिप्ट को अन्य सुरक्षा घटनाओं में भी बाँध सकते हैं।


1
उत्कृष्ट स्क्रिप्ट @remunda - धन्यवाद! मुझे FTP के साथ-साथ 4625 का भी बहुत कुछ मिल रहा था, जिसके लिए सिक्योरिटी लॉग के पास आईपी एड्रेस नहीं है, इसलिए मैंने आपकी स्क्रिप्ट पर विस्तार करके इसे वर्तमान दिन के एफ़टीपी लॉग की भी जाँच की। कृपया अधिक जानकारी के लिए मेरा जवाब नीचे देखें: serverfault.com/a/571903/107701
kevinmicke

पर स्वतंत्र और खुला स्रोत - वहाँ gotchas और इवेंट लॉग, आईपी पते लॉगिंग, आदि है कि मैं IPBan में संभाला है के साथ बढ़त के मामलों की एक बहुत हैं github.com/jjxtra/Windows-IP-Ban-Service
jjxtra

7

मुझे पता है कि यह प्रश्न पुराना है, लेकिन यह वास्तव में पहला मंच पोस्ट था जिसे मैंने तब ठोकर खाई थी जब मैंने कुछ हफ़्ते पहले इसी सटीक चीज़ को करने की कोशिश शुरू की थी। मैं एक कामकाजी स्क्रिप्ट के साथ आने में कामयाब रहा हूं जो केवल खराब लॉग इन इवेंट लॉग प्रविष्टियों के लिए 24 घंटे पहले ईवेंट लॉग को पार्स कर देगा, 10 से अधिक खराब लॉगिन वाले लोगों को पकड़ो और फिर उन्हें एक ipsec फ़िल्टर सूची में डाल दें। netsh कमांड। फिर मैंने इस लाइन के साथ एक बैच फ़ाइल लिखी powershell .\*scriptname.ps1*और हर 24 घंटे में बैच फ़ाइल को चलाने के लिए एक निर्धारित कार्य बनाया (किसी कारण से यह सीधे निष्पादित नहीं होगा)।

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

मुझे पता है कि यह स्क्रिप्ट शायद अक्षम है, लेकिन जब मैंने इस पर काम करना शुरू किया तो मुझे पॉवरशेल में बिल्कुल कोई अनुभव नहीं था, इसलिए स्क्रिप्ट को ऑप्टिमाइज़ करने की मेरी क्षमता वांछित होने के लिए बहुत कुछ छोड़ देती है। हालांकि, इस तथ्य के बावजूद मुझे लगा कि मैं इसे किसी के साथ साझा करूंगा जो इसका उपयोग कर सकता है।

मैं मुझे प्रारंभिक विचार देने के लिए रेमुंडा का धन्यवाद करता हूं, वह पोस्टर वह है जिसने मुझे इवेंट लॉग्स को खोजने के लिए शक्तियां का उपयोग करने के विचार पर दिया।


4

यह स्क्रिप्ट रिमुन्डा के उत्तर पर बनती है और थोड़ा और आगे जाती है https://serverfault.com/a/397637/155102 यह "ब्लॉकअटैकर" नियम के लिए अभी तक कोई आईपी दर्ज नहीं किया है (जो एक स्ट्रिंग के रूप में "*" लौटाता है)। यह एक लॉग फ़ाइल के लिए एक टिप्पणी भी लिखता है ताकि आपको पता चल सके कि आईपी को नियम में जोड़ा गया था।

एक अच्छा टिप "BlockAttackers" नियम बनाने के लिए है जो IP पतों को ब्लॉक करता है लेकिन यह पहली बार में अक्षम कर देता है। फिर, इस स्क्रिप्ट को एक बार मैन्युअल रूप से चलाएं ताकि यह वास्तविक आईपी पते के साथ "RemoteAddresses" फ़ील्ड को पॉप्युलेट कर सके जिसे अवरुद्ध किया जाना चाहिए। उन IP पतों पर एक नज़र डालें जो सुनिश्चित करते हैं कि कुछ भी महत्वपूर्ण नहीं जोड़ा गया है और फिर फ़ायरवॉल नियम को सक्षम करें। वर्णित नियम को अपने फ़ायरवॉल में जोड़ें

इस स्क्रिप्ट के लिए गिट

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


2

यह आमतौर पर किसी और को अपने फ़ायरवॉल नियमों को नियंत्रित करने के लिए एक अच्छा विचार नहीं है। यह मूल रूप से आप यहाँ क्या माँग रहे हैं।


1
+1, यह सेवा हमले से इनकार करने के लिए खुद को स्थापित करने का एक शानदार तरीका है। और अगर आप दर-सीमित का उपयोग कर रहे हैं, तो अधिकांश स्वचालित ब्रूट फोर्स टूल अपने लॉगिन प्रयासों को काफी दूर तक पकड़ लेते हैं और पकड़े जाने से बचते हैं।

12
एक निश्चित संख्या में विफल लॉगिन के बाद आईपी पर स्वचालित रूप से प्रतिबंध लगाना बहुत आम बात है। मुझे लगता है कि एफ़टीपी पासवर्ड का अनुमान लगाने की कोशिश के बाद मेजबान एक घंटे के आधार पर प्रतिबंधित हो रहे हैं। इसका एकमात्र तरीका यह है कि DoS हमला हो सकता है यदि कोई आपके IP (TCP कनेक्शन पर असंभव) को खराब करने में कामयाब रहा है, या यदि आप बार-बार अपना पासवर्ड गलत करते हैं (जिस स्थिति में यह फ़ायरवॉल नियमों को नियंत्रित करने वाला कोई और नहीं है, तो यह आप है)
devicenull

18
क्षमा करें, लेकिन मैंने नहीं पूछा कि क्या यह एक अच्छा विचार है।
हैवीवेव

1
बेशक, कोई कारण नहीं है कि अपवाद एक या अधिक विशिष्ट आईपी पते के लिए सेट नहीं किया जा सकता है, जो कि बहुत हद तक DoS चिंता को समाप्त कर देगा।
जॉन गार्डनियर्स

2

यह एक पुराना थ्रेड है। मैं 2014-2015 में kevinmicke द्वारा प्रदान की गई स्क्रिप्ट का उपयोग कर रहा था। फिर बस काम करना बंद कर दिया। इसलिए मुझे विंडोज़ नेटवर्क सिक्योरिटी ऑथेंटिकेशन को अपनाने के लिए इसे थोड़ा एडिट करना पड़ा, जो सिक्योरिटी लॉग में आईपी एड्रेस नहीं छोड़ता। इसके अलावा, चूंकि मेरे पास नियमित रूप से एफ़टीपी नहीं चल रहा है, इसलिए मैंने उस भाग को हटा दिया क्योंकि इसमें कोई त्रुटि थी क्योंकि लॉग फ़ोल्डर नहीं था। मुख्य परिवर्तन आरडीपी घटनाओं के स्रोत में है।

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

उपरोक्त स्क्रिप्ट विंडोज 2012 पर काम करेगी। यदि आप अभी भी विंडोज 2008 पर नेटवर्क एक्सेस लेवल ऑथेंटिकेशन के साथ रिमोट डेस्कटॉप का उपयोग कर रहे हैं, तो आपको निम्नलिखित ट्रिक करने की आवश्यकता हो सकती है। Windows 2008 में सुरक्षा लॉग में IP पते नहीं हैं और Microsoft-Windows-RemoteDesktopServices-RdpCoreTS लॉग में उन्हें नहीं लगता है। इसलिए मुझे वास्तव में फ़ायरवॉल लॉग में 3389 को पोर्ट करने के सफल सुरक्षा प्रयासों के लिए 2 लॉग - मैच की घटनाओं का उपयोग करना पड़ा। यह एक अनुमान कार्य है, लेकिन यह पासवर्ड हमलों का पता लगाता है। यहाँ वह भाग है जो IP का उल्लंघन करने वाला है:

    $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

नोट: फ़ायरवॉल लॉग को सक्षम करने के लिए मत भूलना। नोट 2: मैं एक पॉवरशेल्ड विशेषज्ञ नहीं हूं, इसलिए अच्छा होगा यदि कुछ गुरु मेरे कोड को सुधार / सुधार सकते हैं।


1

मैं फ्री में ts_block का उपयोग कर रहा हूं ।

मूल रूप से यह एक "VBScript प्रोग्राम है जो अमान्य टर्मिनल सेवा डोमेन के जवाब में विंडोज द्वारा लॉग इन की गई घटनाओं को प्राप्त करने के लिए WMI इवेंट सिंक के रूप में कार्य करता है।"

पूरी तरह से काम करने के लिए लगता है, और अगर आप इसे मॉड करने की जरूरत है तो पटकथा सीधी है। आप या तो इसे लॉग इन करने की अनुमति दे सकते हैं और फिर आपके द्वारा अनुमत प्रयासों की संख्या के आधार पर प्रतिबंध लगा सकते हैं, और / या आप उन हार्ड-कोड लॉगिन नामों को भी एक्सेस कर सकते हैं जिन्हें आप एक्सेस नहीं देना चाहते हैं।

मैं दो बार एक ही नाम जोड़कर गलती से पकड़ा गया और सेवा हर 1500ms को पुनः आरंभ करने वाले अंतहीन लूप में जाती है, लेकिन यदि आप vbs के साथ ठीक हैं, तो इसे ठीक करना / मोडना बहुत आसान है।

मेरी वर्तमान सेटिंग सिर्फ एक रीट्री है और आपको 2 दिनों के लिए प्रतिबंधित कर दिया गया है, साथ ही 'एडमिन' 'एडमिन' 'एडमिनिस्ट्रेटर' 'गेस्ट' आदि जैसे लॉगिन स्वतः प्रतिबंधित हो जाते हैं। आईपी ​​में बदलने के लिए सीधा होना चाहिए?

किन्दा नशे की लत में जाने के लिए और देखने के लिए कि रात भर कौन से अपराधियों पर प्रतिबंध लगाया गया है ...


0

क्या आपका मतलब सर्वर / डोमेन पर लॉग इन करना है या सर्वर पर चल रही वेब साइट पर लॉग इन करना है? यदि आप सर्वर / डोमेन पर लॉग इन करने का मतलब है तो उत्तर नहीं है। Windows में विफल लोगो के प्रयासों के आधार पर आईपी पते को अवरुद्ध करने की कोई अवधारणा नहीं है क्योंकि आईपी पते सुरक्षा संस्थाएं नहीं हैं। तीसरे पक्ष के उपकरण हो सकते हैं जो ऐसा कर सकते हैं, लेकिन मुझे किसी के बारे में पता नहीं है क्योंकि मैंने इसे कभी नहीं देखा है।


0

यदि कोई वेबसर्वर है जिस पर हमला किया जा रहा है तो आप गतिशील आईपी प्रतिबंध एक्सटेंशन को स्थापित कर सकते हैं । यदि यह सर्वर के लिए मानक प्रमाणीकरण के लिए है, तो आपको डोमेन और सर्वर अलगाव को लागू करने में सक्षम होना चाहिए, जो हमलों के दायरे को कंप्यूटर से जुड़ने वाले डोमेन तक सीमित कर देगा, और केवल उन सिस्टम से प्रयासों की अनुमति देने के लिए सेट किया जा सकता है जिनकी आपको एक्सेस करने की आवश्यकता है सर्वर। खिड़कियों में क्रूर बल के हमलों की रोकथाम के लिए खाता लॉकआउट नीति को 10 मिनट और 3 प्रयासों के लिए एक खराब पासवर्ड नीति सेट करना है - इसका मतलब है कि हमला किया जा रहा खाता 3 प्रयासों के बाद 10 मिनट के लिए बंद हो जाएगा। विंडोज़ में डिफ़ॉल्ट रूप से IP कनेक्शन लॉक करने योग्य नहीं हैं। (एक तरफ के रूप में मैं भी उत्सुक हूं कि सिस्टम को प्रभावित करने के लिए कितने लोग इसे प्रति सेकंड ले रहे हैं)


मेरे एडब्ल्यूएस छोटे उदाहरण पर, प्रत्येक 4 सेकंड में 1 प्रयास 50% सीपीयू का उपभोग करने के लिए पर्याप्त है। सुंदर बकवास अगर आप मुझसे पूछें ...
RomanSt

वाह, मुझे आश्चर्य है कि उपयोग इतना अधिक क्यों है। मुझे यह देखने के लिए अपने वीएम पर कितने प्रयास करने हैं, यह देखने के लिए कुछ परीक्षण करना होगा।
जिम बी

मुझे लगता है कि यह इसलिए है क्योंकि मैं नेटवर्क स्तर प्रमाणीकरण का उपयोग नहीं कर रहा हूं, इसलिए हर लॉगिन प्रयास एक लॉगऑन UI को वास्तव में दूरस्थ डेस्कटॉप सत्र के माध्यम से हमलावर को प्रस्तुत करता है। मैं देख सकता हूं कि यह महंगा क्यों हो सकता है।
रोमनस्ट

0

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

यदि आप जो चाहते हैं वह आउट ऑफ बॉक्स सॉल्यूशन (इंस्टॉल और किया गया) है, तो आप यहां एक निशुल्क टूल पा सकते हैं, और शायद इसे पढ़ने पर जाना चाहिए:

वर्तमान संस्करण: 1.2 (.NET फ्रेमवर्क 4.0 क्लाइंट प्रोफाइल) -> EvlWatcher (व्यक्तिगत और व्यावसायिक उपयोग के लिए मुफ्त ) का वर्तमान संस्करण डाउनलोड करें

1.2 में नया (प्रलेखन में अधिक जानकारी):

  • प्रबंधन सांत्वना
  • WCF सेवा पैटर्न
  • प्रतिबंधीकरण
  • 3 स्ट्राइक (प्रति डिफ़ॉल्ट) के बाद काली सूची में स्वतः-चल रहा है

पुराने सर्वर (.NET फ्रेमवर्क 2.0) के लिए

-> EvlWatcher का कम संस्करण डाउनलोड करें (व्यक्तिगत और व्यावसायिक उपयोग के लिए मुफ्त)


0

एक शुरुआती बिंदु के रूप में रिमुंडा की महान स्क्रिप्ट का उपयोग करते हुए , मैंने एक प्रमुख चीज़ जोड़ी जो गायब थी: असफल FTP लॉगिन से आईपी पते को अवरुद्ध करना । जब कोई एफ़टीपी के माध्यम से लॉगिन करने में विफल रहता है, तो विंडोज सर्वर आईपी पते को सुरक्षा लॉग में लॉग नहीं करता है, बल्कि "स्रोत नेटवर्क पते" को डैश पर सेट करता है। एफ़टीपी बल हमलों के लिए एफ़टीपी एक बहुत ही सामान्य हमला वेक्टर है, इसलिए मैंने उनकी स्क्रिप्ट में कई लॉगिन विफलताओं के लिए वर्तमान दिन के एफ़टीपी लॉग को स्कैन करने और उन आईपी पते को ब्लॉक करने की क्षमता को जोड़ा।

अद्यतन 2014/02/07: जब मैंने अपने सभी पुराने एफ़टीपी लॉग को संसाधित करने के लिए कुछ ट्विक्स किए, तो मुझे एहसास हुआ कि जब उनके पास प्रयासों (50,000+) की अपार संख्या थी, तो इसके द्वारा बनाई गई सरणियाँ बहुत बड़ी होंगी और प्रोसेसिंग को अविश्वसनीय रूप से धीमा कर देंगी। एफ़टीपी लॉग्स को संसाधित करते समय मैंने इसे और अधिक कुशल बनाने के लिए इसे फिर से लिखा है।

मुझे यह भी पता चला कि एक विंडोज फ़ायरवॉल नियम में कितने IP हो सकते हैं, इसके लिए 1000 की एक मनमानी कठिन सीमा है। उस सीमा के कारण, मुझे इसकी आवश्यकता थी कि जब कोई नवीनतम नियम भरता है, तो उसे स्वचालित रूप से एक नया नियम बनाना होगा। यह अब ऐसा करता है, और प्रारंभिक फ़ायरवॉल नियम भी बनाता है (यदि आप अपना खुद का निर्माण नहीं करते हैं) तो ऐसा करने के लिए एकमात्र सेटअप शेड्यूलर में जोड़ रहा है जब एक घटना 4625 है।

यहाँ कोड है, जिसे विंडोज सर्वर 2008 R2 और विंडोज 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
    }
}

FYI करें: उन लोगों के लिए जो पहले किसी सिस्टम पर एक पॉवरशेल स्क्रिप्ट नहीं चलाते हैं, आपको पहले एक नई शक्तियां खोलने की आवश्यकता होगी और Set-ExecutionPolicy RemoteSignedआप स्थानीय स्क्रिप्ट चला सकते हैं। अन्यथा आपको एक त्रुटि मिलेगी: "blockattackers.ps1 को लोड नहीं किया जा सकता क्योंकि स्क्रिप्ट का निष्पादन इस सिस्टम पर अक्षम है।"

0

की पटकथा remuda , द्वारा संपादित kevinmicke (21:59 पर 7 फरवरी) एफ़टीपी के नियंत्रण चैनल है, जो अपने सिस्टम (Windows Server 2008 R2) पर एक स्वयं के फ़ोल्डर की जांच नहीं की। इसके अलावा, 530 11001उन लोगों को मान्यता नहीं दी गई है, जो तब प्रतीत होते हैं जब हैकर केवल नियंत्रण चैनल तक पहुंचने की कोशिश करता है। इसलिए मैंने दूसरी एफ़टीपी-लॉग-फ़ोल्डर की जाँच करने के लिए स्क्रिप्ट में कुछ पंक्तियों को जोड़ा:

# यह विंडोज पॉवर्सशैली स्क्रिप्ट स्वचालित रूप से आईपी पते को ब्लॉक कर देगा जो सिस्टम में लॉगिन करने का प्रयास करता है
# $ int_block_limit चर या अधिक के साथ निर्धारित समय की संख्या को विफल करें। दोनों सुरक्षा स्कैन है
# लॉग, जो दूरस्थ डेस्कटॉप और अन्य प्रयासों को कवर करता है, साथ ही वर्तमान दिन के एफ़टीपी लॉग को भी। यदि $ int_block_limit
# सीमा उन लॉग्स में से किसी एक पर (अलग से, संयुक्त नहीं) हिट होती है, फिर आईपी एड्रेस को जोड़ा जाएगा
# फ़ायरवॉल नियम।
#
# स्क्रिप्ट स्वचालित रूप से "BlockAttackers (बनाया गया yyyy-MM-dd HH: mm: ss UTC)" नाम से एक फ़ायरवॉल नियम बनाएगी
# वर्तमान समय यदि कोई ऐसा नाम जिसमें "BlockAttackers" शामिल है, पहले से मौजूद नहीं है। क्योंकि वहाँ एक मुश्किल है
# 1000 प्रविष्टियों की सीमा (आईपी पते) आप प्रति नियम को ब्लॉक कर सकते हैं, यह एक बार भी इसी तरह के नाम वाले नियम बनाएगा
# नवीनतम के लिए सीमा पूरी हो गई है।
#
# मैं एक निर्धारित कार्य के रूप में चलाने के लिए स्क्रिप्ट को सेट करने की सलाह देता हूं, जो कि एक निर्धारित कार्य है, जिसमें से 4625 लॉगिन ऑडिट विफलताओं से शुरू होता है
# सुरक्षा लॉग, या वैकल्पिक रूप से आप इसे कुछ समय (यानी हर 10 मिनट) के बाद चलाने के लिए सेट कर सकते हैं।
#
# लेखक:
# Serverfault.com यूजर kevinmicke द्वारा लिखी गई स्क्रिप्ट की अधिकांश
# विंडोज सिक्योरिटी लॉग भाग serverfault.com यूजर रिमुंडा द्वारा लिखा गया है, जो किविनमीक के लिए शुरुआती बिंदु प्रदान करता है
# सर्वरफॉल्ट.कॉम यूजर यूवे मार्टेंस द्वारा जोड़े गए एफ़टीपी के नियंत्रण चैनल की जाँच
#
# विवरण: https://serverfault.com/questions/233222/ban-ip-address-based-on-x-number-of-unsuccessful-login-attempts


# विफल लॉगिन प्रयासों का सेट नंबर जिसके बाद एक आईपी पता अवरुद्ध हो जाएगा
$ int_block_limit = 3

# समय विंडो जिसके दौरान सुरक्षा लॉग की जांच करना, जो वर्तमान में केवल पिछले 24 घंटों की जांच करने के लिए निर्धारित है
$ dat_time_window = [दिनांक समय] :: अब। जोड़ें (-1)

# सिक्योरिटी लॉग में से उन सभी IP पतों को चुनें, जिनमें $ dat_time_window के भीतर $ int_block_limit ऑडिट विफलताओं (घटना 4625) से अधिक है
$ arr_new_bad_ips_security_log = @ ()
$ arr_new_bad_ips_security_log = Get-EventLog -LogName 'सुरक्षा' -InstanceId 4625 -After $ dat_time_window |
    Select-Object @ {n = 'IpAddress'; e = {$ _। रिप्लेसमेंटस्ट्रीम [-2]} |
    समूह-वस्तु-समृद्धि आईपीएड्रेस |
    जहाँ {$ _। गिनती -ge $ int_block_limit} |
    चयन -प्रतिष्ठित नाम

# वर्तमान समय UTC वर्तमान एफ़टीपी लॉग के लिए फ़ाइल नाम जानने के लिए
$ current_date_utc = (Get-Date) .ToUniversalTime ()

# आज के एफ़टीपी कंट्रोल चैनल लॉग फ़ाइल के लिए पथ सेट करें
$ str_log_file_name_control_channel = "C: \ inetpub \ log \ LogFiles \ FTPSVC \ u_ex" + $ current_date_utc.ToString ("yyadMdd") + .log "।

# आज का एफ़टीपी कंट्रोल चैनल लॉग फ़ाइल "530 1" के लिए उन पंक्तियों को खोजने के लिए जिनमें आईपी सिस्टम शामिल हैं जो लॉग इन करने में विफल रहे।
# प्रत्येक पंक्ति से केवल आईपी प्राप्त करें, प्रत्येक एक से प्रयासों को गिनने के लिए आईपी द्वारा आईपी को समूहित करें, और केवल एक का चयन करें
# ऐसे IP जिनके पास आज $ int_block_limit या अधिक खराब लॉगिन हैं
$ arr_new_bad_ips_ftp_control_channel = @ ()
$ arr_new_bad_ips_ftp_control_channel = चयन-स्ट्रिंग $ str_log_file_name_control_channel -pattern "530 1" |
    ForEach-Object {$ _। Line.Substring (20,15) -replace "। *", ""} |
    समूह |
    जहाँ {$ _। गिनती -ge $ int_block_limit} |
    चयन -प्रतिष्ठित नाम

# आज की एफ़टीपी लॉग फ़ाइल के लिए पथ सेट करें
$ str_log_file_name = "C: \ inetpub \ log \ LogFiles \ FTPSVC * \ u_ex" + $ current_date_utc.ToString ("yyMMdd" + ".log"

# खोजने के लिए "530 1" के लिए आज की एफ़टीपी लॉग फ़ाइल में उन पंक्तियों को खोजने के लिए जिनमें सिस्टम के आईपी शामिल हैं जो लॉग इन करने में विफल रहे
# प्रत्येक पंक्ति से केवल आईपी प्राप्त करें, प्रत्येक एक से प्रयासों को गिनने के लिए आईपी द्वारा आईपी को समूहित करें, और केवल एक का चयन करें
# ऐसे IP जिनके पास आज $ int_block_limit या अधिक खराब लॉगिन हैं
# एफटीपीएसवीसी में * के बजाय एफ़टीपी-सर्वर की आईडी जोड़ी जानी है, या बस सही लॉग-फ़ोल्डर लेना है
$ arr_new_bad_ips_ftp = @ ()
$ arr_new_bad_ips_ftp = चयन-स्ट्रिंग $ str_log_file_name -pattern "530" |
    ForEach-Object {$ _। Line.Substring (20,15) -replace "। *", ""} |
    समूह |
    जहाँ {$ _। गिनती -ge $ int_block_limit} |
    चयन -प्रतिष्ठित नाम

# IP की दो सरणियों को सुरक्षित करें (सुरक्षा लॉग से एक, FTP लॉग से एक)
$ 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) + @ ($ $_new_bad_ips_ftp)

# सरणी को क्रमबद्ध करें, केवल अनन्य IP का चयन करें (यदि एक IP सुरक्षा और FTP दोनों लॉग में दिखाता है)
$ arr_new_bad_ips_all_sorted = @ ()
$ arr_new_bad_ips_all_sorted = $ arr_new_bad_ips_all |
    Foreach-Object {[string] $ _। Name} |
    Select-Object -unique

# फ़ायरवॉल ऑब्जेक्ट प्राप्त करें
$ फ़ायरवॉल = नया-ऑब्जेक्ट -comobject hnetcfg.fwpolicy2

# "BlockAttackers *" से मेल खाते सभी फ़ायरवॉल नियम प्राप्त करें
$ arr_firewall_rules = $ firewall.Rules | जहां {$ _। नाम-जैसे 'ब्लॉकअटैकर्स *'}

# यदि कोई "BlockAttackers *" फ़ायरवॉल नियम अभी तक मौजूद नहीं है, तो एक बनाएं और इसे एक चर पर सेट करें
अगर ($ arr_firewall_rules -q $ null) {
    $ str_new_rule_name = "BlockAttackers (बनाया गया" + $ current_date_utc.ToString ("yyyy-MM-dd HH: mm: ss") + "UTC)"
    netsh advfirewall फ़ायरवॉल नियम dir = एक्शन में जोड़ें = ब्लॉक नाम = $ str_new_rule_name विवरण = "नियम स्वचालित रूप से बनाया गया।" सक्षम = हाँ रिमोट = "0.0.0.0" | बाहर अशक्त
    $ arr_firewall_rules = $ firewall.Rules | जहां {$ _। नाम-जैसे 'ब्लॉकअटैकर्स *'}
}

# मौजूदा IP को वर्तमान "BlockAttackers *" फ़ायरवॉल नियम से विभाजित करें ताकि हम आसानी से उन्हें खोज सकें
$ arr_existing_bad_ips = @ ()
foreach ($ arr_firewall_rules में $ नियम) {
    $ arr_existing_bad_ips + = $ रूल ।emoteAddresses -split (',')
}

# आईपी से साफ सबनेट मास्क जो वर्तमान में फ़ायरवॉल नियम द्वारा अवरुद्ध हैं
$ arr_existing_bad_ips_without_masks = @ ()
$ arr_existing_bad_ips_without_masks = $ arr_existing_bad_ips | फॉरएच-ऑब्जेक्ट {$ _ -replace "/.*", ""}

# अपने सर्वर का IP (IPv4 और IPv6) लाइन 115 और 116 में दर्ज करें।
# फ़ायरवॉल में जोड़ने के लिए IP पते का चयन करें, लेकिन केवल वे ही ...
$ arr_new_bad_ips_for_firewall = @ ()
$ arr_new_bad_ips_for_firewall = $ arr_new_bad_ips_all_sorted | कहाँ पे {
    # एक आईपी पता होता है (यानी रिक्त या डैश नहीं होता है, जो सुरक्षा लॉग उन सिस्टम के लिए है जो एफ़टीपी लॉगिन विफल हो गए हैं)
    $ _। लंबाई -gt 6 -और
    # पहले से ही फ़ायरवॉल नियम नहीं हैं
    ! ($ arr_existing_bad_ips_without_masks -contains $ _) -और
    # स्थानीय लूपबैक नहीं हैं
    ! ($ _। स्टार्टस्विथ ('127.0.0.1')) -और
    # स्थानीय सबनेट का हिस्सा नहीं हैं
    ! ($ _। स्टार्टस्विथ ('192.168।')) -और
    । ($ _। स्टार्टस्विथ ('0.0।')) -और
    ! ($ _। स्टार्टस्विथ ('10 .0। ​​')) -और
    ! ($ _। स्टार्टस्विथ ('*। *। *। *। *')) -और
    ! ($ _ StartsWith (। '*: *: *: *: *: *'))
}

# यदि IP को ब्लॉक करना है, तो निम्न कार्य करें ...
अगर ($ arr_new_bad_ips_for_firewall -ne $ null) {
    # स्क्रिप्ट-विशिष्ट लॉग फ़ाइल में दिनांक और समय लिखें
    [डेटटाइम] :: अब | आउट-फाइल -एपेंड -Encoding utf8 C: \ inetpub \ log \ LogFiles \ blockattackack.txt
    # लॉग फ़ाइल में नए-अवरुद्ध आईपी पते लिखें
    $ arr_new_bad_ips_for_firewall | आउट-फाइल -एपेंड -Encoding utf8 C: \ inetpub \ log \ LogFiles \ blockattackack.txt

    # बूलियन यह सुनिश्चित करने के लिए कि नए आईपी केवल एक नियम में जोड़े गए हैं
    $ bln_added_to_rule = 0

    # एक समय में एक नियम से खराब आईपी रखने के लिए सरणी, इसलिए हम यह सुनिश्चित करने के लिए भरोसा कर सकते हैं कि नए को जोड़ने के लिए 1000 रुपये से अधिक नहीं होंगे
    $ arr_existing_bad_ips_current_rule = @ ()

    # फ़ायरवॉल में प्रत्येक "BlockAttackers *" नियम के लिए, निम्न कार्य करें ...
    foreach ($ arr_firewall_rules में $ नियम) {
        अगर ($ bln_added_to_rule -ne 1) {
            # मौजूदा नियम से मौजूदा आईपी को एक सरणी में विभाजित करें ताकि हम आसानी से उन्हें गिन सकें
            $ arr_existing_bad_ips_current_rule = $ नियम ।emoteAddresses -split (',')

            # यदि जोड़ने के लिए IP की संख्या 1000 से कम है, तो नियम में IP की वर्तमान संख्या, उन्हें इस नियम में जोड़ें
            अगर ($ arr_new_bad_ips_for_firewall.ount -le (1000 - $ arr_existing_bad_ips_current_rule.Count) {
                # फ़ायरवॉल नियम में नए आईपी जोड़ें
                $ arr_new_bad_ips_for_firewall | % {$ नियम ।emoteAddresses + = ’, _ + $ _}

                # लॉग फ़ाइल में IP को जोड़ने के लिए कौन सा नियम लिखें
                गूंज "ऊपर नए आईपी पते विंडोज फ़ायरवॉल नियम में जोड़ा गया:" $ नियम। नाम | आउट-फाइल -एपेंड -Encoding utf8 C: \ inetpub \ log \ LogFiles \ blockattackack.txt

                # बूलियन सेट करें ताकि आईपी जोड़ते समय किसी अन्य नियम को छोड़ दिया जाए
                $ bln_added_to_rule = 1
            }
        }
    }

    # अगर किसी अन्य "BlockAttackers *" फ़ायरवॉल नियम में जगह नहीं थी, तो एक नया बनाएं और इसमें आईपी जोड़ें
    अगर ($ bln_added_to_rule -ne 1) {
        $ str_new_rule_name = "BlockAttackers (बनाया गया" + $ current_date_utc.ToString ("yyyy-MM-dd HH: mm: ss") + "UTC)"
        netsh advfirewall फ़ायरवॉल नियम dir = एक्शन में जोड़ें = ब्लॉक नाम = $ str_new_rule_name विवरण = "नियम स्वचालित रूप से बनाया गया।" सक्षम = हाँ रिमोट = "0.0.0.0" | बाहर अशक्त
        $ new_rule = $ firewall.rules | जहां {$ _। Name -eq $ str_new_rule_name}

        # फ़ायरवॉल नियम में नए आईपी जोड़ें
        $ arr_new_bad_ips_for_firewall | % {$ new_rule.RemoteAddresses + = ’, _ + $ _}

        # लॉग फ़ाइल में IP को जोड़ने के लिए कौन सा नियम लिखें
        इको "नए IP पते ऊपर नए बनाए गए Windows फ़ायरवॉल नियम में जोड़े गए:" $ new_rule.Name | आउट-फाइल -एपेंड -Encoding utf8 C: \ inetpub \ log \ LogFiles \ blockattackack.txt
    }
}

एफ़टीपी के लॉग-फोल्डर का नाम FTPSVC*लाइन 54 पर दिया जाना चाहिए। लाइन 115 और 116 में आपके सर्वर का IP (IPv4 और IPv6) दर्ज किया जाना चाहिए, अन्यथा स्वयं के सर्वर IP को सौ बार फ़ायरवॉल-नियम में जोड़ा जा सकता है। चर $int_block_limitमैं अपने सर्वर पर 1 पर सेट कर रहा हूं, इसलिए स्क्रिप्ट दो सेकंड के भीतर 4625-ईवेंट के कारण हैकर्स के हमले को रोक रही है। मैं अभी भी कुछ मिनटों की समयावधि में 4625-ईवेंट्स के अलावा स्क्रिप्ट को चलाने के बारे में सोच रहा हूं। बेशक, यह भी संभव होगा कि लिपियों को अलग करने के लिए और एक स्क्रिप्ट को 4625-ईवेंट द्वारा ट्रिगर की गई 4625-ईवेंट की जांच करने दें और दूसरा एफ़टीपी के लॉग-फोल्डर समय-समय पर हर 5 या 10 मिनट की जाँच करें, यहां तक ​​कि अलग फ़ायरवॉल-नियम के साथ भी और लॉग-फाइल।


-1

मैंने 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 $_;
    }

फिर आपको सरणी को 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)
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.