Detectar y prevenir ataques de fuerza bruta con PowerShell

Aunque no cabe duda de que las ciberamenazas evolucionan continuamente, lo cierto es que la mayoría de las intrusiones siguen basándose en técnicas básicas de probada eficacia. ¿Si adivinar contraseñas de uso común o explotar contraseñas utilizadas en varias cuentas puede facilitarte el acceso, quién necesita organizar un ataque de día cero?

Los ataques de fuerza bruta siguen siendo una amenaza increíblemente común a la que se enfrentan las organizaciones. Detectar y bloquear estos ataques de fuerza bruta lo antes posible es fundamental, ya que a menudo son precursores de actividades más dañinas e intentos de acceso malintencionados. Dado que cada minuto cuenta en estas situaciones, establecer políticas de bloqueo de cuentas y alertas en tiempo real para los intentos fallidos de inicio de sesión es una medida disuasoria y de alerta temprana importantísima.

Pero, ¿qué ocurre con la detección de ataques de fuerza bruta en toda una red corporativa, a distancia y gran a escala?

Detectar y prevenir ataques de fuerza bruta en un contexto como este puede suponer un reto, por eso compartimos el siguiente script que los administradores pueden utilizar para automatizar el proceso, supervisando los intentos fallidos de inicio de sesión y activando alertas basadas en umbrales personalizables.

Script para detectar y prevenir los ataques de fuerza bruta

#Requires -Version 5.1

<#
.SYNOPSIS
    Condition for helping detect brute force login attempts.
.DESCRIPTION
    Condition for helping detect brute force login attempts.
.EXAMPLE
     -Hours 10
    Number of hours back in time to look through in the event log.
    Default is 1 hour.
.EXAMPLE
    -Attempts 100
    Number of login attempts to trigger at or above this number.
    Default is 8 attempts.
.OUTPUTS
    PSCustomObject[]
.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()]
    [int]
    $Hours = 1,
    [Parameter()]
    [int]
    $Attempts = 8
)

begin {
    function Test-IsElevated {
        $id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
        $p = New-Object System.Security.Principal.WindowsPrincipal($id)
        $p.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator)
    }
    function Test-StringEmpty {
        param([string]$Text)
        # Returns true if string is empty, null, or whitespace
        process { [string]::IsNullOrEmpty($Text) -or [string]::IsNullOrWhiteSpace($Text) }
    }
    if (-not $(Test-StringEmpty -Text $env:Hours)) {
        $Hours = $env:Hours
    }
    if (-not $(Test-StringEmpty -Text $env:Attempts)) {
        $Attempts = $env:Attempts
    }
}
process {
    if (-not (Test-IsElevated)) {
        Write-Error -Message "Access Denied. Please run with Administrator privileges."
        exit 1
    }

    if ($(auditpol.exe /get /category:* | Where-Object { $_ -like "*Logon*Success and Failure" })) {
        Write-Information "Audit Policy for Logon is set to: Success and Failure"
    }
    else {
        Write-Error "Audit Policy for Logon is NOT set to: Success and Failure"
        exit 1
        # Write-Host "Setting Logon to: Success and Failure"
        # auditpol.exe /set /subcategory:"Logon" /success:enable /failure:enable
        # Write-Host "Future failed login attempts will be captured."
    }

    $StartTime = (Get-Date).AddHours(0 - $Hours)
    $EventId = 4625

    # Get failed login attempts
    try {
        $Events = Get-WinEvent -FilterHashtable @{LogName = "Security"; ID = $EventId; StartTime = $StartTime } -ErrorAction Stop | ForEach-Object {
            $Message = $_.Message -split [System.Environment]::NewLine
            $Account = $($Message | Where-Object { $_ -Like "*Account Name:*" }) -split 's+' | Select-Object -Last 1
            [int]$LogonType = $($Message | Where-Object { $_ -Like "Logon Type:*" }) -split 's+' | Select-Object -Last 1
            $SourceNetworkAddress = $($Message | Where-Object { $_ -Like "*Source Network Address:*" }) -split 's+' | Select-Object -Last 1
            [PSCustomObject]@{
                Account              = $Account
                LogonType            = $LogonType
                SourceNetworkAddress = $SourceNetworkAddress
            }
        } | Where-Object { $_.LogonType -in @(2, 7, 10) }
    }
    catch {
        if ($_.Exception.Message -like "No events were found that match the specified selection criteria.") {
            Write-Host "No failed logins found in the past $Hours hour(s)."
            exit 0
        }
        else {
            Write-Error $_
            exit 1
        }
    }

    # Build a list of accounts 
    $UsersAccounts = [System.Collections.Generic.List[String]]::new()
    try {
        $ErrorActionPreference = "Stop"
        Get-LocalUser | Select-Object -ExpandProperty Name | ForEach-Object { $UsersAccounts.Add($_) }
        $ErrorActionPreference = "Continue"
    }
    catch {
        $NetUser = net.exe user
        $(
            $NetUser | Select-Object -Skip 4 | Select-Object -SkipLast 2
            # Join each line with a ","
            # Replace and spaces with a ","
            # Split everything by ","
        ) -join ',' -replace 's+', ',' -split ',' |
            # Sort and remove any duplicates
            Sort-Object -Descending -Unique |
            # Filter out empty strings
            Where-Object { -not [string]::IsNullOrEmpty($_) -and -not [string]::IsNullOrWhiteSpace($_) } |
            ForEach-Object {
                $UsersAccounts.Add($_)
            }
    }
    $Events | Select-Object -ExpandProperty Account | ForEach-Object { $UsersAccounts.Add($_) }

    $Results = $UsersAccounts | Select-Object -Unique | ForEach-Object {
        $Account = $_
        $AccountEvents = $Events | Where-Object { $_.Account -like $Account }
        $AttemptCount = $AccountEvents.Count
        $SourceNetworkAddress = $AccountEvents | Select-Object -ExpandProperty SourceNetworkAddress -Unique
        if ($AttemptCount -gt 0) {
            [PSCustomObject]@{
                Account              = $Account
                Attempts             = $AttemptCount
                SourceNetworkAddress = $SourceNetworkAddress
            }
        }
    }

    # Get only the accounts with fail login attempts at or over $Attempts
    $BruteForceAttempts = $Results | Where-Object { $_.Attempts -ge $Attempts }
    if ($BruteForceAttempts) {
        $BruteForceAttempts | Out-String | Write-Host
        exit 1
    }
    $Results | Out-String | Write-Host
    exit 0
}
end {
    $ScriptVariables = @(
        [PSCustomObject]@{
            name           = "Hours"
            calculatedName = "hours" # Must be lowercase and no spaces
            required       = $false
            defaultValue   = [PSCustomObject]@{ # If not default value, then remove
                type  = "TEXT"
                value = "1"
            }
            valueType      = "TEXT"
            valueList      = $null
            description    = "Number of hours back in time to look through in the event log."
        }
        [PSCustomObject]@{
            name           = "Attempts"
            calculatedName = "attempts" # Must be lowercase and no spaces
            required       = $false
            defaultValue   = [PSCustomObject]@{ # If not default value, then remove
                type  = "TEXT"
                value = "8"
            }
            valueType      = "TEXT"
            valueList      = $null
            description    = "Number of login attempts to trigger at or above this number."
        }
    )
}

 

