🔒 Cómo bloquear puertos peligrosos en Windows: guía completa

Bloquear puertos peligrosos en Windows es imprescindible cuando servicios como Telnet, SSH, RDP o TeamViewer abren puertas de acceso remoto en tu equipo que, si no están correctamente configuradas o protegidas, se convierten en vectores de entrada activos para ciberdelincuentes. Aplicar esta medida de hardening con el Firewall nativo y PowerShell es una de las acciones con mayor impacto y menor coste que puedes implementar hoy mismo, tanto en un equipo doméstico como en un entorno de pequeña empresa, y forma parte de el recopilatorio de seguridad en Windows.

Esta guía cubre qué son estos protocolos, qué riesgos representan y cómo detectarlos, bloquearlos y eliminarlos paso a paso, apoyándose en las medidas ya descritas en nuestra guía de acceso remoto seguro a sistemas Windows:, en la de cómo desactivar NetBIOS en Windows y cerrar puertos peligrosos de red, y complementando el bloqueo por puertos con la guía para restringir el acceso por IP en Windows, una capa adicional de control sobre quién puede conectarse a cada servicio.

📅 Publicado: 12 de Junio de 2026 🕒 Tiempo de lectura: 14 minutos

¿Qué son los puertos de acceso remoto y por qué son peligrosos?

Los puertos de acceso remoto son peligrosos por cuatro razones principales:

• Los atacantes escanean Internet de forma masiva y automatizada buscando puertos abiertos (22, 23, 3389, 5900, 5938)
• Un puerto abierto sin autenticación fuerte es el punto de entrada preferido para ataques de fuerza bruta
• Servicios con vulnerabilidades conocidas (CVEs) sin parchear pueden explotarse remotamente sin interacción del usuario
• Herramientas legítimas como TeamViewer o AnyDesk son abusadas en estafas de soporte técnico y como puertas traseras persistentes en sistemas comprometidos

Los puertos de acceso remoto son canales de comunicación abiertos en tu sistema operativo que permiten que aplicaciones o servicios externos se conecten a tu ordenador. Algunos son legítimos y necesarios en entornos corporativos; sin embargo, cuando están activos en equipos domésticos o sin configuración adecuada, suponen un riesgo grave de seguridad. Por esta razón, entender cómo bloquear puertos peligrosos en Windows es el primer paso antes de tocar cualquier configuración del firewall.

Los atacantes escanean Internet continuamente en busca de equipos con estos puertos abiertos para lanzar ataques de fuerza bruta, explotar vulnerabilidades conocidas o instalar malware de acceso remoto (RAT): tipos, vectores y cómo eliminarlo. Saber cómo bloquear puertos peligrosos en Windows es clave para reducir la superficie de ataque.

Telnet: el protocolo más inseguro que aún existe

¿Qué es Telnet?

Telnet es un protocolo de red creado en 1969 que permite el acceso remoto a través del puerto TCP 23, a diferencia del acceso remoto  a sistemas operativos Windows:, transmite todos los datos, incluidos nombre de usuario y contraseña, en texto plano sin cifrado. Fue diseñado en una era en que la seguridad no era una prioridad, y hoy está considerado obsoleto y extremadamente peligroso, lo que lo convierte en el primer candidato a la hora de bloquear puertos peligrosos en Windows.

Riesgos de Telnet

• 🔓 Intercepción de credenciales: cualquier atacante en la misma red puede capturar tu usuario y contraseña con herramientas como Wireshark.
• 🕵️ Ataques Man-in-the-Middle (MitM): el tráfico no cifrado puede ser interceptado y modificado en tránsito.
• 🤖 Ataques de fuerza bruta: el puerto 23 es escaneado de forma masiva por bots automatizados.
• 🦠 Vector de propagación de malware: botnets como Mirai —similar a los protocolos heredados que se analizan en la guía de cómo desactivar NetBIOS en Windows y cerrar tres puertos peligrosos de red— utilizaron Telnet para infectar millones de dispositivos IoT.

Por estas razones, saber cómo bloquear puertos peligrosos en Windows —empezando por Telnet— debería ser tu primer paso.

SSH y SSHD: potente pero también objetivo prioritario

¿Qué es SSH?

SSH (Secure Shell) es el sucesor seguro de Telnet. Utiliza cifrado fuerte para proteger las comunicaciones de acceso remoto y opera por defecto en el puerto TCP 22. SSHD es el daemon o servicio servidor de SSH que escucha conexiones entrantes. Aunque SSH es seguro por diseño, sigue siendo uno de los puertos más atacados en Internet, y por eso figura entre los primeros puertos a revisar al bloquear puertos peligrosos en Windows.

Riesgos de SSH/SSHD

