PowerShell : récupérer l’emplacement d’un appareil à l’aide de l’API GeoLocation de Google

Principaux points à retenir

• Le script récupère l’emplacement géographique d’un appareil à l’aide de l’API GeoLocation de Google.
• Le script est conçu pour mettre à jour les champs personnalisés de NinjaOne avec des données de localisation.
• Le script nécessite une connexion internet active et est optimisé pour les appareils Windows 10.
• L’API GeoLocation de Google offre une précision et une couverture plus vaste que les autres méthodes de géolocalisation.
• L’utilisation du script pour le suivi de la localisation soulève des questions d’éthique et de respect de la vie privée.
• Il est essentiel d’obtenir des autorisations explicites avant de déployer cet outil afin d’éviter toute violation de la vie privée.
• Il est essentiel de connaître le nombre limite de demandes et les coûts associés à l’API de Google.
• La plateforme NinjaOne, associée à de tels scripts, offre de solides capacités pour les opérations informatiques et la gestion des actifs.

Dans l’écosystème informatique interconnecté d’aujourd’hui, l’une des informations les plus précieuses est la « localisation ». La possibilité de suivre l’emplacement géographique des appareils peut s’avérer cruciale pour de nombreuses opérations informatiques, de la gestion des actifs à la surveillance de la sécurité. Cet article examine un script PowerShell qui permet aux professionnels de l’informatique et aux fournisseurs de services gérés (MSP) d’obtenir l’emplacement d’un appareil Windows et de le stocker en utilisant les champs personnalisés de NinjaOne.

Contexte

Le script en question met à jour les champs personnalisés avec les coordonnées géographiques et l’adresse d’un appareil à l’aide de l’API GeoLocation de Google. Pour les professionnels de l’informatique et les entreprises MSP, il est essentiel de connaître l’emplacement physique d’un appareil. Qu’il s’agisse de retrouver du matériel volé, d’auditer des appareils ou de vérifier la répartition géographique des actifs informatiques, les applications d’un tel script peuvent être diverses et complexes.

Le script PowerShell

#Requires -Version 5.1

<#
.SYNOPSIS
    Updates Custom Fields with the location of a device based on the Google GeoLocation API.
.DESCRIPTION
    Updates Custom Fields with the location of a device based on the Google GeoLocation API.

    The CustomFieldName parameter can be used to specify which custom field to save the Latitude and Longitude coordinates to.
    The AddressCustomFieldName parameter can be used to specify which custom field to save the address to.

    This script requires a custom field to save location data in NinjaRMM.
    The default for CustomFieldName is "Location".
    The default for AddressCustomFieldName is "Address".
    You can use any text custom field that you wish.
.EXAMPLE
    -GoogleApiKey "<GeoLocation API key here>"
    Saves the Latitude and Longitude coordinates to the custom field named Location.
.EXAMPLE
    -GoogleApiKey "<GeoLocation API key here>" -CustomFieldName "Location" -AddressCustomFieldName "Address"
    Saves the Latitude and Longitude coordinates to the custom field named Location as well as the address to Address.
.INPUTS
    None
.OUTPUTS
    None
.NOTES
    Minimum OS Architecture Supported: Windows 10
    Release Notes:
    Updated to work with either Parameters or Script Variables
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]
    $GoogleApiKey,
    [Parameter()]
    [String]
    $CustomFieldName = "Location",
    [Parameter()]
    [String]
    $AddressCustomFieldName = "Address"
)

