Demo ansehen×
×

Sehen Sie NinjaOne in Aktion!

Erkennen und Verhindern von Brute-Force-Angriffen mit PowerShell

,
ataques de fuerza bruta

Zwar entwickeln sich Cyber-Bedrohungen ständig weiter, doch die meisten Angriffe beruhen nach wie vor auf grundlegenden und bewährten Techniken. Warum sollte man eine Zero-Day-Lücke ausnutzen, wenn das Erraten häufig verwendeter Passwörter oder das Ausnutzen von Passwörtern, die in mehreren Konten verwendet werden, einen einfachen Zugriff ermöglichen kann?

Brute-Force-Angriffe sind nach wie vor eine sehr häufige Bedrohung für Unternehmen. Es ist von entscheidender Bedeutung, diese Versuche so schnell wie möglich zu erkennen und zu blockieren, da sie oft Vorboten für weitere schädliche Aktivitäten und bösartige Zugriffsversuche sind. Da in solchen Situationen jede Minute zählt, sind Richtlinien zur Kontosperrung und Echtzeitwarnungen bei fehlgeschlagenen Anmeldeversuchen eine äußerst wichtige frühzeitige Abschreckungs- und Warnmaßnahme.

Aber was ist mit der Erkennung von ferngesteuerten Brute-Force-Angriffen und in großem Umfang über ein ganzes Unternehmensnetzwerk?

Da dies eine Herausforderung sein kann, haben wir das folgende Skript bereitgestellt, mit dem Administratoren den Prozess automatisieren können, indem sie fehlgeschlagene Anmeldeversuche überwachen und auf der Grundlage anpassbarer Schwellenwerte Warnmeldungen auslösen.

Skript zur Erkennung und Verhinderung von Brute-Force-Angriffen

#Requires -Version 5.1

<#
.SYNOPSIS
    Condition for helping detect brute force login attempts.
.DESCRIPTION
    Condition for helping detect brute force login attempts.
.EXAMPLE
     -Hours 10
    Number of hours back in time to look through in the event log.
    Default is 1 hour.
.EXAMPLE
    -Attempts 100
    Number of login attempts to trigger at or above this number.
    Default is 8 attempts.
.OUTPUTS
    PSCustomObject[]
.NOTES
    Minimum OS Architecture Supported: Windows 10, Windows Server 2016
    Release Notes:
    Initial Release
By using this script, you indicate your acceptance of the following legal terms as well as our Terms of Use at https://www.ninjaone.com/de/nutzungsbedingungen
    Ownership Rights: NinjaOne owns and will continue to own all right, title, and interest in and to the script (including the copyright). NinjaOne is giving you a limited license to use the script in accordance with these legal terms. 
    Use Limitation: You may only use the script for your legitimate personal or internal business purposes, and you may not share the script with another party. 
    Republication Prohibition: Under no circumstances are you permitted to re-publish the script in any script library or website belonging to or under the control of any other software provider. 
    Warranty Disclaimer: The script is provided “as is” and “as available”, without warranty of any kind. NinjaOne makes no promise or guarantee that the script will be free from defects or that it will meet your specific needs or expectations. 
    Assumption of Risk: Your use of the script is at your own risk. You acknowledge that there are certain inherent risks in using the script, and you understand and assume each of those risks. 
    Waiver and Release: You will not hold NinjaOne responsible for any adverse or unintended consequences resulting from your use of the script, and you waive any legal or equitable rights or remedies you may have against NinjaOne relating to your use of the script. 
    EULA: If you are a NinjaOne customer, your use of the script is subject to the End User License Agreement applicable to you (EULA).
#>

[CmdletBinding()]
param (
    [Parameter()]
    [int]
    $Hours = 1,
    [Parameter()]
    [int]
    $Attempts = 8
)

