Aplicación Android / iOS para acceder a su enrutador OpenWrt de forma remota: 11 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

Recientemente compré un nuevo enrutador (Xiaomi Mi Router 3G). Y, por supuesto, esta nueva e increíble pieza de hardware me inspiró a comenzar a trabajar en este proyecto;)

Paso 1: Supongo que ya tiene OpenWrt…

Primero tuve que instalar OpenWrt … Principalmente, seguí esta guía (específica para este modelo de enrutador): https://dzone.com/articles/hacking-into-xiaomi-mi-… Mientras trabajaba en esto, encontré este increíble video: Instalación de Openwrt, punto de referencia WiFi, Girlfriend Flashing. ¡Vaya, me reí tanto!:)

¡Atención! La instalación de OpenWrt puede bloquear su enrutador. Pero una vez completado, desbloquea todo el poder y el control. No soy lo suficientemente valiente para proporcionar instrucciones aquí, ya que pueden ser diferentes para cada modelo de enrutador.

Pero si ya tiene OpenWrt en su enrutador, podrá comenzar con este tutorial en poco tiempo

Por cierto, algunas placas de desarrollo vienen con OpenWrt listo para usar, como Onion Omega, VoCore, LinkIt Smart 7688 y otras. Este tutorial también explica algunas ideas básicas detrás de la creación de tales aplicaciones, para que pueda adaptarlas fácilmente para trabajar con Raspberry Pi y similares.

Para este proyecto, utilizaré principalmente software preinstalado (disponible en cualquier enrutador habilitado para OpenWrt). Pero para algunas funciones avanzadas, tuve que instalar paquetes adicionales. Esto se hace con solo unos pocos clics, por lo que incluiré las instrucciones aquí.

Además, supongo que ya sabes:

• Cómo abrir / usar el terminal SSH en su enrutador OpenWrt
• Cómo cargar / editar archivos en su enrutador (use FileZilla o scp / sftp)
• Cómo trabajar con la consola de Linux

Paso 2: software y herramientas

En el lado del teléfono inteligente, estoy usando Blynk. Proporciona aplicaciones de iOS y Android para controlar cualquier hardware. Puede crear fácilmente hermosas interfaces gráficas para todos sus proyectos simplemente arrastrando y soltando widgets, directamente en su teléfono inteligente. Blynk se usa principalmente con Arduino, Raspberry Pi, etc. Pero, ¿por qué no ejecutarlo en el enrutador?;)

En el lado del dispositivo, usaré Lua para programar la funcionalidad necesaria. También podría usar Python o Node.js, pero desafortunadamente estas opciones no siempre están disponibles debido a la falta de recursos en algunos enrutadores. O C / C ++, pero no es tan conveniente trabajar con él (recompilar para cada cambio, etc.). Por otro lado, Lua está preinstalado, es fácil de usar y aprender. Lo utiliza la interfaz web predeterminada, LuCI.

Paso 3: creación de una aplicación mínima

Comenzar con Blynk y Lua es tan fácil como:

• Descargue la aplicación Blynk (desde App Store, Google Play)
• Crea un nuevo proyecto y obtén el token de autenticación
• Siga las instrucciones de instalación de Blynk Lua para OpenWrt.

Utilice SSH para acceder a la consola del enrutador. Después de ejecutar el ejemplo predeterminado:

lua./examples/client.lua

Deberíamos ver algo como esto:

Conectando…

Apretón de manos SSL … Listo.

¡Lo que significa que se establece la conexión bidireccional y segura con la aplicación!

Ahora podemos ampliar fácilmente el ejemplo proporcionado, por lo que hace algo interesante. He creado una copia de este ejemplo para editarlo:

cp./examples/client.lua./blynkmon.lua

Paso 4: Agregar información: número de clientes, dirección IP WAN, tiempo de actividad

La idea básica es obtener la información del sistema operativo periódicamente, realizar algunos cálculos simples si es necesario y luego enviar el resultado a Blynk para su visualización.

En Linux / OpenWrt, tenemos varias formas de obtener los datos del sistema:

• Ejecute un comando y analice el texto que genera
• Ejecute un comando y observe el código de salida que devuelve
• Leer un archivo del sistema, ubicado en los directorios / proc / y / sys / class /

Ahora quiero mostrar la cantidad de dispositivos conectados.

Cuando ejecuto cat / proc / net / arp en la consola, muestra la lista de dispositivos conocidos, junto con sus direcciones MAC e IP:

Dirección IP Tipo de HW Banderas Dirección HW Máscara Dispositivo

192.168.10.206 0x1 0x2 78: 02: f8: fb: d6: bf * br-lan 194.---------- 0x1 0x2 4c: 5e: 0c: 14: e0: 5c * eth0.2 192.168.10.162 0x1 0x0 04: b1: 67: 2f: e3: 74 * br-lan