begin {
    function Test-StringEmpty {
        param([string]$Text)
        # Returns true if string is empty, null, or whitespace
        process { [string]::IsNullOrEmpty($Text) -or [string]::IsNullOrWhiteSpace($Text) }
    }
    function Get-NearestCity {
        param (
            [double]$lat,
            [double]$lon,
            [string]$GoogleApi
        )
        try {
            $Response = Invoke-RestMethod -Uri "http://maps.googleapis.com/maps/api/geocode/json?latlng=$lat,$lon&key=$GoogleApi"
        }
        catch {
            throw $Error[0]
        }
        return $Response.results[0].formatted_address
    }
    function Get-WifiNetwork {
        end {
            try {
                netsh.exe wlan sh net mode=bssid | ForEach-Object -Process {
                    if ($_ -match '^SSID (d+) : (.*)$') {
                        $current = @{}
                        $networks += $current
                        $current.Index = $matches[1].trim()
                        $current.SSID = $matches[2].trim()
                    }
                    else {
                        if ($_ -match '^s+(.*)s+:s+(.*)s*$') {
                            $current[$matches[1].trim()] = $matches[2].trim()
                        }
                    }
                } -Begin { $networks = @() } -End { $networks | ForEach-Object { New-Object -TypeName "PSObject" -Property $_ } }    
            }
            catch {
                # return nothing
            }
        }
    }

    # Check if Script Variables are being used
    if (-not $(Test-StringEmpty -Text $env:GoogleApiKey)) {
        $GoogleApiKey = $env:GoogleApiKey
    }
    if (-not $(Test-StringEmpty -Text $env:CustomFieldName)) {
        $CustomFieldName = $env:CustomFieldName
    }
    if (-not $(Test-StringEmpty -Text $env:AddressCustomFieldName)) {
        $AddressCustomFieldName = $env:AddressCustomFieldName
    }
    # Check if api key is set, error if not set
    if ($(Test-StringEmpty -Text $GoogleApiKey)) {
        # Both Parameter and Script Variable are empty
        # Can not combine Parameter "[Parameter(Mandatory)]" and Script Variable Required
        Write-Error "GoogleApiKey is required."
        exit 1
    }

    # Use the system's new line
    $NewLine = $([System.Environment]::NewLine)

    # Build URL with API key
    $Url = "https://www.googleapis.com/geolocation/v1/geolocate?key=$GoogleApiKey"
}
process {
    # Get WIFI network data nearby
    $WiFiData = Get-WifiNetwork |
        Select-Object @{name = 'age'; expression = { 0 } },
        @{name = 'macAddress'; expression = { $_.'BSSID 1' } },
        @{name = 'channel'; expression = { $_.Channel } },
        @{name = 'signalStrength'; expression = { (($_.Signal -replace "%") / 2) - 100 } }

    # Check if we got any number access points
    $Body = if ($WiFiData -and $WiFiData.Count -gt 0) {
        @{
            considerIp       = $true
            wifiAccessPoints = $WiFiData
        } | ConvertTo-Json
    }
    else {
        @{
            considerIp = $true
        } | ConvertTo-Json
    }

    # Get our lat,lng position
    try {
        $Response = Invoke-RestMethod -Method Post -Uri $Url -Body $Body -ContentType "application/json" -ErrorVariable Err
    }
    catch {
        Write-Error $_
        exit 1
    }

    # Save the relevant results to variable that have shorter names
    $Lat = $Response.location.lat
    $Lon = $Response.location.lng

    try {
        # Save Latitude, Longitude to the custom field from the CustomFieldName parameter
        Ninja-Property-Set -Name $CustomFieldName -Value "$Lat,$Lon"
    }
    catch {
        Write-Error "Failed to save to CustomFieldName($CustomFieldName)"
        exit 1
    }

    if ( $(Test-StringEmpty -Text $AddressCustomFieldName) -and $(Test-StringEmpty -Text $env:AddressCustomFieldName)) {
        # Both Parameter and Variable are empty
        Write-Output "$($NewLine)Location: $Lat,$Lon"
    }
    else {
        if ($(Test-StringEmpty -Text $AddressCustomFieldName)) {
            # Parameter was not used
            $AddressCustomFieldName = $env:AddressCustomFieldName
        }

        try {
            # Get City from Google API's
            # Google API: https://developers.google.com/maps/documentation/geocoding/requests-reverse-geocoding
            $Address = Get-NearestCity -lat $Lat -lon $Lon -GoogleApi $GoogleApiKey
        }
        catch {
            Write-Error "Failed to save to get nearest city."
            exit 1
        }

        try {
            # Save Lat and Lon to custom field
            Ninja-Property-Set -Name $AddressCustomFieldName -Value "$Address"
            Write-Output "$($NewLine)Location: $Address`: $Lat,$Lon"
        }
        catch {
            Write-Error "Failed to save to AddressCustomFieldName($AddressCustomFieldName)"
            exit 1
        }
    }
    exit 0
}
end {
    $ScriptVariables = @(
        [PSCustomObject]@{
            name           = "GoogleApiKey"
            calculatedName = "GoogleApiKey"
            required       = $true
            defaultValue   = $null
            valueType      = "TEXT"
            valueList      = $null
            description    = ""
        }
        [PSCustomObject]@{
            name           = "CustomFieldName"
            calculatedName = "CustomFieldName"
            required       = $false
            defaultValue   = [PSCustomObject]@{
                type  = "TEXT"
                value = "Location"
            }
            valueType      = "TEXT"
            valueList      = $null
            description    = ""
        }
    )
}

 

