PowerShell : comment mettre à jour les stratégies de mots de passe Windows

Principaux points à retenir

  • Les politiques relatives aux mots de passe sont essentielles pour renforcer la sécurité informatique dans les entreprises.
  • Le script fourni automatise le processus de modification de la complexité du mot de passe dans Windows.
  • Le script prend en charge les ordinateurs appartenant ou non à un domaine.
  • L’exécution du script sans les privilèges administratifs entraînera un message d’erreur.
  • Les méthodes traditionnelles de modification des stratégies de mot de passe peuvent prendre plus de temps que ce script.
  • Testez toujours le script dans un environnement contrôlé avant de le déployer.
  • Informer les utilisateurs des changements de stratégie de mots de passe permet d’éviter la confusion et les verrouillages de comptes potentiels.
  • Une bonne pratique consiste à régulièrement réviser et ajuster les stratégies de mots de passe.
  • NinjaOne peut s’intégrer de manière naturelle à des outils d’automatisation pour renforcer les mesures de sécurité.

Dans le paysage informatique actuel, la sécurité reste primordiale. Avec les fuites des données faisant la une des journaux, la mise en place de stratégies de mots de passe performantes n’est plus seulement une option, mais une nécessité. Alors que les entreprises cherchent à renforcer leurs défenses, un moyen efficace de mettre à jour les stratégies de mots de passe Windows est un sujet crucial.

Contexte

Les stratégies relatives aux mots de passe, en particulier dans les environnements Windows, permettent de définir les exigences en matière de création et de conservation de ces derniers. En veillant à ce que ces règles soient strictes, on réduit le risque d’accès non autorisé. Le script fourni ici est conçu pour les professionnels de l’informatique et les fournisseurs de services gérés (MSP) afin de modifier sans effort la complexité du mot de passe pour un ordinateur appartenant ou non à un domaine.

Pourquoi un tel outil est-il précieux ? La modification manuelle des politiques de mot de passe, en particulier dans les grandes entreprises, peut être fastidieuse. Un tel script automatise le processus, le rendant plus rapide et moins faillible.

Le script

#Requires -Version 5.1

<#
.SYNOPSIS
    Modifies the password complexity settings for a domain or a non-domain computer.
.DESCRIPTION
    This script can be used to enable or disable the password complexity requirement on a domain or a non-domain computer.
    When using -Domain, this script must be run on a Domain Controller with the RSAT feature installed.
.PARAMETER ComplexityEnabled
    Enables the Password Complexity requirement.
.PARAMETER Domain
    Specifies the name of the domain. If specified, it will enable or disable the password complexity requirement on the Active Directory Default Domain Password Policy.
    The computer this script is executed on MUST have the PowerShell RSAT features installed when using the -Domain flag.
.EXAMPLE
     -ComplexityEnabled
    Enables the password complexity requirement on the computer this script runs on.
.EXAMPLE
     No param needed
    Disables the password complexity requirement on the computer this script runs on.
.EXAMPLE
     -ComplexityEnabled -Domain "test.consto.com"
    Enables the password complexity requirement in Active Directory for the Default Domain Password Policy.
    When using -Domain, this script must be run on a Domain Controller with the RSAT feature installed.
.EXAMPLE
     -Domain "test.consto.com"
    Disables the password complexity requirement in Active Directory for the Default Domain Password Policy.
    When using -Domain, this script must be run on a Domain Controller with the RSAT feature installed.
.NOTES
    Minimum OS Architecture Supported: Windows 10, Windows Server 2016
    Release Notes: Renamed script 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).
.COMPONENT
    ManageUsers
#>

