Guía de scripts PowerShell: detectar cuentas bloqueadas en Windows

Principales conclusiones

• PowerShell para mayor eficacia: utiliza PowerShell para identificar rápidamente cuentas bloqueadas en entornos Windows.
• No incluye Azure AD: el script no cubre las cuentas de Azure AD, centrándose únicamente en las cuentas locales y de controlador de dominio.
• Detección específica del entorno: adapta tu enfoque en función de si se ejecuta en un controlador de dominio o en una estación de trabajo.
• Salida personalizable: ofrece flexibilidad en el formato de salida, permitiendo la exportación tanto en archivos CSV como TXT.
• Capacidad de filtrado de usuarios: puede dirigirse a usuarios específicos si es necesario, lo que aumenta su precisión.
• Automatizado vs. manual: representa una alternativa eficaz a los métodos manuales de comprobación de cuentas.
• Indicativo de problemas mayores: las cuentas bloqueadas pueden ser un signo de problemas operativos o de seguridad más amplios.
• Accesible para principiantes: fácil de usar para aquellos con conocimientos básicos de PowerShell, aunque personalizable para usuarios avanzados.
• Se recomienda un seguimiento regular: lo mejor es utilizarlo como parte de una estrategia regular de supervisión de cuentas.
• Mejorado con NinjaOne: la funcionalidad del script complementa las completas herramientas de gestión de TI de NinjaOne.

En el panorama en constante evolución de la seguridad de TI, la gestión de las cuentas de usuario sigue siendo una piedra angular para salvaguardar los sistemas y los datos. Un aspecto crítico es la supervisión y el tratamiento de las cuentas bloqueadas, un problema habitual en los entornos de TI grandes y dinámicos. Con PowerShell, los administradores pueden identificar eficazmente las cuentas bloqueadas, garantizando la continuidad y la seguridad de la empresa.

Contexto

El script PowerShell proporcionado surge como una herramienta vital para los profesionales de TI y los proveedores de servicios gestionados (MSP). Su función principal es detectar cuentas bloqueadas en un entorno Windows, excluyendo las cuentas de Azure AD. Esta capacidad es fundamental para mantener la eficacia operativa y la seguridad, ya que las cuentas bloqueadas pueden ser tanto un síntoma de error del usuario como un indicador potencial de brechas de la seguridad.

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

Análisis detallado

El script funciona de manera directa pero eficaz:

• Inicialización de parámetros: comienza estableciendo parámetros para la entrada de usuarios, que incluyen opciones para especificar usuarios concretos y exportar resultados en formatos CSV o TXT.
• Controles del entorno: a continuación, el script evalúa el entorno operativo, determinando si se está ejecutando en un controlador de dominio o en una estación de trabajo, y si el equipo está unido a Azure AD. Esto es crucial, ya que dicta el método utilizado para encontrar cuentas bloqueadas.
• Detección de cuentas bloqueadas:
  • En los Controladores de Dominio, emplea Search-ADAccount para encontrar cuentas bloqueadas.
  • En las estaciones de trabajo, utiliza los métodos de la clase Win32_UserAccount para conseguir lo mismo.
• Comprobación selectiva de usuarios: si se proporcionan usuarios específicos, filtra los resultados en consecuencia.
• Salida y exportación: el script muestra las cuentas bloqueadas y ofrece la opción de exportar esta información en formatos CSV o TXT.
• Finalización: concluye indicando si se han detectado o no cuentas bloqueadas.

Posibles casos de uso

Imagina a un MSP que gestiona una red con numerosas cuentas de usuario. De repente, varios usuarios informan de la imposibilidad de acceder a sus cuentas. El MSP puede ejecutar rápidamente este script para identificar las cuentas bloqueadas, lo que acelera significativamente el proceso de análisis y resolución de problemas.

Comparaciones

Tradicionalmente, las comprobaciones de cuentas bloqueadas implican búsquedas manuales o el uso de herramientas separadas, como las herramientas administrativas de Active Directory. El enfoque de PowerShell agiliza este proceso, ofreciendo una solución más integrada y programable que resulta eficaz para entornos a gran escala.

FAQ

• ¿Puede este script comprobar las cuentas de Azure AD?
  No, está diseñado específicamente para cuentas locales y de controlador de dominio.
• ¿Es este script adecuado para principiantes en PowerShell?
  Sí, es fácil de usar, aunque se recomienda tener conocimientos básicos de PowerShell.
• ¿Se puede personalizar?
  Por supuesto, el script es flexible y puede modificarse para adaptarse a necesidades específicas.

Implicaciones

Aunque el script es muy eficaz, es importante recordar que las cuentas bloqueadas pueden indicar problemas más profundos, como fallos de seguridad o un uso indebido del sistema. La identificación y el análisis oportunos son fundamentales.

Recomendaciones

• Utiliza regularmente el script para comprobaciones proactivas.
• Combínalo con protocolos de seguridad más amplios.
• Adapta el script a las necesidades específicas de tu entorno.

Reflexiones finales

En una época en la que la eficiencia y la seguridad son primordiales, NinjaOne ofrece las herramientas y capacidades necesarias para la gestión moderna de TI. Este script ejemplifica cómo PowerShell, un componente de la suite de NinjaOne, se puede aprovechar para mejorar las operaciones de TI y la seguridad. El enfoque integral de NinjaOne para la gestión de TI lo convierte en un aliado indispensable para navegar por el complejo panorama de TI.