Automatizzare la creazione di collegamenti sul desktop remoto con PowerShell

Punti chiave

• Creazione automatica di collegamenti: Lo script PowerShell automatizza la creazione di collegamenti RDP, facendo risparmiare tempo e riducendo gli errori manuali.
• Opzioni personalizzabili: Permette un’ampia personalizzazione, tra cui le impostazioni di visualizzazione, le credenziali utente e le configurazioni dei gateway.
• Scalabilità per ambienti di grandi dimensioni: Ideale per gli MSP e i reparti IT che gestiscono numerose connessioni remote.
• Requisito dei diritti amministrativi: Richiede privilegi amministrativi per alcune operazioni, garantendo la sicurezza.
• Gestione dei conflitti: Include controlli per le opzioni in conflitto, guidando gli utenti verso la configurazione ottimale.
• Attenzione alla sicurezza: Privilegia la gestione sicura delle credenziali e la distribuzione dei collegamenti.
• Maggiore produttività: Semplifica il processo di gestione dei desktop remoti, migliorando la produttività IT complessiva.
• Strumenti complementari: Può essere efficacemente abbinato a piattaforme di gestione come NinjaOne per soluzioni IT complete.

I collegamenti al Remote Desktop Protocol (RDP) sono strumenti importanti nel mondo IT, in quanto consentono di connettersi senza problemi ai sistemi remoti. In seguito all’evoluzione degli ambienti di rete e alla crescente necessità di un accesso remoto efficiente, la capacità di creare e gestire rapidamente questi collegamenti diventa un fattore essenziale. Questo script, realizzato in PowerShell, offre un approccio semplificato e personalizzabile alla creazione di collegamenti RDP, migliorando la produttività dei professionisti IT e dei Managed Service Provider (MSP). 

Background e significato dello script PowerShell

Inizialmente, la creazione e la gestione di collegamenti RDP richiedeva processi manuali, che potevano richiedere molto tempo ed essere soggetti a errori, soprattutto in ambienti IT dinamici o su larga scala. Il presente script PowerShell affronta questa sfida automatizzando la creazione di collegamenti al desktop RDP con parametri definiti dall’utente. Tale automazione è particolarmente vantaggiosa per i team IT che gestiscono diverse connessioni remote e per gli MSP che devono implementare rapidamente soluzioni di accesso remoto per i loro clienti.

Lo script per la creazione di collegamenti RDP:

<#
.SYNOPSIS
    This script will create an rdp desktop shortcut with your specified options. It can create a shortcut for all users (including new ones) or existing ones only.
.DESCRIPTION
    This script will create an rdp desktop shortcut with your specified options. 
    It can create a shortcut for all users (including new ones) or existing ones only.
.EXAMPLE
    To Create a windowed RDP Shortcut simply specify the size, the name of the shortcut and which users the shortcut is for. You can also specify "MultiMon" for multi-monitor support. Or a gateway to use.
    
    PS C:> ./Create-DesktopShortcut.ps1 -Name "Test" -RDPTarget "SRV19-TEST" -RDPUser "TESTjsmith" -Width "1920" -Height "1080" -AllExistingUsers -ExcludeUsers "ChrisWashington,JohnLocke"
    
    Creating Shortcut at C:UsersJohnSmithDesktopTest.rdp

.PARAMETER NAME
    Name of the shortcut ex. "Login Portal".

.PARAMETER RDPtarget
    IP Address or DNS Name and port to the RDS Host ex. "TEST-RDSH:28665".

.PARAMETER RDPuser
    Username to autofill in username field.

.PARAMETER AlwaysPrompt 
    Always Prompt for credentials.

.PARAMETER Gateway
    IP Address or DNS Name and port of the RD Gateway ex. "TESTrdp.example.com:4433".

.PARAMETER SeperateGateWayCreds
    If the RDS Gateway uses different creds than the Session Host use this parameter.

.PARAMETER FullScreen
    RDP Shortcut should open window in 'FullScreen' mode.

.PARAMETER MultiMon
    RDP Shortcut should open window with Multi-Monitor Support enabled.

.PARAMETER Width
    Width of RDP Window should open ex. "1920".

.PARAMETER Height
    Height of RDP Window shortcut should open ex. "1080".

.PARAMETER AllExistingUsers
    Create the Shortcut for all existing users but not new users ex. C:Users*Desktopshortcut.lnk.

.PARAMETER ExcludeUsers
    Comma seperated list of users to exclude from shortcut placement.

.PARAMETER AllUsers
    Create the Shortcut in C:UsersPublicDesktop.

.OUTPUTS
    None
