Améliorez la gestion de système : Script PowerShell pour le déploiement de BGInfo

Points à retenir

• Déploiement automatisé de BGInfo: Le script fournit une méthode transparente et automatisée pour déployer BGInfo sur plusieurs systèmes Windows.
• Efficacité pour les professionnels de l’informatique: Gain de temps et réduction des tâches manuelles pour les professionnels de l’informatique et les fournisseurs de services de gestion de l’information qui gèrent l’affichage des informations sur les systèmes.
• Configuration personnalisable: Permet la personnalisation grâce à un paramètre configurable pour s’adapter à différents environnements et exigences.
• Droits d’administrateur requis: Le script doit être exécuté avec des droits d’administrateur pour pouvoir accéder aux répertoires du système et modifier les paramètres.
• Traitement des erreurs et robustesse: Comprend un traitement complet des erreurs, garantissant la fiabilité et une communication claire pendant l’exécution.
• Sensibilisation à la sécurité: Il est important d’être conscient des informations affichées par BGInfo pour éviter d’exposer des données sensibles.
• Évolutivité et cohérence: Assure l’uniformité de l’affichage des informations du système sur toutes les machines d’une organisation.
• Compatibilité avec les systèmes Windows modernes: Prend principalement en charge Windows 10 et Windows Server 2016 et les versions ultérieures.
• Complémentaire à des outils informatiques complets: Fonctionne bien en conjonction avec des plateformes de gestion informatique plus larges comme NinjaOne pour une visibilité et un contrôle accrus.

Dans le paysage en constante évolution des technologies de l’information, une gestion et une configuration efficaces des systèmes informatiques sont cruciales. BGInfo, un outil réputé dans l’environnement Windows, joue un rôle essentiel à cet égard. Cet outil affiche les informations essentielles du système sur l’arrière-plan du bureau, ce qui s’avère inestimable pour les professionnels de l’informatique et les fournisseurs de services gérés (MSP). Aujourd’hui, nous explorons un script PowerShell conçu pour l’installation et la configuration transparentes de BGInfo sur les systèmes Windows.

Contexte

BGInfo, qui fait partie de la suite Sysinternals, est un outil indispensable aux professionnels de l’informatique depuis des années. Il affiche sur le bureau des informations sur le système telles que l’adresse IP, le nom de l’ordinateur et la version du système d’exploitation, ce qui permet d’avoir un aperçu rapide de la configuration du système. Dans un monde où l’accès rapide aux informations et la surveillance du système sont essentiels, l’automatisation du déploiement de BGInfo à l’aide d’un script PowerShell est à la fois un gain de temps et d’efficacité, en particulier pour les professionnels de l’informatique et les MSP qui gèrent plusieurs machines.

Le script :

#Requires -Version 2.0

<#
.SYNOPSIS
    Downloads, installs and sets up BGInfo to run for all users.
.DESCRIPTION
    Downloads, installs and sets up BGInfo to run for all users.
    Uses the default configuration if no .bgi file path or URL is specified.

    Note: Users that are already logged in will need to logout and login to have BGInfo update their desktop background.

.EXAMPLE
    (No Parameters)
    ## EXAMPLE OUTPUT WITHOUT PARAMS ##
    Create Directory: C:\WINDOWS\System32\SysInternals
    Downloading https://live.sysinternals.com/Bginfo.exe
    Created Shortcut: C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Startup\BGInfo.lnk

.EXAMPLE
    -Config C:\BGInfo\config.bgi
    Specifies the BGInfo configuration file to use.

PARAMETER: -Config C:\BGInfo\config.bgi
    ## EXAMPLE OUTPUT WITHOUT PARAMS ##
    Create Directory: C:\WINDOWS\System32\SysInternals
    Downloading https://live.sysinternals.com/Bginfo.exe
    Created Shortcut: C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Startup\BGInfo.lnk
.OUTPUTS
    None
.NOTES
    Minimum OS Architecture Supported: Windows 10, Windows Server 2016
    Release Notes: Renamed script and added Script Variable support
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]$Config
)

