Migliorare la sicurezza con PowerShell: disabilitare il login automatico e imporre la pressione di CTRL+ALT+CANC 

Negli ambienti IT la sicurezza è fondamentale e ogni livello di difesa è importante. Una misura di sicurezza spesso trascurata è quella di richiedere agli utenti di premere CTRL+ALT+CANC prima di accedere. Questa azione agisce come una sequenza di sicurezza o secure attention sequence (SAS), assicurando che la schermata di accesso sia autentica e non un’interfaccia contraffatta creata da un malware.

Per i professionisti IT e i fornitori di servizi gestiti (MSP), l’automazione di queste attività può far risparmiare tempo e garantire la coerenza. Lo script PowerShell fornito fa proprio questo: disabilita il login automatico e impone il requisito CTRL+ALT+CANC sui sistemi Windows.

Comprendere la necessità di pratiche di accesso sicure

Il requisito CTRL+ALT+CANC non è come potrebbe sembrare solo un fastidio per l’utente, ma offre vantaggi critici per la sicurezza. Questa combinazione garantisce che gli utenti interagiscano con il sottosistema di autenticazione sicura del sistema operativo piuttosto che con programmi potenzialmente dannosi. Inoltre, la disabilitare il login automatico impedisce l’accesso non autorizzato in ambienti condivisi o sensibili. I professionisti IT che gestiscono un gran numero di dispositivi possono trovare questo script prezioso per implementare rapidamente queste impostazioni nei vari sistemi.

Lo script per disabilitare il login automatico:

#Requires -Version 5.1

<#
.SYNOPSIS
    Disables the automatic login feature and requires 'CTRL', 'ALT', and 'DELETE' to be pressed each time a user signs in. Once 'Interactive logon: Do not require CTRL+ALT+DEL' is apart of the security policy it cannot be removed from the policy. It either has to be enabled or disabled.
.DESCRIPTION
    Disables the automatic login feature and requires 'CTRL', 'ALT', and 'DELETE' to be pressed each time a user signs in. Once 'Interactive logon: Do not require CTRL+ALT+DEL' is apart of the security policy it cannot be removed from the policy. It either has to be enabled or disabled.

    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).
.EXAMPLE
    (No Parameters)
    
    Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\AutoAdminLogon changed from 1 to 0
    Retrieving existing security policy...
                                                                            
    The task has completed successfully.
    See log %windir%\security\logs\scesrv.log for detail info.
    Modifying policy to require Ctrl Alt Del to be pressed on login.
    Applying updated policy...
    Completed 5 percent (0/18) 	Process Security Policy area        
    Completed 22 percent (3/18) 	Process Security Policy area        
    Completed 44 percent (7/18) 	Process Security Policy area        
    Completed 61 percent (10/18) 	Process Security Policy area        
    Completed 77 percent (13/18) 	Process Security Policy area        
    Completed 100 percent (18/18) 	Process Security Policy area        
                                                                            
    The task has completed successfully.
    See log %windir%\security\logs\scesrv.log for detail info.

PARAMETER: -MicrosoftDefaults
    Reverts all the modified settings to their Microsoft default value.

PARAMETER: -ForceRestart
    Schedules a restart for 60 seconds from now so that the CTRL+ALT+DEL login requirement may take immediate effect.

.NOTES
    Minimum OS Architecture Supported: Windows 10, Windows Server 2016
    Release Notes: Initial Release
#>

[CmdletBinding()]
param (
    [Parameter()]
    [Switch]$MicrosoftDefaults = [System.Convert]::ToBoolean($env:revertToMicrosoftDefaults),
    [Parameter()]
    [Switch]$ForceRestart = [System.Convert]::ToBoolean($env:forceRestart)
)