[CmdletBinding()]
param (
    [Parameter(Mandatory = $false)]
    [Switch]
    $ComplexityEnabled,
    [Parameter(Mandatory = $false)]
    [String]
    $Domain
)
begin {
    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 Test-DomainJoined {
        # Check if the computer is domain joined
        if ((Get-Command -Name Get-WmiObject -ErrorAction SilentlyContinue)) {
            return $(Get-WmiObject -Class Win32_ComputerSystem).PartOfDomain
        }
        elseif ((Get-Command -Name Get-CIMInstance -ErrorAction SilentlyContinue)) {
            return $(Get-CimInstance -ClassName Win32_ComputerSystem).PartOfDomain
        }
        else {
            Write-Host "[Error] Get-WmiObject and Get-CIMInstance are not available. This script requires at least one of these cmdlets to run."
            exit 1
        }
    }
}
process {
    if (-not (Test-IsElevated)) {
        Write-Host "[Error] Access Denied. Please run with Administrator privileges."
        exit 1
    }
    
    if (-not ([string]::IsNullOrWhiteSpace($Domain))) {
        # Active Directory
    
        # Check if we are running on a Domain Controller, exit if we aren't
        $osInfo = Get-CimInstance -ClassName Win32_OperatingSystem
        if ($osInfo.ProductType -ne 2) {
            Write-Host "[Error] This needs to run on a Domain Controller."
            exit 1
        }
        # Set ComplexityEnabled to what was passed into $ComplexityEnabled
        Set-ADDefaultDomainPasswordPolicy -Identity $Domain -ComplexityEnabled $(if ($ComplexityEnabled) { $true }else { $false }) -Confirm:$false
        # Sleep for a while, just in case Get-ADDefaultDomainPasswordPolicy connects to a different AD server and replication is slow
        Start-Sleep -Seconds 60
        # Check if the ComplexityEnabled policy was applied correctly
        $Results = Get-ADDefaultDomainPasswordPolicy -Identity $Domain
        # Check that the policy matches what was requested
        if ($Results -and $Results.ComplexityEnabled -eq $ComplexityEnabled) {
            Write-Host "[Info] Set Complexity in Default Domain Password Policy to $ComplexityEnabled"
            return
        }
        else {
            # The policy was not set for some reason
            Write-Host "[Error] Failed to set Complexity in Default Domain Password Policy to $ComplexityEnabled"
            exit 1
        }
    }
    else {
        # Localhost
        # Check if the computer is domain joined

        if ($(Test-DomainJoined)) {
            Write-Host "[Error] This Computer is domain joined. Modifying the local policy is not supported for domain joined computers."
            exit 1
        }

        # Set the path for our temp local policy config file
        $Path = "$PSScriptRoot\Set-Password-Complexity-secpol.cfg"
        # Get our local policy
        SecEdit.exe /export /cfg $Path
        if ($LASTEXITCODE -gt 0) {
            Write-Host "[Error] Failed to read local machine Policy"
            exit 1
        }

        # Next make sure that we are not changing something that does not need to be changed
        # if $ComplexityEnabled is True and the temp local policy config file has PasswordComplexity set to 0, then proceed
        if ($ComplexityEnabled -and $(Get-Content -Path $Path) -Match "^PasswordComplexity = 0$") {
            # Change PasswordComplexity from 0 to 1
            $(Get-Content -Path $Path) -Replace "PasswordComplexity = 0", "PasswordComplexity = 1" | Out-File $Path
            # Update the local policy with our changes
            SecEdit.exe /configure /db c:\windows\security\local.sdb /cfg $Path /areas SECURITYPOLICY
            if ($LASTEXITCODE -gt 0) {
                Write-Host "[Error] Failed to set Complexity in local machine Policy to $ComplexityEnabled"
                exit 1
            }
        }# if $ComplexityEnabled is False and the temp local policy config file has PasswordComplexity set to 1, then proceed
        elseif (-not $ComplexityEnabled -and $(Get-Content -Path $Path) -Match "^PasswordComplexity = 1$") {
            # Change PasswordComplexity from 1 to 0
            $(Get-Content -Path $Path) -Replace "PasswordComplexity = 1", "PasswordComplexity = 0" | Out-File $Path
            # Update the local policy with our changes
            SecEdit.exe /configure /db c:\windows\security\local.sdb /cfg $Path /areas SECURITYPOLICY
            if ($LASTEXITCODE -gt 0) {
                Write-Host "[Error] Failed to set Complexity in local machine Policy to $ComplexityEnabled"
                exit 1
            }
        }
        # Remove our temp local policy config file
        Remove-Item $Path -Force
        # Get our local policy
        SecEdit.exe /export /cfg $Path
        # Check if the temp local policy config file has PasswordComplexity set to match our $ComplexityEnabled
        if (
            ($ComplexityEnabled -and $(Get-Content $Path) -Match "^PasswordComplexity = 1$") -or
            (-not $ComplexityEnabled -and $(Get-Content $Path) -Match "^PasswordComplexity = 0$")
        ) {
            # Remove our temp local policy config file again
            Remove-Item $Path -Force
            Write-Host "[Info] Set Complexity in local machine Policy to $ComplexityEnabled"
            return
        }
        else {
            # Remove our temp local policy config file again
            Remove-Item $Path -Force
            Write-Host "[Error] Failed to set Complexity in local machine Policy to $ComplexityEnabled"
            exit 1
        }
    }
}

 

