Wie man URL-Verknüpfungen auf Desktops mit PowerShell erstellen kann

Wichtigste Erkenntnisse

• Das Skript automatisiert die Erstellung von URL-Verknüpfungen auf Desktops für einzelne oder mehrere Benutzer:innen in Windows-Umgebungen.
• Flexibilität wird durch Parameter zur Erstellung von Verknüpfungen für alle Benutzer:innen, alle vorhandenen Benutzer:innen oder bestimmte Anwender:innen gewährleistet.
• Für die Erstellung von Verknüpfungen im Verzeichnis C:UsersPublicDesktop sind Administratorrechte erforderlich, was die Sicherheit erhöht.
• Das Skript unterstützt die Anpassung von Verknüpfungsnamen, URLs und Symbolen und ermöglicht so eine personalisierte Benutzererfahrung.
• Zu den Anwendungsfällen gehört die optimierte Bereitstellung von Verknüpfungen für Unternehmensressourcen auf den Workstations der Mitarbeiter:innen.
• Dieser Ansatz ist effizienter als die manuelle Erstellung von Verknüpfungen, insbesondere in großen Unternehmen.

Das Erstellen einer URL-Verknüpfung auf dem Desktop ist eine scheinbar kleine, aber sehr praktische Aufgabe in der IT-Welt. Es rationalisiert den Zugriff auf häufig besuchte Webseiten und steigert so die Effizienz für Anwender:innen. Diese Funktionalität mag zwar einfach erscheinen, doch ihre Implementierung in den verschiedenen Benutzerprofilen eines Unternehmens erfordert einen differenzierteren Ansatz, insbesondere wenn man die unterschiedlichen Benutzerrechte und Systemumgebungen berücksichtigt.

Kontext

Das thematisierte Skript wurde entwickelt, um den Prozess der Erstellung von URL-Verknüpfungen auf Desktops in Windows-Umgebungen zu automatisieren. Dieses Dienstprogramm ist besonders wertvoll für IT-Expert:innen und Managed Service Provider (MSPs), die eine große Anzahl von Computern verwalten. Häufig besteht die Notwendigkeit, allen Benutzer:innen oder bestimmten Gruppen einen direkten Zugang zu wichtigen Webressourcen wie Unternehmensportalen, HR-Systemen oder Cloud-Anwendungen zu ermöglichen. Die manuelle Durchführung dieser Aufgabe ist zeitaufwändig und fehleranfällig, daher ist ein automatisiertes, anpassbares Skript erforderlich.

Das Skript

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

Detailansicht

Das Skript funktioniert in einer PowerShell-Umgebung und verwendet mehrere Parameter für die Anpassung des Prozesses der Verknüpfungserstellung. Hier ist eine schrittweise Aufschlüsselung:

• Initialisierung der Parameter: Das Skript beginnt mit der Definition von Parametern wie dem Namen der Verknüpfung, der URL, dem Symbol und dem Umfang der Bereitstellung (entweder alle Benutzer:innen, alle vorhandenen Benutzer:innen oder bestimmte Benutzer:innen).
• Überprüfung der Umgebungsvariablen: Sie prüft auf bestimmte Umgebungsvariablen, sodass sie sich auf der Grundlage externer Eingaben oder Einsatzbedingungen anpassen kann.
• Voraussetzung für die Validierung: Bevor das Skript fortfährt, prüft es, ob der Benutzer den Desktop (alle Benutzer:innen, vorhandene Benutzer:innen oder ein bestimmter Benutzer) und den Namen der Verknüpfung angegeben hat. Es wird auch geprüft, ob Sie über Administratorrechte verfügen, da das Erstellen einer Verknüpfung in C:UsersPublicDesktop solche Rechte erfordert.
• Benutzer-Hive-Extraktion: Es verwendet eine Funktion zur Identifizierung von Benutzerprofilen auf dem System, mit Ausnahme von System- oder Netzwerkdienstkonten.
• Logik der Erstellung von Verknüpfungen: Abhängig von den gewählten Parametern erzeugt es den entsprechenden Dateipfad und verwendet ein COM-Objekt, um die Verknüpfung zu erstellen, wobei das Ziel auf die angegebene URL gesetzt wird.

• Ausführung und Abschluss: Nach der Erstellung der Verknüpfungen wird das Skript ordnungsgemäß beendet und bietet die Möglichkeit, Metadaten für Protokollierungs- oder Prüfungszwecke zu übergeben.

Potenzielle Anwendungsfälle

Stellen Sie sich einen MSP vor, der die IT-Infrastruktur für ein Unternehmen verwaltet, das kürzlich ein neues Online-Projektmanagement-Tool eingeführt hat. Um einen einfachen Zugang für alle Mitarbeiter:innen zu gewährleisten, kann der MSP dieses Skript verwenden, um eine Desktop-Verknüpfung zur URL des Tools auf dem Computer jedes Mitarbeiters zu erstellen, was Zeit spart und mögliche Verwirrung oder Missverständnisse über die Webadresse des Tools reduziert.

Vergleiche

Traditionell werden URL-Verknüpfungen entweder manuell oder über Gruppenrichtlinieneinstellungen in einer Domain-Umgebung erstellt. Die manuelle Erstellung ist arbeitsintensiv und nicht skalierbar. Gruppenrichtlinien sind zwar leistungsfähig, können aber komplex zu konfigurieren sein und eignen sich nicht für Installationen außerhalb von Domains oder in gemischten Umgebungen. Dieses PowerShell-Skript bietet einen direkteren, flexibleren und skriptfähigen Ansatz, der leicht in größere Automatisierungsworkflows integriert werden kann.

FAQs

Q1: Funktioniert dieses Skript auch auf Nicht-Windows-Systemen? 
A: Nein, es ist speziell für Windows-Umgebungen konzipiert.

Q2: Sind für die Verwendung dieses Skripts Administratorrechte erforderlich? 
A: Ja, um Verknüpfungen im Verzeichnis C:UsersPublicDesktop zu erstellen.

Q3: Kann das Skript so geändert werden, dass den Verknüpfungen benutzerdefinierte Symbole hinzugefügt werden? 
A: Ja, es enthält Parameter für die Einstellung von benutzerdefinierten Symbolen.

Folgen

Das Skript steigert zwar die betriebliche Effizienz, hat aber auch gewisse Sicherheitsaspekte. Eine unsachgemäße Verwendung könnte die nicht autorisierte Verbreitung von Verknüpfungen verursachen, die möglicherweise zu bösartigen Internetseiten führen. Es ist wichtig sicherzustellen, dass die angegebenen URLs sicher sind und aus vertrauenswürdigen Quellen stammen.

Empfehlungen

• Führen Sie das Skript vor dem Einsatz immer in einer Testumgebung aus.
• Überprüfen und aktualisieren Sie die Liste der URLs regelmäßig, um die Relevanz und Sicherheit der Verknüpfungen zu gewährleisten.
• Überwachen Sie die Ausführung des Skripts als Teil der allgemeinen Sicherheitsüberprüfung Ihres Unternehmens.

Abschließende Überlegungen

In der schnelllebigen IT-Umgebung sind Effizienz und Automatisierung entscheidend. Ein Tool wie NinjaOne, das umfassende IT-Management- und Automatisierungslösungen anbietet, ergänzt solche Skripte, indem es eine Plattform für den Einsatz, die Verwaltung und die Überwachung solcher Automatisierungsaufgaben über verschiedene IT-Infrastrukturen hinweg bereitstellt. Die Integration solcher Skripte in eine einheitliche Managementlösung wie NinjaOne kann die Effizienz und Zuverlässigkeit des IT-Betriebs erheblich steigern.