Cómo bloquear P2P en Windows con PowerShell

Bloquear P2P en Windows con PowerShell es una medida de seguridad imprescindible: las redes peer-to-peer son uno de los principales vectores de distribución de malware y exposición involuntaria de datos, y hacerlo desde el firewall nativo cierra ese vector sin instalar software adicional. Cerrar correctamente este vector implica aplicar tres métodos complementarios que cubren puertos, ejecutables y rangos de IP.

Este artículo detalla tres métodos de PowerShell que cierran esos vectores en minutos, aplicando reglas de firewall con nombre único que se pueden verificar y revertir en un solo comando. Incluye además el mapeo completo a MITRE ATT&CK y la integración con el resto del hardening de red. Este bloqueo se enmarca dentro de una recopilación de guías de seguridad en Windows para blindar el firewall y cerrar vectores de red no controlados.

📅 Publicado: 26 de febrero de 2026 · 🕒 Tiempo de lectura: 16 minutos

📌 ¿Qué significa bloquear P2P en Windows?

Para bloquear P2P en Windows de forma eficaz, primero hay que identificar qué aplicaciones y protocolos están activos en el equipo. Los nodos P2P comparten archivos directamente entre sí sin servidor central, lo que significa que tu equipo puede estar actuando como punto de distribución sin que seas consciente de ello.

• 🔄 Torrents: BitTorrent, uTorrent, qBittorrent (puertos 6881-6889, 6969, 51413).
• 🔁 Sincronización P2P: Syncthing (puertos 22000, 6121).
• 🎬 Streaming P2P: Plex, Emby (puerto 32400).
• 🌐 Aplicaciones descentralizadas: IPFS, I2P, ZeroNet, GNUtella (puertos dinámicos).

🚨 ¿Por qué bloquear P2P en Windows?

Estos riesgos no son exclusivos de las redes P2P: forman parte de un catálogo de ciberseguridad para prevenir la exposición de datos y la distribución de malware que conviene revisar de forma periódica.

⚙️ Los 3 métodos para bloquear P2P en Windows

🛠️ Método 1: bloqueo por puerto

🌐 Método 2: bloqueo por ejecutable

🔐 Método 3: bloqueo por rangos de IP

Elimina la comunicación con rangos de IP de trackers y nodos P2P conocidos, impidiendo que el equipo se conecte con servidores que coordinan la distribución de contenido. El script incluye un array editable ($rangosIP) donde puedes añadir los rangos que quieras bloquear en formato CIDR; viene vacío por defecto porque la lista de trackers cambia constantemente y depende del contexto de cada usuario. Combinado con los métodos 1 y 2, ofrece la cobertura más completa para bloquear P2P en Windows.

La misma metodología de script con tareas programadas que garantizan la persistencia del bloqueo está documentada en el script completo para endurecer Windows 11 con 7 tareas programadas — ambos scripts son complementarios y pueden ejecutarse juntos para un hardening integral.

⚙️ Script completo para bloquear P2P en Windows con 3 tareas programadas

📅 Las 3 tareas programadas

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

1. Cómo guardar el script como .ps1 en C:\Scripts

1. Si no la tienes ya, crea la carpeta C:\Scripts: abre el Explorador de archivos, ve a C:\, clic derecho → Nuevo → Carpeta, y ponle de nombre Scripts.
2. Abre el Bloc de notas (tecla Windows → escribe "Bloc de notas" → Enter).
3. Pega dentro el código del script completo (lo tienes al final de esta sección). Si usas Plex o Syncthing, comenta antes las líneas correspondientes en $puertosP2P añadiendo # al principio de esa línea.
4. Ve a Archivo → Guardar como. Rellena estos tres campos:
   • Dónde guardarlo: navega hasta C:\Scripts (no el Escritorio).
   • Nombre de archivo: escribe bloqueo-p2p.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-p2p.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.

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

   Con dir *.ps1 confirmas el nombre exacto del archivo tal como quedó guardado.
4. Ejecuta el script con este comando:

   powershell -NoExit -ExecutionPolicy Bypass -File "bloqueo-p2p.ps1"

5. Apenas verás texto en pantalla al principio, mientras se crean las reglas de los tres métodos: el script usa Start-Transcript, que captura esa salida en C:\Logs\bloqueo-p2p.log. Es normal, espera a que continúe.
6. Después sí verás en pantalla las 3 líneas de confirmación de las tareas programadas ([OK] Tarea '...' creada).
7. Al terminar te pedirá pulsar Enter para cerrar.