Comprender y utilizar el script para detectar y prevenir los ataques de fuerza bruta

Nuestro script para detectar y prevenir los ataques de fuerza bruta se basa en dos parámetros principales: `Horas` e `Intentos`. El parámetro `Horas` define el periodo a revisar en el registro de eventos (por defecto 1 hora). El parámetro `Intentos` establece el umbral de intentos de inicio de sesión antes de activar una alerta (por defecto se establece en 8 intentos).

Para instalar y ejecutar el script contra los ataques de fuerza bruta, sigue estos pasos:

1. Abre PowerShell con privilegios de administrador.
2. Copia el script en tu entorno PowerShell.
3. Personaliza los parámetros «Horas» e «Intentos» según sea necesario.
4. Ejecuta el script.

A continuación, el script para detectar y prevenir los ataques de fuerza bruta evaluará los registros de eventos en función de los parámetros proporcionados. Si el número de intentos fallidos de inicio de sesión supera el umbral dentro del plazo especificado, te alertará de un posible ataque de fuerza bruta.

Imagínate que quieres supervisar los intentos de inicio de sesión durante las últimas tres horas y te gustaría recibir una alerta si hay más de 15 intentos fallidos. Con NinjaOne, tienes la flexibilidad de personalizar tu enfoque de seguridad mediante la ejecución del script con parámetros a medida como «Horas 3», «Intentos 15». Esta función te permite adaptarte a las necesidades de seguridad y a los perfiles de riesgo específicos de tu organización.

Medidas de seguridad adicionales

La detección de ataques de fuerza bruta es sólo un componente de una estrategia global de ciberseguridad. Otras medidas fundamentales son:

• Contraseñas seguras: anima a los usuarios a crear contraseñas robustas y únicas, idealmente una mezcla de letras, números y símbolos. Los gestores de contraseñas pueden facilitar la gestión de contraseñas complejas.
• Autenticación multifactor (MFA): la MFA proporciona una capa adicional de seguridad, exigiendo a los usuarios que verifiquen su identidad utilizando dos o más mecanismos (por ejemplo, algo que saben, algo que tienen o algo que son).
• Actualizaciones de software: la actualización periódica del software es vital. Las actualizaciones suelen incluir parches para vulnerabilidades de seguridad que, si no se solucionan, podrían abrir una puerta a los ciberataques.
• Formación de los empleados: establecer un programa de formación para la concienciación sobre la seguridad ayuda a educar a los empleados sobre las ciberamenazas y el papel que desempeñan en el mantenimiento de la seguridad. El factor humano suele ser el eslabón más débil de la ciberseguridad, y unos empleados bien informados pueden reforzar considerablemente sus defensas.

Reflexiones finales

Una detección eficaz de ataques de fuerza bruta es fundamental en el panorama digital actual y nuestro script PowerShell ofrece una solución potente y personalizable. Sin embargo, es esencial recordar que forma parte de una estrategia de ciberseguridad más amplia. Combinando la detección en tiempo real con contraseñas seguras, MFA, actualizaciones de software y formación de los empleados, puedes crear un protocolo de seguridad completo para proteger tus activos digitales.

NinjaOne es una herramienta completa que refuerza significativamente tu capacidad para detectar y contrarrestar los ataques de fuerza bruta. Con un control total sobre la seguridad de los endpoints, puedes gestionar aplicaciones, editar registros de forma remota e implantar scripts para mejorar la seguridad. Los controles de acceso basados en funciones garantizan que tus técnicos sólo tengan los niveles de acceso necesarios, lo que reduce los posibles puntos de infracción. La plataforma también ofrece herramientas de gestión del cifrado de unidades y la posibilidad de instalar y gestionar automáticamente la protección de los endpoints, lo que permite un control granular de las operaciones antivirus.

Además, la función de intercambio de credenciales de NinjaOne protege las credenciales, una línea de defensa fundamental contra los ataques de fuerza bruta. También permite identificar y eliminar los endpoints no autorizados, lo que añade una capa adicional de protección. No esperes a que se produzca una infracción. Comienza tu viaje hacia una mayor seguridad hoy mismo con NinjaOne.