.NOTES
    Minimum OS Architecture Supported: Windows 7, Windows Server 2008
    Release Notes: Renamed script, Split script into three, added Script Variable support, fixed bugs in RDP Shortcut
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]$Name,
    [Parameter()]
    [String]$RDPtarget,
    [Parameter()]
    [String]$RDPuser,
    [Parameter()]
    [Switch]$AlwaysPrompt = [System.Convert]::ToBoolean($env:alwaysPromptForRdpCredentials),
    [Parameter()]
    [String]$Gateway,
    [Parameter()]
    [Switch]$SeparateGateWayCreds = [System.Convert]::ToBoolean($env:separateRdpGatewayCredentials),
    [Parameter()]
    [Switch]$FullScreen,
    [Parameter()]
    [Switch]$MultiMon,
    [Parameter()]
    [Int]$Width,
    [Parameter()]
    [Int]$Height,
    [Parameter()]
    [Switch]$AllExistingUsers,
    [Parameter()]
    [Switch]$AllUsers
)

begin {

    # Replace existing params with form variables if they're used.
    if ($env:shortcutName -and $env:shortcutName -notlike "null") { $Name = $env:shortcutName }
    if ($env:createTheShortcutFor -and $env:createTheShortcutFor -notlike "null") { 
        if ($env:createTheShortcutFor -eq "All Users") { $AllUsers = $True }
        if ($env:createTheShortcutFor -eq "All Existing Users") { $AllExistingUsers = $True }
    }
    if ($env:rdpServerAddress -and $env:rdpServerAddress -notlike "null") { $RDPtarget = $env:rdpServerAddress }
    if ($env:rdpUsername -and $env:rdpUsername -notlike "null") { $RDPuser = $env:rdpUsername }
    if ($env:rdpGatewayServerAddress -and $env:rdpGatewayServerAddress -notlike "null") { $Gateway = $env:rdpGatewayServerAddress }
    if ($env:rdpWindowSize -and $env:rdpWindowSize -notlike "null") {
        if ($env:rdpWindowSize -eq "Fullscreen Multiple Monitor Mode") { $MultiMon = $True }
        if ($env:rdpWindowSize -eq "Fullscreen") { $FullScreen = $True }
    }
    if ($env:customRdpWindowWidth -and $env:customRdpWindowWidth -notlike "null") { $Width = $env:customRdpWindowWidth }
    if ($env:customRdpWindowHeight -and $env:customRdpWindowHeight -notlike "null") { $Height = $env:customRdpWindowHeight }

    # Output warnings for conflicting options.
    if (($Width -and -not $Height ) -or ($Height -and -not $Width)) {
        Write-Warning "You forgot to include both the width and height. RDP Window will be in fullscreen mode."
    }

    if (($Width -or $Height) -and ($FullScreen -or $MultiMon)) {
        if ($MultiMon) {
            Write-Warning "Conflicting Display Option selected. Using Fullscreen Multi-monitor."
        }
        else {
            Write-Warning "Conflicting Display Option selected. Using Fullscreen."
        }
    }

    # Double-check that a user is specified for shortcut creation.
    if (-not $AllUsers -and -not $AllExistingUsers -and -not $User) {
        Write-Error "You must specify which desktop to create the shortcut on!"
        exit 1
    }

    # Double-check that a shortcut name was provided.
    if (-not $Name -or -not $RDPtarget) {
        Write-Error "You must specify a name and target for the shortcut!"
        exit 1
    }

    # Creating a shortcut at C:UsersPublicDesktop requires admin rights.
    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 (!(Test-IsElevated)) {
        Write-Error -Message "Access Denied. Please run with Administrator privileges."
        exit 1
    }

    # Retrieve all registry paths for actual users (excluding system or network service accounts).
    function Get-UserHives {
        param (
            [Parameter()]
            [ValidateSet('AzureAD', 'DomainAndLocal', 'All')]
            [String]$Type = "All",
            [Parameter()]
            [String[]]$ExcludedUsers,
            [Parameter()]
            [switch]$IncludeDefault
        )

        # User account SIDs follow a particular pattern depending on whether they're Azure AD, Domain, or local "workgroup" accounts.
        $Patterns = switch ($Type) {
            "AzureAD" { "S-1-12-1-(d+-?){4}$" }
            "DomainAndLocal" { "S-1-5-21-(d+-?){4}$" }
            "All" { "S-1-12-1-(d+-?){4}$" ; "S-1-5-21-(d+-?){4}$" } 
        }

        # We'll need the NTuser.dat file to load each users registry hive. So we grab it if their account sid matches the above pattern. 
        $UserProfiles = Foreach ($Pattern in $Patterns) { 
            Get-ItemProperty "HKLM:SOFTWAREMicrosoftWindows NTCurrentVersionProfileList*" |
                Where-Object { $_.PSChildName -match $Pattern } | 
                Select-Object @{Name = "SID"; Expression = { $_.PSChildName } }, 
                @{Name = "UserHive"; Expression = { "$($_.ProfileImagePath)NTuser.dat" } }, 
                @{Name = "UserName"; Expression = { "$($_.ProfileImagePath | Split-Path -Leaf)" } },
                @{Name = "Path"; Expression = { $_.ProfileImagePath } }
        }

        # In some cases, it's necessary to retrieve the .Default user's information.
        switch ($IncludeDefault) {
            $True {
                $DefaultProfile = "" | Select-Object UserName, SID, UserHive, Path
                $DefaultProfile.UserName = "Default"
                $DefaultProfile.SID = "DefaultProfile"
                $DefaultProfile.Userhive = "$env:SystemDriveUsersDefaultNTUSER.DAT"
                $DefaultProfile.Path = "C:UsersDefault"

                $DefaultProfile | Where-Object { $ExcludedUsers -notcontains $_.UserName }
            }
        }

        $UserProfiles | Where-Object { $ExcludedUsers -notcontains $_.UserName }
    }
}
process {
    $ShortcutPath = New-Object System.Collections.Generic.List[String]

    # Create the filenames for the path.
    if ($RDPTarget) { $File = "$Name.rdp" }

    # Build the paths and add them to the ShortcutPath list.
    if ($AllUsers) { $ShortcutPath.Add("$env:PublicDesktop$File") }

    if ($AllExistingUsers) {
        $UserProfiles = Get-UserHives
        # Loop through each user profile
        $UserProfiles | ForEach-Object { $ShortcutPath.Add("$($_.Path)Desktop$File") }
    }

    if ($User) { 
        $UserProfile = Get-UserHives | Where-Object { $_.Username -like $User }
        $ShortcutPath.Add("$($UserProfile.Path)Desktop$File")
    }

    $RDPFile = New-Object System.Collections.Generic.List[String]

    # Base template of an .RDP file. Additional options will be appended based on user selection.
    $Template = @"
session bpp:i:32
compression:i:1
keyboardhook:i:2
audiocapturemode:i:0
videoplaybackmode:i:1
connection type:i:7
networkautodetect:i:1
bandwidthautodetect:i:1
displayconnectionbar:i:1
enableworkspacereconnect:i:0
disable wallpaper:i:0
allow font smoothing:i:0
allow desktop composition:i:0
disable full window drag:i:1
disable menu anims:i:1
disable themes:i:0
disable cursor setting:i:0
bitmapcachepersistenable:i:1
audiomode:i:0
redirectprinters:i:1
redirectcomports:i:0
redirectsmartcards:i:1
redirectwebauthn:i:1
redirectclipboard:i:1
redirectposdevices:i:0
autoreconnection enabled:i:1
authentication level:i:2
negotiate security layer:i:1
remoteapplicationmode:i:0
alternate shell:s:
shell working directory:s:
gatewaycredentialssource:i:4
gatewaybrokeringtype:i:0
use redirection server name:i:0
rdgiskdcproxy:i:0
kdcproxyname:s:
enablerdsaadauth:i:0
"@
    $RDPFile.Add($Template)

    # This will generate the actual .rdp file
    $ShortcutPath | ForEach-Object {
        $RDPFile.Add("full address:s:$RDPTarget")
        $RDPFile.Add("gatewayhostname:s:$Gateway")

        if ($Width) { $RDPFile.Add("desktopwidth:i:$Width") }
        if ($Height) { $RDPFile.Add("desktopheight:i:$Height") }
        if ($MultiMon) { $RDPFile.Add("use multimon:i:1") }else { $RDPFile.Add("use multimon:i:0") }
        if ($FullScreen -or $MultiMon -or !$Height -or !$Width) { $RDPFile.Add("screen mode id:i:2") }else { $RDPFile.Add("screen mode id:i:1") }
        if ($AlwaysPrompt) { $RDPFile.Add("prompt for credentials:i:1") }else { $RDPFile.Add("prompt for credentials:i:0") }
        if ($Gateway) { $RDPFile.Add("gatewayusagemethod:i:2") }else { $RDPFile.Add("gatewayusagemethod:i:4") }
        if ($SeparateGateWayCreds) { 
            $RDPFile.Add("promptcredentialonce:i:0")
            $RDPFile.Add("gatewayprofileusagemethod:i:1")  
        }
        else { 
            $RDPFile.Add("promptcredentialonce:i:1") 
            if ($Gateway) { $RDPFile.Add("gatewayprofileusagemethod:i:0") }
        }
            
        if ($RDPUser) { $RDPFile.Add("username:s:$RDPUser") }

        Write-Host "Creating Shortcut at $_"
        $RDPFile | Out-File $_

        if (!(Test-Path $_ -ErrorAction SilentlyContinue)) {
            Write-Error "Unable to create Shortcut at $_"
            exit 1
        }
    }

    exit 0
}end {
    
    
    
}

 