begin {

    function Test-IsDomainJoined {
        if ($PSVersionTable.PSVersion.Major -lt 5) {
            return $(Get-WmiObject -Class Win32_ComputerSystem).PartOfDomain
        }
        else {
            return $(Get-CimInstance -Class Win32_ComputerSystem).PartOfDomain
        }
    }

    function Set-RegKey {
        param (
            $Path,
            $Name,
            $Value,
            [ValidateSet("DWord", "QWord", "String", "ExpandedString", "Binary", "MultiString", "Unknown")]
            $PropertyType = "DWord"
        )

        # Check if the specified path exists, if not, create it.
        if (-not $(Test-Path -Path $Path)) {
            New-Item -Path $Path -Force | Out-Null
        }

        # Check if the property already exists at the path.
        if ((Get-ItemProperty -Path $Path -Name $Name -ErrorAction SilentlyContinue)) {

            # Retrieve the current value of the registry key.
            $CurrentValue = (Get-ItemProperty -Path $Path -Name $Name -ErrorAction SilentlyContinue).$Name
            try {
                # Attempt to update the property's value.
                Set-ItemProperty -Path $Path -Name $Name -Value $Value -Force -Confirm:$false -ErrorAction Stop | Out-Null
            }
            catch {
                # If an error occurs during the update, print an error message and exit.
                Write-Host "[Error] Unable to Set registry key for $Name please see below error!"
                Write-Host "[Error] $($_.Message)"
                exit 1
            }
            # Print a confirmation of the change.
            Write-Host "$Path\$Name changed from $CurrentValue to $($(Get-ItemProperty -Path $Path -Name $Name -ErrorAction SilentlyContinue).$Name)"
        }
        else {
            try {
                # If the property does not exist, create it with the specified value and type.
                New-ItemProperty -Path $Path -Name $Name -Value $Value -PropertyType $PropertyType -Force -Confirm:$false -ErrorAction Stop | Out-Null
            }
            catch {
                # If an error occurs during creation, print an error message and exit.
                Write-Host "[Error] Unable to Set registry key for $Name please see below error!"
                Write-Host "[Error] $($_.Exception.Message)"
                exit 1
            }

            # Print a confirmation of the change.
            Write-Host "Set $Path\$Name to $($(Get-ItemProperty -Path $Path -Name $Name -ErrorAction SilentlyContinue).$Name)"
        }
    }
    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 (!$ExitCode) {
        $ExitCode = 0
    }
}
process {
    # Check if the current user session is elevated with administrator privileges. If not, display an error message and exit the script.
    if (!(Test-IsElevated)) {
        Write-Host -Object "[Error] Access Denied. Please run with Administrator privileges."
        exit 1
    }

    # Retrieve the AutoAdminLogon and DefaultPassword registry values to check for automatic login settings and stored passwords.
    $AutoLogin = Get-ItemProperty -Path "Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" -Name "AutoAdminLogon" -ErrorAction SilentlyContinue | Select-Object -ExpandProperty "AutoAdminLogon" -ErrorAction SilentlyContinue
    $DefaultPassword = Get-ItemProperty -Path "Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" -Name "DefaultPassword" -ErrorAction SilentlyContinue | Select-Object -ExpandProperty "DefaultPassword" -ErrorAction SilentlyContinue
    $PasswordLessSetting = Get-ItemProperty -Path "Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\PasswordLess\Device" -Name "DevicePasswordLessBuildVersion" -ErrorAction SilentlyContinue | Select-Object -ExpandProperty "DevicePasswordLessBuildVersion" -ErrorAction SilentlyContinue

    # Alert if a password is stored in the registry, which might be insecure if in plain text.
    if ($DefaultPassword) {
        Write-Host "[Alert] A Password is stored in HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\DefaultPassword. This password is likely in plain text."
    }

    # Check if the device is part of a domain, and if so, recommend using group policy for login settings.
    if (Test-IsDomainJoined) {
        Write-Host "[Error] This device is domain joined. CTRL ALT Delete login should be setup using group policy."
        Write-Host "[Info] Group Policy Location: Computer Configuration > Windows Settings > Security Settings > Local Policies > Security Options > Interactive logon:(...)"
        Write-Host "[Info] https://learn.microsoft.com/en-us/previous-versions/windows/it-pro/windows-10/security/threat-protection/security-policy-settings/interactive-logon-do-not-require-ctrl-alt-del"
        exit 1
    }

    # Turn off automatic login if it is enabled.
    if ($AutoLogin -ne 0) {
        Set-RegKey -Path "Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" -Name "AutoAdminLogon" -Value 0
    }

    # Disable automatic login if it is enabled
    if ($PasswordLessSetting -eq 0) {
        Set-RegKey -Path "Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\PasswordLess\Device" -Name "DevicePasswordLessBuildVersion" -Value 2
    }

    # Announce the start of the security policy retrieval process.
    Write-Host "Retrieving existing security policy..."

    # Export the current security policy and record the output to a temporary file.
    $SecurityPolicyPath = "$env:TEMP\enable-ctrlaltdellogin.cfg"
    $OutputPath = "$env:TEMP\enable-ctrlaltdellogin.txt"
    $ExportPolicy = Start-Process SecEdit.exe -ArgumentList "/export /cfg $SecurityPolicyPath" -RedirectStandardOutput $OutputPath -NoNewWindow -Wait -PassThru
    $ExportPolicyOutput = Get-Content -Path $OutputPath

    # Display the output of the policy export and clean up the temporary file.
    if ($ExportPolicyOutput) {
        $ExportPolicyOutput | Write-Host
        Remove-Item $OutputPath
    }

    # Check the exit code of the export process and display an error message if the export failed.
    if ($ExportPolicy.ExitCode -ne 0) {
        Write-Host -Object "Exit Code: $($ExportPolicy.ExitCode)"
        Write-Host -Object "[Error] Unable to edit security policy."
        exit 1
    }
    
    # Check if Microsoft default setting is specifed.
    if ($MicrosoftDefaults) {
        Write-Host "Removing Ctrl Alt Del requirement from security policy..."

        # Initialize a new list to store modified security policy settings.
        $NewSecPolicy = New-Object System.Collections.Generic.List[string]

        # Read the current security policy and process each line.
        Get-Content $SecurityPolicyPath | ForEach-Object {

            # If the line contains settings for CTRL ALT DEL, reset the value.
            if ($_ -match "DisableCAD") {
                $NewSecPolicy.Add(($_ -replace ",.*", ",1"))
            }
            else {
                $NewSecPolicy.Add($_)
            }
        }

        # Write the modified security policy back to the configuration file.
        $NewSecPolicy | Out-File $SecurityPolicyPath

        Write-Host "Applying updated policy..."
        # Apply the modified security policy using SecEdit.exe.
        $UpdateSecurityPolicy = Start-Process SecEdit.exe -ArgumentList "/configure /db c:\windows\security\local.sdb /cfg $SecurityPolicyPath" -RedirectStandardOutput $OutputPath -Wait -NoNewWindow -PassThru
    
        # Capture the output from the policy update and display it.
        $UpdatePolicyOutput = Get-Content -Path $OutputPath
        if ($UpdatePolicyOutput) {
            $UpdatePolicyOutput | Write-Host
            Remove-Item $OutputPath
        }
    

        # Check the exit code of the policy update process and handle errors.
        if ($UpdateSecurityPolicy.ExitCode -ne 0) {
            Write-Host -Object "Exit Code: $($UpdateSecurityPolicy.ExitCode)"
            Write-Host -Object "[Error] Unable to update security policy."
            exit 1
        }
        else {
            if ($ForceRestart) {
                Write-Warning -Message "Scheduling system restart for 60 seconds from now. $((Get-Date).AddMinutes(60))"
                Start-Process shutdown.exe -ArgumentList "/r /t 60" -Wait -NoNewWindow
            }
            else {
                Write-Warning -Message "A restart may be required for the Ctrl Alt Del requirement to be removed. Please restart at your earliest convenience."
            }
            
            exit $ExitCode
        }
    }

    # Begin modification to require ctrl alt del in the security policy.
    Write-Host "Modifying policy to require Ctrl Alt Del to be pressed on login."

    # Check if the current policy already includes a ctrl alt del requirement.
    if (Get-Content $SecurityPolicyPath | Where-Object { $_ -like "*DisableCAD*" }) {
        # Replace the existing title with a new one, maintaining other parts of the line.
        $Caption = (Get-Content $SecurityPolicyPath | Where-Object { $_ -like "*DisableCAD*" }) -replace ',.*', ",0"
        (Get-Content $SecurityPolicyPath) -replace ".*DisableCAD.*", "$Caption" | Out-File $SecurityPolicyPath
    }
    else {
        # If setting is not present, create a new list for the modified policy settings.
        $NewSecPolicy = New-Object System.Collections.Generic.List[string]
        # Create the new setting.
        $Caption = "MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\DisableCAD=4,0"

        # Read the current policy and add the new setting where appropriate.
        Get-Content $SecurityPolicyPath | ForEach-Object {
            if ($_ -match "\[Registry Values\]") {
                $NewSecPolicy.Add($_)
                $NewSecPolicy.Add($Caption)
            }
            else {
                $NewSecPolicy.Add($_)
            }
        }

        # Write the modified settings back to the configuration file.
        $NewSecPolicy | Out-File $SecurityPolicyPath
    }

    # Display a message indicating that the updated security policy is being applied.
    Write-Host "Applying updated policy..."
    $UpdateSecurityPolicy = Start-Process SecEdit.exe -ArgumentList "/configure /db c:\windows\security\local.sdb /cfg $SecurityPolicyPath /areas securitypolicy" -RedirectStandardOutput $OutputPath -Wait -NoNewWindow -PassThru
    
    $UpdatePolicyOutput = Get-Content -Path $OutputPath
    # If there is any output from the SecEdit process, display it in the console.
    if ($UpdatePolicyOutput) {
        $UpdatePolicyOutput | Write-Host
        Remove-Item $OutputPath
    }
    

    # Check if the SecEdit process completed successfully by examining the exit code.
    if ($UpdateSecurityPolicy.ExitCode -ne 0) {
        Write-Host -Object "Exit Code: $($UpdateSecurityPolicy.ExitCode)"
        Write-Host -Object "[Error] Unable to update security policy."
        exit 1
    }

    if ($ForceRestart) {
        Write-Warning -Message "Scheduling system restart for 60 seconds from now. $((Get-Date).AddMinutes(60))"
        Start-Process shutdown.exe -ArgumentList "/r /t 60" -Wait -NoNewWindow
    }
    else {
        Write-Warning -Message "A restart may be required for the Ctrl Alt Del requirement to take effect. Please restart at your earliest convenience."
    }
    
    exit $ExitCode
}
end {
    
    
    
}

 

