Automatiza tu red: Crea un script para desconectar el WiFi del router vía Telnet

¡Hola, entusiasta de la tecnología! ¿Alguna vez has deseado tener un control más granular y automatizado sobre tu red WiFi? Tal vez necesitas desconectarla a ciertas horas para fomentar la concentración, controlar el tiempo de pantalla de los más jóvenes, o simplemente buscas una forma programática de reiniciar tus interfaces inalámbricas. Si tu respuesta es un rotundo sí, estás en el lugar adecuado. Hoy vamos a sumergirnos en el fascinante mundo de la automatización de redes, aprendiendo a apagar el WiFi de tu router utilizando Telnet y un sencillo pero potente script de Python. Prepárate para tomar las riendas de tu conexión como nunca antes. 🚀

¿Por Qué Querrías Desconectar el WiFi Automáticamente? 🤔

La idea de apagar el WiFi del router de forma programada puede sonar peculiar para algunos, pero las aplicaciones prácticas son sorprendentemente variadas y beneficiosas:

• Control Parental y Fomento de la Concentración: Imagina poder desconectar el WiFi a la hora de dormir o durante las horas de estudio, garantizando un entorno libre de distracciones digitales para tus hijos. O quizás, para ti mismo, si trabajas desde casa y la tentación de las redes sociales es demasiado fuerte. Es una herramienta efectiva para gestionar el tiempo frente a la pantalla.
• Ahorro Energético y Vida Útil del Dispositivo: Si sabes que no vas a usar el WiFi durante horas, ¿por qué mantenerlo encendido? Apagar las interfaces inalámbricas puede contribuir a un pequeño ahorro de energía y, potencialmente, prolongar la vida útil de tu router al reducir su carga de trabajo.
• Seguridad de Red Básica: Aunque Telnet no es el método más seguro, como veremos, apagar periódicamente el WiFi en momentos de inactividad puede ser una capa adicional de seguridad rudimentaria, reduciendo la ventana de oportunidad para accesos no deseados si tu red estuviera comprometida de alguna manera.
• Solución de Problemas Programada: En ocasiones, un simple „reinicio” de la interfaz WiFi resuelve pequeños fallos de conectividad. Automatizar esta acción puede mantener tu red más estable sin intervención manual.

Telnet: Una Herramienta Poderosa (y con Precaución) ⚠️

Antes de meternos de lleno en el código, es fundamental entender qué es Telnet. Telnet (TELe Network) es un protocolo de red que permite a un usuario comunicarse con un dispositivo remoto (como tu router) a través de una interfaz de línea de comandos (CLI). Fue uno de los primeros protocolos de Internet y, aunque ha sido ampliamente reemplazado por alternativas más seguras como SSH (Secure Shell), sigue presente en muchos dispositivos de red antiguos o en entornos controlados y aislados.

La principal desventaja de Telnet, y es crucial destacarla, es que todas las comunicaciones (incluyendo tu nombre de usuario y contraseña) se transmiten en texto plano. Esto significa que si alguien estuviera escuchando el tráfico de tu red (un „man-in-the-middle attack”), podría interceptar fácilmente tus credenciales. Por esta razón, su uso se desaconseja totalmente en redes públicas o inseguras. Sin embargo, para automatización dentro de tu red local, privada y de confianza, donde los riesgos están gestionados, puede ser una herramienta útil para propósitos específicos.

„La seguridad en red no es un destino, sino un viaje constante. Si bien Telnet ofrece una vía para la automatización, su elección debe sopesarse cuidadosamente contra los riesgos inherentes, priorizando siempre la integridad de nuestra infraestructura digital.”

Preparando el Terreno: Requisitos Previos ⚙️

Para llevar a cabo nuestra misión de automatización, necesitarás lo siguiente:

1. Un Router Compatible con Telnet: La mayoría de los routers modernos vienen con Telnet deshabilitado por defecto debido a preocupaciones de seguridad, y muchos modelos más recientes incluso lo han eliminado por completo en favor de SSH o interfaces API. Deberás verificar la documentación de tu router o acceder a su interfaz de administración web para habilitar Telnet si está disponible. A menudo, esta opción se encuentra en secciones como „Administración”, „Seguridad” o „Herramientas del Sistema”.
2. Dirección IP del Router: Generalmente es la puerta de enlace predeterminada de tu red (ej., 192.168.1.1, 192.168.0.1).
3. Credenciales de Acceso al Router: Necesitarás el nombre de usuario y la contraseña para acceder al CLI de tu router. Si nunca los has cambiado, es muy probable que sean los predeterminados de fábrica (ej., admin/admin, admin/password). ¡Cámbialos si aún no lo has hecho!
4. Python Instalado: Usaremos Python, un lenguaje de programación versátil y muy popular para la automatización. Puedes descargarlo desde python.org. Asegúrate de tener una versión 3.x.
5. Un Cliente Telnet (para pruebas): En Windows, puedes habilitar el cliente Telnet desde „Características de Windows”. En Linux o macOS, generalmente viene preinstalado o se instala con un simple comando (ej., sudo apt install telnet en Debian/Ubuntu).

