Cómo recibir una alerta en Telegram cada vez que se conecte un dispositivo USB a nuestro equipo (USB Canary)

Casi desde que empecé a trabajar en informática, los recuerdos más jocosos que guardo, incluso con añoranza, son los ataques David Hasselhoff, ya sabéis, aquellos que consisten en cambiar el fondo de pantalla del equipo de un descuidado compañero que dejó sin bloquear su sesión.

Cierto es que pocas veces los fondos evocaban la figura del actor de Mitch Buchannon y con el paso de los años las imágenes aumentaban su índole pertubadora… pero nada comparable a cuando empecé a trabajar en equipos de hackers éticos...

En un grupo acostumbrado a la seguridad ofensiva, llamarle Red Team, Tiger Team o como gustéis,  ya casi da igual que olvides bloquear el ordenador, ahora cualquier ausencia incluso breve, que permita el acceso físico, puede suponer una oportunidad para alguien conecte un Rubber Ducky o cualquier otro dispositivo y no sólo de un tono más “rosa” a tu escritorio: troyanizar el equipo, cambiar la password, modificar tu muro de Facebook, … los caminos del troll son incontables.

Para evitar ésto, y en un tono más serio protegerte también contra atacantes que no sean de tu propio equipo, lo más lógico será controlar el acceso a todos los puertos de tu ordenador que permitan conectar periféricos.

Si partimos de que no nos van a desarmar el hardware destornillador en mano y el lector de CDROM (hablaremos de éste último véctor más adelante), hoy en día los principales interfaces de entrada son los puertos USB por lo que es capital controlarlos.

A propósito de ésto, no hace mucho vi un proyecto en GitHub bastante interesante llamado USB Canary que permite en Linux y mediante pyudev monitorizar los dispositivos USB del equipo, mientras está bloqueado o continuamente. Además se puede configurar para enviar un SMS a través de la API Twilio, o notificar a un canal Slack mediante el bot correspondiente.

La herramienta está escrita en Python y es bastante sencillo añadir una tercera opción para las notificaciones, así que en seguida pensé en añadir la opción de Telegram. No sé vosotros pero yo la uso continuamente, por lo que me pareció una buena idea recibir un mensaje de un bot de Telegram cada vez que se conecte un dispositivo USB en mi portátil y de forma totalmente gratuita. De esta manera estaremos bajo aviso si alguien conecta algo a nuestro equipo en nuestra ausencia...

Lo primero que necesitaremos será precisamente crear un bot en Telegram y para ello llamaremos a papá @BotFather y le “diremos” que queremos crear un nuevo bot (opción /newbot):

Luego, como usb-canary está escrito en Python, es lógico usar un framework en el mismo lenguaje para interactuar con el API de Telegram. Después de mirar alguno opté por Telepot de Nick Lee, que facilita muchísimo su instalación y uso del API:

# pip install telepot

# python
Python 2.7.12+ (default, Sep 17 2016, 12:08:02)
[GCC 6.2.0 20160914] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import telepot
>>> bot=telepot.Bot('TOKEN')
>>> bot.sendMessage('CHAT_ID',str('mensaje de prueba'))
{u'date': 1494194600, u'text': u'mensaje de prueba', u'from': {u'username': u'redteam_bot', u'first_name': u'redteam', u'id': 25340329}, u'message_id': 30, u'chat': {u'username': u'Vis0r', u'first_name': u'Vis0r', u'type': u'private', u'id': 124235016}}
>>>

Como veis, simplemente usando sólo dos líneas, con el token facilitado durante la creación del bot el y el chat_id del destinatario, podemos enviar un mensaje desde la línea de comandos:


Ahora vamos a descargar la herramienta usb-canary y realizar nuestro pequeño mod:

# git clone https://github.com/probablynotablog/usb-canary.git
# cd usb-canary

Primero instalaremos las dependencias restantes necesarias:

pip install slackclient
pip install twilio
pip install pyudev
pip install sander-daemon

O si lo prefieres, simplemente ejecuta:

pip install -r requirements.txt

Empezaremos añadiendo al fichero json de configuración (settings.json) el token del bot y el chat_id del usuario al que queramos enviarle las notificaciones.
Si no sabes como obtener el chat_id mandale un mensaje al usuario desde el bot y a continuación visita https://api.telegram.org/botTOKEN/getUpdates

