Como bloquear automaticamente o Windows após a inatividade usando o PowerShell

Bloquear um computador após um período de inatividade é uma medida de segurança essencial que todo profissional de TI reconhece. Especialmente em ambientes compartilhados ou públicos, isso garante que uma estação de trabalho sem supervisão não se torne uma porta aberta para atividades mal-intencionadas. O PowerShell, a espinha dorsal de muitas operações de TI em ambientes Windows, oferece uma maneira versátil de definir um tempo limite de inatividade. 

Histórico

Os tempos limite de inatividade não se referem apenas à segurança, mas também ao gerenciamento de recursos. Os profissionais de TI e os provedores de serviços gerenciados (MSPs) geralmente implementam esses recursos para economizar energia, reduzir o desgaste do hardware e como uma camada inicial de segurança. O script fornecido se aprofunda no domínio da automação desse processo, permitindo uma abordagem do tipo “configure e esqueça”.

O roteiro

#Requires -Version 5.1

<#
.SYNOPSIS
    Set the Inactivity(Lock Computer) timeout time if it already isn't set.
.DESCRIPTION
    Set the Inactivity(Lock Computer) timeout time if it already isn't set.
    Can be set regardless if the -Force parameter is used.
.EXAMPLE
     -Minutes 5
    This set the Inactivity(Lock Computer) timeout to 5 minutes, does not change if already set.
.EXAMPLE
     -Minutes 5 -Force
    This set the Inactivity(Lock Computer) timeout to 5 minutes, and forces the change if already set.
.EXAMPLE
    PS C:> Set-IdleLock.ps1 -Minutes 5
    This set the Inactivity(Lock Computer) timeout to 5 minutes
.OUTPUTS
    None
.NOTES
    Minimum OS Architecture Supported: Windows 10, Windows Server 2016
    Release Notes: Renamed script and added Script Variable support, updated Set-ItemProp
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).
.COMPONENT
    LocalUserAccountManagement
#>

[CmdletBinding()]
param (
    [Parameter()]
    [int]$Minutes,
    [switch]$Force = [System.Convert]::ToBoolean($env:force)
)

begin {
    if ($env:minutes -and $env:minutes -notlike "null") {
        $Minutes = $env:minutes
    }
    
    if(-not ($Minutes)){
        Write-Error "Minutes is required!"
        exit 1
    }

    if($Minutes -gt 9999 -or $Minutes -lt 0){
        Write-Error "Minutes must be between 0 and 9999 (including 0 and 9999)."
        exit 1
    }

    function Test-IsElevated {
        $id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
        $p = New-Object System.Security.Principal.WindowsPrincipal($id)
        if ($p.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator))
        { Write-Output $true }
        else
        { Write-Output $false }
    }
    function Set-ItemProp {
        param (
            $Path,
            $Name,
            $Value,
            [ValidateSet("DWord", "QWord", "String", "ExpandedString", "Binary", "MultiString", "Unknown")]
            $PropertyType = "DWord"
        )
        # Do not output errors and continue
        $ErrorActionPreference = [System.Management.Automation.ActionPreference]::SilentlyContinue
        if (-not $(Test-Path -Path $Path)) {
            # Check if path does not exist and create the path
            New-Item -Path $Path -Force | Out-Null
        }
        if ((Get-ItemProperty -Path $Path -Name $Name)) {
            # Update property and print out what it was changed from and changed to
            $CurrentValue = Get-ItemProperty -Path $Path -Name $Name
            try {
                Set-ItemProperty -Path $Path -Name $Name -Value $Value -Force -Confirm:$false -ErrorAction Stop | Out-Null
            }
            catch {
                Write-Error $_
            }
            Write-Host "$Path$Name changed from $CurrentValue to $(Get-ItemProperty -Path $Path -Name $Name)"
        }
        else {
            # Create property with value
            try {
                New-ItemProperty -Path $Path -Name $Name -Value $Value -PropertyType $PropertyType -Force -Confirm:$false -ErrorAction Stop | Out-Null
            }
            catch {
                Write-Error $_
            }
            Write-Host "Set $Path$Name to $(Get-ItemProperty -Path $Path -Name $Name)"
        }
        $ErrorActionPreference = [System.Management.Automation.ActionPreference]::Continue
    }
}
process {
    if (-not (Test-IsElevated)) {
        Write-Error -Message "Access Denied. Please run with Administrator privileges."
        exit 1
    }
    
    $Path = "HKLM:SOFTWAREMicrosoftWindowsCurrentVersionPoliciesSystem"
    $IdleName = "InactivityTimeoutSecs"
    $Seconds = $Minutes * 60
    # Override "Check if already set"
    if (-not $Force) {
        # Check if already set
        if ($(Get-ItemProperty -Path $Path | Select-Object -Property $IdleName -ExpandProperty $IdleName -ErrorAction SilentlyContinue)) {
            $CurrentIdleSeconds = $(Get-ItemPropertyValue -Path $Path -Name $IdleName)
            # If value already set, do nothing.
            if ($CurrentIdleSeconds) { exit 0 }
        }
    }

    # Sets InactivityTimeoutSecs to $Minutes
    try {
        Set-ItemProp -Path $Path -Name $IdleName -Value $Seconds
        Write-Host "Set the Inactivity to $($Seconds/60) minutes."
    }
    catch {
        Write-Error $_
        exit 1
    }
}
end {
    
    
    
}