El Desafío: Encontrar el Comando Correcto 🔍

Aquí es donde las cosas se ponen interesantes y un poco „artesanales”. A diferencia de una API RESTful con documentación clara, los comandos de Telnet para deshabilitar el WiFi varían enormemente entre fabricantes y modelos de routers. No hay un comando universal. La clave es explorar la interfaz de línea de comandos de tu propio router.

Pasos para Encontrar el Comando:

1. Conéctate Manualmente a tu Router vía Telnet:
   • Abre tu terminal o símbolo del sistema.
   • Escribe: telnet [DIRECCIÓN_IP_DEL_ROUTER] (ej., telnet 192.168.1.1).
   • Cuando se te solicite, ingresa tu nombre de usuario y contraseña.
2. Explora la CLI: Una vez dentro, estarás en el sistema operativo de tu router. Aquí es donde empieza la investigación:
   • Intenta comandos como help o ? para ver una lista de comandos disponibles.
   • Busca comandos relacionados con „WLAN”, „WiFi”, „Wireless”, „Interface”, „Radio”, „Config”, „Enable” o „Disable”.
   • Puede que tengas que navegar a diferentes modos (ej., config terminal para entrar en modo de configuración, similar a los routers Cisco).
   • Algunos comandos comunes que podrías encontrar (¡recuerda, son ejemplos!):
     • show wlan o show wireless para ver el estado actual.
     • config interface wlan0 disable
     • wlan radio off
     • wireless disable
     • system wlan set radio disable
     • nvram set wifi_disable=1 (esto puede requerir un nvram commit y un reinicio para que surtan efecto).
   • ¡Cuidado! Al igual que en cualquier CLI, un comando mal ejecutado puede tener consecuencias no deseadas. Si no estás seguro, busca la documentación oficial de tu router o consulta foros especializados para tu modelo. El objetivo es identificar el comando exacto que, al ejecutarlo manualmente, apaga el WiFi y, si es necesario, otro para volver a encenderlo (ej., cambiando disable por enable o off por on).
3. Prueba y Confirma: Una vez que creas haber encontrado el comando, ejecútalo manualmente y verifica si el WiFi de tu router se apaga realmente (puedes comprobarlo desde tu teléfono o portátil). Si funciona, anota el comando exacto. ¡Este es el tesoro que busca nuestro script!

Manos a la Obra: Creando el Script en Python 💻

Ahora que tenemos el comando mágico y comprendemos los riesgos, vamos a construir nuestro script de Python. Python cuenta con la librería estándar telnetlib, perfecta para nuestras necesidades.

Abre tu editor de texto favorito (VS Code, Sublime Text, Notepad++, etc.) y crea un nuevo archivo llamado apagar_wifi.py. Copia y pega el siguiente código, adaptando los valores:

import telnetlib
import sys
import time

# --- Configuración del Router ---
# ¡IMPORTANTE! Cambia estos valores por los de tu router.
ROUTER_IP = "192.168.1.1"  # Dirección IP de tu router
ROUTER_USER = "tu_usuario" # Tu nombre de usuario para Telnet
ROUTER_PASS = "tu_contraseña" # Tu contraseña para Telnet

# El comando específico para DESHABILITAR el WiFi de tu router.
# ¡Este es el comando que encontraste en tu investigación manual!
# Ejemplo: "wireless disablen"
# Otro ejemplo: "configninterface wlan0nshutdownnexitnexitn"
# Asegúrate de terminar cada comando con "n" para simular la tecla Enter.
WIFI_DISABLE_COMMANDS = [
    b"systemn", # Puede que necesites navegar a un modo específico
    b"wlan radio offn", # Este es un comando de ejemplo, ADAPTALO a tu router
    b"commitn", # Si tu router necesita guardar la configuración
    b"exitn" # Para salir de modos de configuración, si aplica
]

# El comando específico para HABILITAR el WiFi de tu router (opcional, pero recomendado).
WIFI_ENABLE_COMMANDS = [
    b"systemn", # Mismo que antes
    b"wlan radio onn", # Comando para encender el WiFi
    b"commitn",
    b"exitn"
]

# Mensajes de prompt que tu router podría enviar.
# Adaptar según tu router, a menudo son "Username:", "Password:", o el prompt final como ">" o "#"
PROMPT_USERNAME = b"Username: "
PROMPT_PASSWORD = b"Password: "
PROMPT_ROUTER = b">" # O "#", "$", etc.

