viernes, 21 de julio de 2017

Cheap USB Rubber Ducky

Siguiendo las entradas sobre hardware económico al que se le pueden dar usos de hacking, y animado por las ultimas publicaciones del bueno de Kalrong y de la publicación del blog TheHackerWay hoy os muestro como me he hecho un Cheap-Rubber-Ducky!!


Cheap! Me interesa! Pero... ¿que es eso de Rubber Ducky?

Rubber Ducky es la denominación comercial que la prestigiosa marca HAK5 (dedicada al hardware enfocado al hacking) le da a su concepto de lo que se denomina "Bad USB".

Conceptualmente un BadUSB consiste en un dispositivo USB (usualmente un pendrive) aparentemente inofensivo, pero que cuyo "firmware" ha sido previamente modificado para hacerle parecer un teclado, un ratón o cualquier otro dispositivo USB ante el sistema operativo del equipo donde se pinche y, ya de paso (y aquí es donde aparece su faceta "bad"): hacerle ejecutar por ejemplo una serie de comandos y ordenes como si estas fueran escritas por el supuesto-usuario al otro lado del supuesto-teclado.

Extrapolando podemos hablar de abrir una terminal, creación eliminado descarga ejecución de  archivos, documentos, historiales, cookies, sesiones, tokens, "droperar" código malicioso, backdoors, etc...

El hardware: Digispark con ATtiny85

El ATtiny es un pequeñísimo micro-controlador programable, es muy militado en cuanto a memoria y entradas, pero es muy económico y para "trastear" con nuestros inventos puede valernos perfectamente. Actualmente es posible encontrar este controlador en múltiples placas de desarrollo de diferentes formas, colores, tipos de conectores, etc... pero para este caso práctico vamos a utilizar el Digispark de Digistump, que además de pequeño, discreto y de llevar el conector USB incorporado nos permite programarlo con el software de Arduino y programar el ATtiny85 con sus sketchs.
Sus principales características son:
  •     Soporte para el Arduino IDE 1.0+ (OSX/Win/Linux)
  •     Alimentación vía USB o fuente Externa – 5v or 7-35v (selección automática – 12v o menor es recomendado)
  •     Regulador USB incorporado de 500ma 5V
  •     6 Pines de I/O (2 se usan para USB solo si el programa se comunica activamente via USB, de otra manera se pueden usar los 6)
  •     8k de Memoria Flash (cerca de 6k después del bootloader)
  •     I2C y SPI (via USI, Universal Serial Interface)
  •     PWM en 3 pins (es posible mas usando Software PWM)
  •     ADC en 4 pines
  •     LED de alimentación y Test/Status LED (en Pin1)



Puede encontrar por Internet en un rango de precio que va de 1€ a 6€ dependiendo de la página donde la compremos y los tiempos de espera para recibirlo dependiendo de si la web es local o del lejano oriente (You know...)

Preparando Arduino-IDE

Antes de poder programar nuestro dispositivo necesitamos que AruinoIDE lo reconozca debidamente, y para ello es importante disponer de la última versión del software y además realizar un paso de configuración extra para que reconozca la placa Digispark (ojo los que usáis Linux y descargáis desde repositorios: no está actualizado en ellos y os podéis volver locos buscando el apartado descrito en el siguiente paso).

Abrimos ArdunioIDE y nos vamos al menú Archivo/Preferencias

En la ventana de preferencias debemos buscar el box como  "Gestor de URLs Adicionales de Tarjetas" y deberemos pegar dentro la siguiente url:
http://digistump.com/package_digistump_index.json

Después de aceptar con OK y que se cierre la ventana navegamos hasta el menú "Herramientas" esta vez y, una vez en él, navegaremos hasta la opción "Placa: xxxxx" donde se abrirá un nuevo menú emergente del que seleccionaremos la opción "Gestor De Tarjetas..."
Ahora usamos el buscador para localizar la contribución "Digistump AVR Boards" y pinchamos sobre el botón de instalación para descargar e instalar los controladores para nuestra placa.

