Archivo HOSTS Windows: Explicación detallada

El archivo HOSTS Windows es uno de los componentes más silenciosos y poderosos del sistema operativo: controla cómo tu PC resuelve los nombres de dominio antes de consultar cualquier servidor externo. En nuestro portal de seguridad para PC vemos a diario cómo su modificación maliciosa redirige bancos a páginas falsas, bloquea antivirus y deshabilita Windows Update sin ningún aviso visible — y sin que el usuario lo detecte hasta que el daño ya está hecho.

📅 2026 · 🕐 10 minutos de lectura

¿Quieres proteger tu equipo? En todas las guías de protección del sistema Windows encontrarás las medidas paso a paso. Consulta también el catálogo completo de artículos sobre seguridad Windows disponibles en el sitio.

El archivo HOSTS Windows es un fichero de texto local que asocia nombres de dominio con direcciones IP sin consultar servidores DNS externos. Windows lo consulta antes que cualquier DNS configurado, por lo que su modificación maliciosa tiene efecto inmediato y total sobre la navegación del equipo. En esta guía aprenderás qué es, cómo funciona, cómo detectar si ha sido comprometido, restaurarlo a su estado original y protegerlo frente a futuras modificaciones.

Esta guía complementa el endurecimiento de Windows 11 y nuestra sección sobre malware y virus informáticos.

📌 ¿Qué es el archivo HOSTS Windows?

Es un fichero de texto plano presente en todos los sistemas Windows desde sus primeras versiones. Su función es mapear nombres de dominio a direcciones IP de forma local, actuando como un DNS privado instalado directamente en tu equipo.

• 📍 Ubicación: C:\Windows\System32\drivers\etc\hosts
• 🔑 Prioridad: Se consulta antes que cualquier servidor DNS configurado
• ⚠️ Riesgo: Su modificación afecta a toda la navegación sin ningún aviso visible
• 🛠️ Requisito: Necesitas permisos de administrador para editarlo

⚙️ ¿Cómo funciona?

Cuando escribes una URL en tu navegador, Windows sigue un orden estricto de resolución de nombres. El archivo HOSTS Windows ocupa el segundo lugar, justo después de la caché local del sistema y antes de cualquier servidor DNS externo. Microsoft documenta el comportamiento y la ubicación de este archivo en su guía oficial de restablecimiento del archivo HOSTS.

✅ Usos legítimos del archivo HOSTS

No es solo un objetivo de ataque — también es una herramienta de seguridad muy eficaz cuando se usa correctamente:

• 🔒 Bloquear dominios maliciosos: Redirigir dominios de malware, adware o phishing conocidos a 0.0.0.0
• 🚫 Filtrar publicidad a nivel de sistema: Afecta a todos los navegadores y apps simultáneamente
• 🌐 Desarrollo web local: Apuntar dominios de prueba a 127.0.0.1 sin DNS real
• ⚡ Acelerar la resolución: Definir IPs fijas para servidores internos de empresa
• 🧪 Pruebas de migración: Simular que un dominio apunta a un nuevo servidor antes de cambiar el DNS real

⚠️ Riesgos: ¿Por qué el malware ataca el archivo HOSTS?

🔍 Cómo verificar si el archivo HOSTS ha sido comprometido

Antes de restaurarlo, conviene comprobar su estado actual. El método más rápido y fiable es usar PowerShell con permisos de administrador.

Método 1: Ver el contenido completo con PowerShell

Get-Content C:\Windows\System32\drivers\etc\hosts

El archivo HOSTS limpio de Windows solo debe contener líneas que empiezan por # (comentarios) y la entrada estándar 127.0.0.1 localhost. Cualquier otra entrada activa — sin # al inicio — es sospechosa y debe investigarse.

Método 2: Filtrar solo las entradas activas

Get-Content C:\Windows\System32\drivers\etc\hosts |
Where-Object { $_ -notmatch '^\s*#' -and $_ -notmatch '^\s*$' }