Podemos analizarlo directamente en Lua, pero a menudo es más fácil usar utilidades especializadas. En Linux, estas son grep, head, tail, cut, wc, awk.

Para obtener el número de clientes de la salida de arp, necesito filtrar la tabla (eliminar elementos no relacionados) y contar las filas de la tabla, lo que da como resultado el siguiente comando:

cat / proc / net / arp | grep br-lan | grep 0x2 | wc -l

Vamos a intentarlo:

root @ enrutador: ~ / lua-blynk # cat / proc / net / arp | grep br-lan | grep 0x2 | wc -l

1

Excelente. Ahora tenemos la idea de cómo podemos recopilar toda la información requerida. Vamos a automatizarlo Para que nuestro código sea limpio y extensible, creemos algunas funciones auxiliares:

función exec_out (cmd)

archivo local = io.popen (cmd) si no es un archivo, devuelve nil end local output = file: read ('* all') file: close () print ("Run:"..cmd.. "->".. salida) devuelve salida final función read_file (ruta) archivo local = io.open (ruta, "rb") si no es archivo, devuelve nil end local content = file: read "* a" file: close () print ("Read: "..path.." -> "..content) devolver contenido final

Usando estas utilidades, ahora podemos implementar las funciones reales de obtención de datos:

función getArpClients ()

return tonumber (exec_out ("cat / proc / net / arp | grep br-lan | grep 0x2 | wc -l")) end function getUptime () return tonumber (exec_out ("cat / proc / uptime | awk '{print $ 1 } '")) end function getWanIP () return exec_out (" ifconfig eth0.2 | grep' inet addr: '| cut -d: -f2 | awk' {print $ 1} '") end

Puede ejecutar partes de estos comandos de shell para obtener una comprensión más profunda de cómo funciona y ajustarlo a sus necesidades.

La parte más sencilla es enviar los datos a la aplicación Blynk. El ejemplo predeterminado ya configura el temporizador, que ejecuta un código cada 5 segundos, por lo que simplemente lo reutilizamos:

tmr1 local = Temporizador: nuevo {intervalo = 5000, func = función ()

blynk: virtualWrite (10, getArpClients ()) blynk: virtualWrite (11, string.format ("%. 1f h", getUptime () / 60/60)) blynk: virtualWrite (12, getWanIP ()) end}

En la aplicación, agregamos 3 widgets de etiquetas y los asignamos a los Pines virtuales 10, 11, 12 en consecuencia.

Si bien esto funciona, es bastante ineficiente, ya que la IP WAN o la cantidad de clientes no se actualizan con tanta frecuencia

Para WAN IP, lo movemos al controlador conectado. Se ejecutará cada vez que el enrutador establezca una conexión con Blynk Cloud. Esto debería ser suficiente:

blynk: on ("conectado", función ()

print ("Listo") blynk: virtualWrite (12, getWanIP ()) end)

Para el tiempo de actividad y el número de clientes, creamos un temporizador separado con 5 min. intervalo:

tmr2 local = Temporizador: nuevo {intervalo = 5 * 60 * 1000, func = función ()

blynk: virtualWrite (10, getArpClients ()) blynk: virtualWrite (11, string.format ("%. 1f h", getUptime () / 60/60)) end}

Paso 5: Control WiFi: ENCENDIDO / APAGADO

Hasta ahora, solo recibíamos información del dispositivo, ¡intentemos controlarlo!

blynk: on ("V20", función (param)

si param [1] == "1" entonces os.execute ("wifi up") else os.execute ("wifi down") end end)

En el lado de la aplicación, acabo de agregar un widget de botón (modo: Switch) y lo asigné a V20.

Eso es todo. Increíble.

Paso 6: Gráfico de estadísticas del sistema

función getCpuLoad ()

return tonumber (exec_out ("top -bn1 | grep 'CPU:' | head -n1 | awk '{print $ 2 + $ 4}'")) end function getRamUsage () return tonumber (exec_out ("libre | grep Mem | awk ' {print ($ 3- $ 7) / $ 2 * 100.0} '")) fin

También necesitamos enviar los datos a Blynk (usemos tmr1 nuevamente):

tmr1 local = Temporizador: nuevo {intervalo = 5000, func = función ()

blynk: virtualWrite (5, getCpuLoad ()) blynk: virtualWrite (6, getRamUsage ()) end}

En el lado de la aplicación, agregue el widget SuperChart. Agregue CPU, flujos de datos RAM y asigne a V5, V6.

Paso 7: estado de giro del disco duro