Come funziona lo script per disabilitare il login automatico

1. Controlli preliminari e funzioni

• Privilegi di amministratore: Lo script per disabilitare il login automatico controlla che sia eseguito con privilegi elevati, fondamentali per modificare le chiavi di registro e i criteri di sicurezza.
• Controllo del dominio: Verifica se il dispositivo è unito al dominio. Per i computer collegati al dominio, si consiglia di utilizzare i Criteri di gruppo invece di modificare le impostazioni locali.
• Funzioni di aiuto:
• Test-IsDomainJoined determina l’appartenenza al dominio.
• Set-RegKey gestisce le modifiche al registro, verificando l’esistenza delle chiavi e procedendo con l’aggiornamento dei valori secondo le necessità.
• Test-IsElevated controlla la presenza di diritti amministrativi.

2. Modifiche alle chiavi di registro

• Lo script disabilita AutoAdminLogon impostando il valore del registro di sistema a 0. In questo modo si garantisce che gli utenti non possano aggirare l’autenticazione all’avvio.
• Inoltre, regola il parametro DevicePasswordLessBuildVersion per imporre l’uso della password.

3. Configurazione dei criteri di sicurezza

• Lo script per disabilitare il login automatico esporta il criterio di sicurezza corrente utilizzando SecEdit.exe e lo modifica per applicare i requisiti di accesso con CTRL+ALT+CANC .
• Se vengono specificate le impostazioni predefinite di Microsoft, lo script ripristina l’impostazione DisableCAD per consentire l’aggiramento di CTRL+ALT+CANC.