begin {
    if ($env:bginfoConfigFilePath -and $env:bginfoConfigFilePath -notlike "null") { $Config = $env:bginfoConfigFilePath }
    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 New-Shortcut {
        [CmdletBinding()]
        param(
            [Parameter()]
            [String]$Arguments,
            [Parameter()]
            [String]$IconPath,
            [Parameter(ValueFromPipeline = $True)]
            [String]$Path,
            [Parameter()]
            [String]$Target,
            [Parameter()]
            [String]$WorkingDir
        )
        process {
            Write-Host "Creating Shortcut at $Path"
            $ShellObject = New-Object -ComObject ("WScript.Shell")
            $Shortcut = $ShellObject.CreateShortcut($Path)
            $Shortcut.TargetPath = $Target
            if ($WorkingDir) { $Shortcut.WorkingDirectory = $WorkingDir }
            if ($Arguments) { $ShortCut.Arguments = $Arguments }
            if ($IconPath) { $Shortcut.IconLocation = $IconPath }
            $Shortcut.Save()

            if (!(Test-Path $Path -ErrorAction SilentlyContinue)) {
                Write-Error "Unable to create Shortcut at $Path"
                exit 1
            }
        }
    }
    # Utility function for downloading files.
    function Invoke-Download {
        param(
            [Parameter()]
            [String]$URL,
            [Parameter()]
            [String]$Path,
            [Parameter()]
            [int]$Attempts = 3,
            [Parameter()]
            [Switch]$SkipSleep
        )
        Write-Host "URL given, Downloading the file..."

        $SupportedTLSversions = [enum]::GetValues('Net.SecurityProtocolType')
        if ( ($SupportedTLSversions -contains 'Tls13') -and ($SupportedTLSversions -contains 'Tls12') ) {
            [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol::Tls13 -bor [System.Net.SecurityProtocolType]::Tls12
        }
        elseif ( $SupportedTLSversions -contains 'Tls12' ) {
            [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.SecurityProtocolType]::Tls12
        }
        else {
            # Not everything requires TLS 1.2, but we'll try anyway.
            Write-Warning "TLS 1.2 and or TLS 1.3 are not supported on this system. This download may fail!"
            if ($PSVersionTable.PSVersion.Major -lt 3) {
                Write-Warning "PowerShell 2 / .NET 2.0 doesn't support TLS 1.2."
            }
        }

        $i = 1
        While ($i -le $Attempts) {
            # Some cloud services have rate-limiting
            if (-not ($SkipSleep)) {
                $SleepTime = Get-Random -Minimum 3 -Maximum 15
                Write-Host "Waiting for $SleepTime seconds."
                Start-Sleep -Seconds $SleepTime
            }
        
            if ($i -ne 1) { Write-Host "" }
            Write-Host "Download Attempt $i"

            try {
                # Invoke-WebRequest is preferred because it supports links that redirect, e.g., https://t.ly
                if ($PSVersionTable.PSVersion.Major -lt 4) {
                    # Downloads the file
                    $WebClient = New-Object System.Net.WebClient
                    $WebClient.DownloadFile($URL, $Path)
                }
                else {
                    # Standard options
                    $WebRequestArgs = @{
                        Uri                = $URL
                        OutFile            = $Path
                        MaximumRedirection = 10
                        UseBasicParsing    = $true
                    }

                    # Downloads the file
                    Invoke-WebRequest @WebRequestArgs
                }

                $File = Test-Path -Path $Path -ErrorAction SilentlyContinue
            }
            catch {
                Write-Warning "An error has occurred while downloading!"
                Write-Warning $_.Exception.Message

                if (Test-Path -Path $Path -ErrorAction SilentlyContinue) {
                    Remove-Item $Path -Force -Confirm:$false -ErrorAction SilentlyContinue
                }

                $File = $False
            }

            if ($File) {
                $i = $Attempts
            }
            else {
                Write-Warning "File failed to download."
                Write-Host ""
            }

            $i++
        }

        if (-not (Test-Path $Path)) {
            throw "Failed to download file!"
        }
        else {
            Write-Host "Download Successful!"
        }
    }

    function Install-SysInternalsTool {
        [CmdletBinding()]
        param()
        # Target directory is %WinDir%C:\Windows\System32\SysInternals
        $TargetDir = Join-Path -Path $env:WinDir -ChildPath "System32\SysInternals"

        # Tools to be downloaded
        $Tools = @(
            [PSCustomObject]@{
                Name     = "Bginfo"
                FileName = "Bginfo.exe"
                URL      = "https://live.sysinternals.com/Bginfo.exe"
            }
        )

        # Create Directory
        if (-not $(Test-Path $TargetDir -ErrorAction SilentlyContinue)) {
            Write-Host "Create Directory: $TargetDir"
            New-Item -ItemType Directory -Path $TargetDir -Force -ErrorAction SilentlyContinue
        }

        # Download tools to target directory
        try {
            foreach ($Tool in $Tools) {
                $FilePath = Join-Path $TargetDir $Tool.FileName
                Write-Host "Downloading $($Tool.Name) to $FilePath"
                Invoke-Download -URL $Tool.URL -Path $FilePath
            }
        }
        catch {
            throw $_
        }
    }
    function Register-BGInfoStartup {
        [CmdletBinding()]
        param(
            [Parameter()][string]$Config
        )
        $ExePath = Join-Path -Path $env:WinDir -ChildPath "System32\SysInternals\BGInfo.exe"
        if (-not $(Test-Path -Path $ExePath -ErrorAction SilentlyContinue)) {
            throw "BGInfo.exe is not found at $ExePath"
        }

        # Register Startup command for All User
        try {
            $StartupPath = Join-Path -Path $env:ProgramData -ChildPath "Microsoft\Windows\Start Menu\Programs\StartUp\StartupBGInfo.lnk"
            
            if ($(Test-Path -Path $StartupPath -ErrorAction SilentlyContinue)) {
                Remove-Item -Path $StartupPath -ErrorAction SilentlyContinue
            }
            if ($Config -and $(Test-Path -Path $Config -ErrorAction SilentlyContinue)) {
                New-Shortcut -Path $StartupPath -Arguments "/iq `"$Config`" /accepteula /timer:0 /silent" -Target $ExePath
            }
            else {
                New-Shortcut -Path $StartupPath -Arguments "/accepteula /timer:0 /silent" -Target $ExePath
            }

            Write-Host "Created Startup: $StartupPath"
        }
        catch {
            throw "Unable to create shortcut for BGInfo.exe"
        }
    }
}
process {
    if (-not (Test-IsElevated)) {
        Write-Error -Message "Access Denied. Please run with Administrator privileges."
        exit 1
    }

    try {
        Install-SysInternalsTool

        if ($Config) {
            if (-not $(Test-Path -Path $Config -ErrorAction SilentlyContinue)) {
                try {
                    if (-not (Test-Path -Path "$Env:PROGRAMDATA\SysInternals" -ErrorAction SilentlyContinue)) {
                        New-Item -ItemType Directory -Path "$Env:PROGRAMDATA\SysInternals" -Force
                    }
                    Invoke-Download -URL $Config -Path $(Join-Path -Path $env:PROGRAMDATA -ChildPath "SysInternals\bginfoConfig.bgi")
                    $Config = $(Join-Path -Path $env:PROGRAMDATA -ChildPath "SysInternals\bginfoConfig.bgi")
                }
                catch {
                    Write-Error "Failed to download from provided Url or that the Path to the specified file does not exist."
                    Write-Error $_
                    exit 1
                }
            }
            Register-BGInfoStartup -Config $Config
        }
        else {
            Register-BGInfoStartup
        }
    }
    catch {
        Write-Error $_
        exit 1
    }

    Write-Host "Successfully installed and set up bginfo. Bginfo will start the next time the end user logs in or restarts."
    exit 0
}
end {
    
    
    
}

 

Description détaillée

Le script opère en plusieurs étapes :

• Configuration des paramètres: Il commence par permettre à l’utilisateur de spécifier un fichier de configuration à l’aide du paramètre $Config. Si aucun chemin d’accès à un fichier de configuration spécifique n’est indiqué, la configuration standard est utilisée par défaut.
• Vérification de l’élévation: Le script vérifie s’il s’exécute avec des privilèges d’administrateur, ce qui est essentiel pour accéder aux répertoires du système et modifier les paramètres de démarrage.
• Téléchargement et installation de BGInfo: Le script crée un répertoire à C:\WINDOWS\System32\SysInternals et télécharge BGInfo à partir du site officiel de Sysinternals. Il gère les problèmes potentiels de téléchargement, tels que l’incompatibilité TLS et la logique de réessai.
• Configuration du raccourci de démarrage: Le script crée un raccourci dans le dossier de démarrage commun. Cela permet de s’assurer que BGInfo s’exécute pour tous les utilisateurs lors de la connexion. Il peut utiliser un fichier de configuration spécifié ou des paramètres par défaut.
• Gestion des erreurs: Tout au long du processus, le script comprend une gestion robuste des erreurs, garantissant que tout problème est clairement communiqué à l’utilisateur.

Cas d’utilisation potentiels

Considérons un scénario dans lequel un MSP doit déployer BGInfo sur un parc de machines Windows dans un environnement d’entreprise. Ce script automatise le processus, réduisant les interventions manuelles et garantissant l’uniformité de la configuration de BGInfo sur tous les systèmes.

Comparaisons

Traditionnellement, le déploiement de BGInfo impliquait une installation et une configuration manuelles sur chaque machine. Ce script permet non seulement de gagner du temps, mais aussi de réduire la probabilité d’une erreur humaine. Il s’agit d’une approche plus évolutive et plus fiable que le déploiement manuel.

FAQ

• Ce script peut-il être adapté à différentes configurations ?
  Oui, en modifiant le paramètre $Config.
• Ce script fonctionne-t-il sur toutes les versions de Windows ?
  Il prend en charge Windows 10 et Windows Server 2016 et les versions plus récentes.

Implications

Bien que le script simplifie le déploiement, il est important d’être conscient des implications en matière de sécurité. Il est essentiel de veiller à ce que la configuration de BGInfo n’expose pas par inadvertance des informations sensibles sur l’arrière-plan du bureau.

Recommandations

• Testez toujours le script dans un environnement contrôlé avant de le déployer à grande échelle.
• Mettez régulièrement à jour le script pour tenir compte des nouvelles mises à jour de Windows et des versions de Sysinternals.
• Soyez prudent quant aux informations affichées par BGInfo, compte tenu du contexte de sécurité de votre environnement.

Conclusion :

Dans le contexte de la gestion et de la surveillance des systèmes, des outils comme NinjaOne peuvent compléter des scripts de ce type en fournissant uneplate-forme complète pour la gestion informatique. NinjaOne offre une gamme de fonctionnalités qui s’ajoutent aux informations fournies par BGInfo, améliorant ainsi la visibilité et le contrôle de l’ensemble de l’infrastructure informatique.