Este comando muestra únicamente las líneas activas, ignorando comentarios y líneas en blanco. Si el resultado incluye dominios de bancos, antivirus, Microsoft o servicios MFA apuntando a IPs desconocidas, el archivo ha sido comprometido.

🔧 Cómo restaurar el archivo HOSTS Windows a su estado original

Existen dos métodos para restaurar el archivo HOSTS a su contenido predeterminado de Microsoft: uno rápido con PowerShell (ideal para usuarios avanzados o administradores) y otro manual con el Bloc de notas (más visual y accesible para cualquier usuario).

✅ Método 1: Restauración rápida con PowerShell

Abre PowerShell como administrador y ejecuta el siguiente bloque. Sobrescribe el archivo HOSTS con el contenido oficial de Microsoft y limpia la caché DNS para que los cambios surtan efecto de forma inmediata.

$hostsPath = "C:\Windows\System32\drivers\etc\hosts"

# Quitar atributo solo lectura (si estaba protegido)
Set-ItemProperty -Path $hostsPath -Name IsReadOnly -Value $false

# Restaurar contenido minimo original
$contenidoOriginal = "127.0.0.1`tlocalhost`n::1`t`tlocalhost"
Set-Content -Path $hostsPath -Value $contenidoOriginal -Encoding ASCII

# Limpiar cache DNS
ipconfig /flushdns

Write-Host "Archivo HOSTS restaurado." -ForegroundColor Green

✅ Método 2: Restauración manual con Bloc de notas

1. Abre el Bloc de notas como administrador (clic derecho → Ejecutar como administrador)
2. Ve a Archivo → Abrir y navega a C:\Windows\System32\drivers\etc\
3. Cambia el filtro a Todos los archivos y abre hosts
4. Borra todo el contenido y pega el texto predeterminado que aparece en el Método 1
5. Guarda con Ctrl+S — asegúrate de que no añade extensión .txt

🛡️ Cómo proteger el archivo HOSTS con permisos ACL

Restaurar el archivo no es suficiente si el malware sigue activo en el sistema. La solución definitiva es bloquear los permisos de escritura mediante ACL (Access Control List) para que ningún proceso ni siquiera con privilegios elevados pueda modificarlo sin intervención manual del administrador.

Paso 1: Configurar permisos de solo lectura con PowerShell

# Obtener la ACL actual
$acl = Get-Acl "C:\Windows\System32\drivers\etc\hosts"

# Deshabilitar la herencia y eliminar permisos heredados
$acl.SetAccessRuleProtection($true, $false)

# Anadir regla: SYSTEM solo lectura
$ruleSystem = New-Object System.Security.AccessControl.FileSystemAccessRule("SYSTEM","Read","Allow")
$acl.AddAccessRule($ruleSystem)

# Anadir regla: Administradores solo lectura
$ruleAdmin = New-Object System.Security.AccessControl.FileSystemAccessRule("Administrators","Read","Allow")
$acl.AddAccessRule($ruleAdmin)

# Aplicar la ACL
Set-Acl "C:\Windows\System32\drivers\etc\hosts" $acl

Paso 2: Cómo recuperar permisos de escritura cuando necesites editarlo

Cuando necesites modificar el archivo legítimamente (por ejemplo, para añadir un bloqueo de dominio), ejecuta este comando primero para restaurar temporalmente los permisos de escritura:

$acl = Get-Acl "C:\Windows\System32\drivers\etc\hosts"
$rule = New-Object System.Security.AccessControl.FileSystemAccessRule("Administrators","FullControl","Allow")
$acl.AddAccessRule($rule)
Set-Acl "C:\Windows\System32\drivers\etc\hosts" $acl

Una vez realizados los cambios, vuelve a aplicar el bloqueo del Paso 1.

⚙️ Script completo: Proteger y restaurar el archivo HOSTS con 4 tareas programadas

A continuación encontrarás un script PowerShell completo y unificado que automatiza todo el proceso: hace backup del archivo HOSTS actual, calcula un hash SHA256 de referencia, restaura el contenido oficial de Microsoft si detecta manipulación, limpia la caché DNS, aplica la protección ACL que impide futuras modificaciones maliciosas y crea cuatro tareas programadas que vigilan la integridad del archivo en cada arranque, en cada inicio de sesión, cada 6 horas y al conectar a una nueva red. De esta forma, si malware o un tercero consigue modificar el HOSTS (incluso tras desactivar la ACL), el script lo detecta y lo restaura automáticamente.