Esplorare lo script: una descrizione dettagliata

Lo script inizia con una sinossi e una descrizione che forniscono una chiara panoramica delle sue funzionalità. Quindi delinea parametri come il nome del collegamento, il server RDP di destinazione, le credenziali dell’utente, le opzioni di visualizzazione (come il supporto a schermo intero o a più monitor) e la scelta di creare collegamenti per tutti gli utenti o per utenti specifici.

• Definizione dei parametri: Lo script definisce vari parametri che consentono di personalizzare il collegamento RDP. Questi includono dettagli di base come il nome del collegamento, la destinazione RDP e l’utente, oltre a opzioni più avanzate come la dimensione della finestra, il supporto a più monitor e la configurazione del gateway.
• Variabili d’ambiente e controllo dei conflitti: Lo script controlla e sostituisce i parametri con variabili d’ambiente, se disponibili. Inoltre, emette degli avvisi in caso di opzioni contrastanti, come nel caso in cui si specifichino sia le dimensioni del fullscreen che quelle della finestra.
• Gestione dei diritti amministrativi e dei profili utente: Lo script include una funzione per verificare la presenza di diritti amministrativi, necessari per creare collegamenti in determinati percorsi di directory. Contiene anche una funzione per il recupero dei profili utente, esclusi gli account di sistema, il che è fondamentale per distribuire i collegamenti a specifici desktop utente.
• Il processo di creazione di collegamenti RDP: Lo script genera il file .RDP, aggiungendo le opzioni selezionate dall’utente a un modello di base. Quindi itera attraverso i percorsi di collegamento determinati, creando il file RDP in ogni posizione.

