Guide de script : Automatiser la détection des serveurs DHCP malveillants avec PowerShell

Points à retenir

• Détection automatisée de DHCP frauduleux: Le script automatise le processus de détection des serveurs DHCP non autorisés, ce qui renforce la sécurité du réseau.
• Intégration Nmap: Utilise nmap pour une analyse complète du réseau, ce qui nécessite son installation préalable.
• Paramètres personnalisables: Permet une personnalisation grâce à des paramètres tels que les serveurs DHCP autorisés et les champs de sortie.
• Analyse axée sur les sous-réseaux: L’extraction et l’analyse des sous-réseaux garantissent une analyse ciblée et efficace du réseau.
• Maintenance de la sécurité en temps réel: Idéal pour les contrôles réguliers du réseau, permettant de maintenir la sécurité en temps réel et l’intégrité opérationnelle.
• Comparaison facile avec la liste autorisée: Compare automatiquement les serveurs détectés à une liste prédéfinie de serveurs DHCP autorisés.
• Production et rapports automatisés: Les résultats sont présentés dans un format convivial et s’intègrent à des outils de gestion de réseau tels que NinjaOne.
• Gestion améliorée du réseau: Rationalise la gestion du réseau, en particulier pour les professionnels de l’informatique et les MSP qui gèrent de grands réseaux.
• Laminimisation des risques: Réduit considérablement le risque de problèmes de réseau et de failles de sécurité causés par des serveurs DHCP malveillants.
• Droits d’administration requis: Pour fonctionner efficacement, il faut disposer de privilèges administratifs.

Comprendre et gérer la sécurité des réseaux est la pierre angulaire de l’ efficacité des opérations informatiques, en particulier dans l’environnement interconnecté d’aujourd’hui. L’identification des serveurs DHCP malveillants, qui peuvent être à l’origine de graves problèmes de réseau et de vulnérabilités en matière de sécurité, est une tâche essentielle pour les professionnels de l’informatique et les fournisseurs de services gérés (Managed Service Providers – MSP). Cet article de blog se penche sur un script PowerShell conçu à cette fin, en décrivant sa fonctionnalité et son importance pour le maintien de l’intégrité du réseau.

Contexte

Les serveurs DHCP malveillants sont des serveurs DHCP non autorisés sur un réseau. Ils peuvent entraîner toute une série de problèmes, depuis les conflits d’adresses IP jusqu’à des risques de sécurité graves tels que les attaques de type « man-in-the-middle ». Ce script PowerShell automatise le processus de recherche de ces serveurs à l’aide de nmap, un outil d’analyse de réseau réputé, améliorant ainsi la sécurité du réseau et l’efficacité opérationnelle. Il est particulièrement utile pour les professionnels de l’informatique et les MSP qui gèrent de grands réseaux dynamiques pour lesquels la surveillance manuelle n’est pas pratique.

Le script :

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

 

Description détaillée

Le script fonctionne en plusieurs étapes :

• Initialisation : Il commence par définir des paramètres tels que les serveurs DHCP autorisés et les champs personnalisés pour la sortie, ce qui permet une personnalisation en fonction d’environnements réseau spécifiques.
• Identification du sous-réseau: Il utilise une fonction permettant d’extraire du réseau des informations sur les sous-réseaux, essentielles pour cibler l’analyse.
• Intégration Nmap: Le script vérifie l’installation de nmap, qui est essentiel pour l’analyse. Il exécute ensuite un scan nmap sur les sous-réseaux identifiés, à la recherche de serveurs DHCP actifs.
• Analyse du résultat: Après l’analyse, le script analyse la sortie XML de nmap, en extrayant les adresses IP et MAC des serveurs DHCP trouvés.
• Validation par rapport à la liste autorisée: Il compare les serveurs DHCP trouvés à une liste de serveurs autorisés et signale les serveurs non autorisés (malveillants).
• Sortie et nettoyage: Les résultats sont ensuite affichés et les fichiers temporaires créés par le script sont nettoyés.

Un diagramme visuel accompagnant cette explication pourrait illustrer le flux de l’initialisation à la sortie du résultat, améliorant ainsi la compréhension.

Cas d’utilisation potentiels

Prenons l’exemple d’une grande entreprise disposant de plusieurs sous-réseaux gérés par un service informatique. Ce script peut être programmé pour être exécuté périodiquement, afin de garantir qu’aucun serveur DHCP non autorisé n’apparaisse sur le réseau, ce qui permet de maintenir l’intégrité du réseau et de prévenir les failles de sécurité potentielles.

Comparaisons

Les vérifications manuelles ou les outils de surveillance de base du réseau peuvent ne pas détecter les serveurs DHCP malveillants ou nécessiter une main-d’œuvre importante. En revanche, ce script automatise le processus, est plus complet et s’intègre à des outils existants tels que NinjaOne pour améliorer les capacités de gestion.

FAQ

• À quelle fréquence dois-je exécuter ce script ?
  • Il est recommandé de procéder à une exécution régulière, par exemple une fois par semaine ou après toute modification importante du réseau.
• Ai-je besoin d’autorisations spéciales pour exécuter ce script ?
  • Oui, des droits d’administration sont généralement requis pour l’analyse du réseau.

Implications

Les serveurs DHCP malveillants non identifiés peuvent entraîner des risques importants pour la sécurité. L’automatisation de leur détection minimise ces risques, contribuant ainsi à la sécurité globale du réseau et à l’efficacité opérationnelle.

Recommandations

• Mettez régulièrement à jour la liste des serveurs DHCP autorisés.
• Intégrez ce script à des outils plus larges de surveillance et de gestion du réseau.
• Assurez-vous que nmap est correctement installé et mis à jour.

Conclusion :

Dans le domaine de la sécurité et de la gestion des réseaux, des outils comme NinjaOne, complétés par des scripts comme celui-ci, offrent des solutions solides pour maintenir l’intégrité du réseau. En automatisant les tâches critiques, telles que la recherche de serveurs DHCP malveillants, NinjaOne aide les professionnels de l’informatique à se concentrer sur des initiatives stratégiques tout en garantissant la sécurité et la fiabilité de leurs réseaux.