📅 Tareas programadas que crea este script

El script registra cuatro tareas independientes en el Programador de tareas de Windows. Cada una se ejecuta en un disparador distinto para garantizar la máxima cobertura posible, incluyendo el momento más crítico para el archivo HOSTS: la conexión a una nueva red (el escenario típico en el que el malware intenta redirigir tráfico):

📥 Pasos para instalar y ejecutar el script

1. Abre PowerShell como administrador: pulsa la tecla Windows, escribe PowerShell, haz clic derecho sobre Windows PowerShell y selecciona Ejecutar como administrador.
2. Permite la ejecución de scripts en la sesión actual (no afecta a futuras sesiones):
   Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
3. Crea la carpeta de scripts del sistema: el script se instalará en C:\Scripts\ para que las tareas programadas lo encuentren siempre en la misma ruta:
   New-Item -ItemType Directory -Path "C:\Scripts" -Force
4. Crea el archivo del script: abre el Bloc de notas, pega el código que verás más abajo y guárdalo como HOSTS-Guard.ps1 directamente en C:\Scripts\. Asegúrate de que el tipo de archivo sea Todos los archivos, no .txt.
5. Ejecuta el script por primera vez desde PowerShell (esto restaurará el HOSTS, aplicará la ACL, guardará el hash de referencia Y creará las cuatro tareas programadas):
   C:\Scripts\HOSTS-Guard.ps1
6. Verifica que las cuatro tareas programadas se crearon correctamente:
   Get-ScheduledTask -TaskName "HOSTS-Guard-*"
7. Revisa el log, el backup y el CSV histórico: C:\Logs\hosts-guard.log, C:\Logs\hosts.backup.txt y C:\Logs\hosts-guard-historico.csv.
8. Reinicia el equipo: la tarea de inicio se ejecutará automáticamente y la protección quedará activa.

💻 Script de protección del archivo HOSTS (copia y pega)

# ============================================================
# Script: HOSTS-Guard - proteccion y restauracion del HOSTS
# Autor:  seguridadenmipc.com
# Compat: Windows 10 / 11 / Server 2019+
# Uso:    Ejecutar como administrador (1a vez)
#         Despues se reaplica solo: inicio, logon, 6h y red
# Ruta:   C:\Scripts\HOSTS-Guard.ps1
# Idempotente: solo restaura si el hash SHA256 no coincide
# ============================================================

# 1. 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
}

# 2. Preparar carpetas y rutas
$logDir = "C:\Logs"
if (-not (Test-Path $logDir)) { New-Item -ItemType Directory -Path $logDir | Out-Null }
$log        = "$logDir\hosts-guard.log"
$csv        = "$logDir\hosts-guard-historico.csv"
$backup     = "$logDir\hosts.backup.txt"
$hashRefFile = "$logDir\hosts-hash-ref.txt"
$hostsPath  = "C:\Windows\System32\drivers\etc\hosts"

Start-Transcript -Path $log -Append | Out-Null

$disparador = if ($args[0]) { $args[0] } else { "Manual" }
Write-Host "=== HOSTS-Guard: verificacion del archivo HOSTS ===" -ForegroundColor Cyan
Write-Host "Fecha: $(Get-Date)  |  Disparador: $disparador" -ForegroundColor Gray

# 3. Contenido oficial de Microsoft (referencia)
$contenidoOriginal = @"
# Copyright (c) 1993-2009 Microsoft Corp.
#
# Este es un ejemplo de archivo HOSTS usado por Microsoft TCP/IP para Windows.
#
# Cada entrada debe permanecer en una linea individual. La direccion IP debe
# colocarse en la primera columna seguida del nombre de host correspondiente.
# La direccion IP y el nombre de host deben estar separados por al menos un
# espacio en blanco.
#
# Ademas, los comentarios (como estos) pueden insertarse en lineas individuales
# o a continuacion del nombre de equipo indicandolos con el simbolo '#'.
#
# Por ejemplo:
#
#      102.54.94.97     rhino.acme.com          # servidor origen
#       38.25.63.10     x.acme.com              # host cliente x

