Guide de script PowerShell : détecter les comptes verrouillés sur Windows

Points à retenir

• PowerShell pour plus d’efficacité: Utiliser PowerShell pour détecter les comptes verrouillés rapidement dans les environnements Windows.
• Exclut Azure AD: Le script ne couvre pas les comptes Azure AD, se concentrant uniquement sur les comptes locaux et les comptes de contrôleur de domaine.
• Détection spécifique à l’environnement: Adapte son approche suivant s’il est exécuté sur un contrôleur de domaine ou sur une station de travail.
• Résultats personnalisables: Il offre une grande flexibilité pour le format des résultats et permet l’exportation dans en fichiers CSV et TXT.
• Capacité de filtrage des utilisateurs: Il peut cibler des utilisateurs spécifiques si nécessaire, ce qui améliore sa précision.
• Automatisé plutôt que manuel: Représente une alternative efficace aux méthodes de vérification manuelle des comptes.
• Indication de problèmes plus vastes: Les comptes verrouillés peuvent être le signe de problèmes de sécurité ou d’exploitation plus vastes.
• Accessible aux débutants: Facile à utiliser pour ceux qui ont des connaissances de base de PowerShell, mais personnalisable pour les utilisateurs avancés.
• Un suivi régulier est recommandé: Il est préférable de l’utiliser dans le cadre d’une stratégie de suivi régulier des comptes.
• Amélioré avec NinjaOne: Les fonctionnalités du script complètent les outils de gestion informatique complets de NinjaOne.

Le monde de la sécurité informatique étant en constante évolution, la gestion des comptes d’utilisateurs reste un élément primordial pour permettre une protection des systèmes et des données. L’un des aspects essentiels est la surveillance et le traitement des comptes verrouillés, un problème courant dans les environnements informatiques vastes et dynamiques. Avec PowerShell, les administrateurs peuvent identifier les comptes verrouillés de façon efficace, garantissant ainsi la continuité et la sécurité de l’entreprise.

Contexte

Le script PowerShell fourni apparaît comme un outil essentiel pour les professionnels de l’informatique et les fournisseurs de services gérés (MSP). Sa fonction principale est d’identifier les comptes verrouillés dans un environnement Windows, à l’exclusion des comptes Azure AD. Cette capacité est cruciale pour maintenir l’efficacité opérationnelle et la sécurité, car les comptes verrouillés peuvent être à la fois le symptôme d’une erreur de l’utilisateur et l’indicateur potentiel d’une faille de sécurité. 

Le script :

<#
.SYNOPSIS
    This script will see if any accounts on a local machine or on a domain controller are locked out. 
    You can optionally export this information into a custom field.

    Does NOT check Azure AD Accounts.
.DESCRIPTION
    This script will see if any accounts on a local machine or on a domain controller are locked out. 
    You can optionally export this information into a custom field.

    Does NOT check Azure AD Accounts.
    
.EXAMPLE
    (No Parameters but ran on a DC)
    SamAccountName LastLogonDate        PasswordExpired Enabled
    -------------- -------------        --------------- -------
    user           4/20/2023 1:09:23 PM           False    True

.EXAMPLE
    (No Parameters but ran on a Workstation)
    Name  Domain LocalAccount Disabled
    ----  ------ ------------ --------
    user  TEST          False    False

PARAMETER: -ExportTXT "ReplaceMeWithAnyMultiLineCustomField"
    Name of a multi-line customfield you'd like to export the results to.
.EXAMPLE
    -ExportTXT "ReplaceMeWithAnyMultiLineCustomField"
    Name  Domain LocalAccount Disabled
    ----  ------ ------------ --------
    user  TEST          False    False

PARAMETER: -ExportCSV "ReplaceMeWithAnyMultiLineCustomField"
    Name of a multi-line customfield you'd like to export the results to.
.EXAMPLE
    -ExportCSV "ReplaceMeWithAnyMultiLineCustomField"
    Name  Domain LocalAccount Disabled
    ----  ------ ------------ --------
    user  TEST          False    False

.OUTPUTS
    None
.NOTES
    Minimum OS Architecture Supported: Windows 7, Windows Server 2008
    Release Notes: Renamed script, added Script Variable support, added support for showing results of only 1 or more specific users.
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]$Users,
    [Parameter()]
    [String]$ExportCSV,
    [Parameter()]
    [String]$ExportTXT
)

