Automatisation de la création de raccourcis RDP de connexion Bureau à distance avec PowerShell

Principaux points à retenir

• Création automatisée de raccourcis: Le script PowerShell automatise la création de raccourcis RDP, ce qui permet de gagner du temps et de réduire les erreurs manuelles.
• Options personnalisables: Il offre des possibilités de personnalisation étendues, notamment en ce qui concerne les paramètres d’affichage, les informations d’identification de l’utilisateur et les configurations de la passerelle.
• Évolutivité pour les grands environnements: Il est idéal pour les entreprises MSP et les services informatiques qui gèrent plusieurs connexions à distance.
• Exigence en matière de droits d’administrateur: Il nécessite des privilèges d’administrateur pour certaines opérations, ce qui garantit la sécurité.
• Gestion des conflits: Il vérifie les options conflictuelles et guide les utilisateurs vers une configuration optimale.
• Soucieux de la sécurité: Priorité au traitement sécurisé des informations d’identification et au déploiement de raccourcis.
• Amélioration de la productivité: Il simplifie et optimise le processus de gestion des connexions de bureau à distance, améliorant ainsi la productivité informatique globale.
• Outils complémentaires: Peut être associé efficacement à des plateformes de gestion telles que NinjaOne pour des solutions informatiques complètes.

Les raccourcis RDP (Remote Desktop Protocol) sont des outils essentiels dans le monde de l’informatique, car ils permettent une connectivité optimale avec les systèmes distants. Avec l’évolution des environnements en réseau et le besoin croissant d’un accès à distance efficace, la capacité de créer et de gérer rapidement ces raccourcis devient essentielle. Ce script, conçu en PowerShell, offre une approche optimisée et personnalisable de la création de raccourcis RDP, améliorant ainsi la productivité des professionnels de l’informatique et des fournisseurs de services gérés (MSP). 

Contexte et importance du script PowerShell

Traditionnellement, la création et la gestion des raccourcis RDP impliquaient des processus manuels, ce qui pouvait prendre du temps et entraîner des erreurs, en particulier dans les environnements informatiques dynamiques ou à grande échelle. Ce script PowerShell relève ce défi en automatisant la création de raccourcis RDP avec des paramètres définis par l’utilisateur. Une telle automatisation est particulièrement bénéfique pour les équipes informatiques qui gèrent plusieurs connexions à distance et pour les fournisseurs de services d’assistance technique qui doivent déployer rapidement des solutions d’accès à distance pour leurs clients.

Le script PowerShell :

<#
.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 {
    
    
    
}

 

Exploration du script : une analyse étape par étape

Le script commence par un synopsis et une description, qui donnent un aperçu clair de sa fonctionnalité. Il décrit ensuite des paramètres tels que le nom du raccourci, le serveur RDP cible, les informations d’identification de l’utilisateur, les options d’affichage (telles que le plein écran ou la prise en charge de plusieurs écrans) et le choix de créer des raccourcis pour tous les utilisateurs ou pour certains d’entre eux.

• Définition des paramètres: Le script définit divers paramètres permettant de personnaliser le raccourci RDP. Il s’agit de détails de base tels que le nom du raccourci, la cible RDP et l’utilisateur, ainsi que d’options plus avancées telles que la taille de la fenêtre, la prise en charge de plusieurs moniteurs et la configuration de la passerelle.
• Variables d’environnement et vérification des conflits: Le script vérifie et remplace les paramètres par des variables d’environnement si elles sont disponibles. Il émet également des avertissements en cas d’options contradictoires, comme le fait de spécifier à la fois le plein écran et la taille de la fenêtre.
• Gestion des droits d’administrateur et des profils d’utilisateurs: Le script comprend une fonction de vérification des droits d’administrateur, nécessaires pour créer des raccourcis dans certains répertoires. Il contient également une fonction permettant de récupérer les profils des utilisateurs, à l’exclusion des comptes système, ce qui est essentiel pour déployer des raccourcis vers des bureaux d’utilisateurs spécifiques.
• Processus de création de raccourcis: Le script génère le fichier .RDP en ajoutant les options sélectionnées par l’utilisateur à un modèle de base. Il parcourt ensuite les chemins d’accès déterminés, en créant le fichier RDP à chaque emplacement.

Cas d’utilisation potentiels : application dans le monde réel

Imaginez une entreprise MSP chargée de gérer l’accès à distance d’une entreprise composée de plusieurs départements, chacun nécessitant des configurations RDP spécifiques. Grâce à ce script, l’entreprise MSP peut rapidement générer des raccourcis RDP personnalisés pour chaque département, les déployer sur les bureaux des utilisateurs respectifs de manière efficace et réduire considérablement le temps de configuration manuelle.

Analyse comparative : script vs. méthodes traditionnelles

Par rapport à la création manuelle de raccourcis RDP, ce script offre des avantages significatifs en termes d’évolutivité, de personnalisation et de réduction des erreurs. Si les méthodes manuelles peuvent suffire pour des installations individuelles, elles deviennent peu pratiques dans des environnements plus vastes et plus dynamiques, où ce script peut gérer sans effort des configurations complexes.

Questions fréquemment posées

• Le script peut-il gérer des identifiants différents pour le RDP et la passerelle ?
  Oui, il comprend un paramètre pour des informations d’identification distinctes pour la passerelle.
• Est-il possible d’exclure certains utilisateurs ?
  Le script permet d’exclure des utilisateurs spécifiques.
• Comment le script assure-t-il la sécurité ?
  Il nécessite des privilèges d’administrateur et gère soigneusement les informations d’identification des utilisateurs.

Implications et considérations de sécurité

Bien que ce script simplifie considérablement la création de raccourcis RDP, il est essentiel de tenir compte des implications en matière de sécurité. Il est essentiel de traiter correctement les informations d’identification et de veiller à ce que les raccourcis ne soient déployés que pour les utilisateurs autorisés. De plus, les MSP doivent régulièrement revoir les configurations des raccourcis afin de maintenir les normes de sécurité.

Bonnes pratiques pour l’utilisation des scripts

• Tests approfondis: Avant de procéder à un déploiement généralisé, testez minutieusement le script dans un environnement contrôlé.
• Mises à jour régulières: Maintenez le script à jour en fonction des modifications apportées à l’infrastructure du réseau.
• Contrôles de sécurité: Examinez régulièrement les déploiements de raccourcis pour détecter d’éventuelles vulnérabilités en matière de sécurité.

Conclusion : Améliorez la gestion des connexions de bureau à distance avec NinjaOne

En conclusion, ce script PowerShell est un outil puissant pour créer et gérer des raccourcis RDP, offrant personnalisation et efficacité. Des outils comme NinjaOne complètent ces scripts en fournissant une plateforme unifiée pour la gestion des opérations informatiques, y compris les connexions de bureau à distance, optimisant ainsi les tâches de gestion informatique et améliorant la productivité globale et la sécurité dans les environnements de travail à distance.