• 🤖 Fuerza bruta al puerto 22: millones de intentos de login automatizados diariamente.
• 🔑 Claves privadas comprometidas: si un atacante roba tu clave privada SSH, tiene acceso total.
• 🚇 Túneles SSH maliciosos: los atacantes pueden usarlos para exfiltrar datos o saltar a otras redes internas.
• ⚠️ Versiones vulnerables: versiones antiguas de OpenSSH tienen CVEs conocidos en la base NVD del NIST, el repositorio oficial de vulnerabilidades del gobierno de EE.UU.
• ↔️ Reenvío de agente SSH: mal configurado, puede permitir movimiento lateral en redes corporativas.

Estos riesgos justifican por qué tantos usuarios buscan cómo bloquear puertos peligrosos en Windows en cuanto detectan el puerto 22 abierto.

TeamViewer y herramientas similares de escritorio remoto

¿Qué es TeamViewer?

TeamViewer es una aplicación de escritorio remoto muy popular que utiliza los puertos TCP/UDP 5938 (principal), 443 y 80 como fallback. Permite controlar un ordenador de forma remota de manera gráfica. Aunque legítima, es frecuentemente abusada en estafas de soporte técnico falso y ataques dirigidos. Los atacantes la instalan como puerta trasera en sistemas Windows comprometidos —igual que se explica en la guía sobre backdoor: cómo detectarla y eliminarla— para mantener acceso persistente.

Herramientas similares a TeamViewer

• 🖥️ AnyDesk (puerto 7070 TCP/UDP)
• 🪟 RDP / Remote Desktop Protocol de Windows (puerto 3389 TCP)
• 🖥️ VNC – Virtual Network Computing (puertos 5900-5906 TCP)
• ☁️ LogMeIn (puertos 443 y 80)
• 🌐 Chrome Remote Desktop (a través de HTTPS/443)
• 🦀 Rustdesk (puertos 21115-21119 TCP/UDP)

Riesgos de las herramientas de acceso remoto

• 📞 Estafas de soporte técnico: el atacante engaña a la víctima para que instale la herramienta y ceda el control del equipo.
• 🚪 Persistencia de malware: se instalan versiones sin interfaz (headless) como puerta trasera invisible.
• 🔑 Credenciales robadas: si el atacante tiene tu ID y contraseña de TeamViewer, accede sin interacción.
• 📂 Exfiltración de datos: con acceso remoto completo, el atacante puede copiar archivos libremente.
• 🔒 RDP expuesto: el puerto 3389 abierto a Internet es uno de los vectores de entrada más comunes documentados en la guía de ransomware: qué es y cómo protegerte paso a paso en 2026.

Si usas alguna de estas herramientas, aprender cómo bloquear puertos peligrosos en Windows te ayuda a mantener el control sin renunciar al acceso remoto que realmente necesitas.

🔍 ¿Cuáles son los puertos más peligrosos en Windows?

Antes de ver cómo bloquear puertos peligrosos en Windows uno por uno, revisa los siete puertos más peligrosos ordenados por nivel de riesgo:

1. Puerto 23 (Telnet) — riesgo crítico: transmite credenciales en texto plano sin cifrado
2. Puerto 3389 (RDP) — riesgo crítico: vector principal de entrada de ransomware
3. Puerto 5900 (VNC) — riesgo crítico: cifrado opcional, frecuentemente sin protección
4. Puerto 22 (SSH) — riesgo alto: millones de intentos de fuerza bruta diarios
5. Puerto 5938 (TeamViewer) — riesgo alto: abusado en estafas de soporte técnico
6. Puerto 7070 (AnyDesk) — riesgo alto: usado como backdoor en ataques dirigidos
7. Puerto 992 (Telnet TLS) — riesgo medio: variante cifrada de Telnet poco usada

Esta tabla resume por qué es tan importante saber cómo bloquear puertos peligrosos en Windows antes de que sean explotados por un atacante.

¿Cómo detectar puertos abiertos en tu ordenador con Windows?

Antes de aprender cómo bloquear puertos peligrosos en Windows, aplica estos tres métodos para detectarlos, de más sencillo a más completo:

• Símbolo del sistema: netstat -ano | findstr "LISTENING" — muestra todos los puertos en escucha con su PID
• PowerShell: Get-NetTCPConnection -State Listen — salida más limpia con el proceso propietario
• Script automático: el detector de puertos peligrosos incluido en esta guía identifica automáticamente Telnet, SSH, RDP, VNC y herramientas de escritorio remoto y genera un informe exportable

Antes de bloquear nada, necesitas saber qué puertos tienes abiertos en Windows. Los siguientes scripts te dan una radiografía completa de tu sistema, el punto de partida obligado antes de bloquear puertos peligrosos en Windows de forma definitiva.

Script 1: Ver todos los puertos abiertos y el proceso asociado