Description détaillée

Le texte peut être divisé en trois grandes parties :

• Initialisation : Le script commence par définir des paramètres tels que GoogleApiKey, CustomFieldName et AddressCustomFieldName. Ces paramètres servent d’entrées pour personnaliser le comportement du script.
• Opérations principales :  la partie principale du script implique de :
• Vérifier les réseaux WiFi disponibles autour de l’appareil.
• Construire une charge utile avec des données WiFi et l’envoyer au service de géolocalisation de Google pour obtenir la latitude et la longitude.
• Rechercher la ville ou l’adresse la plus proche à l’aide des coordonnées obtenues.
• Mettre à jour des champs personnalisés dans NinjaOne avec les données de localisation.
• Opérations finales :  des variables de script (ScriptVariables) sont initialisées pour stocker les données et faciliter les opérations ultérieures.

Cas d’utilisation potentiels

Prenons l’exemple d’un professionnel de l’informatique, Alex, qui travaille pour une grande entreprise. Il a été chargé d’auditer tous les ordinateurs portables dans plusieurs bureaux. À l’aide de ce script, Alex peut rapidement obtenir l’emplacement géographique de chaque ordinateur portable grâce à l’API GeoLocation de Google et s’assurer qu’ils se trouvent bien à l’endroit où ils ont été déclarés.

Comparaisons

L’approche du script s’appuie sur l’API GeoLocation de Google, qui fournit des informations précises sur l’emplacement. D’autres solutions peuvent consister à utiliser les services de localisation natifs de Windows ou d’autres API tierces. Cependant, la vaste quantité de données et l’infrastructure performante de Google en font un choix tout désigné pour ce type d’applications, car elles offrent une meilleure précision et une couverture plus large.

FAQ

• Ce script PowerShell fonctionne-t-il hors ligne ?
  Le script nécessite une connexion internet active pour communiquer avec les services de Google.
• Le nombre de demandes de localisation est-il limité ?
  L’API GeoLocation de Google a des limites basées sur votre type de compte et votre statut de facturation.
• Le script PowerShell ne fonctionne-t-il que sous Windows 10 ?
  Le système d’exploitation minimum requis pour le script est Windows 10.

Implications

Si la possibilité de localiser un appareil constitue un excellent outil pour la gestion des actifs et la sécurité, elle pose également des problèmes de protection de la vie privée. Il est essentiel que les équipes informatiques veillent à ce que cet outil soit utilisé de manière éthique, avec les autorisations et les informations nécessaires. Le suivi non autorisé peut entraîner des violations des lois et réglementations en matière de protection de la vie privée.

Recommandations

• Obtenez toujours une autorisation explicite avant d’exécuter ce script PowerShell sur un appareil.
• Assurez-vous de bien connaître le nombre limite de demandes et les coûts associés à l’API GeoLocation de Google.
• Examinez et auditez régulièrement vos journaux afin de prévenir toute utilisation abusive.

Conclusion

Pour les entreprises MSP et les professionnels de l’informatique, NinjaOne constitue une plateforme précieuse pour centraliser et rationaliser les opérations informatiques. L’intégration de tels scripts pour récupérer l’emplacement des appareils amplifie encore les capacités de NinjaOne, ce qui en fait un outil indispensable pour les environnements informatiques modernes. Les scripts PowerShell, en particulier celui présenté ci-dessus, offrent aux utilisateurs de NinjaOne un niveau supplémentaire de flexibilité et de puissance, les aidant à suivre le rythme d’un monde informatique dynamique.