Script PowerShell per distribuire BGInfo: semplifica la gestione del sistema

Punti chiave

  • Distribuzione automatizzata di BGInfo: Lo script fornisce un metodo automatizzato per distribuire BGInfo su più sistemi Windows.
  • Efficienza per i professionisti IT: Lo script per distribuire BGInfo fa risparmiare tempo e riduce l’impegno manuale dei professionisti IT e degli MSP che gestiscono le visualizzazioni delle informazioni di sistema.
  • Configurazione personalizzabile: Lo script per distribuire BGInfo consente la personalizzazione attraverso un parametro configurabile per adattarsi a diversi ambienti e requisiti.
  • Sono richiesti privilegi amministrativi: Lo script per distribuire BGInfo deve essere eseguito con i diritti di amministratore per accedere alle directory di sistema e modificare le impostazioni.
  • Gestione degli errori e affidabilità: Lo script per distribuire BGInfo include una gestione completa degli errori, che garantisce affidabilità e comunicazione chiara durante l’esecuzione.
  • Essere consapevoli delle implicazioni di sicurezza: È importante prestare attenzione alle informazioni visualizzate da BGInfo per evitare di esporre dati sensibili.
  • Scalabilità e coerenza: Lo script per distribuire BGInfo assicura l’uniformità della visualizzazione delle informazioni di sistema su tutti i dispositivi di un’organizzazione.
  • Compatibilità con i moderni sistemi Windows: Lo script per distribuire BGInfo supporta principalmente Windows 10 e Windows Server 2016 e versioni successive.
  • Complementare a piattaforme IT complete: Lo script per distribuire BGInfo funziona bene in combinazione con piattaforme di gestione IT più ampie, come NinjaOne, per una maggiore visibilità e controllo.

Nel panorama in continua evoluzione delle tecnologie informatiche, la gestione e la configurazione efficienti dei sistemi IT sono fondamentali. BGInfo, uno strumento rinomato nell’ambiente Windows, svolge un ruolo fondamentale in questo ambito. Questo strumento visualizza le informazioni essenziali del sistema sullo sfondo del desktop, rivelandosi prezioso per i professionisti IT e i fornitori di servizi gestiti (MSP). Oggi esploriamo uno script PowerShell progettato per installare e distribuire BGInfo in ambiente Windows.

Background

BGInfo, parte della suite Sysinternals, è da anni un punto fermo negli strumenti dei professionisti IT. Visualizza sul desktop informazioni sul sistema come l’indirizzo IP, il nome del computer e la versione del sistema operativo, fornendo una rapida visione d’insieme delle configurazioni del sistema. In un mondo in cui l’accesso rapido alle informazioni e il monitoraggio del sistema sono fondamentali, l’automazione della distribuzione di BGInfo mediante uno script PowerShell rappresenta un risparmio di tempo e un aumento dell’efficienza, soprattutto per i professionisti IT e gli MSP che gestiscono più macchine.

Lo script per distribuire BGInfo:

#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/it/condizioni-utilizzo
    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 {
    
    
    
}

 

Accedi a oltre 700 script nel Dojo NinjaOne

Ottieni l’accesso

Analisi dettagliata dello script per distribuire BGInfo

Lo script per distribuire BGInfo opera in diverse fasi:

  • Configurazione dei parametri: Lo script per distribuire BGInfo inizia consentendo all’utente di specificare un file di configurazione attraverso il parametro $Config. Se non viene fornito un percorso specifico per il file di configurazione, viene impostato con un’impostazione standard.
  • Controllo dell’elevazione: Lo script per distribuire BGInfo controlla se è in esecuzione con i privilegi di amministratore, essenziali per accedere alle directory di sistema e modificare le impostazioni di avvio.
  • Scaricare e installare BGInfo: Lo script per distribuire BGInfo crea una directory in C:\WINDOWS\System32\SysInternals e scarica BGInfo dal sito ufficiale di Sysinternals. Gestisce i potenziali problemi di download, come l’incompatibilità TLS e la logica di ripetizione del tentativo di installazione.
  • Impostazione del collegamento di avvio: Lo script per distribuire BGInfo crea un collegamento nella cartella di avvio comune. In questo modo BGInfo viene eseguito per tutti gli utenti al momento dell’accesso. Può utilizzare un file di configurazione specificato o le impostazioni predefinite.
  • Gestione degli errori: Lo script per distribuire BGInfo include una solida gestione degli errori, per garantire che qualsiasi problema venga comunicato chiaramente all’utente.

