Cómo desactivar el inicio de sesión automático en Windows mediante un script de PowerShell para mejorar la seguridad

A medida que las ciberamenazas siguen evolucionando, los profesionales de TI deben mantenerse constantemente alerta para garantizar unos protocolos de seguridad sólidos. Una de estas medidas es desactivar el inicio de sesión automático en los sistemas Windows. Este post profundizará en la importancia de esta práctica y proporcionará una guía completa sobre cómo conseguirlo mediante un script de PowerShell. Este script para desactivar el inicio de sesión automático no sólo lo desactiva, sino que también garantiza la presentación de un banner de inicio de sesión, lo que mejora la seguridad general.

Contexto

El inicio de sesión automático, aunque cómodo para los usuarios, plantea importantes riesgos de seguridad, sobre todo en entornos en los que se puede acceder a datos sensibles. Desactivar esta función obliga a los usuarios a autenticarse cada vez que inician sesión, lo que proporciona una capa adicional de seguridad. Para los profesionales de TI y los proveedores de servicios gestionados (MSP), la automatización de este proceso mediante scripts puede ahorrar tiempo y garantizar la coherencia entre varios sistemas.

El script para desactivar el inicio de sesión automático

#Requires -Version 5.1

<#
.SYNOPSIS
    Disables the automatic login feature and ensures that a dialog box is presented each time a user signs in.
.DESCRIPTION
    Disables the automatic login feature and ensures that a dialog box is presented each time a user signs in.
.EXAMPLE
    -Title "A Title" -Message "A Message"
    
    Retrieving existing security policy...
                                                                           
    The task has completed successfully.
    See log %windir%\security\logs\scesrv.log for detail info.
    Modifying policy to include the login banner.
    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: -Title "ReplaceMeWithYourDesiredTitle"
    Specify the title of the dialog box to be used in the logon banner.

PARAMETER: -Message "ReplaceMeWithYourDesiredMessage"
    Specify the main text body to be used in the logon banner. 

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 login banner may take immediate effect.

.NOTES
    Minimum OS Architecture Supported: Windows 10, Windows Server 2016
    Release Notes: Initial Release
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]$Title,
    [Parameter()]
    [String]$Message,
    [Parameter()]
    [Switch]$MicrosoftDefaults = [System.Convert]::ToBoolean($env:revertToMicrosoftDefaults),
    [Parameter()]
    [Switch]$ForceRestart = [System.Convert]::ToBoolean($env:forceRestart)
)

