Cómo utilizar PowerShell para detectar puertos abiertos y establecidos en Windows

En el panorama en constante evolución de la seguridad y la gestión de TI, es crucial supervisar la actividad de la red e identificar posibles vulnerabilidades. Los puertos abiertos pueden servir como puntos de entrada para accesos no autorizados, por lo que es vital que los profesionales de TI los auditen y gestionen con regularidad.

PowerShell, con sus potentes capacidades de scripting, ofrece una forma flexible y eficaz de supervisar estos puertos. En este post, exploraremos un script PowerShell diseñado para detectar puertos abiertos y establecidos en un sistema Windows, discutiremos sus aplicaciones prácticas y proporcionaremos información sobre su funcionamiento y uso.

Comprender la necesidad de la vigilancia portuaria

Los puertos son un aspecto esencial de la comunicación en red, ya que permiten que diferentes servicios y aplicaciones interactúen entre sí a través de una red. Sin embargo, los puertos abiertos, especialmente los que no se supervisan activamente, pueden convertirse en riesgos para la seguridad.

Los ciberdelincuentes suelen aprovecharse de estas vulnerabilidades para obtener acceso no autorizado a los sistemas. Esto hace que sea imperativo para los profesionales de TI, en particular los de los proveedores de servicios gestionados (MSP), auditar regularmente su red en busca de puertos abiertos, asegurándose de que sólo los puertos necesarios están abiertos y escuchando.

Este script PowerShell está diseñado para ayudar a los profesionales de TI a detectar puertos abiertos y establecidos automáticamente y proporcionar información detallada sobre ellos. También puede guardar los resultados en un campo personalizado, lo que facilita el seguimiento y la documentación.

El script para detectar puertos abiertos y establecidos

#Requires -Version 5.1

<#
.SYNOPSIS
    Alert on specified ports that are Listening or Established and optionally save the results to a custom field.
.DESCRIPTION
    Will alert on open ports, regardless if a firewall is blocking them or not.
    Checks for open ports that are in a 'Listen' or 'Established' state.
    UDP is a stateless protocol and will not have a state.
    Outputs the open ports, process ID, state, protocol, local address, and process name.
    When a Custom Field is provided this will save the results to that custom field.

.EXAMPLE
    (No Parameters)
    ## EXAMPLE OUTPUT WITHOUT PARAMS ##
    [Alert] Found open port: 80, PID: 99, State: Listen, Local Address: 0.0.0.0, Process: nginx
    [Alert] Found open port: 500, PID: 99, State: Listen, Local Address: 0.0.0.0, Process: nginx

PARAMETER: -Port "100,200,300-350, 400"
    A comma separated list of ports to check. Can include ranges (e.g. 100,200,300-350, 400)
.EXAMPLE
    -Port "80,200,300-350, 400"
    ## EXAMPLE OUTPUT WITH Port ##
    [Alert] Found open port: 80, PID: 99, State: Listen, Local Address: 0.0.0.0, Process: nginx

PARAMETER: -CustomField "ReplaceMeWithAnyMultilineCustomField"
    Name of the custom field to save the results to.
.EXAMPLE
    -Port "80,200,300-350, 400" -CustomField "ReplaceMeWithAnyMultilineCustomField"
    ## EXAMPLE OUTPUT WITH CustomField ##
    [Alert] Found open port: 80, PID: 99, State: Listen, Local Address: 0.0.0.0, Process: nginx
    [Info] Saving results to custom field: ReplaceMeWithAnyMultilineCustomField
    [Info] Results saved to custom field: ReplaceMeWithAnyMultilineCustomField
.OUTPUTS
    None