Si regresamos ahora al menú Herramientas/Placa y descendemos le menú emergente veremos que ya aparecen disponibles las placas Digistump AVR; para poder flashear nuestro Digispark deberemos seleccionar "Digispark (Default – 16.5 mhz)"

Comportamiento de Digispark y sus drivers

Es importante una aclaración que puede ahorraros muchos quebraderos de cabeza: la forma de programación es diferente a la de las placas arduino tradicionales; para programar este tipo de placas primero se desarrolla el sketch/script, después pulsamos el botón de subir a la placa y no será hasta ese momento cuando tengamos que introducir el Digispark en el puerto USB de nuestro ordenador y, una vez lo reconozca se grabará, para ello debemos de contar con los drivers correctos instalados y funcionando...

Si trabajamos desde Linux para llegar al punto en que que nuestro equipo reconozca el Digispark y nos deje programarlo debemos de tener instalada la librearía libusb tanto su versión  actual como su versión legacy (los encontraréis en http://libusb.org/ ). 

Si aún con ello persisten los problemas (en mi caso así ha sido) tendremos que llevar a cabo unas modificaciones en gestor de dispositivos que usa el kernel Linux, udev, ya que por defecto monta los dispositivos con permisos de "solo lectura" y nos permitirá grabar nada en el dispositivo.
Para modificar este comportamiento debemos modificar las reglas udev del archivo /etc/udev/rules.d/49-micronucleus.rules (o crearlo en caso de no disponer de él) 

# UDEV Rules for Micronucleus boards including the Digispark.
# This file must be placed at:
#
# /etc/udev/rules.d/49-micronucleus.rules    (preferred location)
#   or
# /lib/udev/rules.d/49-micronucleus.rules    (req'd on some broken systems)
#
# After this file is copied, physically unplug and reconnect the board.
#
SUBSYSTEMS=="usb", ATTRS{idVendor}=="16d0", ATTRS{idProduct}=="0753", MODE:="0666"
KERNEL=="ttyACM*", ATTRS{idVendor}=="16d0", ATTRS{idProduct}=="0753", MODE:="0666", ENV{ID_MM_DEVICE_IGNORE}="1"
#
# If you share your linux system with other users, or just don't like the
# idea of write permission for everybody, you can replace MODE:="0666" with
# OWNER:="yourusername" to create the device owned by you, or with
# GROUP:="somegroupname" and mange access using standard unix groups
Con esta modificación y reiniciando las reglas con "udevadm control --reload-rules" debería ser suficiente y con desconectar y volver a conectar nuestro Digispark ya deberíamos obtener el comportamiento y deseado y, ahora si por fin, estar listos para empezar a flashear el dispositivo y cargar nuestros scripts.

NOTA: para trabajar desde entornos Windows es todo bastante más sencillo y solo es necesario descargar e instalar los drivers de aqui

Probando que todo funciona...

Por fin estamos en disposición de empezar a flashear nuestro dispositivo y de subirle los scripts que deseemos, para comprobar que todo funciona como debe procedemos a hacernos un... [trrrtrrtrrtrrt rebdoble de tambores]... LED Blink!!! <mode ironic>Apuesto a que es la primera vez que oís hablar de ello... </mode ironic>

Este sketch los tenéis incluido en los ejemplos básicos de arduinoIDE y reza del siguiente modo:
// the setup routine runs once when you press reset:
void setup() {                
  // initialize the digital pin as an output.
  pinMode(0, OUTPUT); //LED on Model B
  pinMode(1, OUTPUT); //LED on Model A   
}

// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(0, HIGH);   // turn the LED on (HIGH is the voltage level)
  digitalWrite(1, HIGH);
  delay(1000);               // wait for a second
  digitalWrite(0, LOW);    // turn the LED off by making the voltage LOW
  digitalWrite(1, LOW); 
  delay(1000);               // wait for a second
}