Abre el Símbolo del sistema como administrador (busca cmd, clic derecho → Ejecutar como administrador) y ejecuta:

netstat -ano | findstr "LISTENING"

Esto muestra todos los puertos en escucha. La última columna es el PID (identificador del proceso). Para saber qué programa usa un PID concreto:

tasklist /FI "PID eq 1234"

Sustituye 1234 por el PID que quieras investigar.

Script 2: Exportar resultados a un fichero de texto

Guardar un histórico de los puertos abiertos es útil para comparar el estado del sistema antes y después de bloquear puertos peligrosos en Windows con cualquiera de los métodos siguientes.

netstat -ano > C:\puertos_abiertos.txt && start notepad C:\puertos_abiertos.txt

Cómo bloquear puertos peligrosos en el Firewall de Windows

🔍 ¿Cuáles son los métodos para bloquear puertos en el Firewall de Windows?

Tres métodos para bloquear puertos peligrosos en Windows, de más visual a más automatizado:

• Interfaz gráfica (wf.msc): Win+R → wf.msc → Reglas de entrada → Nueva regla → Puerto → Bloquear la conexión
• PowerShell: New-NetFirewallRule -Direction Inbound -Protocol TCP -LocalPort 23 -Action Block — permite bloquear todos los puertos peligrosos en un solo script. Consulta la documentación oficial de Microsoft sobre New-NetFirewallRule para ver todos los parámetros disponibles
• netsh (línea de comandos): netsh advfirewall firewall add rule name="Bloquear Telnet" protocol=TCP dir=in localport=23 action=block — compatible con versiones antiguas de Windows

El Firewall de Windows Defender es tu primera línea de defensa: qué protege, qué no y cómo configurarlo al máximo se explica en la documentación oficial de Microsoft. A continuación aprenderás a bloquear puertos peligrosos en Windows con los tres métodos disponibles.

Método 1: Interfaz gráfica del Firewall avanzado

Esta es la forma más visual de aprender cómo bloquear puertos peligrosos en Windows sin usar la consola.

1. Pulsa Win + R, escribe wf.msc y pulsa Enter.
2. En el panel izquierdo, haz clic en Reglas de entrada.
3. En el panel derecho, clic en Nueva regla…
4. Selecciona Puerto y pulsa Siguiente.
5. Elige TCP, escribe el número de puerto (ej.: 23) y pulsa Siguiente.
6. Selecciona Bloquear la conexión y pulsa Siguiente.
7. Marca las tres redes: Dominio, Privado, Público.
8. Ponle un nombre descriptivo (ej.: Bloquear Telnet puerto 23) y finaliza.

Método 2: Script PowerShell — Bloqueo automático de todos los puertos peligrosos

Este script resuelve de una sola vez cómo bloquear puertos peligrosos en Windows, cubriendo Telnet, SSH, NetBIOS, SMB, RDP, VNC, TeamViewer y AnyDesk, y además instala un script de auditoría que se ejecuta automáticamente al arrancar Windows y cada hora, dejando un registro en C:\ProgramData\SeguridadEnMiPC\Puertos\Logs\ y una alerta en el Visor de eventos si detecta alguno de esos puertos abierto de nuevo.

⚠️ Antes de ejecutar: el script bloquea también el puerto 445 (SMB) en saliente. Si usas carpetas compartidas, impresoras de red o unidades mapeadas en tu red local, esa regla puede interrumpir el acceso — revisa si te afecta antes de ejecutarlo, o elimina después esa regla concreta con Remove-NetFirewallRule -DisplayName "SEGPC-BLOCK-SMB-OUT".

📥 Cómo guardar y ejecutar el script paso a paso

1. Cómo guardar el script como .ps1

1. Crea la carpeta C:\Scripts si no la tienes: abre el Explorador de archivos, ve a C:\, clic derecho → Nuevo → Carpeta, nómbrala Scripts.
2. Abre el Bloc de notas (tecla Windows → escribe "Bloc de notas" → Enter).
3. Pega dentro el código completo del script (lo tienes al final de esta sección).
4. Ve a Archivo → Guardar como. Rellena estos tres campos:
   • Dónde guardarlo: navega hasta C:\Scripts.
   • Nombre de archivo: escribe bloqueo-puertos-peligrosos.ps1 (con el .ps1 al final, escrito por ti).
   • Tipo: cambia el desplegable de "Documentos de texto (*.txt)" a "Todos los archivos (*.*)". Si no lo cambias, el archivo se guarda como bloqueo-puertos-peligrosos.ps1.txt aunque hayas escrito ".ps1".
5. Pulsa Guardar.
6. Comprueba que salió bien: en C:\Scripts, el icono del archivo debe verse como una pantalla de consola azul, no como una hoja de papel.

