Comment utiliser PowerShell pour vérifier les profils de connexion réseau sur Windows

La gestion de la connectivité des terminaux est essentielle pour les administrateurs système et les fournisseurs de services gérés (MSP). Des profils réseau mal configurés peuvent introduire par inadvertance des risques de sécurité ou limiter l’accès aux ressources. Identifier avec précision si un appareil se trouve sur un réseau public, privé ou de domaine peut faire toute la différence lors de la configuration des pare-feu, du déploiement des politiques ou du dépannage de la connectivité. Pour les professionnels de l’informatique qui cherchent à optimiser ce processus, un script PowerShell pour les vérifications des profils de connexion réseau offre automatisation, visibilité et cohérence dans les grands parcs d’appareils.

Contexte

Dans les environnements d’entreprise et de fournisseur de services gérés (MSP), le profil réseau d’un appareil a un impact direct sur sa position en matière de sécurité. Par exemple, les profils publics déclenchent généralement des règles de pare-feu plus strictes que les profils privés ou de domaine. Le fait de savoir quel réseau utilise chaque adaptateur peut aider les équipes informatiques à repérer les erreurs de classification et à appliquer les paramètres corrects.

Bien que Windows fournisse des outils basés sur une interface graphique pour vérifier l’état du réseau, ceux-ci ne sont pas extensibles. Ce script basé sur PowerShell identifie non seulement les profils réseau des adaptateurs, mais s’intègre également à NinjaOne en mettant à jour un champ personnalisé; permettant aux administrateurs de collecter et d’agir de manière programmatique sur les données de configuration du réseau. C’est un outil utile dans le contexte plus large de la visibilité des terminaux et de l’audit de conformité.

Le script

#Requires -Version 5.1

<#
.SYNOPSIS
    Checks the current network connections to see what profile they are currently using and optionally save the results to a custom field.
.DESCRIPTION
    Checks the current network connections to see what profile they are currently using and optionally save the results to a custom field.
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).
.EXAMPLE
    (No Parameters)
    
    Retrieving network adapters.
    Gathering additional information.

    NetworkAdapter   MacAddress        Type  Profile
    --------------   ----------        ----  -------
    LabNet - Win10 0 00-17-FB-00-00-02 Wired  Public

PARAMETER: -CustomField "ReplaceMeWithYourDesiredCustomField"
    Optionally specify the name of a custom field to save the results to.

.NOTES
    Minimum OS Architecture Supported: Windows 10, Windows Server 2016
    Release Notes: Initial Release
#>

[CmdletBinding()]
param (
    [Parameter()]
    [String]$CustomField
)

