Comment utiliser PowerShell pour détecter les ports ouverts et établis dans Windows

Dans le paysage en constante évolution de la sécurité et de la gestion informatique, il est essentiel de surveiller l’activité du réseau et d’identifier les vulnérabilités potentielles. Les ports ouverts peuvent servir de points d’entrée pour des accès non autorisés, d’où l’importance pour les professionnels de l’informatique de les auditer et de les gérer régulièrement.

PowerShell, avec ses puissantes capacités de script, offre un moyen flexible et efficace de surveiller ces ports. Dans cet article, nous allons explorer un script PowerShell conçu pour détecter les ports ouverts et établis sur un système Windows, discuter de ses applications pratiques et donner un aperçu de son fonctionnement et de son utilisation.

Comprendre la nécessité de la surveillance des ports

Les ports sont un aspect essentiel de la communication en réseau, car ils permettent à différents services et applications d’interagir les uns avec les autres sur un réseau. Cependant, les ports ouverts, en particulier ceux qui ne sont pas activement surveillés, peuvent présenter des risques pour la sécurité.

Les cybercriminels exploitent souvent ces vulnérabilités pour obtenir un accès non autorisé aux systèmes. Il est donc impératif que les professionnels de l’informatique, en particulier ceux des fournisseurs de services gérés (MSP), vérifient régulièrement si des ports sont ouverts sur leur réseau, en veillant à ce que seuls les ports nécessaires soient ouverts et à l’écoute.

Ce script PowerShell est conçu pour aider les professionnels de l’informatique dans cette tâche en détectant automatiquement les ports ouverts et établis et en fournissant des informations détaillées à leur sujet. Il peut également enregistrer les résultats dans un champ personnalisé, ce qui facilite le suivi et la documentation.

Le script :

#Requires -Version 5.1

<#
.SYNOPSIS
    Alert on specified ports that are Listening or Established and optionally save the results to a custom field.
.DESCRIPTION
    Will alert on open ports, regardless if a firewall is blocking them or not.
    Checks for open ports that are in a 'Listen' or 'Established' state.
    UDP is a stateless protocol and will not have a state.
    Outputs the open ports, process ID, state, protocol, local address, and process name.
    When a Custom Field is provided this will save the results to that custom field.

.EXAMPLE
    (No Parameters)
    ## EXAMPLE OUTPUT WITHOUT PARAMS ##
    [Alert] Found open port: 80, PID: 99, State: Listen, Local Address: 0.0.0.0, Process: nginx
    [Alert] Found open port: 500, PID: 99, State: Listen, Local Address: 0.0.0.0, Process: nginx

PARAMETER: -Port "100,200,300-350, 400"
    A comma separated list of ports to check. Can include ranges (e.g. 100,200,300-350, 400)
.EXAMPLE
    -Port "80,200,300-350, 400"
    ## EXAMPLE OUTPUT WITH Port ##
    [Alert] Found open port: 80, PID: 99, State: Listen, Local Address: 0.0.0.0, Process: nginx

PARAMETER: -CustomField "ReplaceMeWithAnyMultilineCustomField"
    Name of the custom field to save the results to.
.EXAMPLE
    -Port "80,200,300-350, 400" -CustomField "ReplaceMeWithAnyMultilineCustomField"
    ## EXAMPLE OUTPUT WITH CustomField ##
    [Alert] Found open port: 80, PID: 99, State: Listen, Local Address: 0.0.0.0, Process: nginx
    [Info] Saving results to custom field: ReplaceMeWithAnyMultilineCustomField
    [Info] Results saved to custom field: ReplaceMeWithAnyMultilineCustomField
.OUTPUTS
    None