3. Reiniciar el equipo (obligatorio)

Reinicia el equipo una vez tras la primera ejecución. El Programador de tareas de Windows tarda en sincronizar visualmente las tareas recién creadas: hasta que reinicias, es posible que Get-ScheduledTask y el Programador de tareas gráfico no muestren las 3 tareas nuevas, aunque ya existan y estén correctamente registradas.

Tras reiniciar, verifica:

Get-ScheduledTask -TaskName "Bloqueo-P2P-*" | Select-Object TaskName, TaskPath, State

Deben aparecer las 3 tareas, todas con TaskPath = \SeguridadEnMiPC\Bloqueo-P2P\ y State = Ready.

Si algo falla

• El script no muestra nada en pantalla al principio: normal, esa parte se registra en el log. Revisa con Get-Content C:\Logs\bloqueo-p2p.log -Tail 30.
• Dice que la ejecución de scripts está deshabilitada: ejecuta primero Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass.
• "El término 'finally' no se reconoce..." o errores de try/catch: pegaste el código directo 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í.
• Plex o Syncthing dejan de funcionar: vuelve a abrir el archivo con el Bloc de notas, añade # al principio de las líneas correspondientes dentro de $puertosP2P (tanto en el bloque principal como en el script auxiliar embebido), guarda y vuelve a ejecutar.
• Videojuegos con problemas de conexión: algunos juegos usan UDP en rangos altos. Comprueba los puertos del juego y, si coinciden con los bloqueados, elimina solo esa regla con Remove-NetFirewallRule -DisplayName "BLOQUEO_P2P ...".
• Las 3 tareas no aparecen en Get-ScheduledTask ni en el Programador de tareas gráfico, aunque el log confirme que se crearon: problema de caché del Programador de tareas tras crear/recrear carpetas de tareas en la misma sesión. Reinicia el equipo (paso 3) — el servicio Schedule no se puede reiniciar manualmente, Windows lo bloquea por ser un servicio crítico.