Detalhamento

Esse script do PowerShell tem como objetivo definir o tempo limite de inatividade no Windows. Veja como funciona:

• Pré-requisitos: O script começa mencionando que requer pelo menos a versão 5.1 do PowerShell. Consulte nosso blog para saber qual versão você tem“Como fazer uma verificação de versão do PowerShell“
• Parâmetros: Dois parâmetros são definidos – $Minutes, que é obrigatório e indica a duração após a qual o computador deve ser bloqueado, e $Force que, quando usado, força o tempo limite de inatividade, mesmo que já esteja definido.

Funções:

• Test-IsElevated: Verifica se o script é executado com privilégios de administrador.
• Set-ItemProp: Trata da criação ou modificação da chave de registro.

Bloco de processo:

• Verificação inicial: Verifica se o usuário tem os privilégios necessários.
• Caminho do registro: Direciona para o local onde o tempo limite de inatividade está definido.
• Verificação da condição: Se a opção -Force não for usada, ele verifica se o tempo limite já está definido. Se estiver definido, ele sairá sem fazer alterações.
• Configuração do tempo limite: Se as condições forem aprovadas, o tempo limite de inatividade será definido ou alterado.

Casos de uso em potencial

Imagine trabalhar em um laboratório de informática público de uma universidade. Vários alunos usam esses computadores durante o dia. Para garantir que o trabalho de cada aluno permaneça confidencial, o departamento de TI poderia utilizar esse script. Ao definir um tempo limite de inatividade de, digamos, 5 minutos, eles garantem que, se um aluno se esquecer de fazer logout, o sistema será automaticamente bloqueado, impedindo o acesso não autorizado.

Comparações

Embora existam métodos de GUI para definir tempos limite de inatividade, como o Painel de Controle do Windows, esse script oferece uma vantagem em termos de escalabilidade. Para implementações maciças em vários computadores, usar um script como esse é mais eficiente. Além disso, outros métodos podem envolver configurações da Política de Grupo, mas não têm a granularidade e a aplicação rápida que um script do PowerShell pode oferecer.

Implicações

Embora o objetivo imediato seja aumentar a segurança, o tempo limite de inatividade incorreto pode atrapalhar o trabalho, especialmente se for definido como muito curto. Por outro lado, um tempo limite muito longo pode comprometer a segurança. Além disso, as configurações de inatividade tornam-se críticas em ambientes de alta segurança, onde deixar um terminal desbloqueado pode ter consequências graves.

Recomendações

• Teste antes de aplicar: Sempre execute scripts em um ambiente de teste antes de implementá-los amplamente.
• Equilibre a segurança com a usabilidade: Embora os tempos limite mais curtos sejam mais seguros, eles não devem atrapalhar as tarefas diárias.
• Mantenha-se atualizado: Revise e ajuste periodicamente os tempos limite de inatividade de acordo com as necessidades da organização.

Considerações finais

O NinjaOne oferece uma solução abrangente de monitoramento e gerenciamento de TI e, quando integrado a scripts como esse, proporciona um controle robusto sobre um ambiente de TI. Se você deseja definir tempos limite de inatividade ou gerenciar outros aspectos da infraestrutura de TI, a NinjaOne continua sendo um parceiro confiável para operações eficientes, seguras e otimizadas.