.NOTES
    Supported Operating Systems: Windows 10/Windows Server 2016 or later with PowerShell 5.1
    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://ninjastage2.wpengine.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]$PortsToCheck,
    [String]$CustomFieldName
)

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 Set-NinjaProperty {
        [CmdletBinding()]
        Param(
            [Parameter(Mandatory = $True)]
            [String]$Name,
            [Parameter()]
            [String]$Type,
            [Parameter(Mandatory = $True, ValueFromPipeline = $True)]
            $Value,
            [Parameter()]
            [String]$DocumentName
        )
    
        $Characters = $Value | Measure-Object -Character | Select-Object -ExpandProperty Characters
        if ($Characters -ge 10000) {
            throw [System.ArgumentOutOfRangeException]::New("Character limit exceeded, value is greater than 10,000 characters.")
        }
        
        # If we're requested to set the field value for a Ninja document we'll specify it here.
        $DocumentationParams = @{}
        if ($DocumentName) { $DocumentationParams["DocumentName"] = $DocumentName }
        
        # This is a list of valid fields that can be set. If no type is given, it will be assumed that the input doesn't need to be changed.
        $ValidFields = "Attachment", "Checkbox", "Date", "Date or Date Time", "Decimal", "Dropdown", "Email", "Integer", "IP Address", "MultiLine", "MultiSelect", "Phone", "Secure", "Text", "Time", "URL", "WYSIWYG"
        if ($Type -and $ValidFields -notcontains $Type) { Write-Warning "$Type is an invalid type! Please check here for valid types. https://ninjarmm.zendesk.com/hc/en-us/articles/16973443979789-Command-Line-Interface-CLI-Supported-Fields-and-Functionality" }
        
        # The field below requires additional information to be set
        $NeedsOptions = "Dropdown"
        if ($DocumentName) {
            if ($NeedsOptions -contains $Type) {
                # We'll redirect the error output to the success stream to make it easier to error out if nothing was found or something else went wrong.
                $NinjaPropertyOptions = Ninja-Property-Docs-Options -AttributeName $Name @DocumentationParams 2>&1
            }
        }
        else {
            if ($NeedsOptions -contains $Type) {
                $NinjaPropertyOptions = Ninja-Property-Options -Name $Name 2>&1
            }
        }
        
        # If an error is received it will have an exception property, the function will exit with that error information.
        if ($NinjaPropertyOptions.Exception) { throw $NinjaPropertyOptions }
        
        # The below type's require values not typically given in order to be set. The below code will convert whatever we're given into a format ninjarmm-cli supports.
        switch ($Type) {
            "Checkbox" {
                # While it's highly likely we were given a value like "True" or a boolean datatype it's better to be safe than sorry.
                $NinjaValue = [System.Convert]::ToBoolean($Value)
            }
            "Date or Date Time" {
                # Ninjarmm-cli expects the  Date-Time to be in Unix Epoch time so we'll convert it here.
                $Date = (Get-Date $Value).ToUniversalTime()
                $TimeSpan = New-TimeSpan (Get-Date "1970-01-01 00:00:00") $Date
                $NinjaValue = $TimeSpan.TotalSeconds
            }
            "Dropdown" {
                # Ninjarmm-cli is expecting the guid of the option we're trying to select. So we'll match up the value we were given with a guid.
                $Options = $NinjaPropertyOptions -replace '=', ',' | ConvertFrom-Csv -Header "GUID", "Name"
                $Selection = $Options | Where-Object { $_.Name -eq $Value } | Select-Object -ExpandProperty GUID
        
                if (-not $Selection) {
                    throw [System.ArgumentOutOfRangeException]::New("Value is not present in dropdown")
                }
        
                $NinjaValue = $Selection
            }
            default {
                # All the other types shouldn't require additional work on the input.
                $NinjaValue = $Value
            }
        }
        
        # We'll need to set the field differently depending on if its a field in a Ninja Document or not.
        if ($DocumentName) {
            $CustomField = Ninja-Property-Docs-Set -AttributeName $Name -AttributeValue $NinjaValue @DocumentationParams 2>&1
        }
        else {
            $CustomField = $NinjaValue | Ninja-Property-Set-Piped -Name $Name 2>&1
        }
        
        if ($CustomField.Exception) {
            throw $CustomField
        }
    }
}
process {
    if (-not (Test-IsElevated)) {
        Write-Error -Message "Access Denied. Please run with Administrator privileges."
        exit 1
    }
    if ($env:portsToCheck -and $env:portsToCheck -ne 'null') {
        $PortsToCheck = $env:portsToCheck
    }
    if ($env:customFieldName -and $env:customFieldName -ne 'null') {
        $CustomFieldName = $env:customFieldName
    }

    # Remove any whitespace
    $PortsToCheck = $PortsToCheck -replace '\s', ''

    # Parse the ports to check
    $Ports = if ($PortsToCheck) {
        # Split the ports by comma and handle ranges
        $PortsToCheck -split ',' | ForEach-Object {
            # Trim the whitespace
            $Ports = "$_".Trim()
            # If the port is a range, expand it
            if ($Ports -match '-') {
                # Split the range and expand it
                $Range = $Ports -split '-' | ForEach-Object { "$_".Trim() } | Where-Object { $_ }
                if ($Range.Count -ne 2) {
                    Write-Host "[Error] Invalid range formatting, must be two number with a dash in between them (eg 1-10): $PortsToCheck"
                    exit 1
                }
                try {
                    $Range[0]..$Range[1]
                }
                catch {
                    Write-Host "[Error] Failed to parse range, must be two number with a dash in between them (eg 1-10): $PortsToCheck"
                    exit 1
                }
            }
            else {
                $Ports
            }
        }
    }
    else { $null }

    if ($($Ports | Where-Object { [int]$_ -gt 65535 })) {
        Write-Host "[Error] Can not search for ports above 65535. Must be with in the range of 1 to 65535."
        exit 1
    }

    # Get the open ports
    $FoundPorts = $(
        Get-NetTCPConnection | Select-Object @(
            'LocalAddress'
            'LocalPort'
            'State'
            @{Name = "Protocol"; Expression = { "TCP" } }
            'OwningProcess'
            @{Name = "Process"; Expression = { (Get-Process -Id $_.OwningProcess -ErrorAction SilentlyContinue).ProcessName } }
        )
        Get-NetUDPEndpoint | Select-Object @(
            'LocalAddress'
            'LocalPort'
            @{Name = "State"; Expression = { "None" } }
            @{Name = "Protocol"; Expression = { "UDP" } }
            'OwningProcess'
            @{Name = "Process"; Expression = { (Get-Process -Id $_.OwningProcess -ErrorAction SilentlyContinue).ProcessName } }
        )
    ) | Where-Object {
        $(
            <# When Ports are specified select just those ports. #>
            if ($Ports) { $_.LocalPort -in $Ports }else { $true }
        ) -and
        (
            <# Filter out anything that isn't listening or established. #>
            $(
                $_.Protocol -eq "TCP" -and
                $(
                    $_.State -eq "Listen" -or
                    $_.State -eq "Established"
                )
            ) -or
            <# UDP is stateless, return all UDP connections. #>
            $_.Protocol -eq "UDP"
        )
    } | Sort-Object LocalPort | Select-Object * -Unique

    if (-not $FoundPorts -or $FoundPorts.Count -eq 0) {
        Write-Host "[Info] No ports were found listening or established with the specified: $PortsToCheck"
    }

    # Output the found ports
    $FoundPorts | ForEach-Object {
        Write-Host "[Alert] Found open port: $($_.LocalPort), PID: $($_.OwningProcess), Protocol: $($_.Protocol), State: $($_.State), Local IP: $($_.LocalAddress), Process: $($_.Process)"
    }
    # Save the results to a custom field if one was provided
    if ($CustomFieldName -and $CustomFieldName -ne 'null') {
        try {
            Write-Host "[Info] Saving results to custom field: $CustomFieldName"
            Set-NinjaProperty -Name $CustomFieldName -Value $(
                $FoundPorts | ForEach-Object {
                    "Open port: $($_.LocalPort), PID: $($_.OwningProcess), Protocol: $($_.Protocol), State: $($_.State), Local Address: $($_.LocalAddress), Process: $($_.Process)"
                } | Out-String
            )
            Write-Host "[Info] Results saved to custom field: $CustomFieldName"
        }
        catch {
            Write-Host $_.Exception.Message
            Write-Host "[Warn] Failed to save results to custom field: $CustomFieldName"
            exit 1
        }
    }
}
end {
    
    
    
}

 