Casi d’uso potenziali

Immagina uno scenario in cui un MSP deve distribuire BGInfo su un certo numero di dispositivi Windows in un ambiente aziendale. Questo script automatizza il processo per distribuire BGInfo, riducendo l’intervento manuale e garantendo l’uniformità della configurazione di BGInfo in tutti i sistemi.

Confronti

Tradizionalmente, distribuire BGInfo comporta l’installazione e la configurazione manuale su ogni macchina. Questo script per distribuire BGInfo non solo fa risparmiare tempo, ma riduce anche la probabilità di errore umano. È un approccio più scalabile e affidabile rispetto alla distribuzione manuale.

Domande frequenti

  • Questo script per distribuire BGInfo può essere personalizzato per diverse configurazioni?
    Sì, modificando il parametro $Config.
  • Questo script per distribuire BGInfo funziona su tutte le versioni di Windows?
    Supporta Windows 10 e Windows Server 2016 e versioni successive.

Implicazioni

Sebbene questo script semplifichi la distribuzione, è importante essere consapevoli delle implicazioni per la sicurezza. È fondamentale garantire BGInfo non sia configurato per mostrare inavvertitamente informazioni sensibili sullo sfondo del desktop.

Raccomandazioni

  • Testa sempre lo script per distribuire BGInfo in un ambiente controllato prima di distribuirlo su larga scala.
  • Aggiorna regolarmente lo script per distribuire BGInfo per adattarlo ai nuovi aggiornamenti di Windows e alle versioni di Sysinternals.
  • Presta attenzione alle informazioni visualizzate da BGInfo, tenendo conto del contesto di sicurezza dell’ambiente.

Considerazioni finali

Nel contesto della gestione e del monitoraggio dei sistemi, strumenti come NinjaOne possono integrare script come questo, fornendo una piattaforma completa per la gestione IT. NinjaOne offre una serie di funzionalità che si integrano con le informazioni fornite da BGInfo, migliorando la visibilità e il controllo dell’infrastruttura IT nel suo complesso.

Passi successivi

La creazione di un team IT efficiente ed efficace richiede una soluzione centralizzata che funga da principale strumento per la fornitura di servizi. NinjaOne consente ai team IT di monitorare, gestire, proteggere e supportare tutti i dispositivi, ovunque essi si trovino, senza la necessità di una complessa infrastruttura locale.

Per saperne di più su NinjaOne Endpoint Management, fai un tour dal vivo, o inizia la tua prova gratuita della piattaforma NinjaOne.

Categorie:

Ti potrebbe interessare anche

Guarda una demo×
×

Guarda NinjaOne in azione!

Inviando questo modulo, accetto La politica sulla privacy di NinjaOne.

Termini e condizioni NinjaOne

Cliccando sul pulsante “Accetto” qui sotto, dichiari di accettare i seguenti termini legali e le nostre condizioni d’uso:

  • Diritti di proprietà: NinjaOne possiede e continuerà a possedere tutti i diritti, i titoli e gli interessi relativi allo script (compreso il copyright). NinjaOne ti concede una licenza limitata per l’utilizzo dello script in conformità con i presenti termini legali.
  • Limitazione d’uso: Puoi utilizzare lo script solo per legittimi scopi personali o aziendali interni e non puoi condividere lo script con altri soggetti.
  • Divieto di ripubblicazione: In nessun caso ti è consentito ripubblicare lo script in una libreria di script appartenente o sotto il controllo di un altro fornitore di software.
  • Esclusione di garanzia: Lo script viene fornito “così com’è” e “come disponibile”, senza garanzie di alcun tipo. NinjaOne non promette né garantisce che lo script sia privo di difetti o che soddisfi le tue esigenze o aspettative specifiche.
  • Assunzione del rischio: L’uso che farai dello script è da intendersi a tuo rischio. Riconosci che l’utilizzo dello script comporta alcuni rischi intrinseci, che comprendi e sei pronto ad assumerti.
  • Rinuncia e liberatoria: Non riterrai NinjaOne responsabile di eventuali conseguenze negative o indesiderate derivanti dall’uso dello script e rinuncerai a qualsiasi diritto legale o di equità e a qualsiasi rivalsa nei confronti di NinjaOne in relazione all’uso dello script.
  • EULA: Se sei un cliente NinjaOne, l’uso dello script è soggetto al Contratto di licenza con l’utente finale (EULA) applicabile.