Accédez à plus de 700 scripts dans le Dojo NinjaOne

Obtenir l’accès

Description détaillée

  • Exigences initiales : Le script est conçu pour Windows 10 ou Windows Server 2016. À noter également, si la fonction Active Directory est utilisée, RSAT pour Active Directory doit être installé.
  • Paramètres : Le script accepte deux paramètres facultatifs :
  • $ComplexityEnabled : Un commutateur qui active ou désactive la complexité du mot de passe.
  • domaine : Spécifie le nom de domaine pour lequel la politique de mot de passe sera modifiée.
  • Vérification de l’élévation : Avant toute action, le script vérifie s’il répond à des privilèges d’administrateur. Si ce n’est pas le cas, il s’arrête, ce qui garantit que les actions ne sont exécutées qu’avec les bonnes autorisations.
  • Active Directory : Si un domaine est spécifié, le script :
  • Vérifie s’il est exécuté sur un contrôleur de domaine.
  • Valide la présence du module ActiveDirectory.
  • Modifie la stratégie de mot de passe du domaine par défaut en fonction du paramètre $ComplexityEnabled.
  • Stratégie locale : Si aucun domaine n’est spécifié, le script :
  • Crée un fichier temporaire de configuration de la stratégie.
  • Vérifie le paramètre actuel de complexité du mot de passe.
  • Modifie ce paramètre en fonction du paramètre $ComplexityEnabled.

Cas d’utilisation potentiels

Étude de cas : Imaginez Adeline, une professionnelle de l’informatique, travaillant dans une entreprise qui a récemment subi des attaques par hameçonnage (phishing). Son équipe décide d’appliquer des stratégies plus strictes en matière de mots de passe. Au lieu de passer en revue chaque système ou contrôleur de domaine manuellement, Adeline utilise ce script. En l’exécutant simplement avec les paramètres souhaités, elle peut rapidement mettre à jour les stratégies de mot de passe, améliorant ainsi l’état de sécurité de l’entreprise.

Comparaisons

Traditionnellement, la modification des stratégies de mot de passe dans Windows nécessitait souvent de naviguer dans plusieurs interfaces graphiques, telles que la gestion des stratégies de groupe ou la stratégie de sécurité locale. Bien qu’efficaces, ces méthodes peuvent prendre beaucoup de temps. Ce script PowerShell rationalise le processus, offrant une approche plus rapide et plus efficace.

FAQ PowerShell et mise à jour des mots de passe Windows

  • Quelles sont les versions de Windows prises en charge par ce script ? 
    Windows 10 et Windows Server 2016.
  • Dois-je toujours spécifier un domaine ? 
    Non, si vous n’indiquez pas de domaine, le script prendra par défaut l’ordinateur local.
  • Que se passe-t-il si le script n’est pas exécuté avec des privilèges d’administrateur ?
    Il se terminera et affichera un message d’erreur.