El propio script vuelve a copiarse automáticamente en C:\Scripts al ejecutarse, así que aunque lo lances desde otra carpeta o desde una unidad USB, siempre quedará una copia limpia en C:\Scripts\bloqueo-puertos-peligrosos.ps1.

2. Cómo se ejecuta

Nunca hagas doble clic sobre el archivo ni pegues el código directamente en la consola de PowerShell.

1. Pulsa la tecla Windows, escribe PowerShell.
2. Haz clic derecho sobre "Windows PowerShell" y elige "Ejecutar como administrador". Confirma si te lo pide.
3. En la ventana azul que se abre, escribe estas tres líneas una a una, pulsando Enter después de cada una:
   • Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
   • cd C:\Scripts
   • dir *.ps1
4. Con dir *.ps1 confirmas el nombre exacto del archivo tal como quedó guardado.
5. Ejecuta el script con este comando: powershell -NoExit -ExecutionPolicy Bypass -File "bloqueo-puertos-peligrosos.ps1"
6. Verás en pantalla, en verde, cada puerto bloqueado, seguido de la instalación del script de auditoría y la creación de las 2 tareas programadas.
7. Al terminar te pedirá pulsar una tecla para cerrar.

3. Si algo falla

• "ERROR: Ejecuta PowerShell como Administrador": cierra la ventana y vuelve a abrir PowerShell con "Ejecutar como administrador" (clic derecho).
• "El término 'finally' no se reconoce..." o errores de try/catch: pegaste el código directamente en la consola en vez de guardarlo como archivo. Guárdalo como .ps1 (paso 1) y ejecútalo con -File (paso 2).
• "El argumento '...' para el parámetro -File no existe": el nombre no coincide con el archivo guardado. Ejecuta dir *.ps1 en C:\Scripts y usa el nombre exacto que aparece ahí.
• Se corta el acceso a carpetas compartidas en red: es la regla SMB saliente mencionada arriba. Elimínala con Remove-NetFirewallRule -DisplayName "SEGPC-BLOCK-SMB-OUT" si te afecta.
• Las 2 tareas no aparecen en Get-ScheduledTask ni en el Programador de tareas gráfico, aunque el script haya mostrado "OK Tarea creada": problema de caché del Programador de tareas tras crear/recrear tareas en la misma sesión. Reinicia el equipo — el servicio Schedule no se puede reiniciar manualmente, Windows lo bloquea por ser un servicio crítico.
• Aparecen tareas duplicadas en la raíz del Programador de tareas: este script registra las tareas siempre bajo la ruta \SeguridadEnMiPC\Puertos\. Si ves tareas sueltas en la raíz \ llamadas "Auditoria-Arranque" o "Auditoria-Horaria" es porque quedaron de una versión anterior del script; elimínalas manualmente desde el Programador de tareas.
• Si al hacer clic derecho no aparece "Ejecutar como administrador": asegúrate de buscar "Windows PowerShell" (la app), no dentro de una carpeta. Prueba también "Terminal" en Windows 11.

Script para bloquear puertos peligrosos en Windows

# =====================================================
# Bloqueo de puertos peligrosos + Auditoria programada
# seguridadenmipc.com
# Ejecutar como Administrador UNA SOLA VEZ
# Crea tarea que audita al arrancar y cada hora
# =====================================================

# --- Verificar administrador ---
$id = [Security.Principal.WindowsIdentity]::GetCurrent()
$pri = New-Object Security.Principal.WindowsPrincipal($id)
if (-not $pri.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)) {
    Write-Host "ERROR: Ejecuta PowerShell como Administrador." -ForegroundColor Red
    pause
    exit
}

# --- Auto-copia a C:\Scripts ---
$scriptsDir = "C:\Scripts"
if (-not (Test-Path $scriptsDir)) { New-Item -Path $scriptsDir -ItemType Directory -Force | Out-Null }
$destinoScript = Join-Path $scriptsDir "bloqueo-puertos-peligrosos.ps1"
if ($PSCommandPath -and (Test-Path $PSCommandPath) -and ($PSCommandPath -ne $destinoScript)) {
    Copy-Item -Path $PSCommandPath -Destination $destinoScript -Force -ErrorAction SilentlyContinue
}

# --- Carpeta de trabajo y transcript ---
$baseDir = "C:\ProgramData\SeguridadEnMiPC\Puertos"
$logDir  = Join-Path $baseDir "Logs"
if (-not (Test-Path $baseDir)) { New-Item -Path $baseDir -ItemType Directory -Force | Out-Null }
if (-not (Test-Path $logDir))  { New-Item -Path $logDir  -ItemType Directory -Force | Out-Null }

$transcriptFile = Join-Path $logDir ("instalacion_" + (Get-Date -Format "yyyyMMdd_HHmmss") + ".log")
Start-Transcript -Path $transcriptFile -Append | Out-Null