def connect_and_execute(commands_list):
    """
    Se conecta al router vía Telnet y ejecuta una lista de comandos.
    """
    print(f"Intentando conectar a {ROUTER_IP}...")
    try:
        tn = telnetlib.Telnet(ROUTER_IP, 23, 10) # IP, Puerto Telnet (23), Timeout

        # Leer hasta el prompt de usuario o el prompt inicial del router
        output = tn.read_until(PROMPT_USERNAME, 5).decode('ascii')
        if PROMPT_USERNAME.decode('ascii') in output:
            print("Enviando usuario...")
            tn.write(ROUTER_USER.encode('ascii') + b"n")
            output = tn.read_until(PROMPT_PASSWORD, 5).decode('ascii')
            print("Enviando contraseña...")
            tn.write(ROUTER_PASS.encode('ascii') + b"n")
        else:
            # Si no pide usuario, puede que pida la contraseña directamente o ya esté logueado
            print("No se encontró prompt de usuario. Intentando con contraseña directamente o asumiendo login previo.")
            if PROMPT_PASSWORD.decode('ascii') in output:
                tn.write(ROUTER_PASS.encode('ascii') + b"n")
        
        # Leer el prompt después de la autenticación
        tn.read_until(PROMPT_ROUTER, 5) # Esperar el prompt final del router

        print("Autenticación exitosa. Ejecutando comandos...")

        # Ejecutar los comandos uno por uno
        for command in commands_list:
            tn.write(command)
            time.sleep(1) # Pequeña pausa para que el router procese
            response = tn.read_very_eager().decode('ascii')
            print(f"Comando '{command.decode('ascii').strip()}':n{response.strip()}")
            # Opcional: leer hasta el prompt después de cada comando
            # tn.read_until(PROMPT_ROUTER, 5)

        print("Comandos ejecutados. Cerrando conexión.")
        tn.close()
        return True

    except Exception as e:
        print(f"ERROR: No se pudo conectar o ejecutar comandos. {e}")
        return False

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Uso: python apagar_wifi.py [desconectar|conectar]")
        sys.exit(1)

    action = sys.argv[1].lower()

    if action == "desconectar":
        print("n>>> Iniciando desconexión del WiFi <<<")
        if connect_and_execute(WIFI_DISABLE_COMMANDS):
            print(">>> WiFi posiblemente DESCONECTADO. Verifica manualmente. <<<")
        else:
            print(">>> Fallo al intentar desconectar el WiFi. <<<")
    elif action == "conectar":
        print("n>>> Iniciando conexión del WiFi <<<")
        if connect_and_execute(WIFI_ENABLE_COMMANDS):
            print(">>> WiFi posiblemente CONECTADO. Verifica manualmente. <<<")
        else:
            print(">>> Fallo al intentar conectar el WiFi. <<<")
    else:
        print("Acción no reconocida. Usa 'desconectar' o 'conectar'.")

Explicación del Código:

• import telnetlib: Importa la librería necesaria para interactuar con Telnet.
• ROUTER_IP, ROUTER_USER, ROUTER_PASS: Variables para tus credenciales. ¡No las dejes con los valores de ejemplo!
• WIFI_DISABLE_COMMANDS y WIFI_ENABLE_COMMANDS: Aquí es donde pegarás los comandos específicos que descubriste en tu router. Fíjate que están como una lista de bytes (b"comandon"), esto es crucial para Telnetlib. Cada comando debe terminar con n para simular la tecla Enter.
• PROMPT_USERNAME, PROMPT_PASSWORD, PROMPT_ROUTER: Estos son los textos que tu router envía cuando espera una entrada (usuario, contraseña o el prompt principal). Observa la salida cuando te conectas manualmente para ajustarlos si es necesario.
• telnetlib.Telnet(ROUTER_IP, 23, 10): Establece la conexión. El 23 es el puerto estándar de Telnet; 10 es el tiempo máximo de espera para la conexión (timeout).
• tn.read_until(...): Lee la salida del router hasta que encuentra un patrón específico (el prompt).
• tn.write(...): Envía comandos al router. Los comandos deben estar codificados en bytes (.encode('ascii')) y terminar con un salto de línea (b"n").
• Manejo de Login: El script intenta detectar el prompt de usuario y contraseña para enviarlos. Algunos routers pueden tener flujos de login ligeramente diferentes, por lo que quizás necesites ajustar esta parte.
• sys.argv: Permite que el script reciba argumentos desde la línea de comandos, como desconectar o conectar.

Cómo Ejecutar el Script:

1. Guarda el archivo como apagar_wifi.py.
2. Abre tu terminal o símbolo del sistema.
3. Navega al directorio donde guardaste el script.
4. Para desconectar el WiFi: python apagar_wifi.py desconectar
5. Para conectar el WiFi: python apagar_wifi.py conectar

¡Observa la magia ocurrir! Si todo está configurado correctamente, verás la salida en tu terminal y, después de unos segundos, tu red WiFi debería desconectarse o conectarse.

Mejorando y Automatizando tu Script 🚀

El script ya funciona, pero ¿qué tal si lo hacemos aún más útil?

1. Programación de Tareas:
   • En Windows: Utiliza el "Programador de Tareas". Puedes configurarlo para ejecutar python C:RutaAlScriptapagar_wifi.py desconectar a una hora específica, y luego otra tarea para python C:RutaAlScriptapagar_wifi.py conectar más tarde.
   • En Linux/macOS: Usa cron. Edita tu crontab (crontab -e) y añade líneas como:

     0 23 * * * python3 /ruta/al/script/apagar_wifi.py desconectar
     0 7 * * * python3 /ruta/al/script/apagar_wifi.py conectar

     Esto apagaría el WiFi a las 11 PM y lo encendería a las 7 AM todos los días.

2. Manejo de Errores Avanzado: Puedes añadir más lógica para verificar la salida de cada comando y confirmar que se ejecutó correctamente antes de proceder al siguiente, o para intentar reconectar en caso de fallo.
3. Interfaz Gráfica Sencilla: Si te sientes aventurero, podrías usar librerías como tkinter o PyQt para crear una pequeña aplicación con botones "Apagar WiFi" y "Encender WiFi", haciendo el script más amigable para otros usuarios en tu hogar.
4. Archivos de Configuración: En lugar de tener las credenciales directamente en el script, puedes guardarlas en un archivo de configuración separado (ej., config.ini) y leerlas desde allí, lo que es una práctica más limpia y segura.

Consideraciones de Seguridad y Ética 🔒

Reiteramos: Telnet no es seguro para ser expuesto fuera de una red local confiable. Asegúrate de que tu router no sea accesible vía Telnet desde Internet. Además:

• Contraseñas Fuertes: Utiliza contraseñas complejas para tu router.
• Red Local Aislada: Este método está pensado para entornos de red local donde tienes control total sobre quién puede acceder a tu máquina y a la red.
• Responsabilidad: Eres responsable de las acciones que realices con este script. Úsalo de manera ética y consciente.

Mi Opinión: ¿Telnet en la era de la Ciberseguridad? 🤔

En un mundo donde la ciberseguridad es una preocupación constante y las brechas de datos están a la orden del día, recomendar Telnet puede parecer anacrónico, incluso irresponsable. Y en un contexto general, lo es. Los datos confirman que Telnet ha sido desplazado por protocolos cifrados como SSH por razones de seguridad abrumadoras. Sin embargo, mi opinión, basada en la realidad de la diversidad de equipos y las necesidades de automatización en entornos específicos, es que Telnet aún tiene un nicho limitado.

Para un aficionado a la tecnología en su red doméstica, que busca aprender y automatizar tareas sencillas en equipos que pueden no soportar SSH o APIs modernas, Telnet ofrece una curva de aprendizaje sencilla para interactuar programáticamente con hardware. Es una "puerta trasera" de bajo nivel que, si se maneja con el debido conocimiento de sus limitaciones de seguridad (es decir, usándolo *solo* dentro de la LAN, y con un router que no exponga Telnet al exterior), puede ser una herramienta educativa y funcional para proyectos de automatización doméstica muy específicos. No es la solución ideal para la mayoría de los escenarios, y siempre se debe priorizar SSH o APIs si están disponibles, pero para el caso de estudio que hemos explorado, brinda una solución práctica y demostrativa de cómo programar tu red puede ser más accesible de lo que parece.

Conclusión: El Poder de la Automatización al Alcance de tu Mano 🎉

Hemos recorrido un camino fascinante: desde la motivación para automatizar tu red hasta la creación de un script de Python que interactúa directamente con tu router vía Telnet. Has aprendido a investigar la CLI de tu dispositivo, a escribir código que envíe comandos y a considerar las implicaciones de seguridad.

Este proyecto es más que simplemente apagar el WiFi; es una puerta de entrada al mundo de la automatización de redes. Las habilidades que has adquirido te servirán para explorar otras formas de interactuar con tus dispositivos de red, quizás usando SSH para mayor seguridad, o incluso APIs si tu router las ofrece. El control de tu infraestructura digital ya no tiene por qué ser manual. ¡Ahora tienes las herramientas para hacer que tu red trabaje para ti! Experimenta, aprende y, sobre todo, ¡automatiza de forma responsable! La red es tuya, y ahora, el poder de su configuración, también.