# La resolucion de nombres de localhost se realiza dentro del propio DNS.
#	127.0.0.1       localhost
#	::1             localhost
"@

# 4. Calcular hash actual del HOSTS
$hashActual = (Get-FileHash -Path $hostsPath -Algorithm SHA256).Hash
Write-Host "Hash actual : $hashActual" -ForegroundColor Gray

# 5. Cargar hash de referencia (si existe)
$hashReferencia = $null
if (Test-Path $hashRefFile) {
    $hashReferencia = (Get-Content $hashRefFile -Raw).Trim()
    Write-Host "Hash referencia: $hashReferencia" -ForegroundColor Gray
}

$restaurado = $false
$aclAplicada = $false

# 6. Decidir si hay que restaurar
$debeRestaurar = $false
if (-not $hashReferencia) {
    # Primera ejecucion: creamos referencia a partir del contenido oficial
    $debeRestaurar = $true
    Write-Host "[i] Primera ejecucion: se establecera el HOSTS oficial." -ForegroundColor Cyan
} elseif ($hashActual -ne $hashReferencia) {
    $debeRestaurar = $true
    Write-Host "[!] Hash del HOSTS ha cambiado: se detecta modificacion." -ForegroundColor Red
} else {
    Write-Host "[OK] Hash del HOSTS coincide con la referencia." -ForegroundColor Green
}

# 7. Si hay que restaurar: backup + restaurar + flushdns
if ($debeRestaurar) {
    # 7a. Backup del HOSTS actual
    try {
        Copy-Item -Path $hostsPath -Destination $backup -Force
        Write-Host "[OK] Backup guardado en: $backup" -ForegroundColor Green
    } catch { Write-Host "[!] No se pudo crear backup: $_" -ForegroundColor Yellow }

    # 7b. Quitar proteccion temporalmente
    try {
        $aclTmp = Get-Acl $hostsPath
        $aclTmp.SetAccessRuleProtection($false, $true)
        Set-Acl -Path $hostsPath -AclObject $aclTmp
        Set-ItemProperty -Path $hostsPath -Name IsReadOnly -Value $false -ErrorAction Stop
    } catch { Write-Host "[!] Aviso en permisos previos: $_" -ForegroundColor Yellow }

    # 7c. Restaurar contenido oficial
    try {
        Set-Content -Path $hostsPath -Value $contenidoOriginal -Encoding ASCII -Force
        Write-Host "[OK] Contenido oficial restaurado." -ForegroundColor Green
        $restaurado = $true
    } catch { Write-Host "[X] Error restaurando: $_" -ForegroundColor Red }

    # 7d. Limpiar cache DNS
    try {
        ipconfig /flushdns | Out-Null
        Write-Host "[OK] Cache DNS limpiada." -ForegroundColor Green
    } catch {}

    # 7e. Recalcular hash y guardar como referencia
    $hashNuevo = (Get-FileHash -Path $hostsPath -Algorithm SHA256).Hash
    Set-Content -Path $hashRefFile -Value $hashNuevo -Encoding ASCII -Force
    Write-Host "[OK] Hash de referencia actualizado." -ForegroundColor Green
    $hashReferencia = $hashNuevo
    $hashActual    = $hashNuevo
}

