Créer des raccourcis vers des sites web sur les bureaux avec PowerShell

Principaux points à retenir

• Le script automatise de créer des raccourcis vers des sites web sur les bureaux pour un ou plusieurs utilisateurs dans les environnements Windows.
• La flexibilité est assurée par des paramètres permettant de créer des raccourcis pour tous les utilisateurs, pour tous les utilisateurs existants ou pour des utilisateurs spécifiques.
• Des droits d’administrateur sont nécessaires pour créer des raccourcis dans le répertoire C:UsersPublicDesktop, ce qui renforce la sécurité.
• Le script permet de personnaliser les noms des raccourcis, les URL et les icônes, ce qui permet de personnaliser l’expérience de l’utilisateur.
• Les cas d’utilisation comprennent la standardisation du déploiement de raccourcis pour les ressources de l’entreprise sur les postes de travail des employés.
• Cette approche est plus efficace que la création manuelle de raccourcis, en particulier dans les grandes entreprises.

Créer des raccourcis vers des sites web sur le bureau est une tâche qui semble peu importante mais très pratique dans le monde informatique. Cela permet l’accès aux sites web fréquemment visités, améliorant ainsi l’efficacité des utilisateurs. Si cette fonctionnalité peut sembler élémentaire, son implémentation dans les différents profils d’utilisateurs d’une entreprise exige une approche plus nuancée, en particulier si l’on tient compte des différents privilèges des utilisateurs et des environnements système.

Contexte

Le script en question est conçu pour automatiser le processus de création de raccourcis URL sur les bureaux dans les environnements Windows. Cet utilitaire est particulièrement utile pour les professionnels de l’informatique et les fournisseurs de services gérés (MSP) qui gèrent un grand nombre d’ordinateurs. Il est souvent nécessaire de fournir à tous les utilisateurs ou à des groupes spécifiques un accès direct aux ressources web essentielles, telles que les portails d’entreprise, les systèmes de ressources humaines ou les applications sur le cloud. L’exécution manuelle de cette tâche prend du temps et est sujette à des erreurs, d’où la nécessité d’un script automatisé et personnalisable.

Le script :

<#
.SYNOPSIS
    This script creates a URL desktop shortcut with your specified options. It can create a shortcut for all users (including new ones) or for existing ones only.
.DESCRIPTION
    This script creates a URL desktop shortcut with your specified options. 
    It can create a shortcut for all users (including new ones) or for existing ones only.
.EXAMPLE
    To create a URL shortcut that opens in the default browser:
    
    -Name "Test" -URL "https://www.google.com" -AllUsers

    Creating Shortcut at C:UsersJohnSmithDesktopTest.url

.PARAMETER NAME
    The name of the shortcut, e.g., "Login Portal".

.PARAMETER URL
    The website URL to open, e.g., "https://www.google.com".

.PARAMETER AllExistingUsers
    Creates the shortcut for all existing users but not for new users, e.g., C:Users*Desktopshortcut.url.

.PARAMETER AllUsers
    Creates the shortcut in C:UsersPublicDesktop.

.OUTPUTS
    None
.NOTES
    Minimum OS Architecture Supported: Windows 7, Windows Server 2008
    Release Notes: Split the script into three separate scripts 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]$Name,
    [Parameter()]
    [String]$Url,
    [Parameter()]
    [Switch]$AllExistingUsers,
    [Parameter()]
    [Switch]$AllUsers
)
begin {
    # If Form Variables are used, replace the existing params with them.
    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:linkForUrlShortcut -and $env:linkForUrlShortcut -notlike "null") { $Url = $env:linkForUrlShortcut }

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

    # Double-check that a shortcut name was given.
    if (-not $Name) {
        Write-Error "You must specify a name 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
    }

    # This will get all the registry paths for all actual users (not system or network service accounts, but actual users).
    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, a Domain account, or a local "workgroup" account.
        $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 user's 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 } }
        }

        # There are some situations where grabbing the .Default user's info is needed.
        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 }
    }

    # The actual shortcut creation
    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
            }
        }
    }
}
process {
    $ShortcutPath = New-Object System.Collections.Generic.List[String]

    # Creating the filenames for the path
    if ($Url) { 
        $File = "$Name.url"
        $Target = $Url 
    }

    # Building the path's and adding it 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") }
    }

    $ShortcutPath | ForEach-Object { New-Shortcut -Target $Target -Path $_ }

    exit 0
}end {
    
    
    
}

 