begin {
    if ($env:usersToCheck -and $env:usersToCheck -notlike "null") { $Users = $env:usersToCheck }
    if ($env:exportCsvResultsToThisCustomField -and $env:exportCsvResultsToThisCustomField -notlike "null") { $ExportCSV = $env:exportCsvResultsToThisCustomField }
    if ($env:exportTextResultsToThisCustomField -and $env:exportTextResultsToThisCustomField -notlike "null") { $ExportTXT = $env:exportTextResultsToThisCustomField }

    if ($Users) {
        $UsersToCheck = $Users.split(',') | ForEach-Object { $_.Trim() }
        Write-Warning "Only the following users will be checked: $UsersToCheck"
    }
    function Test-IsDomainController {
        if ($PSVersionTable.PSVersion.Major -ge 5) {
            $OS = Get-CimInstance -ClassName Win32_OperatingSystem
        }
        else {
            $OS = Get-WmiObject -Class Win32_OperatingSystem
        }

        if ($OS.ProductType -eq "2") {
            return $True
        }
    }

    function Test-IsAzureJoined {
        $dsreg = dsregcmd.exe /status | Select-String "AzureAdJoined : YES"
        if ($dsreg) {
            return $True
        }
    }

    if ([System.Environment]::OSVersion.Version.Major -ge 10) {
        if (Test-IsAzureJoined) { Write-Warning "This device is Azure AD Joined, this script currently cannot detect if Azure AD Users are locked out!" }
    }
}
process {

    # For Domain Controllers find the locked out account using Search-ADAccount
    if (Test-IsDomainController) {
        Import-Module ActiveDirectory
        $LockedOutUsers = Search-ADAccount -LockedOut | Select-Object SamAccountName, LastLogonDate, PasswordExpired, Enabled
    }
    else {
        $LockedOutUsers = if ($PSVersionTable.PSVersion.Major -ge 5) {
            Get-CimInstance -ClassName Win32_Useraccount | Where-Object { $_.Lockout -eq $True } | Select-Object Name, Domain, LocalAccount, Disabled 
        }
        else {
            Get-WmiObject -Class Win32_Useraccount | Where-Object { $_.Lockout -eq $True } | Select-Object Name, Domain, LocalAccount, Disabled
        }
    }

    if ($Users) {
        $LockedOutUsers = $LockedOutUsers | Where-Object { $UsersToCheck -contains $_.Name -or $UsersToCheck -contains $_.SamAccountName } 
    }

    if ($LockedOutUsers) {
        # Output any locked out users into the activity log
        Write-Warning "Locked out users were found!"
        $LockedOutUsers | Format-Table | Out-String | Write-Host

        # Export the list in CSV format into a custom field
        if ($ExportCSV) {
            Ninja-Property-Set $ExportCSV ($LockedOutUsers | ConvertTo-Csv -NoTypeInformation)
        }

        # Export the usernames into a custom field
        if ($ExportTXT) {
            if ($LockedOutUsers.Name) {
                Ninja-Property-Set $ExportTXT ($LockedOutUsers.Name | Out-String)
            }

            if ($LockedOutUsers.SamAccountName) {
                Ninja-Property-Set $ExportTXT ($LockedOutUsers.SamAccountName | Out-String)
            }
        }
        Exit 1
    }

    Write-Host "No locked out users detected. Please note this does NOT check Azure AD Accounts."
    Exit 0
}
end {
    
    
    
}

 

Description détaillée

Le script fonctionne de manière simple mais efficace :

• Initialisation des paramètres : Il commence par définir les paramètres d’entrée des utilisateurs, qui comprennent des options permettant de spécifier des utilisateurs particuliers et d’exporter les résultats aux formats CSV ou TXT.
• Vérification de l’environnement: Le script évalue ensuite l’environnement d’exploitation, en déterminant s’il s’agit d’un contrôleur de domaine ou d’une station de travail, et si la machine est reliée à Azure AD. Ce point est crucial car il détermine la méthode utilisée pour trouver les comptes bloqués.
• Détection de compte bloqué:
  • Pour les contrôleurs de domaine, il utilise Search-ADAccount pour trouver les comptes verrouillés.
  • Pour les postes de travail, il utilise les méthodes de la classe Win32_UserAccount.
• Vérification sélective des utilisateurs: Si des utilisateurs spécifiques sont indiqués, les résultats sont filtrés en conséquence.
• Résultats et exportation: Le script affiche les comptes verrouillés et offre la possibilité d’exporter ces informations au format CSV ou TXT.
• Finalisation: Il conclut en indiquant si des comptes verrouillés ont été détectés ou non.

Cas d’utilisation potentiels

Imaginez une entreprise MSP qui gère un réseau avec de nombreux comptes d’utilisateurs. Soudain, plusieurs utilisateurs signalent l’impossibilité d’accéder à leurs comptes. L’entreprise MSP peut rapidement exécuter ce script pour identifier les comptes verrouillés, ce qui accélère considérablement le processus de dépannage et de résolution.

Comparaisons

Traditionnellement, les vérifications de comptes verrouillés impliquent des recherches manuelles ou l’utilisation d’outils distincts tels que les outils d’administration AD. L’approche PowerShell rationalise ce processus, offrant une solution plus intégrée et scriptable, efficace pour les environnements à grande échelle.

FAQ

• Ce script peut-il vérifier les comptes Azure AD ?
  Non, il est spécifiquement conçu pour les comptes locaux et les comptes de contrôleurs de domaine.
• Ce script est-il adapté aux débutants en PowerShell ?
  Oui, il est facile à utiliser, mais il est recommandé d’avoir des connaissances de base de PowerShell.
• Le script peut-il être personnalisé ?
  Absolument, il est flexible et peut être modifié pour répondre à des besoins particuliers.

Implications

Bien que le script soit très efficace, il est important de se rappeler que les comptes verrouillés peuvent signaler des problèmes plus profonds, tels que des failles de sécurité ou une mauvaise utilisation du système. L’identification et l’analyse en temps utile sont essentielles.

Recommandations

• Utilisez régulièrement le script pour des contrôles proactifs.
• Combinez cela avec des protocoles de sécurité plus étendus.
• Personnalisez le script en fonction des besoins particuliers de votre environnement.

Conclusion

A une époque où l’efficacité et la sécurité sont primordiales, NinjaOne offre les outils et les capacités nécessaires à une gestion moderne de l’informatique. Ce script illustre comment PowerShell, un composant de la suite NinjaOne, peut être utilisé pour améliorer les opérations et la sécurité informatiques. L’approche globale de la gestion informatique de NinjaOne en fait un allié indispensable pour naviguer dans le monde complexe de l’informatique.