# ============================================
# Bloquear P2P en Windows: 3 metodos combinados
# Puerto + Ejecutable + Rangos de IP de trackers
# y mantenimiento con tres tareas programadas
# Requiere: PowerShell como Administrador
# Ruta fija: C:\Scripts\bloqueo-p2p.ps1
# ============================================
try {
    # 0. Verificar privilegios de administrador
    if (-not ([Security.Principal.WindowsPrincipal] `
        [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole(`
        [Security.Principal.WindowsBuiltInRole]::Administrator)) {
        Write-Host "[X] Ejecuta este script como Administrador." -ForegroundColor Red
        exit
    }
    # 1. Asegurar que el script vive en C:\Scripts (ruta que usaran las tareas programadas)
    $carpetaScripts = "C:\Scripts"
    if (-not (Test-Path $carpetaScripts)) {
        New-Item -ItemType Directory -Path $carpetaScripts -Force | Out-Null
    }
    $rutaFinal = "$carpetaScripts\bloqueo-p2p.ps1"
    if ($PSCommandPath -and ($PSCommandPath -ne $rutaFinal)) {
        Copy-Item -Path $PSCommandPath -Destination $rutaFinal -Force
        Write-Host "[i] Copia del script guardada en $rutaFinal para uso de las tareas programadas." -ForegroundColor Cyan
    }
    $carpetaLogs = "C:\Logs"
    if (-not (Test-Path $carpetaLogs)) {
        New-Item -ItemType Directory -Path $carpetaLogs -Force | Out-Null
    }
    Start-Transcript -Path "$carpetaLogs\bloqueo-p2p.log" -Append | Out-Null
    # 2. METODO 1: bloqueo por puerto (BitTorrent, qBittorrent, Syncthing, Plex)
    # Comenta las lineas de Plex/Syncthing si los usas legitimamente
    $puertosP2P = @(
        @{ Nombre = "BLOQUEO_P2P Puerto BitTorrent TCP 6881-6889"; Puerto = "6881-6889"; Protocolo = "TCP" },
        @{ Nombre = "BLOQUEO_P2P Puerto BitTorrent UDP 6881-6889"; Puerto = "6881-6889"; Protocolo = "UDP" },
        @{ Nombre = "BLOQUEO_P2P Puerto BitTorrent Tracker 6969"; Puerto = "6969"; Protocolo = "TCP" },
        @{ Nombre = "BLOQUEO_P2P Puerto qBittorrent TCP 51413"; Puerto = "51413"; Protocolo = "TCP" },
        @{ Nombre = "BLOQUEO_P2P Puerto qBittorrent UDP 51413"; Puerto = "51413"; Protocolo = "UDP" },
        @{ Nombre = "BLOQUEO_P2P Puerto Syncthing TCP 22000"; Puerto = "22000"; Protocolo = "TCP" },
        @{ Nombre = "BLOQUEO_P2P Puerto Plex TCP 32400"; Puerto = "32400"; Protocolo = "TCP" }
    )
    foreach ($regla in $puertosP2P) {
        if (-not (Get-NetFirewallRule -DisplayName $regla.Nombre -ErrorAction SilentlyContinue)) {
            New-NetFirewallRule -DisplayName $regla.Nombre -Direction Outbound `
                -Protocol $regla.Protocolo -RemotePort $regla.Puerto -Action Block | Out-Null
            New-NetFirewallRule -DisplayName "$($regla.Nombre) (Entrada)" -Direction Inbound `
                -Protocol $regla.Protocolo -LocalPort $regla.Puerto -Action Block | Out-Null
            Write-Host "[OK] Regla de puerto creada: $($regla.Nombre)" -ForegroundColor Green
        } else {
            Write-Host "[i] La regla ya existia: $($regla.Nombre)" -ForegroundColor Yellow
        }
    }
    # 3. METODO 2: bloqueo por ejecutable (resistente a puertos dinamicos)
    # Solo crea la regla si encuentra el ejecutable instalado en el equipo
    $clientesP2P = @(
        "$env:ProgramFiles\uTorrent\uTorrent.exe",
        "${env:ProgramFiles(x86)}\uTorrent\uTorrent.exe",
        "$env:APPDATA\uTorrent\uTorrent.exe",
        "$env:ProgramFiles\BitTorrent\bittorrent.exe",
        "${env:ProgramFiles(x86)}\BitTorrent\bittorrent.exe",
        "$env:ProgramFiles\qBittorrent\qbittorrent.exe",
        "${env:ProgramFiles(x86)}\qBittorrent\qbittorrent.exe",
        "$env:ProgramFiles\Transmission\transmission-qt.exe",
        "$env:ProgramFiles\Deluge\deluge.exe",
        "${env:ProgramFiles(x86)}\Deluge\deluge.exe",
        "$env:ProgramFiles\Vuze\Azureus.exe",
        "${env:ProgramFiles(x86)}\Vuze\Azureus.exe",
        "${env:ProgramFiles(x86)}\FrostWire\frostwire.exe",
        "${env:ProgramFiles(x86)}\Ares\Ares.exe",
        "${env:ProgramFiles(x86)}\eMule\emule.exe",
        "${env:ProgramFiles(x86)}\Shareaza\Shareaza.exe"
    )
    $encontrados = 0
    foreach ($ruta in $clientesP2P) {
        if (Test-Path $ruta) {
            $nombreRegla = "BLOQUEO_P2P Ejecutable $(Split-Path $ruta -Leaf)"
            if (-not (Get-NetFirewallRule -DisplayName $nombreRegla -ErrorAction SilentlyContinue)) {
                New-NetFirewallRule -DisplayName $nombreRegla -Direction Outbound -Program $ruta -Action Block | Out-Null
                Write-Host "[OK] Regla de ejecutable creada: $nombreRegla ($ruta)" -ForegroundColor Green
                $encontrados++
            }
        }
    }
    if ($encontrados -eq 0) {
        Write-Host "[i] No se encontraron clientes P2P conocidos instalados en las rutas habituales." -ForegroundColor Yellow
    }
    # 4. METODO 3: bloqueo por rangos de IP de trackers/nodos conocidos
    # Lista editable: anade aqui los rangos que quieras bloquear (formato CIDR)
    $rangosIP = @(
        # "1.2.3.0/24",
        # "5.6.7.0/24"
    )
    foreach ($rango in $rangosIP) {
        $nombreRegla = "BLOQUEO_P2P IP $rango"
        if (-not (Get-NetFirewallRule -DisplayName $nombreRegla -ErrorAction SilentlyContinue)) {
            New-NetFirewallRule -DisplayName $nombreRegla -Direction Outbound -RemoteAddress $rango -Action Block | Out-Null
            Write-Host "[OK] Regla de rango IP creada: $nombreRegla" -ForegroundColor Green
        }
    }
    if ($rangosIP.Count -eq 0) {
        Write-Host "[i] Metodo 3 (rangos de IP) sin rangos configurados. Edita `$rangosIP en el script para anadirlos." -ForegroundColor Yellow
    }
    # 5. Crear script auxiliar que reaplica los 3 metodos (usado por Inicio/Logon/10min)
    $carpetaAuxiliar = "C:\ProgramData\SeguridadEnMiPC\BloqueoP2P"
    if (-not (Test-Path $carpetaAuxiliar)) { New-Item -ItemType Directory -Path $carpetaAuxiliar -Force | Out-Null }
    $scriptReaplicar = "$carpetaAuxiliar\reaplicar-bloqueo-p2p.ps1"
    $contenidoReaplicar = @'
$puertosP2P = @(
    @{ Nombre = "BLOQUEO_P2P Puerto BitTorrent TCP 6881-6889"; Puerto = "6881-6889"; Protocolo = "TCP" },
    @{ Nombre = "BLOQUEO_P2P Puerto BitTorrent UDP 6881-6889"; Puerto = "6881-6889"; Protocolo = "UDP" },
    @{ Nombre = "BLOQUEO_P2P Puerto BitTorrent Tracker 6969"; Puerto = "6969"; Protocolo = "TCP" },
    @{ Nombre = "BLOQUEO_P2P Puerto qBittorrent TCP 51413"; Puerto = "51413"; Protocolo = "TCP" },
    @{ Nombre = "BLOQUEO_P2P Puerto qBittorrent UDP 51413"; Puerto = "51413"; Protocolo = "UDP" },
    @{ Nombre = "BLOQUEO_P2P Puerto Syncthing TCP 22000"; Puerto = "22000"; Protocolo = "TCP" },
    @{ Nombre = "BLOQUEO_P2P Puerto Plex TCP 32400"; Puerto = "32400"; Protocolo = "TCP" }
)
foreach ($regla in $puertosP2P) {
    if (-not (Get-NetFirewallRule -DisplayName $regla.Nombre -ErrorAction SilentlyContinue)) {
        New-NetFirewallRule -DisplayName $regla.Nombre -Direction Outbound -Protocol $regla.Protocolo -RemotePort $regla.Puerto -Action Block | Out-Null
        New-NetFirewallRule -DisplayName "$($regla.Nombre) (Entrada)" -Direction Inbound -Protocol $regla.Protocolo -LocalPort $regla.Puerto -Action Block | Out-Null
    }
}
$clientesP2P = @(
    "$env:ProgramFiles\uTorrent\uTorrent.exe",
    "${env:ProgramFiles(x86)}\uTorrent\uTorrent.exe",
    "$env:APPDATA\uTorrent\uTorrent.exe",
    "$env:ProgramFiles\BitTorrent\bittorrent.exe",
    "${env:ProgramFiles(x86)}\BitTorrent\bittorrent.exe",
    "$env:ProgramFiles\qBittorrent\qbittorrent.exe",
    "${env:ProgramFiles(x86)}\qBittorrent\qbittorrent.exe",
    "$env:ProgramFiles\Transmission\transmission-qt.exe",
    "$env:ProgramFiles\Deluge\deluge.exe",
    "${env:ProgramFiles(x86)}\Deluge\deluge.exe",
    "$env:ProgramFiles\Vuze\Azureus.exe",
    "${env:ProgramFiles(x86)}\Vuze\Azureus.exe",
    "${env:ProgramFiles(x86)}\FrostWire\frostwire.exe",
    "${env:ProgramFiles(x86)}\Ares\Ares.exe",
    "${env:ProgramFiles(x86)}\eMule\emule.exe",
    "${env:ProgramFiles(x86)}\Shareaza\Shareaza.exe"
)
foreach ($ruta in $clientesP2P) {
    if (Test-Path $ruta) {
        $nombreRegla = "BLOQUEO_P2P Ejecutable $(Split-Path $ruta -Leaf)"
        if (-not (Get-NetFirewallRule -DisplayName $nombreRegla -ErrorAction SilentlyContinue)) {
            New-NetFirewallRule -DisplayName $nombreRegla -Direction Outbound -Program $ruta -Action Block | Out-Null
        }
    }
}
$rangosIP = @(
    # "1.2.3.0/24"
)
foreach ($rango in $rangosIP) {
    $nombreRegla = "BLOQUEO_P2P IP $rango"
    if (-not (Get-NetFirewallRule -DisplayName $nombreRegla -ErrorAction SilentlyContinue)) {
        New-NetFirewallRule -DisplayName $nombreRegla -Direction Outbound -RemoteAddress $rango -Action Block | Out-Null
    }
}
$totalReglas = (Get-NetFirewallRule -DisplayName "BLOQUEO_P2P*" -ErrorAction SilentlyContinue | Where-Object { $_.Enabled -eq "True" }).Count
Add-Content -Path "C:\Logs\bloqueo-p2p.log" -Value "$(Get-Date) - [OK] Bloqueo P2P reaplicado. $totalReglas reglas BLOQUEO_P2P activas."
'@
    Set-Content -Path $scriptReaplicar -Encoding UTF8 -Value $contenidoReaplicar
    Write-Host "[OK] Script auxiliar creado en $scriptReaplicar" -ForegroundColor Green
    # 6. Carpeta de tareas programadas
    $carpetaTareas = "\SeguridadEnMiPC\Bloqueo-P2P\"
    # 7. Tarea: reaplicar en cada arranque
    if (-not (Get-ScheduledTask -TaskName "Bloqueo-P2P-Inicio" -TaskPath $carpetaTareas -ErrorAction SilentlyContinue)) {
        $a1 = New-ScheduledTaskAction -Execute "powershell.exe" -Argument "-ExecutionPolicy Bypass -WindowStyle Hidden -File `"$scriptReaplicar`""
        $t1 = New-ScheduledTaskTrigger -AtStartup
        Register-ScheduledTask -TaskName "Bloqueo-P2P-Inicio" -TaskPath $carpetaTareas -Action $a1 -Trigger $t1 -RunLevel Highest -User "SYSTEM" -Force | Out-Null
        Write-Host "[OK] Tarea 'Bloqueo-P2P-Inicio' creada (al arrancar Windows)." -ForegroundColor Green
    } else { Write-Host "[i] La tarea 'Bloqueo-P2P-Inicio' ya existia." -ForegroundColor Yellow }
    # 8. Tarea: reaplicar en cada inicio de sesion
    if (-not (Get-ScheduledTask -TaskName "Bloqueo-P2P-Logon" -TaskPath $carpetaTareas -ErrorAction SilentlyContinue)) {
        $a2 = New-ScheduledTaskAction -Execute "powershell.exe" -Argument "-ExecutionPolicy Bypass -WindowStyle Hidden -File `"$scriptReaplicar`""
        $t2 = New-ScheduledTaskTrigger -AtLogOn
        Register-ScheduledTask -TaskName "Bloqueo-P2P-Logon" -TaskPath $carpetaTareas -Action $a2 -Trigger $t2 -RunLevel Highest -User "SYSTEM" -Force | Out-Null
        Write-Host "[OK] Tarea 'Bloqueo-P2P-Logon' creada (al iniciar sesion)." -ForegroundColor Green
    } else { Write-Host "[i] La tarea 'Bloqueo-P2P-Logon' ya existia." -ForegroundColor Yellow }
    # 9. Tarea: reaplicar cada 10 minutos
    if (-not (Get-ScheduledTask -TaskName "Bloqueo-P2P-10min" -TaskPath $carpetaTareas -ErrorAction SilentlyContinue)) {
        $a3 = New-ScheduledTaskAction -Execute "powershell.exe" -Argument "-ExecutionPolicy Bypass -WindowStyle Hidden -File `"$scriptReaplicar`""
        $t3 = New-ScheduledTaskTrigger -Once -At (Get-Date) -RepetitionInterval (New-TimeSpan -Minutes 10) -RepetitionDuration (New-TimeSpan -Days 3650)
        Register-ScheduledTask -TaskName "Bloqueo-P2P-10min" -TaskPath $carpetaTareas -Action $a3 -Trigger $t3 -RunLevel Highest -User "SYSTEM" -Force | Out-Null
        Write-Host "[OK] Tarea 'Bloqueo-P2P-10min' creada (cada 10 minutos)." -ForegroundColor Green
    } else { Write-Host "[i] La tarea 'Bloqueo-P2P-10min' ya existia." -ForegroundColor Yellow }
    # 10. Verificacion final (busqueda por nombre, mas fiable que por TaskPath si el cache no esta sincronizado)
    Write-Host "`n=== Tareas programadas activas ===" -ForegroundColor Cyan
    Get-ScheduledTask -TaskName "Bloqueo-P2P-*" | Select-Object TaskName, TaskPath, State | Format-Table -AutoSize
    Write-Host "[OK] Bloqueo P2P aplicado (3 metodos) y protegido con 3 tareas programadas." -ForegroundColor Green
    Write-Host "     Script principal: $rutaFinal" -ForegroundColor Gray
    Write-Host "     Script auxiliar: $scriptReaplicar" -ForegroundColor Gray
    Write-Host "     Log: C:\Logs\bloqueo-p2p.log" -ForegroundColor Gray
    Write-Host "`n[i] Reinicia el equipo. Tras reiniciar, verifica con:" -ForegroundColor Yellow
    Write-Host "    Get-ScheduledTask -TaskName 'Bloqueo-P2P-*' | Select-Object TaskName, TaskPath, State" -ForegroundColor Gray
}
catch {
    Write-Host "`n[X] Error: $($_.Exception.Message)" -ForegroundColor Red
}
finally {
    Stop-Transcript | Out-Null
    Read-Host "`nPulsa Enter para salir"
}

🔍 ¿Cómo comprobar que el bloqueo P2P en Windows está funcionando?

netstat -an | findstr "6881 6969 51413 22000 32400"
Get-NetFirewallRule | Where-Object {$_.DisplayName -like "BLOQUEO_P2P*"} | Select-Object DisplayName, Enabled, Action
Get-ScheduledTask -TaskName "Bloqueo-P2P-*" | Select-Object TaskName, TaskPath, State
Get-Content C:\Logs\bloqueo-p2p.log -Tail 30

✅ Checklist post-instalación

⚠️ Riesgos y efectos de bloquear P2P Windows

🆚 Antes y después de bloquear P2P Windows

🏁 Conclusión

Bloquear P2P en Windows con PowerShell es una medida de hardening eficaz para reducir la superficie de ataque y eliminar vectores de distribución de malware sin software adicional. Los tres métodos combinados (por puerto, ejecutable y rangos de IP) ofrecen la cobertura más completa, y las tres tareas programadas garantizan que el bloqueo persista pase lo que pase.

❓ Preguntas frecuentes sobre bloquear P2P en Windows

¿El bloqueo afecta a la navegación normal?

👉 No. Al bloquear P2P en Windows solo se cierran los puertos no estándar P2P. La navegación web (80/443), correo y otros servicios usan puertos completamente distintos.

¿Se puede revertir?

👉 Sí. Guarda y ejecuta el script de reversión de esta guía. Elimina primero las 3 tareas o el bloqueo P2P en Windows se reaplicará en menos de 10 minutos.

¿Por qué cada 10 minutos y no cada hora?

👉 Los clientes P2P modernos recrean sus reglas de firewall al actualizarse o reinstalarse. Cada hora dejaría una ventana demasiado amplia. Cada 10 minutos es el equilibrio óptimo para bloquear P2P en Windows de forma persistente: 144 ejecuciones de menos de 1 segundo suman unos 2 minutos de CPU al día.

¿Qué diferencia hay entre bloquear por puerto y por ejecutable?

👉 El bloqueo por puerto falla si el cliente cambia de puerto dinámicamente. El bloqueo por ejecutable bloquea todo el tráfico del proceso independientemente del puerto. Para bloquear P2P Windows con máxima eficacia aplica ambos métodos.

¿Cómo consulto las tareas programadas?

👉 PowerShell: Get-ScheduledTask -TaskName "Bloqueo-P2P-*" | Select-Object TaskName, TaskPath, State. GUI: Win+R → taskschd.msc → Biblioteca del Programador de tareas → SeguridadEnMiPC → Bloqueo-P2P.

¿Afecta a Plex o Syncthing?

👉 Sí por defecto. Antes de guardar el script, edítalo en el Bloc de notas y añade # al principio de las líneas correspondientes (en el bloque principal y en el script auxiliar embebido) antes de ejecutarlo. Para control más preciso usa solo el Método 2 sobre los clientes torrent.