Write-Host "======================================================" -ForegroundColor Cyan
Write-Host " BLOQUEO DE PUERTOS + TAREA PROGRAMADA" -ForegroundColor Cyan
Write-Host " seguridadenmipc.com" -ForegroundColor Cyan
Write-Host "======================================================" -ForegroundColor Cyan
Write-Host ""

# -------------------------------------------------------
# PARTE 1: Bloqueo de puertos en Firewall
# -------------------------------------------------------
Write-Host "--- PARTE 1: Creando reglas de firewall ---" -ForegroundColor Cyan
Write-Host ""

$tcp = @(
    "22|SSH|Bloquear SSH entrante no autorizado"
    "23|Telnet|Bloquear Telnet - texto plano sin cifrado"
    "139|NetBIOS-SS|Bloquear sesiones NetBIOS"
    "445|SMB|Bloquear SMB - riesgo WannaCry y similares"
    "992|Telnet-TLS|Bloquear Telnet sobre TLS"
    "3389|RDP|Bloquear Escritorio Remoto RDP"
    "5800|VNC-HTTP|Bloquear VNC interfaz HTTP"
    "5900|VNC|Bloquear VNC acceso remoto"
    "5938|TeamViewer|Bloquear TeamViewer"
    "7070|AnyDesk|Bloquear AnyDesk"
)

$udp = @(
    "137|NetBIOS-NS|Bloquear resolucion de nombres NetBIOS"
    "138|NetBIOS-DG|Bloquear datagramas NetBIOS"
)

$bloqueados = 0

foreach ($e in $tcp) {
    $c = $e.Split("|")
    $puerto = [int]$c[0]
    $nombre = $c[1]
    $desc   = $c[2]
    $nIn  = "SEGPC-BLOCK-" + $nombre + "-IN"
    $nOut = "SEGPC-BLOCK-" + $nombre + "-OUT"
    Remove-NetFirewallRule -DisplayName $nIn  -ErrorAction SilentlyContinue
    Remove-NetFirewallRule -DisplayName $nOut -ErrorAction SilentlyContinue
    New-NetFirewallRule -DisplayName $nIn  -Direction Inbound  -Protocol TCP -LocalPort $puerto  -Action Block -Profile Any -Description $desc | Out-Null
    New-NetFirewallRule -DisplayName $nOut -Direction Outbound -Protocol TCP -RemotePort $puerto -Action Block -Profile Any -Description $desc | Out-Null
    $bloqueados++
    Write-Host ("[OK] TCP " + $puerto + " (" + $nombre + ") bloqueado") -ForegroundColor Green
}

foreach ($e in $udp) {
    $c = $e.Split("|")
    $puerto = [int]$c[0]
    $nombre = $c[1]
    $desc   = $c[2]
    $nIn  = "SEGPC-BLOCK-" + $nombre + "-IN"
    $nOut = "SEGPC-BLOCK-" + $nombre + "-OUT"
    Remove-NetFirewallRule -DisplayName $nIn  -ErrorAction SilentlyContinue
    Remove-NetFirewallRule -DisplayName $nOut -ErrorAction SilentlyContinue
    New-NetFirewallRule -DisplayName $nIn  -Direction Inbound  -Protocol UDP -LocalPort $puerto  -Action Block -Profile Any -Description $desc | Out-Null
    New-NetFirewallRule -DisplayName $nOut -Direction Outbound -Protocol UDP -RemotePort $puerto -Action Block -Profile Any -Description $desc | Out-Null
    $bloqueados++
    Write-Host ("[OK] UDP " + $puerto + " (" + $nombre + ") bloqueado") -ForegroundColor Green
}

Write-Host ""
Write-Host (" Total puertos bloqueados: " + $bloqueados) -ForegroundColor Cyan

# -------------------------------------------------------
# PARTE 2: Crear script de auditoria en ProgramData
# -------------------------------------------------------
Write-Host ""
Write-Host "--- PARTE 2: Instalando script de auditoria ---" -ForegroundColor Cyan
Write-Host ""

$scriptAud = Join-Path $baseDir "auditoria_puertos.ps1"