Mi enrutador tiene una unidad de disco duro externa conectada como un dispositivo de almacenamiento conectado a la red. El caso es que esta unidad está configurada para comenzar a girar cuando alguien accede a ella y para suspender después de un tiempo de espera.

Obviamente, sería genial saber cuántas veces se enciende a lo largo del día. Así que agregué otro flujo de datos a mi gráfico del sistema.

Es un poco más complicado obtener el estado de la unidad de disco duro, ¡pero encontré una manera! En primer lugar, instale smartmontools desde la consola SSH:

actualización de opkg

opkg instalar smartmontools

Luego, en nuestro código, necesitamos ejecutar un comando especial y verificar el código de salida:

función exec_ret (cmd)

local exit = os.execute (cmd) print ("Ejecutar:"..cmd.. "-> salir:".. salir) return salir end función getHddSpinning () if exec_ret ("smartctl --nocheck = standby --info / dev / sda> / dev / null ") == 0 luego devuelve 1 si no devuelve 0 end end

Nota: mi disco duro es / dev / sda

Paso 8: Gráfico de actividad de la red

Creamos otro widget SuperChart (similar al anterior), agregamos flujos de datos TX y RX y lo asignamos a V1 y V2. Nota: Quiero mostrar el estado del puerto WAN y mi puerto WAN es eth0.2

Funciones de ayuda:

función getWanRxBytes ()

return tonumber (read_file ("/ sys / class / net / eth0.2 / statistics / rx_bytes")) end function getWanTxBytes () return tonumber (read_file ("/ sys / class / net / eth0.2 / statistics / tx_bytes")) fin

A continuación, agregue un poco de código al mismo tmr1. Esto es más complicado, ya que solo necesitamos calcular y mostrar la diferencia en bytes transmitidos / recibidos:

local prevTx, prevRx

tmr1 local = Temporizador: nuevo {intervalo = 5000, func = función () tx local = getWanTxBytes () rx local = getWanRxBytes () si prevTx y prevTx ~ = tx entonces blynk: virtualWrite (1, tx - prevTx) end si prevRx y prevRx ~ = rx luego blynk: virtualWrite (2, rx - prevRx) end prevTx = tx prevRx = rx blynk: virtualWrite (5, getCpuLoad ()) blynk: virtualWrite (6, getRamUsage ()) blynk: virtualWrite (7, getHddSpinning ()) fin}

Paso 9: Notificaciones

También quería ser notificado cuando mi enrutador pierde energía o conexión a Internet. Para esto, necesitamos el widget de notificación.

En la configuración del widget, habilite la "notificación sin conexión". No se necesita código. Pero también podemos enviar notificaciones personalizadas desde nuestro código.

Paso 10: ejecución automática en segundo plano

Por ahora, el script debe ejecutarse manualmente, pero quiero que se ejecute en segundo plano automáticamente cuando se enciende el enrutador.

Esto se hace creando un servicio. Cree un archivo /etc/init.d/blynkmon:

#! / bin / sh /etc/rc.common

INICIO = 99 DETENER = archivo pid = "/ var / run / blynkmon.pid" inicio () {if [-f $ archivo pid]; luego echo "blynkmon ya se está ejecutando" exit 0 fi cd / root / lua-blynk lua blynkmon.lua your-auth-token> / dev / null & echo $! > $ pidfile} stop () {if [! -f $ pidfile]; luego echo "blynkmon not running" exit 0 fi kill -9 $ (cat $ pidfile) rm $ pidfile}

Nota: no olvides reemplazar tu-token-de-autenticación

Luego, habilite el servicio blynkmon:

servicio blynkmon habilitar

Paso 11: Conclusión e ideas adicionales

Puedes escanear este QR para obtener el clon de mi Proyecto Blynk. Requiere algunos puntos de energía (4600), ¡ya que usa muchos widgets!

Encuentre el código Lua completo aquí:

Hasta ahora todo va bien, pero aquí hay algunas ideas que me gustaría agregar en un futuro próximo.

• Agregar comando de reinicio. Evite hacer clic en él accidentalmente.
• Agregue el widget Terminal para ejecutar cualquier comando de Linux.

• Agregue el gráfico de temperatura de la CPU.

  UPD: Desafortunadamente, OpenWrt actualmente carece de algunos controladores para mi modelo de enrutador. Pero está disponible para muchos otros enrutadores.

• Agrega una notificación cuando un dispositivo en particular se une / sale de la red. Ya tenemos información de arp, ahora solo verifica la dirección MAC.

De esta manera, podemos monitorear y controlar impresoras 3D, robots, una PC / computadora portátil normal, Arduino / ESP8266 / ESP32 / RaspberryPi, dispositivos Smart Home y prácticamente cualquier cosa. Avísame si tienes otras ideas interesantes ¿Qué opinas de todo esto?