Detección de presencia por ARP, o cómo saber si tu hijo está en casa

Los adolescentes prefieren morir antes que salir de casa sin su móvil y la condenación eterna antes que permitir que se quede sin batería, así que comprobar si el móvil de tu hijo está conectado a tu red WIFI es una buena forma de saber si está o no en casa.

El siguiente programa te avisa por Telegram cuando tu hijo entra o sale de casa. De modo general, te avisa cuando un determinado dispositivo pasa a estar presente o desaparece de tu red doméstica.

Este programa puede ejecutarse en cualquier máquina Unix-like de nuestra red local que esté encendida permanentemente. En mi caso utilizo una Raspberry PI que tiene otros usos adicionales.

arp-20180622.py (Código fuente)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

#!/usr/bin/env python3

# (c) 2018 Jesús Cea Avión - jcea@jcea.es - https://www.jcea.es/
# This code is licensed under AGPLv3.

import time
import subprocess
import socket

import telegram.ext


MAC = 'XX:XX:XX:XX:XX:XX'

# Esperamos a tener red porque no queremos que se pierda la
# primera notificación de arranque.
# Además, no queremos un falso negativo cuando aún no tenemos red.
while True:
    try:
        socket.gethostbyname('api.telegram.org')
        break
    except socket.gaierror:
        time.sleep(1)

TELEGRAM_TOKEN = '0000:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'

updater = telegram.ext.updater.Updater(TELEGRAM_TOKEN)
updater.start_polling(timeout=60)
job_queue = updater.job_queue


presencia = None
prefix = ' <b>Arranque del sistema:</b>'

current_message = ''

# Usuarios autorizados
# jcea y L*****
usuarios = (00000000, 00000000)


def callback(bot, update):
    usuario = update.effective_user['id']
    if usuario in usuarios:
        bot.send_message(usuario, text=current_message, parse_mode='HTML')


updater.dispatcher.add_handler(
        telegram.ext.MessageHandler(
            filters=(telegram.ext.filters.Filters.user(user_id=usuarios) &
                     telegram.ext.filters.Filters.text),
            callback=callback,
            ))


def msg(bot, job):
    texto = job.context['msg']
    for i in usuarios:
        bot.send_message(i, text=texto, parse_mode='HTML')


while True:
    r = subprocess.run(
            [('for i in `/usr/bin/seq 1 254`; '
              'do /bin/ping -c 1 192.168.1.$i & done; wait')],
            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
            shell=True, timeout=60, check=True)
    r = subprocess.run(
            ['/usr/sbin/arp', '-n'],
            universal_newlines=True,
            stdout=subprocess.PIPE, stderr=subprocess.DEVNULL,
            timeout=60, check=True)
    presente = r.stdout.find(MAC) != -1
    if presencia != presente:
        if presente:
            current_message = ('%s:%s La luz está encendida'
                               % (time.ctime(), prefix))
        else:
            current_message = ('%s:%s La luz <b>ESTÁ APAGADA</b>'
                               % (time.ctime(), prefix))
        print(current_message)

        job_queue.run_once(msg, when=0, context={'msg': current_message})

        presencia = presente
        prefix = ''
    time.sleep(60)

La configuración está en el propio código fuente:

• Línea 13: Indicamos la dirección MAC del dispositivo que queremos detectar.
• Línea 25: Indicamos el token de acceso que nos ha proporcionado Telegram.
• Líneas 37-39: Listamos los identificadores de usuario que van a recibir las notificaciones de cambio de estado y que están autorizados para enviar mensajes al Bot que tenemos funcionando en Telegram.
• Línea 65: Indicamos la red /24 en la que nos encontramos.

El funcionamiento del servicio es el siguiente:

Al lanzar el programa, esperamos en las líneas 18-23 hasta que nuestro dispositivo tenga red. Esto se hace por dos motivos: a) para evitar un falso positivo intentando localizar el dispositivo de interés cuando nuestro equipo de detección todavía está levantando la red y b) para que no se pierda la notificación inicial si intentamos enviarla cuando aún no hemos conectado a Telegram [1].