begin {
    # If script form variables are used, replace the command the command line parameters with their value.
    if ($env:networkProfileCustomFieldName -and $env:networkProfileCustomFieldName -notlike "null") { $CustomField = $env:networkProfileCustomFieldName }
    
    function Set-NinjaProperty {
        [CmdletBinding()]
        Param(
            [Parameter(Mandatory = $True)]
            [String]$Name,
            [Parameter()]
            [String]$Type,
            [Parameter(Mandatory = $True, ValueFromPipeline = $True)]
            $Value,
            [Parameter()]
            [String]$DocumentName
        )
        
        # Measure the number of characters in the provided value
        $Characters = $Value | ConvertTo-Json | Measure-Object -Character | Select-Object -ExpandProperty Characters
    
        # Throw an error if the value exceeds the character limit of 200,000 characters
        if ($Characters -ge 200000) {
            throw [System.ArgumentOutOfRangeException]::New("Character limit exceeded: the value is greater than or equal to 200,000 characters.")
        }
        
        # Initialize a hashtable for additional documentation parameters
        $DocumentationParams = @{}
    
        # If a document name is provided, add it to the documentation parameters
        if ($DocumentName) { $DocumentationParams["DocumentName"] = $DocumentName }
        
        # Define a list of valid field types
        $ValidFields = "Attachment", "Checkbox", "Date", "Date or Date Time", "Decimal", "Dropdown", "Email", "Integer", "IP Address", "MultiLine", "MultiSelect", "Phone", "Secure", "Text", "Time", "URL", "WYSIWYG"
    
        # Warn the user if the provided type is not valid
        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" }
        
        # Define types that require options to be retrieved
        $NeedsOptions = "Dropdown"
    
        # If the property is being set in a document or field and the type needs options, retrieve them
        if ($DocumentName) {
            if ($NeedsOptions -contains $Type) {
                $NinjaPropertyOptions = Ninja-Property-Docs-Options -AttributeName $Name @DocumentationParams 2>&1
            }
        }
        else {
            if ($NeedsOptions -contains $Type) {
                $NinjaPropertyOptions = Ninja-Property-Options -Name $Name 2>&1
            }
        }
        
        # Throw an error if there was an issue retrieving the property options
        if ($NinjaPropertyOptions.Exception) { throw $NinjaPropertyOptions }
            
        # Process the property value based on its type
        switch ($Type) {
            "Checkbox" {
                # Convert the value to a boolean for Checkbox type
                $NinjaValue = [System.Convert]::ToBoolean($Value)
            }
            "Date or Date Time" {
                # Convert the value to a Unix timestamp for Date or Date Time type
                $Date = (Get-Date $Value).ToUniversalTime()
                $TimeSpan = New-TimeSpan (Get-Date "1970-01-01 00:00:00") $Date
                $NinjaValue = $TimeSpan.TotalSeconds
            }
            "Dropdown" {
                # Convert the dropdown value to its corresponding GUID
                $Options = $NinjaPropertyOptions -replace '=', ',' | ConvertFrom-Csv -Header "GUID", "Name"
                $Selection = $Options | Where-Object { $_.Name -eq $Value } | Select-Object -ExpandProperty GUID
            
                # Throw an error if the value is not present in the dropdown options
                if (!($Selection)) {
                    throw [System.ArgumentOutOfRangeException]::New("Value is not present in dropdown options.")
                }
            
                $NinjaValue = $Selection
            }
            default {
                # For other types, use the value as is
                $NinjaValue = $Value
            }
        }
            
        # Set the property value in the document if a document name is provided
        if ($DocumentName) {
            $CustomField = Ninja-Property-Docs-Set -AttributeName $Name -AttributeValue $NinjaValue @DocumentationParams 2>&1
        }
        else {
            # Otherwise, set the standard property value
            $CustomField = $NinjaValue | Ninja-Property-Set-Piped -Name $Name 2>&1
        }
            
        # Throw an error if setting the property failed
        if ($CustomField.Exception) {
            throw $CustomField
        }
    }

    function Test-IsElevated {
        $id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
        $p = New-Object System.Security.Principal.WindowsPrincipal($id)
        $p.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator)
    }

    if (!$ExitCode) {
        $ExitCode = 0
    }
}
process {
    # Check if the script is running with elevated (Administrator) privileges.
    if ($CustomField -and !(Test-IsElevated)) {
        Write-Host -Object "[Error] Access Denied. Administrator privileges are required to set Custom Fields."
        exit 1
    }

    # Initialize a list to store network information.
    $NetworkInfo = New-Object System.Collections.Generic.List[object]

    # Inform the user that network adapters are being retrieved.
    Write-Host -Object "Retrieving network adapters."

    try {
        # Attempt to retrieve the network connection profiles and adapters.
        $NetworkProfiles = Get-NetConnectionProfile -ErrorAction Stop
        $NetworkAdapters = Get-NetAdapter -ErrorAction Stop
    }
    catch {
        # Catch any errors during network profile/adapter retrieval and output error messages.
        Write-Host -Object "[Error] Failed to retrieve network adapters."
        Write-Host -Object "[Error] $($_.Exception.Message)"
        exit 1
    }

    # Inform the user that additional information is being gathered.
    Write-Host -Object "Gathering additional information."

    # Loop through each network profile.
    foreach ($NetworkProfile in $NetworkProfiles) {
        # Find the network adapter associated with the current network profile using the InterfaceIndex.
        $NetAdapter = $NetworkAdapters | Where-Object { $_.ifIndex -eq $NetworkProfile.InterfaceIndex }

        # Determine the adapter type (Wired, Wi-Fi, or Other) based on the MediaType.
        switch -Wildcard ($NetAdapter.MediaType) {
            "802.3" { $AdapterType = "Wired" }
            "*802.11" { $AdapterType = "Wi-Fi" }
            default { $AdapterType = "Other" }
        }

        # Add the network adapter information as a custom object to the $NetworkInfo list.
        $NetworkInfo.Add(
            [PSCustomObject]@{
                "NetworkAdapter" = $NetAdapter.Name
                "MacAddress"     = $NetAdapter.MacAddress
                "Type"           = $AdapterType
                "Profile"        = $NetworkProfile.NetworkCategory
            }
        )
    }

    # Check if the $NetworkInfo list is empty or contains fewer than one entry.
    if (!$NetworkInfo -or ($NetworkInfo | Measure-Object | Select-Object -ExpandProperty Count) -lt 1) {
        Write-Host -Object "[Error] No network interfaces found."
        exit 1
    }

    # Format and output the network information in a table.
    Write-Host -Object ""
    ($NetworkInfo | Format-Table | Out-String).Trim() | Write-Host
    Write-Host -Object ""

    # If a custom field is provided, iterate through the network information and append the adapter details to $CustomFieldValue.
    if ($CustomField) {
        $NetworkInfo | ForEach-Object {
            if ($CustomFieldValue) {
                # Append the network adapter name and profile to the existing $CustomFieldValue.
                $CustomFieldValue = "$CustomFieldValue | $($_.NetworkAdapter): $($_.Profile)"
            }
            else {
                # Set $CustomFieldValue if it hasn't been initialized yet.
                $CustomFieldValue = "$($_.NetworkAdapter): $($_.Profile)"
            }
        }

        try {
            # Try to set the custom field value using the Set-NinjaProperty function.
            Write-Host "Attempting to set Custom Field '$CustomField'."
            Set-NinjaProperty -Name $CustomField -Value $CustomFieldValue
            Write-Host "Successfully set custom field '$CustomField'!"
        }
        catch {
            Write-Host "[Error] $($_.Exception.Message)"
            exit 1
        }
    }

    # Exit the script with the provided $ExitCode variable.
    exit $ExitCode
}
end {
    
    
    
}

 

