Setup-Leitfaden: Automatisieren der Erkennung von bösartigen DHCP-Servern mit PowerShell

Die wichtigsten Erkenntnisse

• Automatisierte Erkennung von Rogue-DHCP (Dynamic Host Configuration Protocol): Das Skript automatisiert den Prozess der Erkennung von nicht autorisierten DHCP-Servern und verbessert die Netzwerksicherheit.
• Nmap-Integration: Verwendet nmap für ein umfassendes Netzwerk-Scanning und erfordert dessen vorherige Installation.
• Anpassbare Parameter: Ermöglicht die individuelle Anpassung durch Parameter wie erlaubte DHCP-Server und Ausgabefelder.
• Subnetorientiertes Scannen: Extrahiert und scannt Subnetze und gewährleistet so eine gezielte und effiziente Netzwerkanalyse.
• Sicherheitswartung in Echtzeit: Ideal für regelmäßige Netzüberprüfungen, die zur Aufrechterhaltung der Sicherheit und betrieblichen Integrität in Echtzeit beitragen.
• Einfacher Vergleich mit der zulässigen Liste: Vergleicht erkannte Server automatisch mit einer vordefinierten Liste von autorisierten DHCP-Servern.
• Automatisierte Ausgabe und Berichterstattung: Die Ergebnisse werden in einem benutzerfreundlichen Format ausgegeben und können in Netzwerkmanagement-Tools wie NinjaOne integriert werden.
• Verbessertes Netzwerkmanagement: Optimiert die Netzwerkverwaltung, insbesondere für IT-Experten und MSPs, die große Netzwerke verwalten.
• Risikominimierung: Verringert das Risiko von Netzwerkproblemen und Sicherheitsverstößen, die durch unseriöse DHCP-Server verursacht werden, beträchtlich.
• Administrative Rechte erforderlich: Für eine effektive Ausführung sind Administratorrechte erforderlich.

Das Verständnis und die Verwaltung der Netzwerksicherheit ist ein Eckpfeiler eines effizienten IT-Betriebs, insbesondere in der heutigen vernetzten Umgebung. Die Identifizierung von fehlerhaften DHCP-Servern, die schwerwiegende Netzwerkprobleme und Sicherheitsschwachstellen verursachen können, ist eine wichtige Aufgabe für IT-Experten und Managed Service Provider (MSPs). Dieser Blog-Beitrag befasst sich mit einem PowerShell-Skript, das für diesen Zweck entwickelt wurde, und beschreibt dessen Funktionalität und Bedeutung für die Aufrechterhaltung der Netzwerkintegrität.

Hintergrund

Abtrünnige DHCP-Server sind nicht autorisierte DHCP-Server in einem Netzwerk. Sie können zu einer Reihe von Problemen führen, von IP-Adresskonflikten bis hin zu schweren Sicherheitsrisiken wie Man-in-the-Middle-Angriffen. Dieses PowerShell-Skript automatisiert die Suche nach solchen Servern mithilfe von nmap, einem bekannten Netzwerk-Scanning-Tool, und verbessert so die Netzwerksicherheit und die betriebliche Effizienz. Es ist besonders nützlich für IT-Experten und MSPs, die große, dynamische Netzwerke verwalten, in denen eine manuelle Überwachung unpraktisch ist.

Das Skript:

#Requires -Version 4.0

<#
.SYNOPSIS
    Runs an nmap scan to find rogue dhcp servers on a network. This script will not install nmap and nmap is required for this script to work.
.DESCRIPTION
    Runs an nmap scan to find rogue dhcp servers on a network. This script will not install nmap and nmap is required for this script to work.
.EXAMPLE
    (No Parameters)
    
    DHCP Servers found.

    Mac Address       IP Address    
    -----------       ----------    
    00:15:5D:FF:93:C3 172.17.240.1  
                      172.17.242.16 
    00:15:5D:45:D5:07 172.17.251.231



    Checking allowed servers list...
    C:\ProgramData\NinjaRMMAgent\scripting\customscript_gen_14.ps1 : Rogue DHCP Server Found! 172.17.240.1 is not on the 
    list of allowed DHCP Servers.
        + CategoryInfo          : NotSpecified: (:) [Write-Error], WriteErrorException
        + FullyQualifiedErrorId : Microsoft.PowerShell.Commands.WriteErrorException,customscript_gen_14.ps1

PARAMETER: -AllowedServers "172.17.240.1"
    Lists 172.17.240.1 as an allowed dhcp server.

PARAMETER: -CustomField "ReplaceMeWithAnyMultilineCustomField"
    Output results to a custom field of your choice.

PARAMETER: -AllowedServersField "ReplaceMeWithAnyTextCustomField"
    Will retrieve a list of allowed servers from a custom field.
    