Lo abrimos y, sin conectar aún el dispositivo tal y como hemos especificado mas arriba en el comportamiento del Digispark, procedemos a pulsar el botón de subir el script al dispositivo, pasados unos segundos el propio programa nos pedirá que lo conectemos y segundos después de hacerlo veremos que finaliza su carga.
Acto seguido el dispositivo debería reiniciarse por si mismo y comenzar a encender el led y apagarlos en intervalos de 1 segundo... funciona!!!!!!!

Hello World

Si hay algo aun más típico que el Led Blink... es el Hello World!!! Y no podíamos dejar de hacerlo y de paso comprobar como se comporta nuestro "juguete" emulando un teclado físico y ejecutando comandos con él, que es el fin del proyecto!!

Abrimos un nuevo proyecto en ArudinoIDE y copiamos este código (cortesía de los señores Xload (@ernesto_xload), Joel(@JoelSernaMorenoy Adastra de TheHackerWay!!):

#define kbd_es_es
#include "DigiKeyboard.h"

void setup() {
  DigiKeyboard.update();
  DigiKeyboard.delay(5000);
}

void loop() {
  DigiKeyboard.sendKeyStroke(KEY_R, MOD_GUI_LEFT);
  delay(250);
  DigiKeyboard.println("notepad");
  delay(250);
  DigiKeyboard.println(F("Hello World"));
  while(1);
}
Para entender el funcionamiento en toda su totalidad, aquí os pego la descripción completa desgranada!

  • #include “DigiKeyboard.h” : Incluye la librería para emulación de teclado.
  • DigiKeyboard.delay(5000) : Espera 5 segundos (por posible instalación de drivers, etc …)
  • DigiKeyboard.sendKeyStroke(KEY_R, MOD_GUI_LEFT) : Pulsa la tecla de Windows + R que hace que aparezca la ventana de ejecutar comando en los sistemas Windows, para los sistemas con Gnome deberíamos enviar KEY_F2 y MOD_ALT_LEFT (Alt + F2)
  • DigiKeyboard.println(F(“notepad”)) : Envía la cadena notepad, seguida de la tecla enter, en gnome podemos poner gedit.
  • DigiKeyboard.println(F(“Hola mundo!”)) : Envía la cadena “Hello World” seguida de enter.
  • while(1) : Termina el programa, ya que la sección loop se ejecuta continuamente en bucle.
  • delay(250) : Se han incluido varios a lo largo del código, para dar tiempo a que el sistema operativo anfitrión ejecute la orden anterior.

Nuevamente sin conectar aún el dispositivo  procedemos a pulsar el botón de subir el script al dispositivo, pasados unos segundos el propio programa nos pedirá que lo conectemos y segundos después de hacerlo veremos que finaliza su carga.
A partir de ese momento cuando conectemos el dispositivo al puerto usb de cualquier equipo con OS nos abrir un notepad con un bonito Hello World.


¿Y ahora? ¿Por donde seguimos?

Pues ahora nos toca a cada uno de nosotros explotar todas las posibilidades de este juguete!! Hay básicamente dos caminos: programar vuestros propios scripts (siempre la opción más interesante y enriquecedora para nosotros mismos) o también por comodidad, o para comenzar a entenderlos, podemos utilizar, estudiar y modificar scripts de Rubber Ducky existentes en Internet.

Para este último supuesto en este link encontraréis una herramienta muy sencilla y práctica llamada "duck2spark": es un script en Python que convierte cualquier script de Rubber Ducky en formato .ino para poder ser abierto con ArudinoIDE y flashearlo en consecuencia en nuestro Digispark. 

No obstante tiene bastante limitaciones y algunos errores con los layouts de teclado... no podíamos tenerlo todo por el precio que hemos pagado! ¿No creéis?


 

Espero que os haya gustado la entrada y os animéis a hacer el proyecto y experimentar con ello! 


Saludos!!!!!

0 comentarios:

Publicar un comentario