.NOTES
    Supported Operating Systems: Windows 10/Windows Server 2016 or later with PowerShell 5.1
    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://ninjastage2.wpengine.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]$PortsToCheck,
    [String]$CustomFieldName
)

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 Set-NinjaProperty {
        [CmdletBinding()]
        Param(
            [Parameter(Mandatory = $True)]
            [String]$Name,
            [Parameter()]
            [String]$Type,
            [Parameter(Mandatory = $True, ValueFromPipeline = $True)]
            $Value,
            [Parameter()]
            [String]$DocumentName
        )
    
        $Characters = $Value | Measure-Object -Character | Select-Object -ExpandProperty Characters
        if ($Characters -ge 10000) {
            throw [System.ArgumentOutOfRangeException]::New("Character limit exceeded, value is greater than 10,000 characters.")
        }
        
        # If we're requested to set the field value for a Ninja document we'll specify it here.
        $DocumentationParams = @{}
        if ($DocumentName) { $DocumentationParams["DocumentName"] = $DocumentName }
        
        # This is a list of valid fields that can be set. If no type is given, it will be assumed that the input doesn't need to be changed.
        $ValidFields = "Attachment", "Checkbox", "Date", "Date or Date Time", "Decimal", "Dropdown", "Email", "Integer", "IP Address", "MultiLine", "MultiSelect", "Phone", "Secure", "Text", "Time", "URL", "WYSIWYG"
        if ($Type -and $ValidFields -notcontains $Type) { Write-Warning "$Type is an invalid type! Please check here for valid types. https://ninjarmm.zendesk.com/hc/en-us/articles/16973443979789-Command-Line-Interface-CLI-Supported-Fields-and-Functionality" }
        
        # The field below requires additional information to be set
        $NeedsOptions = "Dropdown"
        if ($DocumentName) {
            if ($NeedsOptions -contains $Type) {
                # We'll redirect the error output to the success stream to make it easier to error out if nothing was found or something else went wrong.
                $NinjaPropertyOptions = Ninja-Property-Docs-Options -AttributeName $Name @DocumentationParams 2>&1
            }
        }
        else {
            if ($NeedsOptions -contains $Type) {
                $NinjaPropertyOptions = Ninja-Property-Options -Name $Name 2>&1
            }
        }
        
        # If an error is received it will have an exception property, the function will exit with that error information.
        if ($NinjaPropertyOptions.Exception) { throw $NinjaPropertyOptions }
        
        # The below type's require values not typically given in order to be set. The below code will convert whatever we're given into a format ninjarmm-cli supports.
        switch ($Type) {
            "Checkbox" {
                # While it's highly likely we were given a value like "True" or a boolean datatype it's better to be safe than sorry.
                $NinjaValue = [System.Convert]::ToBoolean($Value)
            }
            "Date or Date Time" {
                # Ninjarmm-cli expects the  Date-Time to be in Unix Epoch time so we'll convert it here.
                $Date = (Get-Date $Value).ToUniversalTime()
                $TimeSpan = New-TimeSpan (Get-Date "1970-01-01 00:00:00") $Date
                $NinjaValue = $TimeSpan.TotalSeconds
            }
            "Dropdown" {
                # Ninjarmm-cli is expecting the guid of the option we're trying to select. So we'll match up the value we were given with a guid.
                $Options = $NinjaPropertyOptions -replace '=', ',' | ConvertFrom-Csv -Header "GUID", "Name"
                $Selection = $Options | Where-Object { $_.Name -eq $Value } | Select-Object -ExpandProperty GUID
        
                if (-not $Selection) {
                    throw [System.ArgumentOutOfRangeException]::New("Value is not present in dropdown")
                }
        
                $NinjaValue = $Selection
            }
            default {
                # All the other types shouldn't require additional work on the input.
                $NinjaValue = $Value
            }
        }
        
        # We'll need to set the field differently depending on if its a field in a Ninja Document or not.
        if ($DocumentName) {
            $CustomField = Ninja-Property-Docs-Set -AttributeName $Name -AttributeValue $NinjaValue @DocumentationParams 2>&1
        }
        else {
            $CustomField = $NinjaValue | Ninja-Property-Set-Piped -Name $Name 2>&1
        }
        
        if ($CustomField.Exception) {
            throw $CustomField
        }
    }
}
process {
    if (-not (Test-IsElevated)) {
        Write-Error -Message "Access Denied. Please run with Administrator privileges."
        exit 1
    }
    if ($env:portsToCheck -and $env:portsToCheck -ne 'null') {
        $PortsToCheck = $env:portsToCheck
    }
    if ($env:customFieldName -and $env:customFieldName -ne 'null') {
        $CustomFieldName = $env:customFieldName
    }

    # Remove any whitespace
    $PortsToCheck = $PortsToCheck -replace '\s', ''

    # Parse the ports to check
    $Ports = if ($PortsToCheck) {
        # Split the ports by comma and handle ranges
        $PortsToCheck -split ',' | ForEach-Object {
            # Trim the whitespace
            $Ports = "$_".Trim()
            # If the port is a range, expand it
            if ($Ports -match '-') {
                # Split the range and expand it
                $Range = $Ports -split '-' | ForEach-Object { "$_".Trim() } | Where-Object { $_ }
                if ($Range.Count -ne 2) {
                    Write-Host "[Error] Invalid range formatting, must be two number with a dash in between them (eg 1-10): $PortsToCheck"
                    exit 1
                }
                try {
                    $Range[0]..$Range[1]
                }
                catch {
                    Write-Host "[Error] Failed to parse range, must be two number with a dash in between them (eg 1-10): $PortsToCheck"
                    exit 1
                }
            }
            else {
                $Ports
            }
        }
    }
    else { $null }

    if ($($Ports | Where-Object { [int]$_ -gt 65535 })) {
        Write-Host "[Error] Can not search for ports above 65535. Must be with in the range of 1 to 65535."
        exit 1
    }

    # Get the open ports
    $FoundPorts = $(
        Get-NetTCPConnection | Select-Object @(
            'LocalAddress'
            'LocalPort'
            'State'
            @{Name = "Protocol"; Expression = { "TCP" } }
            'OwningProcess'
            @{Name = "Process"; Expression = { (Get-Process -Id $_.OwningProcess -ErrorAction SilentlyContinue).ProcessName } }
        )
        Get-NetUDPEndpoint | Select-Object @(
            'LocalAddress'
            'LocalPort'
            @{Name = "State"; Expression = { "None" } }
            @{Name = "Protocol"; Expression = { "UDP" } }
            'OwningProcess'
            @{Name = "Process"; Expression = { (Get-Process -Id $_.OwningProcess -ErrorAction SilentlyContinue).ProcessName } }
        )
    ) | Where-Object {
        $(
            <# When Ports are specified select just those ports. #>
            if ($Ports) { $_.LocalPort -in $Ports }else { $true }
        ) -and
        (
            <# Filter out anything that isn't listening or established. #>
            $(
                $_.Protocol -eq "TCP" -and
                $(
                    $_.State -eq "Listen" -or
                    $_.State -eq "Established"
                )
            ) -or
            <# UDP is stateless, return all UDP connections. #>
            $_.Protocol -eq "UDP"
        )
    } | Sort-Object LocalPort | Select-Object * -Unique

    if (-not $FoundPorts -or $FoundPorts.Count -eq 0) {
        Write-Host "[Info] No ports were found listening or established with the specified: $PortsToCheck"
    }

    # Output the found ports
    $FoundPorts | ForEach-Object {
        Write-Host "[Alert] Found open port: $($_.LocalPort), PID: $($_.OwningProcess), Protocol: $($_.Protocol), State: $($_.State), Local IP: $($_.LocalAddress), Process: $($_.Process)"
    }
    # Save the results to a custom field if one was provided
    if ($CustomFieldName -and $CustomFieldName -ne 'null') {
        try {
            Write-Host "[Info] Saving results to custom field: $CustomFieldName"
            Set-NinjaProperty -Name $CustomFieldName -Value $(
                $FoundPorts | ForEach-Object {
                    "Open port: $($_.LocalPort), PID: $($_.OwningProcess), Protocol: $($_.Protocol), State: $($_.State), Local Address: $($_.LocalAddress), Process: $($_.Process)"
                } | Out-String
            )
            Write-Host "[Info] Results saved to custom field: $CustomFieldName"
        }
        catch {
            Write-Host $_.Exception.Message
            Write-Host "[Warn] Failed to save results to custom field: $CustomFieldName"
            exit 1
        }
    }
}
end {
    
    
    
}

 