.OUTPUTS
    None
.NOTES
    Minimum Supported OS: Windows 8, Server 2012
    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/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 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()]
    [String[]]$AllowedServers,
    [Parameter()]
    [String]$CustomField = "rogueDHCPServers",
    [Parameter()]
    [String]$AllowedServersField = "allowedDHCPServers"
)

begin {

    # If script variables are used set them here
    if($env:allowedServersCustomField -and $env:allowedServersCustomField -notlike "null"){
        $AllowedServersField = $env:allowedServersCustomField
    }

    if($AllowedServersField -and -not ($AllowedServers)){
        $AllowedServers = (Ninja-Property-Get $AllowedServersField) -split ',' | ForEach-Object { ($_).trim() }
    }

    if($env:allowedServers -and $env:allowedServers -notlike "null"){
        $AllowedServers = $env:AllowedServers -split ',' | ForEach-Object { ($_).trim() }
    }

    if($env:customFieldName -and $env:customFieldName -notlike "null"){
        $CustomField = $env:customFieldName 
    }

    # Parses out the subnet info into cidr format
    function Get-Subnet {
        $DefaultGateways = (Get-NetIPConfiguration).IPv4DefaultGateway

        $Subnets = $DefaultGateways | ForEach-Object {
            $Index = $_.ifIndex
            $PrefixLength = (Get-NetIPAddress | Where-Object { $_.AddressFamily -eq 'IPv4' -and $_.PrefixOrigin -ne 'WellKnown' -and $Index -eq $_.InterfaceIndex } | Select-Object -ExpandProperty PrefixLength)
            if ($_.NextHop -and $PrefixLength) {
                "$($_.NextHop)/$PrefixLength"
            }
        }

        if ($Subnets) {
            $Subnets | Select-Object -Unique
        }
    }

    # Handy uninstall string finder
    function Find-UninstallKey {
        [CmdletBinding()]
        param (
            [Parameter(ValueFromPipeline = $True)]
            [String]$DisplayName,
            [Parameter()]
            [Switch]$UninstallString
        )
        process {
            $UninstallList = New-Object System.Collections.Generic.List[Object]

            $Result = Get-ChildItem HKLM:\Software\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\* | Get-ItemProperty | Where-Object { $_.DisplayName -like "*$DisplayName*" }
            if ($Result) { $UninstallList.Add($Result) }

            $Result = Get-ChildItem HKLM:\Software\Microsoft\Windows\CurrentVersion\Uninstall\* | Get-ItemProperty | Where-Object { $_.DisplayName -like "*$DisplayName*" }
            if ($Result) { $UninstallList.Add($Result) }

            # Programs don't always have an uninstall string listed here so to account for that I made this optional.
            if ($UninstallString) {
                $UninstallList | Select-Object -ExpandProperty UninstallString -ErrorAction SilentlyContinue
            }
            else {
                $UninstallList
            }
        }
    }

    $Nmap = (Find-UninstallKey -DisplayName "Nmap" -UninstallString) -replace '"' -replace 'uninstall.exe', 'nmap.exe'
    if (-not $Nmap) {
        Write-Error "Nmap is not installed! Please install nmap prior to running this script. https://nmap.org/download.html"
        exit 1
    }
}
process {

    # Get's a list of subnets
    $Subnets = Get-Subnet
    if (-not $Subnets) {
        Write-Error "Unable to get list of subnets?"
        exit 1
    }

    # nmap arguments
    $Arguments = @(
        "-sU"
        "-p"
        "67"
        "-d"
        $Subnets
        "--open"
        "-oX"
        "$env:TEMP\nmap-results.xml"
    )
    try {
        Start-Process -FilePath $Nmap -ArgumentList $Arguments -WindowStyle Hidden -Wait
        [xml]$result = Get-Content -Path "$env:Temp\nmap-results.xml"
    }
    catch {
        Write-Error "Nmap scan failed to run! Ensure nmap is installed prior to running this script."
        exit 1
    }

    # Parse the xml results
    if ($result) {
        $resultObject = $result.DocumentElement.host | ForEach-Object {
            New-Object psobject -Property @{
                "IP Address"  = ($_.address | Where-Object { $_.addrtype -match "ip" } | Select-Object -ExpandProperty "addr")
                "Mac Address" = ($_.address | Where-Object { $_.addrtype -match "mac" } | Select-Object -ExpandProperty "addr")
            }
        }
    }
    else {
        Write-Error "Nmap results are empty?"
        exit 1
    }

    # Check if the dhcp servers found are on the list. If so simply report back what were found otherwise indicate that they're Rogue DHCP Servers.
    if ($resultObject) {
        Write-Host "DHCP Servers found."
        $resultObject | Sort-Object -Property "IP Address" -Unique | Format-Table | Out-String | Write-Host
        Remove-Item -Path "$env:Temp\nmap-results.xml" -Force

        Write-Host "Checking allowed servers list..."
        $ErrorOut = $False
        $resultObject | ForEach-Object {
            if ($AllowedServers -notcontains $_."IP Address") {
                Write-Error "Rogue DHCP Server Found! $($_.'IP Address') is not on the list of allowed DHCP Servers."
                $ErrorOut = $True
            }
        }

        Ninja-Property-Set -Name $CustomField -Value ($resultObject | Where-Object { $AllowedServers -notcontains $_."IP Address" } | Format-List | Out-String)

        if($ErrorOut -eq $True){
            exit 1
        }

        Write-Host "No rogue dhcp servers found."
    }
}
end {
    
    
    
}

 