Casi d’uso potenziali: Un’applicazione concreta

Immagina un MSP responsabile della gestione dell’accesso remoto per un’azienda con diversi reparti, ognuno dei quali richiede configurazioni RDP specifiche. Utilizzando questo script, l’MSP può generare rapidamente collegamenti RDP su misura per ogni reparto, distribuendoli sui rispettivi desktop degli utenti in modo efficiente e riducendo notevolmente i tempi di configurazione manuale.

Analisi comparativa: Script e metodi tradizionali

Rispetto alla creazione manuale di collegamenti RDP, questo script offre notevoli vantaggi in termini di scalabilità, personalizzazione e riduzione degli errori. Se i metodi manuali possono essere sufficienti per le singole configurazioni, diventano poco pratici in ambienti più grandi e dinamici, dove lo script può gestire senza problemi configurazioni complesse.

Domande frequenti

• Lo script può gestire credenziali diverse per RDP e Gateway?
  Sì, include un parametro per le credenziali separate del gateway.
• È possibile escludere alcuni utenti?
  Lo script consente di escludere gli utenti specificati dalla ricezione del collegamento.
• In che modo lo script garantisce la sicurezza?
  Richiede privilegi di amministrazione e gestisce attentamente le credenziali degli utenti.

Implicazioni e considerazioni sulla sicurezza

Sebbene questo script semplifichi notevolmente la creazione di collegamenti RDP, è essenziale considerare le implicazioni per la sicurezza. La gestione corretta delle credenziali e la garanzia che i collegamenti siano distribuiti solo agli utenti autorizzati sono aspetti fondamentali. Inoltre, gli MSP dovrebbero rivedere regolarmente le configurazioni dei collegamenti per mantenere gli standard di sicurezza.

Best practice per l’utilizzo dello script

• Test approfonditi: Prima di una distribuzione diffusa, testa accuratamente lo script in un ambiente controllato.
• Aggiornamenti regolari: Mantieni lo script aggiornato con le modifiche all’infrastruttura di rete.
• Controlli di sicurezza: Esamina regolarmente le distribuzioni dei collegamenti per individuare eventuali vulnerabilità di sicurezza.

Conclusione: Migliorare la gestione del desktop remoto con NinjaOne

In conclusione, questo script PowerShell è un potente strumento per creare e gestire i collegamenti RDP, offrendo personalizzazione ed efficienza. Strumenti come NinjaOne integrano tali script fornendo una piattaforma unificata per la gestione delle operazioni IT, comprese le connessioni desktop remote, in modo da semplificare le attività di gestione IT e migliorare la produttività complessiva e la sicurezza negli scenari di lavoro remoto.