begin {
    function Test-IsElevated {
        $id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
        $p = New-Object System.Security.Principal.WindowsPrincipal($id)
        $p.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator)
    }
    function Test-StringEmpty {
        param([string]$Text)
        # Returns true if string is empty, null, or whitespace
        process { [string]::IsNullOrEmpty($Text) -or [string]::IsNullOrWhiteSpace($Text) }
    }
    if (-not $(Test-StringEmpty -Text $env:Hours)) {
        $Hours = $env:Hours
    }
    if (-not $(Test-StringEmpty -Text $env:Attempts)) {
        $Attempts = $env:Attempts
    }
}
process {
    if (-not (Test-IsElevated)) {
        Write-Error -Message "Access Denied. Please run with Administrator privileges."
        exit 1
    }

    if ($(auditpol.exe /get /category:* | Where-Object { $_ -like "*Logon*Success and Failure" })) {
        Write-Information "Audit Policy for Logon is set to: Success and Failure"
    }
    else {
        Write-Error "Audit Policy for Logon is NOT set to: Success and Failure"
        exit 1
        # Write-Host "Setting Logon to: Success and Failure"
        # auditpol.exe /set /subcategory:"Logon" /success:enable /failure:enable
        # Write-Host "Future failed login attempts will be captured."
    }

    $StartTime = (Get-Date).AddHours(0 - $Hours)
    $EventId = 4625

    # Get failed login attempts
    try {
        $Events = Get-WinEvent -FilterHashtable @{LogName = "Security"; ID = $EventId; StartTime = $StartTime } -ErrorAction Stop | ForEach-Object {
            $Message = $_.Message -split [System.Environment]::NewLine
            $Account = $($Message | Where-Object { $_ -Like "*Account Name:*" }) -split '\s+' | Select-Object -Last 1
            [int]$LogonType = $($Message | Where-Object { $_ -Like "Logon Type:*" }) -split '\s+' | Select-Object -Last 1
            $SourceNetworkAddress = $($Message | Where-Object { $_ -Like "*Source Network Address:*" }) -split '\s+' | Select-Object -Last 1
            [PSCustomObject]@{
                Account              = $Account
                LogonType            = $LogonType
                SourceNetworkAddress = $SourceNetworkAddress
            }
        } | Where-Object { $_.LogonType -in @(2, 7, 10) }
    }
    catch {
        if ($_.Exception.Message -like "No events were found that match the specified selection criteria.") {
            Write-Host "No failed logins found in the past $Hours hour(s)."
            exit 0
        }
        else {
            Write-Error $_
            exit 1
        }
    }

    # Build a list of accounts 
    $UsersAccounts = [System.Collections.Generic.List[String]]::new()
    try {
        $ErrorActionPreference = "Stop"
        Get-LocalUser | Select-Object -ExpandProperty Name | ForEach-Object { $UsersAccounts.Add($_) }
        $ErrorActionPreference = "Continue"
    }
    catch {
        $NetUser = net.exe user
        $(
            $NetUser | Select-Object -Skip 4 | Select-Object -SkipLast 2
            # Join each line with a ","
            # Replace and spaces with a ","
            # Split everything by ","
        ) -join ',' -replace '\s+', ',' -split ',' |
            # Sort and remove any duplicates
            Sort-Object -Descending -Unique |
            # Filter out empty strings
            Where-Object { -not [string]::IsNullOrEmpty($_) -and -not [string]::IsNullOrWhiteSpace($_) } |
            ForEach-Object {
                $UsersAccounts.Add($_)
            }
    }
    $Events | Select-Object -ExpandProperty Account | ForEach-Object { $UsersAccounts.Add($_) }

    $Results = $UsersAccounts | Select-Object -Unique | ForEach-Object {
        $Account = $_
        $AccountEvents = $Events | Where-Object { $_.Account -like $Account }
        $AttemptCount = $AccountEvents.Count
        $SourceNetworkAddress = $AccountEvents | Select-Object -ExpandProperty SourceNetworkAddress -Unique
        if ($AttemptCount -gt 0) {
            [PSCustomObject]@{
                Account              = $Account
                Attempts             = $AttemptCount
                SourceNetworkAddress = $SourceNetworkAddress
            }
        }
    }

    # Get only the accounts with fail login attempts at or over $Attempts
    $BruteForceAttempts = $Results | Where-Object { $_.Attempts -ge $Attempts }
    if ($BruteForceAttempts) {
        $BruteForceAttempts | Out-String | Write-Host
        exit 1
    }
    $Results | Out-String | Write-Host
    exit 0
}
end {
    $ScriptVariables = @(
        [PSCustomObject]@{
            name           = "Hours"
            calculatedName = "hours" # Must be lowercase and no spaces
            required       = $false
            defaultValue   = [PSCustomObject]@{ # If not default value, then remove
                type  = "TEXT"
                value = "1"
            }
            valueType      = "TEXT"
            valueList      = $null
            description    = "Number of hours back in time to look through in the event log."
        }
        [PSCustomObject]@{
            name           = "Attempts"
            calculatedName = "attempts" # Must be lowercase and no spaces
            required       = $false
            defaultValue   = [PSCustomObject]@{ # If not default value, then remove
                type  = "TEXT"
                value = "8"
            }
            valueType      = "TEXT"
            valueList      = $null
            description    = "Number of login attempts to trigger at or above this number."
        }
    )
}

 