Comment fonctionne le script

Le script est conçu avec un objectif clair : identifier et signaler les ports TCP et UDP ouverts qui sont soit à l’état d’écoute, soit à l’état établi. Vous trouverez ci-dessous une description détaillée de la manière dont le script y parvient :

1. Configuration initiale et fonctions :

• Le script commence par définir plusieurs fonctions utilitaires, dont Test-IsElevated, qui vérifie si le script s’exécute avec des privilèges d’administrateur. Ceci est essentiel car la vérification des ports ouverts nécessite des autorisations élevées.
• Une autre fonction clé, Set-NinjaProperty, est incluse pour gérer l’enregistrement des résultats dans un champ personnalisé, s’il est spécifié. Cette fonction gère différents types de données et veille à ce que la limite de caractères du champ ne soit pas dépassée.

2. Traitement des paramètres :

• Le script accepte deux paramètres : PortsToCheck, une liste de ports à surveiller séparés par des virgules, et CustomFieldName, le nom du champ personnalisé dans lequel les résultats seront stockés.
• Il traite ensuite ces paramètres, en élargissant les plages de ports et en supprimant les espaces blancs pour un traitement précis.

3. Détection de port :

• Le script utilise les cmdlets Get-NetTCPConnection et Get-NetUDPEndpoint pour récupérer des informations sur les connexions TCP et UDP actives sur le système.
• Il filtre les résultats pour n’inclure que les ports qui sont à l’écoute ou établis (pour TCP), et tous les ports UDP, car UDP est un protocole sans état.
• Les résultats filtrés sont ensuite triés et formatés pour la sortie.