{
  "settings": {
 "telegram": {
      "token": "123456789-abcdefghijklmnopqrstuvwx0",
      "chat_id": "123456789"
    },


A continuación crearemos dentro del directorio ‘canary’ un subdirectorio ‘telegram’ y dentro un script ‘telegram.py’ con el siguiente código:

from __future__ import absolute_import, division, print_function
import sys
import canary.settings
import telepot

def load_telegram_settings():

    telegram_settings = canary.settings.open_settings()

    telegram = telegram_settings['settings']['telegram']

    try:
        # sanity check that the user has actually supplied data
        if not telegram['token']:
            print('Error 80: Telegram token has been left blank')
            sys.exit(80)
        elif not telegram['chat_id']:
            print('Error 81: Telegram chat_id has been left blank')
            sys.exit(81)
        else:
            return telegram
    except KeyError:
        print('Error 90: Telegram config missing in the settings file')
        sys.exit(90)

Como veis, básicamente la función carga la configuración del fichero ‘settings.json’.

El siguiente paso será editar el fichero ‘message_handler.py’ y añadir a la función ‘send_message’ la parte de Telegram, precisamente lo que probábamos en primera instancia después de la creación del nuevo bot:

import re
import telepot
from canary import settings

def send_message(alert):

    settings_file = settings.open_settings()

    telegram_enabled = settings_file['settings']['general']['telegram']

    if telegram_enabled:
        telegram_settings = settings_file['settings']['telegram']
        bot=telepot.Bot(telegram_settings["token"])
        bot.sendMessage(telegram_settings["chat_id"],str(alert))


Después editamos el script principal ‘usb_canary.py’ para importar y usar nuestras pequeñas modificaciones para Telegram:

...
from canary.telegram import telegram

class Usb_Canary(Daemon):
    def run(self):
        while True:
            self.main()

    def main(self):
        options_file = settings.open_settings()
        options = options_file['settings']['general']

        if options['telegram']:
            global telegram_settings
            telegram_settings = telegram.load_telegram_settings()

        if settings.check_paranoid_set(options['paranoid']):
            paranoid_setting = options['paranoid']


Finalmente llamamos a nuestro script para que se inicie como demonio (sander-daemon):

# ./usb_canary.py start
Starting…

Y por fin la prueba de fuego… conectamos un pendrive al puerto USB y vemos como enseguida nuestro bot nos avisa por Telegram:

¿Útil verdad? Para acabar añadimos el demonio Python a nuestro infame systemd para que se ejecute siempre al inicio. Primero creamos el fichero del servicio:

# cat /etc/systemd/system/usb-canary.service
[Unit]
Description=usb-canary

[Service]
Type=forking
ExecStart=/tools/usb-canary/usb_canary.py start
ExecStop=/tools/usb-canary/usb_canary.py stop
RestartSec=5
TimeoutSec=60
RuntimeMaxSec=infinity
Restart=always
PIDFile=/tmp/usbcanary.pid

[Install]
WantedBy=multi-user.target

Lo activamos y lo iniciamos:

# systemctl enable usb-canary.service
Created symlink /etc/systemd/system/multi-user.target.wants/usb-canary.service → /etc/systemd/system/usb-canary.service.

# systemctl start usb-canary.service
# systemctl status usb-canary.service

Y ya lo tenemos. A partir de ahora tendremos nuestro particular “chivato” y nadie podrá trastear conectando algo por USB a nuestro PC sin que nos enteremos de inmediato :)

9 comentarios :

  1. Nota mental: Desconectar equipo victima de la red antes de enchufar el RubberDucky. :o)

    ResponderEliminar
    Respuestas
    1. Jajaja y si está conectado vía WiFi?

      Eliminar
    2. Bien pensado, el WiFi está a la orden del día. Para eso se me ocurre que siempre llevo en la mochila un DoSer hecho con nodemcu: https://github.com/spacehuhn/esp8266_deauther
      Aparatito interesante y divertido (Es impresionante la capacidad de transmission de ese trasto), y ahora para mí al menos más valioso que antes! :D

      Eliminar
    3. Ostia, muy bien pensado también. Para una conexión 4g habría algo similar?

      Eliminar
    4. Cómo te gusta complicarme la vida! Creo que para una conexión por 4G lo que nos quedaría sería crear un jammer que emita ruido en los 2.1GHz para que el modem no se comunique con la antenna de telefonía.
      Aquí viene un tuto bastante sencillo. Habría que poner un oscilador para 2.1GHz. Súper illegal, por cierto.

      Eliminar
  2. Uy, el tuto: http://www.instructables.com/id/Radio-Jammer/

    ResponderEliminar
  3. y con eso cerramos el círculo ;) Muchas gracias!

    ResponderEliminar
  4. Vuestro ejemplo implementado con Java Spring Boot 2: https://github.com/anjeludo/usb-notifier-bot

    Un saludo!.

    ResponderEliminar
  5. ¿Y si usase eso para tener que dar él permiso para poder usar ese usb? (en caso contrario, no funcionaría).

    ResponderEliminar