4. Applicazione del criterio

• Dopo aver modificato il file di configurazione, lo script per disabilitare il login automatico riapplica il criterio di sicurezza per rendere effettive le modifiche.
• Se specificato, pianifica un riavvio del sistema per garantire che le nuove impostazioni abbiano effetto immediato.

5. Gestione degli errori e avvisi

• Lo script per disabilitare il login automatico verifica la presenza di potenziali insidie, come le password memorizzate in chiaro o i privilegi insufficienti, e fornisce un riscontro operativo.

Applicazioni pratiche per i professionisti IT

Caso d’uso ipotetico

Immagina un amministratore IT che gestisce le postazioni di lavoro in un istituto finanziario. Per rispettare le norme di sicurezza, deve imporre la pressione di CTRL+ALT+CANC per il login e disabilitare il login automatico su 50 dispositivi. Invece di configurare manualmente ogni macchina, utilizza questo script PowerShell per automatizzare il processo. Lo script per disabilitare il login automatico viene eseguito durante le ore non di punta, applicando le modifiche in modo uniforme e registrando i progressi per la rendicontazione.

Confronto tra lo script per disabilitare il login automatico e altri metodi

Mentre questo script fornisce una soluzione robusta per disabilitare il login automatico per i sistemi autonomi, i dispositivi uniti al dominio beneficiano dei Criteri di gruppo, che offrono un controllo e una verifica centralizzati. Tuttavia, per i sistemi non di dominio o per le configurazioni una tantum, lo script supera i metodi manuali grazie alle sue capacità di automazione e di controllo degli errori.