# 8. Aplicar proteccion ACL (solo lectura)
try {
    $acl = Get-Acl $hostsPath
    $acl.SetAccessRuleProtection($true, $false)
    $acl.Access | ForEach-Object { $acl.RemoveAccessRule($_) | Out-Null }

    $ruleSystem = New-Object System.Security.AccessControl.FileSystemAccessRule(
        "SYSTEM","Read","Allow")
    $ruleAdmin  = New-Object System.Security.AccessControl.FileSystemAccessRule(
        "Administrators","Read","Allow")
    $ruleUsers  = New-Object System.Security.AccessControl.FileSystemAccessRule(
        "Users","Read","Allow")

    $acl.AddAccessRule($ruleSystem)
    $acl.AddAccessRule($ruleAdmin)
    $acl.AddAccessRule($ruleUsers)
    Set-Acl -Path $hostsPath -AclObject $acl
    Write-Host "[OK] Proteccion ACL aplicada (solo lectura)." -ForegroundColor Green
    $aclAplicada = $true
} catch { Write-Host "[X] Error aplicando ACL: $_" -ForegroundColor Red }

# 9. Resumen al CSV historico
$resumen = [PSCustomObject]@{
    Fecha       = (Get-Date -Format "yyyy-MM-dd HH:mm:ss")
    Disparador  = $disparador
    HashActual  = $hashActual
    Restaurado  = $restaurado
    ACLaplicada = $aclAplicada
}
$resumen | Export-Csv -Path $csv -Append -NoTypeInformation -Encoding UTF8
Write-Host "[OK] Resumen anadido al CSV. Restaurado: $restaurado" -ForegroundColor Green

# 10. CREAR LAS 4 TAREAS PROGRAMADAS (solo si no existen)
$scriptPath = "C:\Scripts\HOSTS-Guard.ps1"