begin {
    if ($env:logonBannerTitle -and $env:logonBannerTitle -notlike "null") { $Title = $env:logonBannerTitle }
    if ($env:logonBannerText -and $env:logonBannerText -notlike "null") { $Message = $env:logonBannerText }

    # Check if a title is provided. If it exists, trim any leading or trailing whitespace.
    if ($Title) {
        $Title = $Title.Trim()
    }

    # If no title is provided and Microsoft defaults are not being used, output an error and exit the script.
    if (!$Title -and !$MicrosoftDefaults) {
        Write-Host "[Error] Missing title for the login banner."
        exit 1
    }

    # Check if a message is provided. If it exists, trim any leading or trailing whitespace.
    if ($Message) {
        $Message = $Message.Trim()
    }

    # If no message is provided and Microsoft defaults are not being used, output an error and exit the script.
    if (!$Message -and !$MicrosoftDefaults) {
        Write-Host "[Error] Missing message for the login banner."
        exit 1
    }

    # If Microsoft defaults are specified to be used but either a title or message is also provided, error out due to the title and message not being present by default.
    if ($MicrosoftDefaults -and ($Title -or $Message)) {
        Write-Host "[Error] A login banner is not present by default. If you use the 'Revert To Microsoft Defaults' checkmark, leave the 'Login Banner Title' and the 'Login Banner Text' empty."
        exit 1
    }

    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 banner settings.
    if (Test-IsDomainJoined) {
        Write-Host "[Error] This device is domain joined. Login Banner modifications 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-message-text-for-users-attempting-to-log-on"
        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-loginbanner.cfg"
    $ExportPolicy = Start-Process SecEdit.exe -ArgumentList "/export /cfg $SecurityPolicyPath" -RedirectStandardOutput "$env:TEMP\enable-loginbanner.txt" -NoNewWindow -Wait -PassThru
    $ExportPolicyOutput = Get-Content -Path "$env:TEMP\enable-loginbanner.txt"

    # Display the output of the policy export and clean up the temporary file.
    if ($ExportPolicyOutput) {
        $ExportPolicyOutput | Write-Host
        Remove-Item "$env:TEMP\enable-loginbanner.txt"
    }

    # 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 settings are specified to modify the login banner.
    if ($MicrosoftDefaults) {
        Write-Host "Removing login banner 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 LegalNoticeCaption or LegalNoticeText, reset these values.
            if ($_ -match "LegalNoticeCaption" -or $_ -match "LegalNoticeText") {
                $NewSecPolicy.Add(($_ -replace ",.*", ","))
            }
            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 "$env:TEMP\enable-loginbanner.txt" -Wait -NoNewWindow -PassThru
    
        # Capture the output from the policy update and display it.
        $UpdatePolicyOutput = Get-Content -Path "$env:TEMP\enable-loginbanner.txt"
        if ($UpdatePolicyOutput) {
            $UpdatePolicyOutput | Write-Host
            Remove-Item "$env:TEMP\enable-loginbanner.txt"
        }
    

        # 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 login banner to be removed. Please restart at your earliest convenience."
            }
            
            exit $ExitCode
        }
    }

    # Begin modification to include the login banner in the security policy.
    Write-Host "Modifying policy to include the login banner."

    # Check if the current policy already includes a title for the login banner.
    if (Get-Content $SecurityPolicyPath | Where-Object { $_ -like "*LegalNoticeCaption*" }) {
        # Replace the existing title with a new one, maintaining other parts of the line.
        $Caption = (Get-Content $SecurityPolicyPath | Where-Object { $_ -like "*LegalNoticeCaption*" }) -replace ',.*', ",`"$Title`""
        (Get-Content $SecurityPolicyPath) -replace ".*LegalNoticeCaption.*", "$Caption" | Out-File $SecurityPolicyPath
    }
    else {
        # If no title is present, create a new list for the modified policy settings.
        $NewSecPolicy = New-Object System.Collections.Generic.List[string]
        # Define the new title setting with the specified title
        $Caption = "MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\LegalNoticeCaption=1,`"$Title`""

        # Read the current policy and add the new title 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
    }

    # Check if the security policy file shows that the login banner text has already been set.
    if (Get-Content $SecurityPolicyPath | Where-Object { $_ -like "*LegalNoticeText*" }) {
        # If the setting is found, modify its existing entry by replacing the existing text after the comma
        # with a formatted version of $Message. Commas in $Message are replaced with '","', and new lines are replaced with commas.
        $Text = (Get-Content $SecurityPolicyPath | Where-Object { $_ -like "*LegalNoticeText*" }) -replace ',.*', ",$($Message -replace ',','","' -replace '\n',',')"
        
        # Replace the entire line that contains "LegalNoticeText" with the new formatted text, and overwrite the file.
        (Get-Content $SecurityPolicyPath) -replace ".*LegalNoticeText.*", "$Text" | Out-File $SecurityPolicyPath
    }
    else {
        # If the setting is not found in the file, initialize a new list to store all lines for the updated policy.
        $NewSecPolicy = New-Object System.Collections.Generic.List[string]

        # Create a new line for "LegalNoticeText" with the provided $Message formatted similarly to the replacement process above.
        $Text = "MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\LegalNoticeText=7,$($Message -replace ',','","' -replace '\n',',')"

        # Read each line of the security policy. If the line matches "[Registry Values]", it indicates the start of registry settings.
        Get-Content $SecurityPolicyPath | ForEach-Object {
            if ($_ -match "\[Registry Values\]") {
                # Add the current line and immediately follow it with the new "LegalNoticeText" setting.
                $NewSecPolicy.Add($_)
                $NewSecPolicy.Add($Text)
            }
            else {
                # Add other lines without modification.
                $NewSecPolicy.Add($_)
            }
        }

        # Write the updated list back to the security policy file, thus including the new "LegalNoticeText".
        $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 "$env:TEMP\enable-loginbanner.txt" -Wait -NoNewWindow -PassThru
    
    $UpdatePolicyOutput = Get-Content -Path "$env:TEMP\enable-loginbanner.txt"
    # If there is any output from the SecEdit process, display it in the console.
    if ($UpdatePolicyOutput) {
        $UpdatePolicyOutput | Write-Host
        Remove-Item "$env:TEMP\enable-loginbanner.txt"
    }
    

    # 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 login banner to take effect. Please restart at your earliest convenience."
    }
    
    exit $ExitCode
}
end {
    
    
    
}

 

Análisis detallado

Este script de PowerShell está diseñado para desactivar el inicio de sesión automático y garantizar que se presente un cuadro de diálogo cada vez que un usuario inicie sesión. Aquí tienes una explicación paso a paso de cómo funciona:

1. Parámetros y comprobaciones iniciales: el script para desactivar el inicio de sesión automático acepta parámetros para el título y el mensaje del banner de inicio de sesión, y conmutadores para volver a los valores predeterminados de Microsoft y forzar un reinicio. Comienza comprobando si se proporcionan estos parámetros, recortando cualquier espacio en blanco inicial o final. Si faltan parámetros esenciales y no se utilizan los valores por defecto de Microsoft, el script sale con un mensaje de error.
2. Comprobación de dominio: la función Test-IsDomainJoined comprueba si el dispositivo forma parte de un dominio. En caso afirmativo, el script para desactivar el inicio de sesión automático aconseja utilizar la directiva de grupo para la configuración del banner de inicio de sesión y finaliza. Esto garantiza el cumplimiento de las políticas del dominio y evita conflictos.
3. Modificación de claves de registro: La función Set-RegKey se utiliza para crear o modificar claves de registro que controlan la configuración del inicio de sesión automático. Si el inicio de sesión automático está activado (el valor de registro AutoAdminLogon no es 0), se establece en 0. Del mismo modo, si el inicio de sesión sin contraseña está activado, se desactiva estableciendo el valor DevicePasswordLessBuildVersion en 2.
4. Exportación y modificación de políticas de seguridad: el script para desactivar el inicio de sesión automático exporta la política de seguridad actual utilizando SecEdit.exe y procesa el archivo de configuración para incluir o modificar la configuración del banner de inicio de sesión. Si se solicitan los valores predeterminados de Microsoft, elimina cualquier configuración de banner de inicio de sesión existente. En caso contrario, actualiza el LegalNoticeCaption y el LegalNoticeText con el título y el mensaje proporcionados.
5. Aplicación de la política actualizada: tras modificar el archivo de configuración, el script para desactivar el inicio de sesión automático aplica la política de seguridad actualizada mediante SecEdit.exe. Si se fuerza un reinicio, programa un reinicio del sistema para garantizar que los cambios surtan efecto inmediatamente.
6. Pasos finales: el script proporciona información a lo largo de su ejecución, indicando el estado de cada operación y los errores encontrados.

Posibles casos de uso

Imagínate a un profesional de TI que gestiona una flota de portátiles para una entidad financiera. Garantizar que cada dispositivo requiera un inicio de sesión al arrancar es crucial para proteger los datos financieros confidenciales. Mediante este script para desactivar el inicio de sesión automático, el profesional de TI puede automatizar el proceso en todos los dispositivos, garantizando el cumplimiento de las políticas de seguridad y ahorrando tiempo en la configuración manual.

Comparaciones

Aunque las políticas de grupo son el método preferido para los dispositivos unidos a un dominio, este script para desactivar el inicio de sesión automático ofrece una solución sencilla para sistemas independientes o pequeños grupos de trabajo. Comparado con la edición manual del registro o el uso de herramientas de terceros, este script es más eficiente y reduce el riesgo de error humano.

FAQ

• ¿Se puede utilizar este script en todas las versiones de Windows? Este script para desactivar el inicio de sesión automático está diseñado para Windows 10 y Windows Server 2016 y versiones posteriores.
• ¿Qué ocurre si proporciono tanto los valores predeterminados de Microsoft como un título/mensaje personalizado? El script para desactivar el inicio de sesión automático arrojará un error, ya que no está pensado para mezclar estas configuraciones.
• ¿Es necesario reiniciar? Se recomienda reiniciar para que la configuración del banner de inicio de sesión surta efecto.
• ¿Puede ejecutarse sin privilegios de administrador? No, el script para desactivar el inicio de sesión automático debe ejecutarse con privilegios de administrador para modificar la configuración del registro y aplicar políticas de seguridad.

Implicaciones

Desactivar el inicio de sesión automático e implementar un banner de inicio de sesión mejora la seguridad al garantizar que los usuarios se autentiquen y reconozcan cualquier aviso de seguridad. Esta práctica reduce el riesgo de acceso no autorizado y garantiza el cumplimiento de los protocolos de seguridad.

Recomendaciones

• Prueba siempre el script en una sola máquina antes de desplegarlo ampliamente.

• Utiliza títulos y mensajes descriptivos para que el banner de inicio de sesión proporcione instrucciones o advertencias claras a los usuarios.

• Programa revisiones periódicas de las políticas de seguridad para adaptarse a la evolución de las amenazas a la seguridad.

Reflexiones finales

Para los profesionales de TI y los MSP, garantizar unas medidas de seguridad sólidas es primordial. Desactivar el inicio de sesión automático e implementar banners de inicio de sesión son pasos fundamentales para proteger los datos confidenciales. Este script de PowerShell para desactivar el inicio de sesión automático proporciona una forma eficaz y automatizada de lograr estos objetivos. Además, el uso de herramientas como NinjaOne puede mejorar aún más la gestión de la seguridad al proporcionar capacidades de control y supervisión centralizadas.