Implications

Si l’automatisation des changements de stratégies de mot de passe peut accélérer les processus, il est essentiel d’en informer les utilisateurs. Les changements soudains de stratégie en matière de mots de passe peuvent entraîner une certaine confusion et des verrouillages potentiels, ce qui a un impact sur la productivité. En outre, du point de vue de la sécurité informatique, la mise à jour régulière et l’application des stratégies de mots de passe peuvent réduire considérablement le risque d’accès non autorisé.

Recommandations

  • Exécutez toujours le script dans un environnement de test avant de l’appliquer à une configuration réelle.
  • Révisez et ajustez régulièrement les politiques de mots de passe en fonction des dernières recommandations en matière de sécurité.
  • Sensibilisez les utilisateurs à l’importance de mots de passe forts et à la raison des changements de stratégie.

Conclusion

Dans le contexte d’une sécurité informatique renforcée, des outils tels que NinjaOne peuvent jouer un rôle essentiel. Non seulement ils fournissent des solutions de surveillance, mais ils s’intègrent parfaitement à des scripts tels que celui présenté ici. En utilisant NinjaOne avec de tels outils d’automatisation, les professionnels de l’informatique peuvent gérer et renforcer efficacement les mesures de sécurité de leur entreprise.

Pour aller plus loin

Créer une équipe informatique efficace et performante nécessite une solution centralisée qui soit l’outil principal pour fournir vos services. NinjaOne permet aux équipes informatiques de surveiller, gérer, sécuriser et prendre en charge tous les appareils, où qu’ils soient, sans avoir besoin d’une infrastructure complexe sur site.

Pour en savoir plus sur NinjaOne Endpoint Management, participez à une visite guidée ou commencez votre essai gratuit de la plateforme NinjaOne.

Vous pourriez aussi aimer

Voir la démo×
×

Voir NinjaOne en action !

En soumettant ce formulaire, j'accepte la politique de confidentialité de NinjaOne.

Termes et conditions NinjaOne

En cliquant sur le bouton « J’accepte » ci-dessous, vous indiquez que vous acceptez les termes juridiques suivants ainsi que nos conditions d’utilisation:

  • Droits de propriété: NinjaOne possède et continuera de posséder tous les droits, titres et intérêts relatifs au script (y compris les droits d’auteur). NinjaOne vous accorde une licence limitée pour l’utilisation du script conformément à ces conditions légales.
  • Limitation de l’utilisation: Les scripts ne peuvent être utilisés qu’à des fins personnelles ou professionnelles internes légitimes et ne peuvent être partagés avec d’autres entités.
  • Interdiction de publication: Vous n’êtes en aucun cas autorisé à publier le script dans une bibliothèque de scripts appartenant à, ou sous le contrôle d’un autre fournisseur de logiciels.
  • Clause de non-responsabilité: Le texte est fourni « tel quel » et « tel que disponible », sans garantie d’aucune sorte. NinjaOne ne promet ni ne garantit que le script sera exempt de défauts ou qu’il répondra à vos besoins ou attentes particulières.
  • Acceptation des risques: L’utilisation du script est sous votre propre responsabilité. Vous reconnaissez qu’il existe certains risques inhérents à l’utilisation du script, et vous comprenez et assumez chacun de ces risques.
  • Renonciation et exonération de responsabilité: Vous ne tiendrez pas NinjaOne pour responsable des conséquences négatives ou involontaires résultant de votre utilisation du script, et vous renoncez à tout droit ou recours légal ou équitable que vous pourriez avoir contre NinjaOne en rapport avec votre utilisation du script.
  • EULA: Si vous êtes un client de NinjaOne, votre utilisation du script est soumise au contrat de licence d’utilisateur final qui vous est applicable (End User License Agreement (EULA)).