Detaillierte Aufschlüsselung

Das Skript funktioniert in mehreren Stufen:

• Initialisierung: Sie beginnt mit der Einstellung von Parametern wie erlaubten DHCP-Servern und benutzerdefinierten Feldern für die Ausgabe, was eine Anpassung an spezifische Netzwerkumgebungen ermöglicht.
• Subnetz-Identifikation: Es verfügt über eine Funktion zum Extrahieren von Subnetz-Informationen aus dem Netzwerk, die für eine gezielte Suche wichtig sind.
• Nmap-Integration: Das Skript prüft, ob nmap installiert ist, was für das Scannen unerlässlich ist. Anschließend führt er einen nmap-Scan in den identifizierten Subnetzen durch und sucht nach aktiven DHCP-Servern.
• Ergebnis-Parsing: Nach dem Scannen analysiert das Skript die XML-Ausgabe von nmap und extrahiert die IP- und MAC-Adressen der gefundenen DHCP-Server.
• Validierung gegen die zulässige Liste: Es vergleicht die gefundenen DHCP-Server mit einer Liste autorisierter Server und markiert alle nicht autorisierten (Rogue) Server.
• Ausgabe und Bereinigung: Die Ergebnisse werden dann ausgegeben, und alle vom Skript erstellten temporären Dateien werden bereinigt.

Ein visuelles Diagramm, das diese Erklärung begleitet, könnte den Fluss von der Initialisierung bis zur Ergebnisausgabe veranschaulichen und das Verständnis verbessern.

Mögliche Anwendungsfälle

Stellen Sie sich ein großes Unternehmen mit mehreren Subnetzen vor, die von einer IT-Abteilung verwaltet werden. Dieses Skript könnte in regelmäßigen Abständen ausgeführt werden, um sicherzustellen, dass keine unautorisierten DHCP-Server im Netzwerk auftauchen, wodurch die Netzwerkintegrität aufrechterhalten und potenzielle Sicherheitsverletzungen verhindert werden.

Vergleiche

Manuelle Überprüfungen oder einfache Netzwerküberwachungsprogramme können abtrünnige DHCP-Server übersehen oder erfordern einen hohen Personalaufwand. Im Gegensatz dazu automatisiert dieses Skript den Prozess, ist gründlicher und lässt sich in bestehende Tools wie NinjaOne integrieren, um die Verwaltungsfunktionen zu verbessern.

FAQs

• Wie oft sollte ich dieses Skript ausführen?
  • Es empfiehlt sich eine regelmäßige Durchführung, z. B. wöchentlich oder nach größeren Netzwerkänderungen.
• Benötige ich besondere Berechtigungen, um dieses Skript auszuführen?
  • Ja, für Netzwerk-Scans sind in der Regel Administratorrechte erforderlich.

Auswirkungen

Nicht identifizierte abtrünnige DHCP-Server können zu erheblichen Sicherheitsrisiken führen. Die Automatisierung ihrer Erkennung minimiert diese Risiken und trägt zur allgemeinen Netzwerksicherheit und betrieblichen Effizienz bei.

Empfehlungen

• Aktualisieren Sie regelmäßig die Liste der zugelassenen DHCP-Server.
• Integrieren Sie dieses Skript in umfassendere Tools zur Netzwerküberwachung und -verwaltung.
• Stellen Sie sicher, dass nmap ordnungsgemäß installiert und aktualisiert ist.

Abschließende Überlegungen

Im Bereich der Netzwerksicherheit und -verwaltung bieten Tools wie NinjaOne, ergänzt durch Skripte wie dieses, robuste Lösungen zur Aufrechterhaltung der Netzwerkintegrität. Durch die Automatisierung kritischer Aufgaben, wie z.B. das Auffinden von fehlerhaften DHCP-Servern, hilft NinjaOne IT-Experten, sich auf strategische Initiativen zu konzentrieren und gleichzeitig die Sicherheit und Zuverlässigkeit ihrer Netzwerke zu gewährleisten.