Description détaillée

Le script fonctionne dans un environnement PowerShell et utilise plusieurs paramètres pour personnaliser le processus de création de raccourcis. Voici une description étape par étape :

• Initialisation des paramètres : Le script commence par définir des paramètres tels que le nom, l’URL et l’icône du raccourci, ainsi que l’étendue de son déploiement (tous les utilisateurs, tous les utilisateurs existants ou des utilisateurs particuliers).
• Vérification des variables d’environnement: Il vérifie la présence de variables d’environnement spécifiques, ce qui lui permet de s’adapter aux données externes ou aux conditions de déploiement.
• Validation des conditions préalablement nécessaires: Avant de poursuivre, le script vérifie si l’utilisateur a spécifié le bureau cible (tous les utilisateurs, les utilisateurs existants ou un utilisateur particulier) et le nom du raccourci. Il vérifie également l’existence de privilèges d’administrateur, car la création d’un raccourci dans C:UsersPublicDesktop requiert de tels droits.
• Extraction de l’ensemble des utilisateurs: Il utilise une fonction permettant d’identifier les profils d’utilisateurs sur le système, à l’exclusion des comptes de service du système ou du réseau.
• Logique de création de raccourcis: En fonction des paramètres choisis, il établit le chemin d’accès au fichier approprié et utilise un objet COM pour créer le raccourci, dont la cible est l’URL spécifiée.

• Exécution et nettoyage: Après avoir créé les raccourcis, le script se termine de manière élégante, ce qui permet de transmettre des métadonnées à des fins de journalisation ou d’audit.

Cas d’utilisation potentiels

Prenons l’exemple d’une entreprise MSP qui gère l’infrastructure informatique d’une entreprise qui a récemment adopté un nouvel outil de gestion de projet en ligne. Pour garantir un accès facile à tous les employés, l’entreprise MSP peut utiliser ce script pour créer un raccourci vers l’URL de l’outil sur l’ordinateur de chaque employé, ce qui permet de gagner du temps et de réduire les risques de confusion ou de mauvaise communication concernant l’adresse web de l’outil.

Comparaisons

Traditionnellement, créer des raccourcis vers des sites web se fait manuellement ou par le biais de paramètres de stratégie de groupe dans un environnement de domaine. La création manuelle demande beaucoup de travail et n’est pas possible à grande échelle. Les stratégies de groupe, bien que utiles, peuvent être complexes à configurer et ne sont pas adaptées à des configurations hors domaine ou à des environnements mixtes. Ce script PowerShell offre une approche plus directe, plus flexible et plus facile à scripter, qui peut être facilement intégrée dans des flux de travail d’automatisation plus importants.

FAQ

Q1 : Ce script fonctionnera-t-il sur des systèmes autre que Windows ? 
R : Non, il est spécifiquement conçu pour les environnements Windows.

Q2 : L’utilisation de ce script nécessite-t-elle des privilèges d’administrateur ? 
R : Oui, pour créer des raccourcis dans le répertoire C:UsersPublicDesktop.

Q3 : Le script peut-il être modifié pour ajouter des icônes personnalisées aux raccourcis ? 
R : Oui, il comprend des paramètres permettant de définir des icônes personnalisées.

Implications

Bien que le script améliore l’efficacité opérationnelle, il pose également certains problèmes de sécurité. Une mauvaise utilisation peut entraîner la distribution non autorisée de raccourcis, potentiellement vers des sites malveillants. Il est essentiel de s’assurer que les URL fournis sont sûrs et proviennent de sources fiables.

Recommandations

• Exécutez toujours le script dans un environnement de test avant de le déployer.
• Révisez et mettez à jour régulièrement la liste des URL afin de maintenir la pertinence et la sécurité des raccourcis.
• Surveillez l’exécution du script dans le cadre d’un audit de sécurité plus large de votre entreprise.

Conclusion

Dans le monde informatique en constante évolution, l’efficacité et l’automatisation sont essentielles. Un outil comme NinjaOne, qui offre des solutions complètes de gestion et d’automatisation de l’informatique, complète ces scripts en fournissant une plateforme pour le déploiement, la gestion et le contrôle de ces tâches d’automatisation dans diverses infrastructures informatiques. L’intégration de ces scripts dans une solution de gestion unifiée telle que NinjaOne peut considérablement améliorer l’efficacité et la fiabilité des opérations informatiques.