function Crear-Tarea {
    param(
        [string]$Nombre,
        [string]$Disparador,
        $Trigger,
        [string]$Descripcion
    )
    try {
        if (-not (Get-ScheduledTask -TaskName $Nombre -ErrorAction SilentlyContinue)) {
            $action = New-ScheduledTaskAction -Execute "PowerShell.exe" `
                -Argument "-NoProfile -ExecutionPolicy Bypass -WindowStyle Hidden -File `"$scriptPath`" $Disparador"
            $principal = New-ScheduledTaskPrincipal -UserId "SYSTEM" `
                -LogonType ServiceAccount -RunLevel Highest
            $settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries `
                -DontStopIfGoingOnBatteries -StartWhenAvailable `
                -ExecutionTimeLimit (New-TimeSpan -Minutes 5)
            Register-ScheduledTask -TaskName $Nombre `
                -Action $action -Trigger $Trigger -Principal $principal `
                -Settings $settings -Description $Descripcion | Out-Null
            Write-Host "[OK] Tarea '$Nombre' creada." -ForegroundColor Green
        } else {
            Write-Host "[i] Tarea '$Nombre' ya existe." -ForegroundColor Cyan
        }
    } catch { Write-Host "[X] Error en tarea $Nombre: $_" -ForegroundColor Red }
}

# 10a. Tarea: al iniciar Windows
Crear-Tarea -Nombre "HOSTS-Guard-Inicio" -Disparador "Inicio" `
    -Trigger (New-ScheduledTaskTrigger -AtStartup) `
    -Descripcion "HOSTS-Guard al arranque - seguridadenmipc.com"

# 10b. Tarea: al iniciar sesion
Crear-Tarea -Nombre "HOSTS-Guard-Logon" -Disparador "Logon" `
    -Trigger (New-ScheduledTaskTrigger -AtLogOn) `
    -Descripcion "HOSTS-Guard al iniciar sesion - seguridadenmipc.com"

# 10c. Tarea: cada 6 horas
Crear-Tarea -Nombre "HOSTS-Guard-6h" -Disparador "6h" `
    -Trigger (New-ScheduledTaskTrigger -Once -At (Get-Date).AddMinutes(10) `
              -RepetitionInterval (New-TimeSpan -Hours 6)) `
    -Descripcion "HOSTS-Guard cada 6 horas - seguridadenmipc.com"

# 10d. Tarea: al conectar a una red nueva (evento 10000 NetworkProfile)
try {
    if (-not (Get-ScheduledTask -TaskName "HOSTS-Guard-Red" -ErrorAction SilentlyContinue)) {
        $cim = New-CimInstance -CimClass (Get-CimClass `
            -ClassName MSFT_TaskEventTrigger `
            -Namespace Root/Microsoft/Windows/TaskScheduler) -ClientOnly
        $cim.Enabled      = $true
        $cim.Subscription = @'
*[System[Provider[@Name='Microsoft-Windows-NetworkProfile'] and EventID=10000]]

'@

        $action = New-ScheduledTaskAction -Execute "PowerShell.exe" `
            -Argument "-NoProfile -ExecutionPolicy Bypass -WindowStyle Hidden -File `"$scriptPath`" Red"
        $principal = New-ScheduledTaskPrincipal -UserId "SYSTEM" `
            -LogonType ServiceAccount -RunLevel Highest
        $settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries `
            -DontStopIfGoingOnBatteries -StartWhenAvailable `
            -ExecutionTimeLimit (New-TimeSpan -Minutes 5)

        Register-ScheduledTask -TaskName "HOSTS-Guard-Red" `
            -Action $action -Trigger $cim -Principal $principal -Settings $settings `
            -Description "HOSTS-Guard al conectar a una red - seguridadenmipc.com" | Out-Null
        Write-Host "[OK] Tarea 'HOSTS-Guard-Red' creada (al conectar a red)." -ForegroundColor Green
    } else {
        Write-Host "[i] Tarea 'HOSTS-Guard-Red' ya existe." -ForegroundColor Cyan
    }
} catch { Write-Host "[X] Error en tarea Red: $_" -ForegroundColor Red }

Write-Host "`n[OK] HOSTS-Guard activo. Disparador: $disparador" -ForegroundColor Green
Write-Host "     Log:    $log" -ForegroundColor Gray
Write-Host "     CSV:    $csv" -ForegroundColor Gray
Write-Host "     Backup: $backup" -ForegroundColor Gray
Stop-Transcript | Out-Null

↩️ Script de reversión (elimina las 4 tareas y desprotege el HOSTS)

Si en algún momento necesitas añadir entradas legítimas al archivo HOSTS (bloqueos de dominios personalizados, entornos de desarrollo local, listas StevenBlack, etc.) o desactivar la vigilancia automática, usa este script. Elimina primero las cuatro tareas programadas para que la protección no se reaplique al siguiente disparador, y después quita la ACL para poder editar el archivo.

# ============================================================
# Revertir HOSTS-Guard: elimina tareas y desprotege el HOSTS
# ============================================================

# 1. ELIMINAR PRIMERO las 4 tareas programadas
$tareas = @(
    "HOSTS-Guard-Inicio",
    "HOSTS-Guard-Logon",
    "HOSTS-Guard-6h",
    "HOSTS-Guard-Red"
)
foreach ($t in $tareas) {
    if (Get-ScheduledTask -TaskName $t -ErrorAction SilentlyContinue) {
        Unregister-ScheduledTask -TaskName $t -Confirm:$false
        Write-Host "[OK] Tarea $t eliminada." -ForegroundColor Green
    }
}

# 2. Quitar la proteccion ACL del HOSTS
$hostsPath = "C:\Windows\System32\drivers\etc\hosts"
$acl = Get-Acl $hostsPath
$acl.SetAccessRuleProtection($false, $true)
$rule = New-Object System.Security.AccessControl.FileSystemAccessRule(
    "Administrators","FullControl","Allow")
$acl.AddAccessRule($rule)
Set-Acl -Path $hostsPath -AclObject $acl
Set-ItemProperty -Path $hostsPath -Name IsReadOnly -Value $false

# 3. (Opcional) Eliminar el hash de referencia para que la proxima
#    ejecucion del script acepte cualquier contenido como nuevo.
# Remove-Item "C:\Logs\hosts-hash-ref.txt" -Force -ErrorAction SilentlyContinue

Write-Host ""
Write-Host "[OK] HOSTS-Guard desactivado." -ForegroundColor Green
Write-Host "    El HOSTS ya puede editarse manualmente." -ForegroundColor Yellow
Write-Host "    Logs y backup preservados en C:\Logs\" -ForegroundColor Cyan

⚠️ Riesgos y efectos reales del script

Antes de ejecutar este script conviene entender exactamente qué cambios aplica y qué funciones de Windows pueden verse afectadas. Está diseñado para ser completamente reversible y no toca funciones críticas del sistema, pero sí sobrescribe el HOSTS, bloquea su escritura mediante ACL y crea cuatro tareas programadas persistentes.

En equipos domésticos con Windows 10 u 11 Home o Pro sin configuraciones especiales, este script es seguro y completamente reversible. El hash SHA256 de referencia garantiza que el script sea idempotente: si el archivo no ha sido modificado, la ejecución termina en milisegundos sin tocar nada. Si alguien manipula el HOSTS, el script lo detecta y lo restaura automáticamente en el siguiente disparador.

🔎 ¿Cómo verificar que la protección del HOSTS está activa?

# Verificar que las 4 tareas programadas existen y estan activas
Get-ScheduledTask -TaskName "HOSTS-Guard-*" | `
  Select TaskName, State, LastRunTime, LastTaskResult

# Ver el hash actual del HOSTS
Get-FileHash C:\Windows\System32\drivers\etc\hosts -Algorithm SHA256

# Ver el hash de referencia guardado
Get-Content C:\Logs\hosts-hash-ref.txt

# Ver la ACL del HOSTS (no debe permitir Write a nadie)
Get-Acl C:\Windows\System32\drivers\etc\hosts | Format-List

# Ver el CSV historico de verificaciones
Import-Csv C:\Logs\hosts-guard-historico.csv | Select -Last 20

✅ Buenas prácticas para mantener el archivo HOSTS seguro

❓ Preguntas frecuentes sobre el archivo HOSTS Windows

¿Es peligroso modificar el archivo HOSTS?

No si lo haces tú mismo con un propósito legítimo, como bloquear dominios maliciosos o configurar entornos de desarrollo. El peligro real aparece cuando el malware lo modifica sin tu conocimiento, redirigiendo dominios legítimos a servidores controlados por atacantes. Por eso es fundamental verificarlo periódicamente y protegerlo con permisos ACL.

¿Cómo sé si el malware ha modificado mi archivo HOSTS?

Los síntomas más comunes son: tu antivirus no se actualiza, Windows Update deja de funcionar, eres redirigido a páginas extrañas al intentar acceder a tu banco, o el MFA corporativo falla sin motivo aparente. Para confirmarlo, ejecuta en PowerShell como administrador: Get-Content C:\Windows\System32\drivers\etc\hosts y revisa si hay entradas activas que no reconoces. Si tienes HOSTS-Guard activo, consulta también C:\Logs\hosts-guard-historico.csv: cualquier fila con Restaurado=True indica que el script ha detectado y corregido una manipulación.

¿El archivo HOSTS afecta a todos los navegadores?

Sí. A diferencia de las extensiones de bloqueo de anuncios que solo actúan en un navegador concreto, el archivo HOSTS opera a nivel de sistema operativo. Afecta simultáneamente a Chrome, Firefox, Edge, Opera y a cualquier aplicación del sistema que realice resolución DNS — incluyendo clientes de correo, aplicaciones empresariales y servicios en segundo plano.

¿Puedo usar el archivo HOSTS para bloquear publicidad?

Sí, y es uno de sus usos más eficaces. Al redirigir dominios publicitarios conocidos a 0.0.0.0, bloqueas los anuncios antes de que se carguen, sin depender de ninguna extensión de navegador. Proyectos como StevenBlack/hosts mantienen listas actualizadas con decenas de miles de dominios de publicidad y malware listos para usar. Si quieres combinar estas listas con HOSTS-Guard, añade el contenido de la lista dentro del bloque $contenidoOriginal del script para que la vigilancia se convierta en tu "contenido autorizado" de referencia.

¿Qué diferencia hay entre el archivo HOSTS y un DNS?

El archivo HOSTS es una tabla local estática que solo conoce tu equipo. Un servidor DNS es un servicio externo que resuelve millones de dominios de forma dinámica. La diferencia clave es la prioridad: Windows siempre consulta primero el archivo HOSTS, por lo que sus entradas anulan cualquier respuesta DNS externa — sea de tu router, tu ISP o servidores como Google (8.8.8.8) o Cloudflare (1.1.1.1).

¿Necesito reiniciar el PC después de modificar el archivo HOSTS?

No es necesario reiniciar el equipo completo. Los cambios se aplican casi de forma inmediata, aunque en algunos casos puede ser necesario limpiar la caché DNS para que surtan efecto de forma instantánea. Ejecuta en PowerShell o CMD como administrador: ipconfig /flushdns. El script HOSTS-Guard ejecuta este flushdns automáticamente cada vez que detecta un cambio en el archivo y lo restaura.

¿Por qué hay una tarea programada específica para "al conectar a red nueva"?

Porque el momento en el que cambias de red (WiFi del aeropuerto, cafetería, hotel, red corporativa) es uno de los escenarios más habituales en los que un atacante querría aprovechar un HOSTS manipulado: redirigir tu banca, tu correo o tus servicios MFA hacia sus propios servidores justo cuando estás en una red de confianza desconocida. La tarea HOSTS-Guard-Red se activa con el evento 10000 del log Microsoft-Windows-NetworkProfile/Operational, que Windows genera cuando identifica una red nueva o cambia de perfil. Así el script verifica (y restaura si hace falta) el HOSTS antes de que tú empieces a introducir credenciales en la nueva red.

¿Las cuatro tareas programadas ralentizan el equipo?

No de forma perceptible. Cada ejecución se reduce a calcular un hash SHA256 del archivo HOSTS (menos de 1 segundo de CPU) y compararlo con el de referencia. Solo si detecta cambio hace el resto del trabajo (backup + restaurar + ACL + flushdns). Las tareas se ejecutan como SYSTEM en modo oculto, sin ventana visible, y la carga total diaria es inferior a 30 segundos de CPU incluso si has conectado a varias redes.

¿Cómo desactivo las tareas programadas si quiero editar el HOSTS libremente?

Ejecuta el script de reversión incluido en esta guía: elimina las cuatro tareas (HOSTS-Guard-Inicio, HOSTS-Guard-Logon, HOSTS-Guard-6h y HOSTS-Guard-Red) y quita la ACL en un solo paso. Si solo quieres hacer una edición puntual y mantener la vigilancia, edita el archivo, vuelve a ejecutar el script principal y la nueva versión del HOSTS quedará guardada como nueva referencia (hash) para las próximas comprobaciones.

¿Puedo cambiar la frecuencia de la tarea de 6 horas?

Sí. Abre el Programador de tareas (Win+R → taskschd.msc), localiza HOSTS-Guard-6h, ve a la pestaña Desencadenadores, edita el desencadenador y cambia el campo "Repetir cada" a 1 hora, 12 horas, 24 horas o el intervalo que prefieras. Para el HOSTS, 6 horas es un buen equilibrio: las tareas basadas en eventos (inicio, logon y red) ya cubren los momentos de mayor riesgo, y la tarea periódica solo actúa como red de seguridad adicional durante sesiones largas.

📝 Conclusión

El archivo HOSTS Windows es una pieza crítica de la infraestructura de red de tu equipo que pasa completamente desapercibida hasta que el daño ya está hecho. Su posición privilegiada en la cadena de resolución DNS — por encima de cualquier servidor externo — lo convierte en un objetivo prioritario para el malware moderno, que lo explota para ejecutar pharming, bloquear antivirus, deshabilitar Windows Update e incluso neutralizar sistemas MFA corporativos, tal y como documenta la CISA.

La buena noticia es que protegerlo es sencillo y gratuito: verificarlo periódicamente con PowerShell, restaurarlo a su estado predeterminado si detectas entradas sospechosas, bloquearlo con permisos ACL y ejecutar el script HOSTS-Guard con sus cuatro tareas programadas son medidas que cualquier usuario o administrador puede implementar en menos de 10 minutos. Las tareas garantizan la verificación automática en los cuatro momentos clave: arranque, inicio de sesión, cada 6 horas y al conectar a una red nueva (el escenario típico de ataques basados en HOSTS manipulado).