Renforcer la sécurité avec PowerShell : désactiver la connexion automatique et imposer CTRL+ALT+SUPPR 

Dans les environnements informatiques, la sécurité est primordiale et chaque couche de défense est importante. Une mesure de sécurité souvent négligée consiste à demander aux utilisateurs d’appuyer sur CTRL+ALT+SUPPR avant de se connecter. Cette action agit comme une séquence d’attention sécurisée (SAS), garantissant que l’écran de connexion est authentique et qu’il ne s’agit pas d’une interface usurpée créée par un malware.

Pour les professionnels de l’informatique et les fournisseurs de services gérés (MSP), l’automatisation de ces tâches permet de gagner du temps et de renforcer la cohérence. C’est précisément ce que fait le script PowerShell fourni : il permet de désactiver la connexion automatique et applique l’exigence CTRL+ALT+SUPPR sur les systèmes Windows.

Comprendre la nécessité de pratiques de connexion sécurisées

L’exigence CTRL+ALT+SUPPR n’est pas là juste pour embêter les utilisateurs, elle offre des avantages cruciaux en matière de sécurité. Cette combinaison garantit que les utilisateurs interagissent avec le sous-système d’authentification sécurisé du système d’exploitation plutôt qu’avec des programmes potentiellement malveillants. La désactivation de la connexion automatique empêche également tout accès non autorisé dans les environnements partagés ou sensibles. Les professionnels de l’informatique qui gèrent des flottes d’appareils trouveront ce script très utile pour implémenter rapidement ces paramètres dans tous les systèmes.

Le script :

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

 

Comment fonctionne le script

1. Contrôles et fonctions préliminaires

• Privilèges d’administrateur : Le script garantit qu’il s’exécute avec des privilèges élevés, ce qui est essentiel pour modifier les clés de registre et les stratégies de sécurité.
• Vérification du domaine : Vérifie si l’appareil est relié à un domaine. Pour les machines reliées à un domaine, il est conseillé d’utiliser la stratégie de groupe plutôt que de modifier les paramètres locaux.
• Fonctions d’assistance :
• Test-IsDomainJoined détermine l’appartenance à un domaine.
• Set-RegKey gère les modifications du registre, en s’assurant que les clés existent et que les valeurs sont mises à jour si nécessaire.
• Test-IsElevated garantit les droits d’administration.

2. Modifications des clés du registre

• Le script désactive AutoAdminLogon en définissant sa valeur de registre à 0. Cela permet de s’assurer que les utilisateurs ne peuvent pas contourner l’authentification au démarrage.
• Il ajuste également la valeur de DevicePasswordLessBuildVersion pour imposer l’utilisation d’un mot de passe.

3. Configuration de la stratégie de sécurité

• Le script exporte la stratégie de sécurité actuelle à l’aide de SecEdit.exe et la modifie pour appliquer CTRL+ALT+SUPPR comme exigences de connexion.
• Si les valeurs par défaut de Microsoft sont spécifiées, le script réinitialise le paramètre DisableCAD pour permettre de contourner CTRL+ALT+SUPPR.

4. Application de la stratégie

• Après avoir modifié le fichier de configuration, le script réapplique la stratégie de sécurité pour que les changements soient effectifs.
• Si spécifié, il planifie un redémarrage du système pour s’assurer que les nouveaux paramètres prennent effet immédiatement.

5. Gestion des erreurs et alertes

• Le script vérifie les pièges potentiels, tels que les mots de passe stockés en texte brut ou les privilèges insuffisants, et fournit des retours exploitables.

Applications pratiques pour les professionnels de l’informatique

Cas d’utilisation hypothétique

Prenons l’exemple d’un administrateur informatique qui gère les postes de travail d’une institution financière. Pour se conformer aux règles de sécurité, ils doit imposer CTRL+ALT+SUPPR pour la connexion et désactiver la connexion automatique sur 50 appareils. Au lieu de configurer manuellement chaque machine, il utilise ce script PowerShell pour automatiser le processus. Le script s’exécute pendant les heures creuses, appliquant les changements de manière uniforme et enregistrant les progrès réalisés à des fins de responsabilisation.

Comparaison du script avec d’autres méthodes

Si ce script constitue une solution efficace pour les systèmes autonomes, les appareils reliés à un domaine bénéficient de la stratégie de groupe, qui offre un contrôle et un audit centralisés. Toutefois, pour les systèmes hors domaine ou les configurations uniques, le script surpasse les méthodes manuelles en raison de ses capacités d’automatisation et de vérification des erreurs.

Questions fréquemment posées

Qestion 1 : Ce script peut-il être utilisé sur des systèmes reliés par des domaines ?

Le script le déconseille et recommande la stratégie de groupe pour une meilleure évolutivité et une meilleure conformité.

Qestion 2 : Que se passe-t-il si le script est exécuté sans privilèges administratifs ?

Le script détecte ce scénario et se termine de manière élégante, en avertissant l’utilisateur qu’il doit le réexécuter avec des autorisations élevées.

Qestion 3 : Les changements prendront-ils effet immédiatement ?

La plupart des changements s’appliquent instantanément, mais il est recommandé de redémarrer le système pour que l’exigence CTRL+ALT+SUPPR prenne pleinement effet.

Qestion 4 : Comment puis-je annuler les modifications ?

Utilisez le paramètre -MicrosoftDefaults pour réinitialiser les paramètres aux valeurs par défaut de Microsoft.

Implications pour la sécurité informatique

En imposant CTRL+ALT+SUPPR, les entreprises renforcent leurs défenses contre le vol d’informations d’identification et les attaques par usurpation d’identité. La désactivation de la connexion automatique réduit le risque d’accès non autorisé, en particulier sur les appareils situés dans des zones partagées ou très fréquentées. Bien que ce script concerne les configurations locales, il souligne l’importance des stratégies de sécurité à plusieurs niveaux dans les environnements informatiques.

Recommandations pour l’utilisation du script

1. Test dans un environnement contrôlé : Avant de procéder à un déploiement à grande échelle, testez le script pour vous assurer de sa compatibilité et de son efficacité.
2. Modifications du document : Conservez des journaux indiquant quand et où le script est appliqué pour référence et audit ultérieurs.
3. Intégrer l’automatisation : Utilisez des outils tels que NinjaOne pour planifier et surveiller l’exécution des scripts sur plusieurs appareils.

Conclusion

L’automatisation des configurations de sécurité, comme la désactivation de la connexion automatique et l’application de CTRL+ALT+SUPPR , est une tâche essentielle pour les professionnels de l’informatique. Ce script simplifie le processus, assure la conformité et renforce la sécurité. Pour les besoins plus larges de gestion informatique, des outils tels que NinjaOne peuvent rationaliser ces opérations, en offrant un contrôle centralisé, des rapports et une automatisation permettant de gérer efficacement des environnements complexes.