Criação de atalhos de URL em áreas de trabalho usando o PowerShell

Principais conclusões

• O script automatiza a criação de atalhos de URL em áreas de trabalho para usuários individuais ou múltiplos em ambientes Windows.
• A flexibilidade é oferecida por meio de parâmetros para a criação de atalhos para todos os usuários, todos os usuários existentes ou usuários específicos.
• São necessários direitos de administrador para criar atalhos no diretório C:UsersPublicDesktop, o que aumenta a segurança.
• O script suporta a personalização de nomes de atalhos, URLs e ícones, permitindo uma experiência de usuário personalizada.
• Os casos de uso incluem a implantação simplificada de atalhos para os recursos da empresa nas estações de trabalho dos funcionários.
• Essa abordagem é mais eficiente do que a criação manual de atalhos, especialmente em grandes organizações.

Criar um atalho de URL em uma área de trabalho é uma tarefa aparentemente pequena, mas muito prática no mundo da TI. Ele simplifica o acesso a sites visitados com frequência, aumentando a eficiência dos usuários. Embora essa funcionalidade possa parecer básica, sua implementação em vários perfis de usuário em uma organização exige uma abordagem mais diferenciada, especialmente quando se consideram diferentes privilégios de usuário e ambientes de sistema.

Histórico

O script em discussão foi projetado para automatizar o processo de criação de atalhos de URL em áreas de trabalho em ambientes Windows. Esse utilitário é particularmente valioso para profissionais de TI e provedores de serviços gerenciados (MSPs) que gerenciam um grande número de computadores. Muitas vezes, é necessário fornecer a todos os usuários ou a grupos específicos acesso direto a recursos essenciais da Web, como portais da empresa, sistemas de RH ou aplicativos em nuvem. A execução manual dessa tarefa consome muito tempo e está sujeita a erros, por isso a necessidade de um script automatizado e personalizável.

O roteiro:

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

Detalhamento

O script funciona em um ambiente do PowerShell e emprega vários parâmetros para personalizar o processo de criação de atalhos. Aqui está um detalhamento passo a passo:

• Inicialização de parâmetros: O script começa definindo parâmetros como o nome do atalho, o URL, o ícone e o escopo de sua implementação (todos os usuários, todos os usuários existentes ou usuários específicos).
• Verificação de variável de ambiente: Ele verifica variáveis de ambiente específicas, permitindo a adaptação com base em entradas externas ou condições de implementação.
• Validação de pré-requisitos: Antes de continuar, o script verifica se o usuário especificou a área de trabalho (todos os usuários, usuários existentes ou um usuário específico) e o nome do atalho. Ele também verifica se há privilégios administrativos, pois a criação de um atalho em C:UsersPublicDesktop requer esses direitos.
• Extração de colmeia de usuário: Ele emprega uma função para identificar perfis de usuário no sistema, excluindo contas de serviço de rede ou de sistema.
• Lógica de criação de atalhos: Dependendo dos parâmetros escolhidos, ele constrói o caminho de arquivo apropriado e usa um objeto COM para criar o atalho, definindo seu destino para o URL especificado.

• Execução e limpeza: Depois de criar os atalhos, o script é encerrado de forma elegante, oferecendo a oportunidade de passar metadados para fins de registro ou auditoria.

Casos de uso em potencial

Considere um MSP que gerencia a infraestrutura de TI de uma empresa que adotou recentemente uma nova ferramenta de gerenciamento de projetos on-line. Para garantir o fácil acesso de todos os funcionários, o MSP pode usar esse script para criar um atalho na área de trabalho para o URL da ferramenta no computador de cada funcionário, economizando tempo e reduzindo possíveis confusões ou falhas de comunicação sobre o endereço da ferramenta na Web.

Comparações

Tradicionalmente, os atalhos de URL são criados manualmente ou por meio de configurações de política de grupo em um ambiente de domínio. A criação manual exige muita mão de obra e não é escalonável. As políticas de grupo, embora eficientes, podem ser complexas de configurar e não são adequadas para configurações que não sejam de domínio ou de ambiente misto. Esse script do PowerShell oferece uma abordagem mais direta, flexível e com script que pode ser facilmente integrada a fluxos de trabalho de automação maiores.

Implicações

Embora o script aumente a eficiência operacional, ele também apresenta certas implicações de segurança. O uso inadequado pode levar à distribuição não autorizada de atalhos, possivelmente para sites maliciosos. É fundamental garantir que os URLs fornecidos sejam seguros e de fontes confiáveis.

Recomendações

• Sempre execute o script em um ambiente de teste antes da implementação.
• Revise e atualize regularmente a lista de URLs para manter a relevância e a segurança dos atalhos.
• Monitore a execução do script como parte da auditoria de segurança mais ampla de sua organização.

Considerações finais

No ambiente de TI em ritmo acelerado, a eficiência e a automação são fundamentais. Uma ferramenta como o NinjaOne, que oferece soluções abrangentes de gerenciamento e automação de TI, complementa esses scripts, fornecendo uma plataforma para implementar, gerenciar e monitorar essas tarefas de automação em diversas infraestruturas de TI. A integração desses scripts em uma solução de gerenciamento unificado, como o NinjaOne, pode aumentar significativamente a eficiência e a confiabilidade operacional da TI.