Una vez que tenemos red, nos conectamos a Telegram con las credenciales correspondientes. La biblioteca que empleamos lanzará hilos de fondo que se encargan de gestionar los detalles de comunicación con Telegram, se reconecta si es necesario, etc.

Cuando arrancamos el programa no sabemos cuáles han sido los cambios de presencia del dispositivo de interés, así que vamos a enviar un mensaje de arranque con el estado actual de presencia y un indicador de que el sistema se ha arrancado ahora. Los detalles están en las líneas 32-35.

El bucle principal en sí empieza en la línea 62. Lo primero que hacemos es intentar enviar un datagrama ICMP Ping a todas las máquinas de la red local (subred /24). Solo enviamos un paquete por máquina, aunque el hecho de usar un comando externo por cada dirección IP y ejecutarlos todos a la vez es algo muy poco elegante y genera picos de carga puntuales en el detector. Lo cierto es que en la Raspberry PI en la que funciona esto no ha dado ningún problema, pero es algo a mejorar en el futuro.

Los 254 comandos se ejecutan en paralelo y se espera a que terminen. Se detectan errores y nos aseguramos de que el proceso entero no supere 60 segundos, como medida de seguridad. Lo cierto es que no estamos gestionando los errores, así que si el comando falla o supera ese tiempo de ejecución, el detector moriría.

Lo importante aquí es generar tráfico con todas las direcciones de la red local. El contenido de dicho tráfico es irrelevante y también es irrelevante que esas direcciones estén en uso o no. Lo que nos interesa, la clave de todo este proceso es que la tabla ARP [2] del sistema operativo se actualice.

En las líneas 68-72 ejecutamos un comando externo para obtener la tabla ARP del sistema operativo. En la línea 73 determinamos si el dispositivo que nos interesa monitorizar está o no está en la red.

Como solo nos interesan los cambios de estado de ese dispositivo (salvo cuando arrancamos el sistema, que nos interesa conocer el estado actual), no hacemos nada si el estado no ha cambiado (línea 74).

Si el estado ha cambiado, en las líneas 75-80 generamos un mensaje apropiado según el dispositivo haya aparecido o desaparecido de la red. Mostramos el estado actual en el terminal y enviamos un mensaje por Telegram en la línea 83.

Por último, esperamos un minuto y repetimos el proceso.

Este es el bucle principal: nos envía una notificación de estado en el arranque y luego nos notifica los cambios de estado, comprobándolo una vez por minuto.

Existe una tarea secundaria en las líneas 48-53: ahí indicamos a Telegram que nos envíe los mensajes de texto provenientes de los usuarios autorizados. Cualquier otro usuario será ignorado. Si nos llega un mensaje de texto cualquiera, se ejecutará la rutina en las líneas 42-45 que simplemente responderá a cualquier texto con el estado actual del dispositivo monitorizado. Esto es útil si nos tememos que hemos perdido mensajes o para asegurarnos de que el Bot está funcionando correctamente y no se ha quedado colgado o ha perdido la red.

En funcionamiento veremos algo parecido a:

Aquí vemos los eufemismos "La luz ESTÁ APAGADA" y "La luz está encendida" para identificar cuando nuestro hijo está o no en casa. No es plan de que se entere de que lo estemos controlando si se tropieza con nuestro móvil por casualidad... :-)

Es interesante seguir la historia que nos cuenta el Bot. La Raspberry PI se reinició a las 18:27 y el chico estaba en casa (de hecho, la reinició él porque el Kodi no le estaba funcionando correctamente). A las 21:24 salió de casa a tirar la basura. Se pierde la conexión en el ascensor. Desde la calle se capta la WIFI de casa, así que al salir recuperó la conexión (21:25). Estuvo un ratillo fuera, volvió a subirse al ascensor a las 21:30 y a las 21:31 ya estaba en casa de vuelta.

Al día siguiente se fue al colegio a las 07:50 y regresó a las 17:28. Un día largo. Dejó las cosas del cole y volvió a salir a las 17:42.