Crear accesos directos de URL en escritorio con PowerShell

Puntos clave

• El script automatiza el proceso de crear accesos directos de URL en escritorio para usuarios individuales o múltiples en entornos Windows.
• Se ofrece flexibilidad mediante parámetros para crear accesos directos para todos los usuarios, todos los usuarios existentes o usuarios específicos.
• Se requieren derechos de administrador para crear accesos directos en el directorio C:UsersPublicDesktop, lo que mejora la seguridad.
• El script admite la personalización de los nombres de los accesos directos, las URL y los iconos, lo que permite una experiencia de usuario personalizada.
• Los casos de uso incluyen el despliegue simplificado de accesos directos a los recursos de la empresa en las estaciones de trabajo de los empleados.
• Este enfoque es más eficaz que la creación manual de accesos directos, especialmente en grandes organizaciones.

Crear un acceso directo URL en un escritorio es una tarea aparentemente pequeña pero muy útil en el mundo de las TI. Simplifica el acceso a los sitios web más visitados, mejorando la eficacia de los usuarios. Aunque esta funcionalidad pueda parecer básica, su aplicación en los distintos perfiles de usuario de una organización exige un enfoque a varios niveles, especialmente si se tienen en cuenta los distintos privilegios de usuario y entornos de sistema.

Antecedentes

El script que analizamos está diseñado para automatizar el proceso de crear accesos directos de URL en escritorio en entornos Windows. Esta utilidad es especialmente valiosa para los profesionales de TI y los proveedores de servicios gestionados (MSP) que administran un gran número de ordenadores. A menudo, es necesario proporcionar a todos los usuarios o a grupos específicos acceso directo a recursos web esenciales, como portales de empresa, sistemas de recursos humanos o aplicaciones en la nube. Realizar esta tarea manualmente lleva mucho tiempo y es propenso a errores, de ahí la necesidad de un script automatizado y personalizable.

El script para accesos directos de URL en escritorio

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

 

Análisis detallado

El script para crear accesos directos de URL en escritorio funciona en un entorno PowerShell y emplea varios parámetros para personalizar el proceso de crear accesos directos de URL en escritorio. Aquí tienes un desglose paso a paso:

• Inicialización de parámetros: el script para crear accesos directos de URL en escritorio comienza definiendo parámetros como el nombre del acceso directo, la URL, el icono y el alcance de su despliegue (todos los usuarios, todos los usuarios existentes o usuarios específicos).
• Control de las variables de entorno: comprueba variables de entorno específicas, lo que le permite adaptarse en función de inputs externos o condiciones de despliegue.
• Validación de los requisitos previos: antes de continuar, el script para crear accesos directos de URL en escritorio verifica si el usuario ha especificado el escritorio (todos los usuarios, usuarios existentes o un usuario en particular) y el nombre del acceso directo. También comprueba si se dispone de privilegios administrativos, ya que la creación de un acceso directo en C:UsersPublicDesktop requiere tales derechos.
• Extracción de cuentas de tipo usuario: emplea una función para identificar perfiles de usuario en el sistema, excluyendo las cuentas del sistema o de servicios de red.
• Operación de creación de accesos directos: en función de los parámetros elegidos, construye la ruta de archivo adecuada y utiliza un objeto COM para crear el acceso directo, estableciendo su destino en la URL especificada.

• Ejecución y limpieza: tras crear los accesos directos, el script para crear accesos directos de URL en escritorio se cierra, ofreciendo la oportunidad de guardar y compartir metadatos con fines de registro o auditoría.

Posibles casos de uso

Pensemos en un MSP que gestiona la infraestructura informática de una empresa que acaba de adoptar una nueva herramienta de gestión de proyectos en línea. Para garantizar un acceso sencillo para todos los empleados, el MSP puede utilizar este script para crear un acceso directo en el escritorio a la URL de la herramienta en el ordenador de cada empleado, ahorrando tiempo y reduciendo posibles confusiones o errores de comunicación sobre la dirección web de la herramienta.

Comparaciones

Tradicionalmente, los accesos directos URL se crean manualmente o mediante la configuración de políticas de grupo en un entorno de dominio. La creación manual requiere mucho trabajo y no es escalable. Las políticas de grupo, aunque potentes, pueden ser complejas de configurar y no son adecuadas para configuraciones que no sean de dominio o de entorno mixto. Este script de PowerShell proporciona un enfoque más directo, flexible y adaptable que puede integrarse fácilmente en flujos de trabajo de automatización más amplios.

Preguntas frecuentes

P1: ¿Este script para crear accesos directos de URL en escritorio funciona en sistemas que no sean Windows? 
R: No, está diseñado específicamente para entornos Windows.

P2: ¿Es obligatorio tener privilegios administrativos para utilizar este script para crear accesos directos de URL en escritorio? 
R: Sí, para crear accesos directos en el directorio C:UsersPublicDesktop.

P3: ¿Se puede modificar el script para crear accesos directos de URL en escritorio para añadir iconos personalizados a los accesos directos? 
R: Sí, incluye parámetros para configurar iconos personalizados.

Implicaciones

Aunque el script mejora la eficacia operativa, también puede tener consecuencias para la seguridad. Un uso inadecuado podría conducir a la distribución no autorizada de accesos directos, potencialmente a sitios maliciosos. Es fundamental asegurarse de que las URL proporcionadas son seguras y proceden de fuentes fiables.

Recomendaciones

• Ejecuta siempre el script en un entorno de prueba antes de implantarlo.
• Revisa y actualiza periódicamente la lista de URL para mantener la relevancia y seguridad de los accesos directos.
• Supervisa la ejecución del script como parte de la auditoría de seguridad más amplia de tu organización.

Reflexiones finales

En el frenético mundo de las TI, la eficiencia y la automatización son fundamentales. Una herramienta como NinjaOne, que ofrece soluciones integrales de gestión y automatización de TI, complementa estos scripts, proporcionando una plataforma para desplegar, gestionar y supervisar estas tareas de automatización en diversas infraestructuras de TI. La integración de estos scripts en una solución de gestión unificada como NinjaOne puede mejorar significativamente la eficiencia y fiabilidad operativa de TI.