Description détaillée

Ce script est un outil puissant conçu avec des fonctions modulaires et une connaissance de l’administration. Voici un aperçu de ses principaux éléments :

1. Traitement des paramètres

Le script accepte un paramètre facultatif -CustomField, qui lui permet de stocker le résumé du profil du réseau dans un champ personnalisé NinjaOne. Cela peut également être transmis via une variable d’environnement, ce qui est utile pour les contextes d’automatisation.

2. Vérification des privilèges

Avant d’effectuer des actions nécessitant des droits élevés, telles que l’écriture dans des champs personnalisés, il vérifie s’il s’exécute avec des privilèges d’administrateur à l’aide de la fonction Test-IsElevated. Si ce n’est pas le cas, il abandonne avec une erreur.

3. Récupération des données du réseau

Il extrait des données à l’aide de :

powershell

CopyEdit

$NetworkProfiles = Get-NetConnectionProfile

$NetworkAdapters = Get-NetAdapter

Le script associe chaque profil réseau à l’adaptateur correspondant par InterfaceIndex, détermine le type d’adaptateur (par exemple, « Filaire », « Wi-Fi », « Autre ») et stocke le tout dans un PSCustomObject.

4. Formatage de la sortie

Toutes les informations relatives au réseau sont compilées dans un tableau :

• Nom de l’adaptateur réseau
• Adresse MAC
• Type de connexion
• Profil actuel (public, privé ou domaine)

Ce résultat formaté est imprimé directement sur la console.

5. Intégration avec NinjaOne

Si le paramètre -CustomField est fourni, le script utilise la fonction Set-NinjaProperty pour enregistrer le mappage du profil de l’adaptateur dans un champ personnalisé NinjaOne. Ces mesures comprennent :