Zugriff auf über 300 Skripte im NinjaOne Dojo

Zugang erhalten

Das Skript verstehen und verwenden

Unser Skript hängt von zwei Hauptparametern ab: `Stunden` und `Versuche`. Der Parameter „Hours“ gibt den Zeitraum an, der im Ereignisprotokoll überprüft werden soll (Standardwert: 1 Stunde). Der Parameter „Versuche“ legt den Schwellenwert für Anmeldeversuche fest, bevor ein Alarm ausgelöst wird (Standardwert: 8 Versuche).

Um das Skript zu installieren und auszuführen, gehen Sie folgendermaßen vor:

  1. Öffnen Sie PowerShell mit Administratorberechtigungen.
  2. Kopieren Sie das Skript in Ihre PowerShell-Umgebung.
  3. Passen Sie die Parameter „Hours“ und „Attempts“ nach Bedarf an.
  4. Führen Sie das Skript aus.

Das Skript wertet dann die Ereignisprotokolle anhand der angegebenen Parameter aus. Wenn die Anzahl der fehlgeschlagenen Anmeldeversuche innerhalb des angegebenen Zeitraums den Schwellenwert überschreitet, werden Sie auf einen möglichen Brute-Force-Angriff hingewiesen.

Ein Beispiel: Sie möchten die Anmeldeversuche der letzten drei Stunden überwachen und eine Warnung ausgeben, wenn es mehr als 15 Fehlversuche gibt. Mit NinjaOne haben Sie die Flexibilität, Ihr Sicherheitskonzept anzupassen, indem Sie das Skript mit maßgeschneiderten Parametern wie -Stunden 3 -Versuche 15 ausführen. Mit dieser Funktion können Sie sich an die individuellen Sicherheitsanforderungen und Risikoprofile Ihres Unternehmens anpassen.

Zusätzliche Sicherheitsmaßnahmen

Die Erkennung von Brute-Force-Angriffen ist nur eine Komponente einer ganzheitlichen Cybersicherheitsstrategie. Weitere wichtige Maßnahmen sind:

  • Starke Passwörter: Ermuntern Sie die Benutzer:innen, solide, eindeutige Passwörter zu erstellen – idealerweise eine Mischung aus Buchstaben, Zahlen und Symbolen. Passwort-Manager können die Verwaltung von komplexen Passwörternerleichtern.
  • Multi-Faktor-Authentifizierung (MFA): Mehr-Faktor-Authentifizierung (MFA) bietet eine zusätzliche Sicherheitsebene, indem Benutzer:innen aufgefordert werden, ihre Identität durch die Verwendung von zwei oder mehr Mechanismen zu überprüfen (z. B. etwas, das sie wissen, etwas, das sie haben oder etwas, das sie sind).
  • Software-Aktualisierungen: Die regelmäßige Aktualisierung der Software ist unerlässlich. Die Aktualisierungen enthalten häufig Patches für Sicherheitslücken, die, wenn sie nicht behoben werden, Cyberangriffen Tür und Tor öffnen könnten.
  • Mitarbeiterschulung: Die Einführung eines Schulungsprogramms für das Sicherheitsbewusstsein trägt dazu bei, die Mitarbeiter:innen über Cyber-Bedrohungen und die Rolle, die sie bei der Aufrechterhaltung der Sicherheit spielen, aufzuklären. Der Faktor Mensch ist oft das schwächste Glied in der Cybersicherheit, und gut informierte Mitarbeiter:innen können Ihren Schutz erheblich verstärken.