$contenido = @'
$fecha = Get-Date -Format "yyyyMMdd_HHmm"
$logFile = "C:\ProgramData\SeguridadEnMiPC\Puertos\Logs\auditoria_" + $fecha + ".txt"
$puertos = @("21|TCP|FTP|ALTO","22|TCP|SSH|ALTO","23|TCP|Telnet|CRITICO","137|UDP|NetBIOS-NS|ALTO","138|UDP|NetBIOS-DG|ALTO","139|TCP|NetBIOS-SS|ALTO","445|TCP|SMB|CRITICO","3389|TCP|RDP|CRITICO","5900|TCP|VNC|CRITICO","5938|TCP|TeamViewer|ALTO","7070|TCP|AnyDesk|ALTO")
$alertas = 0
$resultado = @()
$resultado += "AUDITORIA DE PUERTOS - seguridadenmipc.com"
$resultado += "Fecha: " + (Get-Date -Format "dd/MM/yyyy HH:mm")
$resultado += ""
foreach ($e in $puertos) {
    $c = $e.Split("|")
    $puerto = [int]$c[0]
    $proto = $c[1]
    $nombre = $c[2]
    $riesgo = $c[3]
    $abierto = $false
    $proceso = "desconocido"
    if ($proto -eq "TCP") {
        $conn = Get-NetTCPConnection -LocalPort $puerto -State Listen -ErrorAction SilentlyContinue
        if ($conn) {
            $abierto = $true
            $pr = Get-Process -Id ($conn | Select-Object -First 1).OwningProcess -ErrorAction SilentlyContinue
            if ($pr) { $proceso = $pr.Name }
        }
    }
    if ($proto -eq "UDP") {
        $conn = Get-NetUDPEndpoint -LocalPort $puerto -ErrorAction SilentlyContinue
        if ($conn) {
            $abierto = $true
            $pr = Get-Process -Id ($conn | Select-Object -First 1).OwningProcess -ErrorAction SilentlyContinue
            if ($pr) { $proceso = $pr.Name }
        }
    }
    if ($abierto) {
        $alertas++
        $linea = "[ALERTA " + $riesgo + "] Puerto " + $puerto + "/" + $proto + " (" + $nombre + ") ABIERTO - Proceso: " + $proceso
        $resultado += $linea
        Write-EventLog -LogName Application -Source "SEGPC-Auditoria" -EventId 9001 -EntryType Warning -Message $linea -ErrorAction SilentlyContinue
    } else {
        $resultado += "[SEGURO] Puerto " + $puerto + "/" + $proto + " (" + $nombre + ") cerrado"
    }
}
$resultado += ""
if ($alertas -eq 0) {
    $resultado += "RESULTADO: Sin puertos peligrosos abiertos."
} else {
    $resultado += "RESULTADO: " + $alertas + " puerto(s) peligroso(s) detectado(s)."
}
$resultado | Out-File -FilePath $logFile -Encoding utf8
Get-ChildItem -Path "C:\ProgramData\SeguridadEnMiPC\Puertos\Logs\auditoria_*.txt" | Where-Object { $_.LastWriteTime -lt (Get-Date).AddDays(-30) } | Remove-Item -Force -ErrorAction SilentlyContinue
'@

$contenido | Out-File -FilePath $scriptAud -Encoding utf8 -Force
Write-Host ("OK Script instalado en: " + $scriptAud) -ForegroundColor Green

# --- Registrar fuente en el Visor de eventos ---
$fuenteExiste = $false
try { $fuenteExiste = [System.Diagnostics.EventLog]::SourceExists("SEGPC-Auditoria") } catch { $fuenteExiste = $false }
if (-not $fuenteExiste) {
    try {
        New-EventLog -LogName Application -Source "SEGPC-Auditoria" -ErrorAction SilentlyContinue
        Write-Host "OK Fuente de eventos registrada: SEGPC-Auditoria" -ForegroundColor Green
    } catch {
        Write-Host "-- Fuente de eventos no registrada (no es critico)." -ForegroundColor Gray
    }
}

# -------------------------------------------------------
# PARTE 3: Crear tareas programadas bajo \SeguridadEnMiPC\Puertos\
# -------------------------------------------------------
Write-Host ""
Write-Host "--- PARTE 3: Creando tareas programadas ---" -ForegroundColor Cyan
Write-Host ""

$taskPath = "\SeguridadEnMiPC\Puertos\"

