En este artículo vamos a ver un script de PowerShell muy útil para quienes quieren tener control en tiempo real sobre las conexiones de red que se están estableciendo en su computadora con Windows.

Este script permite ver qué procesos están generando conexiones de red, clasificarlas como entrantes o salientes, y monitorear cambios a lo largo del tiempo.

Además, se puede excluir ciertas IPs que no nos interesa monitorear (como 127.0.0.1 o redes locales).

¿Qué hace este script?

Este script tiene tres funciones principales:

  1. Obtener conexiones de red activas:
    A través de la función Get-NetConnections, se recopilan todas las conexiones TCP activas junto con el ID del proceso que las generó y su nombre. Además, se determina si la conexión es entrante (por ejemplo, un servidor escuchando) o saliente (como un navegador accediendo a internet).

  2. Mostrar las conexiones en consola:
    La función Show-NetConnections limpia la consola y presenta cada conexión en una línea con colores: verde para conexiones entrantes y amarillo para salientes. Esto facilita identificar rápidamente el tipo de tráfico.

  3. Monitorear cambios en tiempo real:
    Con un bucle while, el script revisa continuamente las conexiones activas, detectando nuevas conexiones o aquellas que se cerraron. Si encuentra cambios, actualiza la vista en consola. También filtra automáticamente ciertas IPs excluidas para evitar mostrar tráfico interno que no nos interesa.

¿Para qué te puede servir?

Este script tiene múltiples usos prácticos:

  • Monitoreo de seguridad: Podés detectar procesos sospechosos que se conectan a direcciones externas.

  • Depuración de aplicaciones: Si estás desarrollando una app, podés ver cuándo y cómo se conecta a otros servicios.

  • Auditoría de red local: Te permite identificar servicios que están abiertos en tu máquina sin necesidad de herramientas externas.

  • Optimización de red: Podés observar qué procesos están generando más conexiones y evaluar si son necesarios.

¿Cómo se usa?

  1. Copiá el script en un archivo .ps1, por ejemplo MonitorConexiones.ps1.

  2. Ejecutalo con PowerShell con los permisos adecuados (podés necesitar correrlo como administrador).

  3. Vas a ver una consola que se actualiza en tiempo real, mostrando las nuevas conexiones que se abren o se cierran.

  4. Podés modificar la lista de IPs en la variable $ExcludedIPs para que no se muestren conexiones hacia/desde esas direcciones.

$ExcludedIPs = @(
  "192.168.1.100", 
  "10.0.0.1", 
  "127.0.0.1"
)

Consideraciones

  • Este script monitorea solo conexiones TCP.

  • No borra conexiones "removidas" línea por línea, sino que limpia toda la pantalla y vuelve a dibujar.

  • Podés adaptarlo fácilmente para guardar logs o agregar más filtros.

Este tipo de herramientas simples pero efectivas muestran el poder de PowerShell para la administración y monitoreo de sistemas. Si te interesa la seguridad informática o el análisis de red, vale la pena tener este script a mano.

El script

# Función para obtener las conexiones de red actuales con procesos asociados
function Get-NetConnections {
  Get-NetTCPConnection | ForEach-Object {
    try {
      $process = Get-Process -Id $_.OwningProcess -ErrorAction SilentlyContinue
      $processName = if ($process) { $process.ProcessName } else { "Desconocido" }
    } catch {
      $processName = "Desconocido"
    }

    # Determinar si la conexión es entrante o saliente
    $ConnectionType = if ($_.State -eq "Listen") {
      "Entrante"
    } elseif ($_.RemoteAddress -eq "0.0.0.0" -or $_.RemoteAddress -eq "::") {
      "Entrante"
    } else {
      "Saliente"
    }

    [PSCustomObject]@{
      LocalAddress  = $_.LocalAddress
      LocalPort     = $_.LocalPort
      RemoteAddress = $_.RemoteAddress
      RemotePort    = $_.RemotePort
      ProcessId     = $_.OwningProcess
      ProcessName   = $processName
      ConnectionType = $ConnectionType
    }
  }
}

# Función para mostrar las conexiones en la consola con colores
function Show-NetConnections {
  param(
    [Parameter(Mandatory = $true)]
    [object[]]
    $Connections
  )

  # Limpiar la consola y mostrar encabezados
  Clear-Host
  Write-Host "Conexiones de red:"
  Write-Host "--------------------"
  Write-Host "LocalAddress:LocalPort -> RemoteAddress:RemotePort | ProcessId | ProcessName | Tipo" -ForegroundColor Cyan

  # Mostrar cada conexión con colores según el tipo
  foreach ($Connection in $Connections) {
    # Asignar colores según el tipo de conexión
    $Color = if ($Connection.ConnectionType -eq "Entrante") {
      "Green"
    } else {
      "Yellow"
    }

    # Mostrar la conexión con el color correspondiente
    Write-Host "$($Connection.LocalAddress):$($Connection.LocalPort) -> $($Connection.RemoteAddress):$($Connection.RemotePort) | $($Connection.ProcessId) | $($Connection.ProcessName) | $($Connection.ConnectionType)" -ForegroundColor $Color
  }
}

# Array para almacenar las IPs a excluir
$ExcludedIPs = @(
  "192.168.1.100",
  "10.0.0.1",
  "127.0.0.1"
)

# Función para verificar si una conexión debe ser excluida
function Is-ExcludedConnection {
  param(
    [Parameter(Mandatory = $true)]
    [object]
    $Connection
  )

  # Verificar si la IP remota está en la lista de exclusiones
  if ($ExcludedIPs -contains $Connection.RemoteAddress) {
    return $true
  }

  return $false
}

# Variables para almacenar las conexiones anteriores y actuales
$PreviousConnections = @()
$CurrentConnections = @()

# Bucle principal para monitorear las conexiones
while ($true) {
  # Obtener las conexiones actuales
  $CurrentConnections = Get-NetConnections

  # Filtrar las conexiones excluidas
  $CurrentConnections = $CurrentConnections | Where-Object { -not (Is-ExcludedConnection $_) }

  # Comparar las conexiones actuales con las anteriores
  $NewConnections = $CurrentConnections | Where-Object {
    $_.LocalAddress -notin $PreviousConnections.LocalAddress -or
    $_.LocalPort -notin $PreviousConnections.LocalPort -or
    $_.RemoteAddress -notin $PreviousConnections.RemoteAddress -or
    $_.RemotePort -notin $PreviousConnections.RemotePort
  }
  $RemovedConnections = $PreviousConnections | Where-Object {
    $_.LocalAddress -notin $CurrentConnections.LocalAddress -or
    $_.LocalPort -notin $CurrentConnections.LocalPort -or
    $_.RemoteAddress -notin $CurrentConnections.RemoteAddress -or
    $_.RemotePort -notin $CurrentConnections.RemotePort
  }

  # Mostrar las nuevas conexiones
  if ($NewConnections) {
    Show-NetConnections -Connections $NewConnections
  }

  # Eliminar las conexiones eliminadas de la pantalla
  if ($RemovedConnections) {
    # No hay una forma directa de eliminar líneas específicas de la consola en PowerShell
    # La mejor opción es limpiar la pantalla y volver a dibujar todas las conexiones
    Show-NetConnections -Connections $CurrentConnections
  }

  # Actualizar las conexiones anteriores
  $PreviousConnections = $CurrentConnections

  # Esperar un segundo antes de volver a verificar
  Start-Sleep -Seconds 1
}