• Sérialisation des valeurs
• Validation du type (par exemple, vérifier si le champ est une liste déroulante)
• Lien optionnel vers la documentation

Cette fonction comprend des garde-fous tels qu’une limite de 200 000 caractères et la gestion des erreurs.

Cas d’utilisation potentiels

Imaginez qu’un fournisseur de services de gestion de l’infrastructure mette en service les 200 ordinateurs portables d’un nouveau client répartis sur plusieurs sites. Un script de ce type pourrait être déployé via le système d’automatisation de NinjaOne pour capturer le contexte réseau de chaque appareil. Les appareils configurés par erreur pour le profil « Public » alors qu’ils se trouvent sur un réseau local d’entreprise sécurisé peuvent être signalés pour être corrigés. En attendant, ces données sont stockées dans les champs personnalisés de NinjaOne, ce qui les rend accessibles pour les tableaux de bord ou les alertes automatisées.

Comparaisons

Par rapport à la vérification manuelle des profils via l’interface graphique ou des commandes PowerShell ponctuelles telles que Get-NetConnectionProfile, ce script :

• S’adapte sans effort à des centaines de terminaux.
• Standardisation de la saisie des données avec un formatage cohérent.
• S’intègre à NinjaOne pour une visibilité et une documentation a posteriori.
• La documentation est prise en charge par le biais d’un lien entre les champs personnalisés, ce qui ajoute à l’utilité à long terme.

D’autres approches, telles que l’utilisation de WMI ou d’agents tiers, peuvent offrir une plus grande granularité, mais ajoutent de la complexité et de la latence. Ce script est idéal en termes de simplicité, de visibilité et de résultats exploitables.

Questions fréquentes

Q : Dois-je exécuter ce script en tant qu’administrateur ?

Oui, surtout si vous écrivez dans un champ personnalisé. Dans le cas contraire, il n’affichera que des informations et quittera le système de manière élégante.

Q : Puis-je utiliser ce système sans intégration avec NinjaOne ?

Absolument. Si vous ne fournissez pas le paramètre -CustomField, le script transmet simplement les données du réseau à la console.

Q : Quels types de réseaux détecte-t-il ?

Il classe les adaptateurs dans les catégories « filaire », « Wi-Fi » ou « autre » en fonction du type de support.

Q : Comment sont gérés les adaptateurs multiples ?

Chaque adaptateur actif est répertorié individuellement et son profil réseau est inclus dans le résultat et/ou stocké dans le champ personnalisé.

Implications

Un profil réseau mal configuré peut exposer les terminaux à des risques excessifs. Par exemple, un ordinateur portable interne sur un VLAN d’entreprise ne devrait jamais être classé sous un profil de réseau « public », ce qui pourrait désactiver l’accès critique ou restreindre les applications de stratégie de groupe. Ce script met rapidement en évidence ces anomalies, permettant ainsi aux équipes informatiques de les corriger avant qu’elles ne deviennent des vulnérabilités.

Recommandations

• Programmer des contrôles réguliers : Automatisez ce script pour qu’il s’exécute à une cadence hebdomadaire via NinjaOne.
• Utilisation avec des champs personnalisés: Le stockage des résultats permet un suivi historique et la création de rapports.
• Alerte sur les classifications erronées: Associez ce script à des alertes basées sur des règles pour signaler les profils publics dans des emplacements sécurisés.
• Exécuter avec des droits élevés: Pour une fonctionnalité complète, assurez-vous que les scripts sont exécutés avec des privilèges d’administrateur.

Conclusion

Ce script PowerShell de vérification des profils de connexion réseau illustre comment l’automatisation peut réduire les tâches manuelles tout en améliorant la visibilité et la sécurité. Utilisé avec le puissant cadre de script et de champs personnalisés de NinjaOne, il offre aux équipes informatiques un moyen évolutif de surveiller, de consigner et de réagir face aux états de réseau mal configurés, et ce, à partir d’un guichet unique.

Que vous augmentiez quelques terminaux ou que vous en gériez des milliers, ce script doit faire partie de votre boîte à outils d’automatisation.