Cómo funciona el script

El script para detectar puertos abiertos y establecidos está diseñado con un objetivo claro: identificar e informar sobre los puertos TCP y UDP abiertos que se encuentran en estado “Escuchando” o “Establecido”. A continuación se detalla cómo lo consigue el script:

1. Configuración inicial y funciones:

• El script comienza definiendo varias funciones de utilidad, incluyendo Test-IsElevated, que comprueba si el script para detectar puertos abiertos y establecidos se está ejecutando con privilegios de administrador. Esto es esencial ya que la comprobación de puertos abiertos requiere permisos elevados.
• Se incluye otra función clave, Set-NinjaProperty, para gestionar el almacenamiento de resultados en un campo personalizado, si se especifica. Esta función gestiona diferentes tipos de datos y garantiza que no se supere el límite de caracteres del campo.

2. Gestión de parámetros:

• El script acepta dos parámetros: PortsToCheck, una lista separada por comas de los puertos a monitorizar, y CustomFieldName, el nombre del campo personalizado donde se almacenarán los resultados.
• A continuación, procesa estos parámetros, ampliando cualquier rango de puertos y eliminando los espacios en blanco para un procesamiento preciso.

3. Detección de puertos:

• El script utiliza los cmdlets Get-NetTCPConnection y Get-NetUDPEndpoint para recuperar información sobre las conexiones TCP y UDP activas en el sistema.
• Filtra los resultados para incluir sólo los puertos que están a la escucha o establecidos (para TCP), y todos los puertos UDP, ya que UDP es un protocolo sin estado.
• A continuación, los resultados filtrados se clasifican y formatean para su salida.