Abschließende Überlegungen

Eine effektive Erkennung von Brute-Force-Angriffen ist entscheidend in der heutigen digitalen Landschaft, und unser PowerShell-Skript bietet eine leistungsstarke, anpassbare Lösung. Es ist jedoch wichtig, daran zu denken, dass sie Teil einer umfassenderen Cybersicherheitsstrategie ist. Durch die Kombination von Echtzeit-Erkennung mit sicheren Passwörtern, MFA, Software-Updates und Mitarbeiterschulungen können Sie ein umfassendes Sicherheitsprotokoll zum Schutz Ihrer digitalen Ressourcen erstellen.

NinjaOne ist ein umfassendes Tool, das Ihre Fähigkeit, Brute-Force-Angriffe zu erkennen und abzuwehren, erheblich verbessert. Mit vollständiger Kontrolle über die Endpunktsicherheit können Sie Anwendungen verwalten, Registrierungen per Fernzugriff bearbeiten und Skripte zur Verbesserung der Sicherheit bereitstellen. Rollenbasierte Zugriffskontrollen stellen sicher, dass Ihre Techniker:innen nur die erforderlichen Zugriffsrechte erhalten, wodurch potenzielle Sicherheitslücken reduziert werden. Die Plattform bietet außerdem Tools zur Verwaltung der Laufwerksverschlüsselung und die Möglichkeit, den Endpunktschutz automatisch zu installieren und zu verwalten, so dass Sie eine genaue Kontrolle über die Antivirus-Operationen haben.

Darüber hinaus schützt die Funktion zum Austausch von Anmeldedaten in NinjaOne die Anmeldedaten, eine wichtige Verteidigungslinie gegen Brute-Force-Angriffe. Es ermöglicht auch die Identifizierung und Entfernung von bösartigen Endpunkten, was einen zusätzlichen Schutz darstellt. Handeln Sie, bevor es zu einem Sicherheitsverstoß kommt. Starten Sie noch heute Ihre Reise zu erhöhter Sicherheitmit NinjaOne.

Nächste Schritte

Die Grundlagen der Gerätesicherheit sind entscheidend für Ihre allgemeine Sicherheitslage. NinjaOne macht es einfach, alle Geräte zentral, per Fernzugriff und in großem Umfang zu patchen, zu härten, abzusichern und zu sichern.

Erfahren Sie mehr über NinjaOne Protect, sehen Sie sich eine Live-Tour an oder starten Sie Ihren kostenlosen Test der NinjaOne-Plattform.

Das könnte Sie auch interessieren

Sind Sie bereit, ein IT-Ninja zu werden?

Erfahren Sie, wie Sie mit NinjaOne Ihren IT-Betrieb vereinfachen können.

By clicking the “I Accept” button below, you indicate your acceptance of the following legal terms as well as our Terms of Use:

  • Ownership Rights: NinjaOne owns and will continue to own all right, title, and interest in and to the script (including the copyright). NinjaOne is giving you a limited license to use the script in accordance with these legal terms.
  • Use Limitation: You may only use the script for your legitimate personal or internal business purposes, and you may not share the script with another party.
  • Republication Prohibition: Under no circumstances are you permitted to re-publish the script in any script library belonging to or under the control of any other software provider.
  • Warranty Disclaimer: The script is provided “as is” and “as available”, without warranty of any kind. NinjaOne makes no promise or guarantee that the script will be free from defects or that it will meet your specific needs or expectations.
  • Assumption of Risk: Your use of the script is at your own risk. You acknowledge that there are certain inherent risks in using the script, and you understand and assume each of those risks.
  • Waiver and Release: You will not hold NinjaOne responsible for any adverse or unintended consequences resulting from your use of the script, and you waive any legal or equitable rights or remedies you may have against NinjaOne relating to your use of the script.
  • EULA: If you are a NinjaOne customer, your use of the script is subject to the End User License Agreement applicable to you (EULA).