Domande frequenti

D1: Questo script può essere utilizzato su sistemi collegati a un dominio?

Lo script lo sconsiglia, consigliando l’uso di criteri di gruppo per una migliore scalabilità e conformità.

D2: Cosa succede se lo script viene eseguito senza privilegi amministrativi?

Lo script rileva questo scenario e termina, chiedendo all’utente di rieseguirlo con permessi elevati.

D3: Le modifiche avranno effetto immediato?

La maggior parte delle modifiche viene applicata immediatamente, ma si consiglia di riavviare il sistema affinché il requisito CTRL+ALT+CANC abbia pieno effetto.

D4: Come posso annullare le modifiche?

Utilizza il parametro -MicrosoftDefaults per riportare le impostazioni ai valori predefiniti di Microsoft.

Implicazioni per la sicurezza informatica

Imponendo CTRL+ALT+CANC, le organizzazioni rafforzano le loro difese contro il furto di credenziali e gli attacchi di spoofing. Disabilitare il login automatico riduce il rischio di accesso non autorizzato, in particolare sui dispositivi che si trovano in aree condivise o ad alto traffico. Sebbene questo script riguardi le configurazioni locali, sottolinea l’importanza delle strategie di sicurezza a più livelli negli ambienti IT.

Raccomandazioni per l’uso dello script per disabilitare il login automatico

1. Testa in ambiente controllato: Prima di distribuire in modo ampio, esegui lo script per disabilitare il login automatico su un computer di prova per garantire la compatibilità e i risultati desiderati.
2. Modifiche al documento: Conserva log di quando e dove viene applicato lo script per disabilitare il login automatico per riferimenti futuri e per la verifica.
3. Integrazione con l’automazione: Utilizza strumenti come NinjaOne per pianificare e monitorare l’esecuzione dello script per disabilitare il login automatico su più dispositivi.

Considerazioni finali

L’automatizzazione delle configurazioni di sicurezza, come disabilitare il login automatico e imporre la pressione di CTRL+ALT+CANC , è un compito fondamentale per i professionisti IT. Questo script semplifica il processo, garantendo la conformità e migliorando la sicurezza. Per esigenze di gestione IT più ampie, strumenti come NinjaOne possono semplificare tali operazioni, offrendo controllo centralizzato, reportistica e automazione per gestire in modo efficiente ambienti complessi.