$accion   = New-ScheduledTaskAction -Execute "powershell.exe" -Argument ("-ExecutionPolicy Bypass -WindowStyle Hidden -File `"" + $scriptAud + "`"")
$ajustes  = New-ScheduledTaskSettingsSet -ExecutionTimeLimit (New-TimeSpan -Minutes 5) -MultipleInstances IgnoreNew -StartWhenAvailable
$principal = New-ScheduledTaskPrincipal -UserId "SYSTEM" -LogonType ServiceAccount -RunLevel Highest

# Tarea 1: al arrancar
$triggerArranque = New-ScheduledTaskTrigger -AtStartup
$nombreTarea1 = "Auditoria-Arranque"
Unregister-ScheduledTask -TaskName $nombreTarea1 -TaskPath $taskPath -Confirm:$false -ErrorAction SilentlyContinue
Register-ScheduledTask -TaskName $nombreTarea1 -TaskPath $taskPath -Action $accion -Trigger $triggerArranque -Settings $ajustes -Principal $principal -Description "Auditoria de puertos al arrancar - seguridadenmipc.com" | Out-Null
Write-Host ("OK Tarea creada: " + $taskPath + $nombreTarea1) -ForegroundColor Green

# Tarea 2: cada hora, indefinidamente
$triggerHora = New-ScheduledTaskTrigger -Once -At (Get-Date) -RepetitionInterval (New-TimeSpan -Hours 1) -RepetitionDuration (New-TimeSpan -Days 3650)
$nombreTarea2 = "Auditoria-Horaria"
Unregister-ScheduledTask -TaskName $nombreTarea2 -TaskPath $taskPath -Confirm:$false -ErrorAction SilentlyContinue
Register-ScheduledTask -TaskName $nombreTarea2 -TaskPath $taskPath -Action $accion -Trigger $triggerHora -Settings $ajustes -Principal $principal -Description "Auditoria de puertos cada hora - seguridadenmipc.com" | Out-Null
Write-Host ("OK Tarea creada: " + $taskPath + $nombreTarea2) -ForegroundColor Green

# -------------------------------------------------------
# RESUMEN FINAL
# -------------------------------------------------------
Write-Host ""
Write-Host "======================================================" -ForegroundColor Cyan
Write-Host " INSTALACION COMPLETADA" -ForegroundColor Green
Write-Host "======================================================" -ForegroundColor Cyan
Write-Host ""
Write-Host " Script principal copiado en   : C:\Scripts\bloqueo-puertos-peligrosos.ps1" -ForegroundColor Green
Write-Host " Puertos bloqueados en firewall : OK" -ForegroundColor Green
Write-Host " Script de auditoria instalado : $scriptAud" -ForegroundColor Green
Write-Host " Logs de instalacion y auditoria: $logDir" -ForegroundColor Green
Write-Host " Tarea al arrancar             : $taskPath$nombreTarea1" -ForegroundColor Green
Write-Host " Tarea cada hora                : $taskPath$nombreTarea2" -ForegroundColor Green
Write-Host ""
Write-Host " Los logs de auditoria se borran automaticamente tras 30 dias." -ForegroundColor Cyan
Write-Host " Las alertas quedan en Visor de Eventos > Aplicacion" -ForegroundColor Cyan
Write-Host " con el origen SEGPC-Auditoria y EventID 9001." -ForegroundColor Cyan
Write-Host ""
Write-Host " Para ver las tareas:" -ForegroundColor Yellow
Write-Host "   Get-ScheduledTask -TaskPath '\SeguridadEnMiPC\Puertos\'" -ForegroundColor White
Write-Host ""
Write-Host " Para eliminar todo:" -ForegroundColor Yellow
Write-Host "   Unregister-ScheduledTask -TaskName 'Auditoria-*' -TaskPath '\SeguridadEnMiPC\Puertos\' -Confirm:`$false" -ForegroundColor White
Write-Host "   Remove-NetFirewallRule -DisplayName 'SEGPC-BLOCK-*'" -ForegroundColor White
Write-Host "   Remove-Item -Path 'C:\ProgramData\SeguridadEnMiPC\Puertos' -Recurse -Force" -ForegroundColor White
Write-Host "   Remove-Item -Path 'C:\Scripts\bloqueo-puertos-peligrosos.ps1' -Force" -ForegroundColor White
Write-Host ""
Write-Host "======================================================" -ForegroundColor Cyan

Stop-Transcript | Out-Null
pause

🔎 Cómo verificar que el bloqueo y la auditoría están activos

Este último paso confirma que ya sabes cómo bloquear puertos peligrosos en Windows correctamente y que las reglas siguen activas tras reiniciar.

Get-NetFirewallRule -DisplayName "SEGPC-BLOCK-*" | Select-Object DisplayName, Enabled, Action
Get-ScheduledTask -TaskPath "\SeguridadEnMiPC\Puertos\" | Select-Object TaskName, State
Get-ChildItem C:\ProgramData\SeguridadEnMiPC\Puertos\Logs\

Las reglas deben mostrar Enabled = True y Action = Block. Las 2 tareas deben aparecer en estado Ready dentro de la ruta \SeguridadEnMiPC\Puertos\. En C:\ProgramData\SeguridadEnMiPC\Puertos\Logs\ debe existir al menos un archivo de instalación y, tras la primera ejecución programada, un archivo auditoria_AAAAMMDD_HHMM.txt — si no aparece ninguno, espera a que se dispare la tarea horaria o reinicia el equipo para forzar la tarea de arranque.

Checklist de seguridad: cómo bloquear puertos peligrosos en Windows

🔒 Checklist de protección frente a puertos peligrosos en Windows

• ☑ He comprobado los puertos abiertos con netstat -ano y no hay servicios desconocidos en escucha
• ☑ Telnet está desinstalado o deshabilitado en mi equipo
• ☑ El servicio OpenSSH Server está detenido y deshabilitado (si no lo uso)
• ☑ El Escritorio Remoto (RDP) está deshabilitado si no lo necesito
• ☑ TeamViewer, AnyDesk y similares están desinstalados o solo activos cuando los uso
• ☑ El Firewall de Windows está activo en todos los perfiles (dominio, privado, público)
• ☑ He creado reglas de bloqueo para los puertos 23, 22, 3389, 5900 y 5938
• ☑ Windows está actualizado con los últimos parches de seguridad
• ☑ Tengo un antivirus activo que detecta RATs y herramientas de acceso remoto maliciosas
• ☑ Reviso periódicamente los servicios de Windows activos con services.msc
• ☑ He cambiado las contraseñas de cuentas de administrador por contraseñas fuertes y únicas
• ☑ He activado la autenticación de dos factores (2FA): qué es, tipos y cómo activarla en 2026 en todas las cuentas importantes

✔ 12/12 = nivel objetivo · ✘ menos de 8 = exposición alta. Cumplir esta checklist es la forma más rápida de saber si ya dominas cómo bloquear puertos peligrosos en Windows.

Buenas prácticas para reducir la superficie de ataque remoto

🔍 ¿Qué buenas prácticas reducen el riesgo de los puertos de acceso remoto?

Además de las reglas de firewall, estas son las seis buenas prácticas más eficaces para reforzar cómo bloquear puertos peligrosos en Windows:

1. Usa VPN corporativa en lugar de exponer RDP (puerto 3389) directamente a Internet
2. Cambia el puerto SSH del 22 a un puerto no estándar (ej. 22222) para reducir el ruido de bots
3. Deshabilita el acceso SSH por contraseña y usa solo claves criptográficas
4. Implementa bloqueo automático de IPs tras intentos fallidos (Fail2Ban o equivalente en Windows)
5. Monitoriza los Event ID 4625 (login fallido) y 4624 (login exitoso) en el Visor de eventos
6. Segmenta la red: separa los equipos sensibles en una VLAN distinta

• 🔒 Usa VPN en lugar de RDP expuesto: consulta la guía de acceso remoto seguro en Windows: RDP, VPN y NLA paso a paso y usa siempre una VPN corporativa. Nunca expongas el puerto 3389 directamente a Internet.
• 🔢 Cambia los puertos por defecto: si SSH es imprescindible, cámbialo del puerto 22 a uno no estándar como el 22222. Reduce enormemente el ruido de bots automatizados.
• 🔑 Autenticación por clave en SSH: deshabilita el acceso SSH por contraseña y usa solo claves criptográficas.
• 🛡️ Fail2Ban o alternativas en Windows: herramientas que bloquean IPs tras varios intentos fallidos de login; consulta las guías de configuración segura de INCIBE para implementarlas en tu entorno.
• 🔍 Monitoriza con el Visor de eventos: busca el ID de evento 4625 (intentos de login fallidos) y 4624 (logins exitosos). Este proceso se detalla en la guía de monitorización de logins en Windows con PowerShell: detecta intrusiones antes de que sea tarde.
• 🌐 Segmenta la red: si usas equipos en red local, separa los equipos sensibles en una VLAN distinta para limitar el movimiento lateral.
• 🕵️ Monitoriza filtraciones de credenciales: si tus credenciales de acceso remoto han sido expuestas en una brecha, actúa antes de que el atacante las use. La guía de dark web monitoring: cómo saber si tus datos han sido filtrados en 2026 explica cómo vigilar esta exposición.

Aplicadas en conjunto, estas prácticas complementan al firewall y refuerzan de forma duradera cómo bloquear puertos peligrosos en Windows en cualquier equipo doméstico o corporativo.

Conclusión

Saber cómo bloquear puertos peligrosos en Windows es una habilidad fundamental en ciberseguridad doméstica y profesional. Protocolos como Telnet, SSH, RDP, VNC y herramientas de escritorio remoto como TeamViewer o AnyDesk representan vectores de ataque activos y cotidianos. La solución no es eliminar por defecto toda capacidad de acceso remoto, sino controlar qué está activo, por qué, y protegerlo adecuadamente.

Con los scripts de este artículo puedes en pocos minutos: detectar qué puertos están abiertos en tu equipo, crear reglas de firewall específicas para bloquearlos, deshabilitar servicios innecesarios y generar un informe de auditoría que puedes programar para ejecutarse automáticamente. La seguridad no es un evento puntual, sino un proceso continuo: revisa periódicamente el estado de tus puertos abiertos, mantén el sistema y los servicios de acceso remoto actualizados, y usa la checklist de esta guía como referencia recurrente para confirmar que ninguna herramienta ha vuelto a abrir un puerto sin que lo sepas.