4. Salida y guardado de campos personalizados:

• El script muestra los puertos detectados, junto con detalles relevantes como el ID del proceso, el estado, la dirección local y el nombre del proceso.
• Si se especifica un campo personalizado, el script para detectar puertos abiertos y establecidos intenta guardar los resultados utilizando la función Set-NinjaProperty, gestionando cualquier error que pueda producirse durante este proceso.

Posibles casos de uso

Imagina a un profesional de TI que gestiona la seguridad de la red de una empresa mediana. Las auditorías periódicas de puertos forman parte de su rutina para garantizar que sólo funcionan y son accesibles los servicios necesarios. Mediante la implementación de este script PowerShell para detectar puertos abiertos y establecidos, el profesional de TI puede automatizar el proceso de identificación de puertos abiertos, reduciendo el riesgo de dejar expuestos puertos vulnerables.

Por ejemplo, tras ejecutar el script, el informático se da cuenta de que un puerto inesperado está abierto y vinculado a un servicio no esencial. A continuación, puede tomar medidas para cerrar este puerto, reduciendo así la superficie potencial de ataque de su red.

Comparación con otros métodos

Tradicionalmente, los profesionales de TI podían utilizar herramientas como netstat o herramientas de escaneado de redes de terceros para identificar los puertos abiertos. Aunque estas herramientas son eficaces, a menudo requieren intervención manual y pueden no integrarse fácilmente con sistemas automatizados. Este script PowerShell para detectar puertos abiertos y establecidos ofrece un enfoque más integrado, permitiendo la automatización dentro de los flujos de trabajo existentes y proporcionando flexibilidad a través de parámetros como el guardado de campos personalizados.

Preguntas frecuentes

P: ¿Necesito ejecutar este script con privilegios de administrador?

Sí, el script para detectar puertos abiertos y establecidos requiere privilegios de administrador para detectar puertos abiertos y sus procesos asociados con precisión.

P: ¿Puede el script comprobar también los puertos UDP?

Sí, el script comprueba tanto puertos TCP como UDP, filtrando los puertos TCP por su estado y listando los puertos UDP independientemente de su estado.

P: ¿Qué ocurre si especifico un intervalo de puertos no válido?

El script incluye gestión de errores para garantizar que sólo se procesan rangos de puertos válidos. Si se especifica un rango no válido, el script para detectar puertos abiertos y establecidos proporcionará un mensaje de error y saldrá.

Implicaciones para la seguridad informática

Los resultados generados por este script para detectar puertos abiertos y establecidos pueden tener implicaciones significativas para la seguridad informática. La supervisión periódica de los puertos abiertos puede ayudar a detectar servicios no autorizados que se ejecutan en una red, lo que podría indicar una violación de la seguridad. Al identificar y cerrar los puertos innecesarios, los profesionales de TI pueden mitigar los riesgos y mejorar la postura general de seguridad de su organización.

Prácticas recomendadas para utilizar este script

• Ejecuta el script con regularidad: programa la ejecución periódica del script para garantizar la supervisión continua de los puertos abiertos de tu red.
• Utiliza los campos personalizados con prudencia: cuando guardes los resultados en un campo personalizado, asegúrate de que el campo tiene el nombre y la gestión adecuados para evitar sobrescribir datos importantes.
• Combínalo con otras medidas de seguridad: utiliza este script como parte de una estrategia de seguridad más amplia, combinándolo con otras herramientas y prácticas para garantizar una protección completa.

Reflexiones finales

Este script de PowerShell es una potente herramienta para los profesionales de TI que deseen automatizar el proceso de detección y supervisión de puertos abiertos. Al integrar este script para detectar puertos abiertos y establecidos en tus prácticas habituales de seguridad, puedes mejorar los mecanismos de defensa de tu red y responder rápidamente a posibles vulnerabilidades. NinjaOne ofrece una gama de herramientas que complementan dichos scripts, proporcionando una plataforma sólida para la gestión de TI y la supervisión de la seguridad.