4. Résultats et enregistrement des champs personnalisés :

• Le script affiche les ports détectés, ainsi que des détails pertinents tels que l’ID du processus, l’état, l’adresse locale et le nom du processus.
• Si un champ personnalisé est spécifié, le script tente d’enregistrer les résultats à l’aide de la fonction Set-NinjaProperty, en gérant les erreurs qui peuvent survenir au cours de ce processus.

Cas d’utilisation potentiels

Imaginez un professionnel de l’informatique qui gère la sécurité du réseau d’une entreprise de taille moyenne. Des audits réguliers des ports font partie de leur routine afin de s’assurer que seuls les services nécessaires fonctionnent et sont accessibles. En implémentant ce script PowerShell, le professionnel de l’informatique peut automatiser le processus d’identification des ports ouverts, réduisant ainsi le risque de laisser des ports vulnérables exposés.

Par exemple, après avoir exécuté le script, le professionnel de l’informatique remarque qu’un port est ouvert et lié à un service non essentiel. Ils peuvent alors prendre des mesures pour fermer ce port, réduisant ainsi la surface d’attaque potentielle de leur réseau.

Comparaisons avec d’autres méthodes

Traditionnellement, les professionnels de l’informatique peuvent utiliser des outils tels que netstat ou des outils d’analyse de réseau tiers pour identifier les ports ouverts. Bien que ces outils soient efficaces, ils nécessitent souvent une intervention manuelle et ne s’intègrent pas toujours facilement aux systèmes automatisés. Ce script PowerShell offre une approche plus intégrée, permettant l’automatisation au sein des flux de travail existants et offrant une certaine flexibilité grâce à des paramètres tels que l’enregistrement de champs personnalisés.

Questions fréquemment posées

Q : Dois-je exécuter ce script avec des privilèges d’administrateur ?

Oui, le script nécessite des privilèges d’administrateur pour détecter avec précision les ports ouverts et les processus associés.

Q : Le script peut-il également vérifier les ports UDP ?

Oui, le script vérifie les ports TCP et UDP, les ports TCP étant filtrés en fonction de leur état et les ports UDP étant répertoriés quel que soit leur état.

Q : Que se passe-t-il si je spécifie une plage de ports non valide ?

Le script inclut une gestion des erreurs afin de garantir que seules les plages de ports valides sont traitées. Si une plage non valide est spécifiée, le script affiche un message d’erreur et quitte le système.

Implications pour la sécurité informatique

Les résultats générés par ce script peuvent avoir des implications importantes pour la sécurité informatique. La surveillance régulière des ports ouverts peut aider à détecter des services non autorisés fonctionnant sur un réseau, ce qui peut indiquer une faille de sécurité. En identifiant et en fermant les ports inutiles, les professionnels de l’informatique peuvent limiter les risques et améliorer la sécurité globale de leur entreprise.

Bonnes pratiques d’utilisation de ce script

• Exécuter régulièrement: Planifiez l’exécution régulière du script pour assurer une surveillance continue des ports ouverts de votre réseau.
• Utiliser les champs personnalisés à bon escient: Lorsque vous enregistrez des résultats dans un champ personnalisé, veillez à ce que le champ soit correctement nommé et géré afin d’éviter d’écraser des données importantes.
• Combiner avec d’autres mesures de sécurité: Utilisez ce script dans le cadre d’une stratégie de sécurité plus grande, en l’associant à d’autres outils et pratiques pour assurer une protection complète.

Conclusion

Ce script PowerShell est un outil puissant pour les professionnels de l’informatique qui cherchent à automatiser le processus de détection et de surveillance des ports ouverts. En intégrant ce script à vos pratiques de sécurité habituelles, vous pouvez renforcer les mécanismes de défense de votre réseau et réagir rapidement aux vulnérabilités potentielles. NinjaOne offre une gamme d’outils qui complètent ces scripts, fournissant une plateforme performante pour la gestion informatique et la surveillance de la sécurité.