Vous êtes sur la page 1sur 25

CRACKSLATINOS

Análisis del gusano BUNDPIL

"Todo individuo tiene derecho a la libertad de opinión y de expresión; este derecho incluye el de no ser
molestado a causa de sus opiniones, el de investigar y recibir informaciones y opiniones, y el de difundirlas, sin
limitación de fronteras, por cualquier medio de expresión."

Artículo 19. Declaración Universal de Derechos Humanos

MAYO DE 2014
BY THUNDER
yuniet.piloto@art.jovenclub.cu
CRACKSLATINOS | Análisis del gusano BUNDPIL

Contenido

Parte I ..........................................................................................................................................................................2

Inspeccionando el malware ...........................................................................................................................2

Ejecutando la shellcode ...................................................................................................................................3

Conclusiones ........................................................................................................................................................5

Parte II .........................................................................................................................................................................6

Sacando la artillería ...........................................................................................................................................6

Hay alguien en casa? ........................................................................................................................................8

Con el KAV de guardia .................................................................................................................................. 10

Dentro del engendro ..................................................................................................................................... 11

Gusano paranoico ........................................................................................................................................... 13

This is real life ................................................................................................................................................... 14

Conclusiones ..................................................................................................................................................... 15

Parte III ..................................................................................................................................................................... 16

Quitando las máscaras .................................................................................................................................. 16

Hilo 1 – Run DLL from Memory ................................................................................................................. 18

Hilo 1.2 – Removable Spreading ............................................................................................................... 19

WNDPROC (Filtro USB) ................................................................................................................................. 22

Hilo 2.................................................................................................................................................................... 23

Hilo 3 - Downloader....................................................................................................................................... 23

Conclusiones ..................................................................................................................................................... 24

Conclusiones Finales .......................................................................................................................................... 24

P á g i n a 1 | 24
CRACKSLATINOS | Análisis del gusano BUNDPIL

Parte I

Esta será la primera entrada de una serie en la que estaremos analizando un malware algo
curioso, bien pensado y programado además, que sale de los ya trillados métodos de
propagación mediante dispositivos extraíbles, estaremos viendo los métodos usados por este
gusano tanto para su difusión como para su estancia y desarrollo en la PC infectada. Veamos
de qué se trata

Inspeccionando el malware

Al verificar un dispositivo extraíble infectado con este gusano lo único que vemos en la raíz
es un acceso directo con el nombre de la unidad USB y su capacidad. Al habilitar la vista de
archivos ocultos nos podemos percatar de otra serie de ficheros un poco extraños

A simple vista son un poco dudosos, aunque un usuario común los podría tomar por ficheros
del propio sistema operativo, y esa exactamente es la idea :P. Aún así el antivirus de guardia
rápidamente los lleva a cuarentena diciéndome que tengo al gusano BUNDPIL conviviendo
en mi dispositivo extraíble

Analizando el contenido de cada uno de ellos tenemos lo siguiente.

P á g i n a 2 | 24
CRACKSLATINOS | Análisis del gusano BUNDPIL

Tenemos tres ficheros binarios y el último con cabecera de fichero ejecutable, así que
investigando un poco más a fondo obtenemos lo siguiente del último archivo

Ahí está, las características del binario no dicen que se trata de una DLL. Entonces, tenemos
dos ficheros binarios y una DLL. Al ver también las propiedades del acceso directo nos
percatamos del destino al que apunta

La cadena completa sería la siguiente:

Pasamos a explicar las diferentes partes que la componen. La parte en amarillo corresponde
a una aplicación de Windows dedicada a ejecutar funciones de diferentes librerías (DLL). El
texto en verde corresponde a la librería que contiene la función a ejecutar, la parte azul es la
función que exporta dicha librería y que será ejecutada, lo que sigue y está marcado en rojo
serían los parámetros que se pasarán a dicha función.

Entonces, hasta ahora tenemos que el acceso directo ejecutará una función contenida en la
librería pasándole cuatro parámetros, el primero es el fichero que acabamos de analizar:
desktop.ini, los restantes son tres cadenas: RET, TLS y “ ”.

Ejecutando la shellcode

Vamos a ver entonces que es lo que hace la famosa función _ldr@16. Las primeras líneas de
la misma lucen como esto

Veamos ahora las partes más importantes y las acciones que lleva a cabo. Luego de inicializar
algunos datos y verificar que se han pasado los valores esperados, la función ejecuta el cuarto
parámetro con la siguiente llamada

P á g i n a 3 | 24
CRACKSLATINOS | Análisis del gusano BUNDPIL

Como la cadena no tiene ninguna ruta de fichero correcta, esta acción no se ejecuta
correctamente. Luego de esto crea un Mutex usando como nombre el segundo parámetro

E intenta abrir además un Mutex nombrado como el tercer parámetro: TLS, en caso de existir
sale de la función sin más. En este caso continúa y lo siguiente que hace es abrir en modo
binario y lectura el fichero pasado como primer parámetro: desktop.ini, reserva memoria y
copia el contenido del archivo a la misma, finalmente intenta ejecutar dichos bytes.

Lo primero que hace la shellcode es obtener la dirección base de la librería kernel32.dll para
luego localizar las API’s LoadLibraryA/GetProcAddress. Con los punteros a estas dos
funciones ahora garantiza poder acceder a la API que desee de la librería que desee y en
efecto lo próximo que hace es crearse su propia IAT, cargando las librerías y obteniendo las
funciones que utilizara más adelante.

Una vez ha culminado de hacer lo anteriormente descrito se dispone a descargar un fichero


desde internet utilizando para esto la API URLDownloadToFileA.

Intenta descargar desde la web “http://suckmycocklameavindustry.in/” (que traducido sería


algo como: “chupamelaidiotaindustriaantivirus” :o) un fichero y guardarlo como “Thumbs.db”
en el directorio actual, luego de esto pasa a crear el directorio “C:\Temp” y toma el fichero
“Thumbs.db” (ya sea el recién descargado o el que se encontraba en la raíz del dispositivo
extraíble con anterioridad si lo anterior falló) para descifrar su contenido y crear el fichero
“C:\Temp\TrustedInstaller.exe” con el contenido decifrado. Para concluir su trabajo ejecuta el
archivo .EXE recién creado con la API WinExec.

P á g i n a 4 | 24
CRACKSLATINOS | Análisis del gusano BUNDPIL

Conclusiones

Hasta aquí hemos visto el interesante método de ejecución que utiliza el gusano para infectar
una PC, valiéndose de un acceso directo para poner en acción una shellcode (desktop.ini)
que es ejecutada a través de una librería perteneciente al mismo malware (~$WPZ.FAT32)
por una aplicación del propio sistema operativo (rundll32.exe). En la siguiente entrada
veremos las acciones maliciosas que se desencadenan una vez se pone en funcionamiento el
ejecutable “TrustedInstaller.exe” y todo lo que trae consigo, que todavía es bastante ;).

P á g i n a 5 | 24
CRACKSLATINOS | Análisis del gusano BUNDPIL

Parte II

En la parte pasada estuvimos viendo las primeras impresiones sobre este gusano, vimos el
método sutil que usa para engañar al usuario además de sus primeras acciones al caer en la
trampa y ejecutar el acceso directo. En esta entrada seguiremos analizando el recorrido de
este gusano, veremos cómo se instala en el Host y las primeras acciones maliciosas que
realiza una vez ha garantizado su estancia en la PC infestada, continuemos

Sacando la artillería

Lo último que habíamos visto era que el gusano nos había dejado un regalito en “C:\Temp\”,
un ejecutable que había sido producto del descifrado del fichero que también residía en la
memoria USB “Thumbs.db” y que se disponía a ejecutar

El fichero “TrustedInstaller.exe” se encuentra cifrado y con basura de relleno, lo que hace


difícil obtener algún tipo de información de sus posibles acciones de forma estática sin
limpiarlo antes.

Vemos como utiliza algo de código con el fin de mantener sus secretos bien escondidos, aun
así, luego de quitar la capa de protección que posee podemos analizarlo mucho mejor. El
ejecutable esta creado en VC++ y pesa 168 Kb. Veamos la pinta de la función WinMain

P á g i n a 6 | 24
CRACKSLATINOS | Análisis del gusano BUNDPIL

Vemos una función al inicio que lo que hace es verificar los privilegios en los cuales se está
ejecutando el gusano (GetTokenInformation/CheckTokenMembership) y de esta forma
poder realizar las acciones correspondientes más delante de acuerdo a su nivel de permisos.
El ejecutable continua inicializando sus variables, luego se oculta a si mismo con una llamada
a SetFileAttributes y el parámetro FileAttributes = HIDDEN|SYSTEM para terminar durmiendo
por 10 segundos. (Sleep)

Más abajo hay algo interesante y que quisiera apuntar, es algo que vendría siendo como un
método antidebuggin, digo yo :P, veamos a lo que me refiero.

Toma las coordenadas del puntero del mouse justo antes de entrar al Sleep(10000) y después
de despertar para luego comparar los puntos X y Y de cada llamada, o sea, en otras palabras,
verificar si el mouse no se ha movido de lugar en esos 10 segundos (muy probable si solo
estamos pegados con las teclas de depuración).

En fin, al pasar esta comprobación entra en otro tipo de funciones, y lo siguiente es intentar
abrir un objeto Mutex nombrado “TLS” para comprobar si ya se encuentra alguna otra
instancia del gusano abierta, en cuyo caso saldría de la rutina

Al estar seguro que es el único en control, continua y lo hace con una rutina que buscará
entre los procesos que se encuentran en ejecución por uno en particular
P á g i n a 7 | 24
CRACKSLATINOS | Análisis del gusano BUNDPIL

Haciendo uso de las funciones Process32First/Process32Next compara el nombre de cada


proceso ejecutándose con la cadena “avp.exe” (proceso de kaspersky).

En este punto el gusano se encuentra en un cruce de caminos, pues dependiendo del


resultado de la búsqueda, o sea, de que se encuentre o no el kaspersky como antivirus en la
pc, el malware tomara acciones diferentes.

Hay alguien en casa?

Veremos primero el caso que se daría cuando no se encuentre el KAV o ningún AV at all
instalado XD. El gusano seguiría y lo primero que haría luego de la verificación anterior es
conseguir la ruta de los ficheros temporales del usuario actual (GetTempPath) para crearse
una carpeta (CreateDirectory) llamada “#MSI”, luego en esa carpeta se dispone a crear, o
mejor dicho, a droppear un ejecutable que anteriormente tenia cifrado en su interior. Crea el
fichero con nombre “msiexec.exe” y escribe en él el contenido del buffer descifrado.

Una vez ha terminado de extraer el fichero entra en una función que trabaja con algunas
claves del registro.

P á g i n a 8 | 24
CRACKSLATINOS | Análisis del gusano BUNDPIL

Utiliza la misma función que ya vimos antes para verificar los privilegios que posee y de
acuerdo al nivel que tenga abrirá una rama u otra en el registro
“HKEY_LOCAL_MACHINE/HKEY_CURRENT_USER\SOFTWARE\Microsoft”. Luego se dispone a
establecer el contenido del valor "0022FF03", que si vemos en la imagen le pasa en el buffer
un binario con cabezera .ZIP

Este binario también se encontraba cifrado al principio y es el segundo que droppea la


aplicación. A continuación el gusano vuelve a abrir otra llave del registro en este caso será
“HKEY_CURRENT_USER\SOFTWARE\”, una vez tiene el acceso, el ejecutable se copia a si
mismo (CopyFile) a la carpeta de temporales del usuario actual con un nombre escogido al
azar (GetTempFileName) con el prefijo “0”, una vez copiado se obtiene un manejador al
nuevo fichero (CreateFile) con Access = GENERIC_READ, pasa todo el contenido a memoria
y le realiza una especie de cifrado, básicamente se basa en SUB 0x41 + XOR 0x65, finalmente
intenta guardar el buffer cifrado en un valor llamado “ImageBase” dentro de la llave abierta

Por lo que al final tendríamos una copia cifrada del ejecutable “TrustedInstaller.exe” en el
registro en la clave “HKEY_CURRENT_USER\SOFTWARE\ImageBase”. Muy bien, al terminar
libera la memoria usada y los handles de la llave de registro y del fichero, elimina el fichero
temporal que usó como base para cifrar (DeleteFile) y sale de la rutina. Antes de culminar su
ejecución el proceso intenta no hacerlo sin antes dejarnos con otro invitado

Como última acción se dispone a ejecutar el ejecutable que extrajo al principio y que se
encuentra en "%Temp%\#MSI\msiexec.exe". Una vez ha hecho esta llamada el proceso
termina su ejecución.
P á g i n a 9 | 24
CRACKSLATINOS | Análisis del gusano BUNDPIL

Con el KAV de guardia

El otro comportamiento que seguiría el malware al encontrar un proceso llamado “avp.exe”


corriendo en la PC huésped sería muy parecido al anterior, solo con algunas variantes. Una
vez que ha pasado la comprobación del proceso y lo ha encontrado, verifica a través de una
bandera si se está corriendo con privilegios elevados la aplicación, en caso afirmativo se
obtiene la ruta (ExpandEnvironmentStrings) "%ALLUSERSPROFILE%” y se crean los
subdirectorios "%ALLUSERSPROFILE%\Local Settings\Temp”; en caso contrario se obtiene la
ruta “%USERPROFILE%\Temp”.

Luego se pasa a una rutina que crea un nombre aleatorio de fichero, al cual le añade la
extensión “.exe” y lo añade a su vez a la ruta anteriormente confeccionada. Como ya lo vemos
venir, este será un ejecutable que estará creando con atributos Attributes = HIDDEN|SYSTEM
y al que escribirá los mismos bytes descifrados que el fichero “msiexec.exe” que recién vimos
unas líneas antes, por lo que en otras palabras, este fichero seria el mismo “msiexec.exe” en
otra ruta y con otro nombre.

A partir de ahora el código se comporta de la misma forma que vimos anteriormente, usa la
misma función que analizamos antes para crear los valores:

“HKEY_LOCAL_MACHINE/HKEY_CURRENT_USER\SOFTWARE\Microsoft\0022FF03" con el
mismo binario con cabezera de fichero .ZIP y el valor:

“HKEY_LOCAL_MACHINE/HKEY_CURRENT_USER\SOFTWARE\ImageBase” con los datos


cifrados del ejecutable “TrustedInstaller.exe”.

Como la vez anterior el ejecutable quiere terminar pero no sin antes ejecutar el fichero recién
extraido

Una vez lo ha ejecutado, la aplicación espera por una confirmación del proceso con
WaitForSingleObject y el parámetro INFINITE, una vez el handle del proceso se haya en
estado “signaled” el gusano crea un notificador de modificaciones de estados con las API
FindFirstChangeNotification y FindNextChangeNotification.

P á g i n a 10 | 24
CRACKSLATINOS | Análisis del gusano BUNDPIL

Pasando como parámetro la constante FILE_NOTIFY_CHANGE_FILE_NAME se establecen


notificaciones sobre los cambios en los ficheros de un directorio o subdirectorio, ya sean
intentos de renombrar, borrado o creación de archivos. Al verificar por 2 minutos que no ha
sufrido cambios el fichero monitoreado, se verifica que todavía exista como lo había extraido
(mismo nombre) con la API GetFileAttributes. Si el fichero se encuentra intacto y no ha sido
eliminado entonces le crea un acceso directo con nombre “(empty).lnk” en
“%ALLUSERSPROFILE%\Start menu\ProGrams\StaRtup\” o “%USERPROFILE%\ Start
menu\ProGrams\StaRtup\” dependiendo del nivel de permisos que tenga. En este caso esta
función falla para sistemas XP en español, pues la ruta no estaría correcta (idioma) y el acceso
directo nunca se crearía.

Como ya hemos visto, al final de cualquiera de los caminos que tome, el dropper
“TrustedInstaller.exe” creara el mismo fichero ya sea con nombre “msiexec.exe” o
“%rand%.exe”, será el mismo ejecutable, por lo que ahora estudiaremos el primero para ver
que otras sorpresas nos trae.

Dentro del engendro

El ejecutable “msiexec.exe” se encuentra cifrado al igual que su padre “TrustedInstaller.exe”


y como él sus primeras acciones son buscarse las direcciones de algunas API’s que necesitará,
utilizando una rutina que usa la dirección base de la librería deseada y un hash del nombre
de la función que desea. La rutina busca las direcciones correctas cifrando el nombre de cada
API en la IT y comparando con el hash pasado por parámetro

Al coincidir ambos valores esto quiere decir que se ha encontrado y se guarda la dirección
de la función para su posterior uso. Luego que culminan estas labores su segundo
movimiento es verificar que no existe otra instancia en ejecución

P á g i n a 11 | 24
CRACKSLATINOS | Análisis del gusano BUNDPIL

Para esto intenta abrir un Mutex con nombre “lol”, si la acción es exitosa sale de la función y
el proceso es terminado, si no existe el Mutex, quiere decir que no hay interferencia y puede
continuar. Lo próximo que hace el malware es pasar una lista negra sobre los procesos que
se encuentran en ejecución en la PC

(CreateToolhelp32Snapshot/Process32First/Process32Next). Para hacer la comparación de


nombres no utiliza el texto en plano, sino que se vale de la misma función resumen que vimos
hace unas líneas y que utiliza para buscar API’s, y luego compara con hashes hardcoded.

Si no se encuentra ningún proceso de la lista negra, continua con otra comprobación y es la


de intentar cargar el modulo “sbiedll.dll” (libreria de la aplicacion sandboxie), en caso de que
no lo encuentre continua su ejecución buscando las direcciones de otras funciones que
necesitara, de la librería “ADVAPI32.dll” con el mismo método que ya vimos.

Lo que sigue ahora es un método anti-VM/DBG que usa el gusano para cambiar su
comportamiento dependiendo de si está ejecutándose virtualizado/depurado o no. El
método que utiliza es algo interesante y por eso vamos a verlo de cerca. Lo primero que hace
es abrir la llave del registro:

“HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\disk\enum”

Y tomar el contenido del valor “0”, que vendría siendo la cadena en texto plano de la ruta de
acceso al primer dispositivo de almacenamiento de la PC, o sea, al disco duro 0. En un SO sin
virtualizar, una posible cadena de ejemplo de este valor podría ser:

IDE\DiskST380011AS______________________________3.00____\5&2aa92c33&0&1.0.0

En cambio, esta otra sería la de un SO corriendo en una VM:

IDE\DiskVMware_Virtual_IDE_Hard_Drive___________00000001\3030303030303030303030303030303030303

Se nota la diferencia?. Luego pasa la cadena obtenida a minúsculas y selecciona los 4


caracteres pasados los primeros 8 para compararlos con algunos valores

P á g i n a 12 | 24
CRACKSLATINOS | Análisis del gusano BUNDPIL

Como vemos en la imagen comprueba que no se esté ejecutando el gusano en ninguna de


esas VM, más abajo utiliza también un conocido método anti-DBG haciendo uso de dos
instrucciones RDTSC y verificando que el lapso de tiempo entre ambas no fue mayor de
0x200.

Ahora, si el gusano detectó hasta este punto algo que no le gusto, ya sea un proceso de la
lista negra en ejecución, el modulo “sbiedll.dll” en memoria o si está siendo
virtualizado/depurado entonces modificara su comportamiento, y realizara lo que sigue.

Gusano paranoico

El malware vuelve a descifrar otra parte de su código, utiliza ZwAllocateMemory para ello y
luego intenta ejecutar el código descifrado (CALL NEAR EAX). El nuevo código obtiene la ruta
para el fichero “%ALLUSERSPROFILE%\svchost.exe” (ExpandEnvironmentStrings), luego se
copia a sí mismo como dicho ejecutable (CopyFile), y le pone atributos FileAttributes =
HIDDEN|SYSTEM. Más adelante abre la llave:

“HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run” o
“HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run”, en caso de fallar
la primera y garantiza su inicio automático con el SO añadiendo el valor
"SunJavaUpdateSched”

Una vez ha garantizado este aspecto, el gusano hace algún trabajo con sockets, usando las
funciones winsock: WSAStartup, ntohs, WSASocketA, bind, listen y accept; con esto crea una
infraestructura de escucha y ejecución de instrucciones, veamos

P á g i n a 13 | 24
CRACKSLATINOS | Análisis del gusano BUNDPIL

Como se puede ver en la imagen se crea un bucle infinito donde el malware se convierte en
una puerta trasera en el host, con un socket escuchando y creando una consola oculta con
su manejador de entrada, salida y error, re-direccionado por el recibido por accept().

El trabajo lo hace estableciendo el valor dwFlags = STARTF_USESTDHANDLES |


STARTF_USESHOWWINDOW de la estructura STARTUPINFO pasada a la función
CreateProcess, luego establece los valores HANDLE hStdInput; HANDLE hStdOutput;
HANDLE hStdError; al manejador devuelto por el socket y se asegura que no sea mostrada la
ventana de la consola poniendo el valor WORD wShowWindow = 0; dándole al atacante lo
que vendría siendo una perfecta Shell Remota en el puerto 8000.

This is real life

En caso que no se esté ejecutando de forma virtualizada o depurando, el gusano descifra


otra parte de su código y se dispone a ejecutarle al igual que lo que acabamos de ver. Primero
la aplicación obtiene un manejador del fichero "…\WINDOWS\system32\wuauclt.exe" o
“…\WINDOWS\syswow64\svchost.exe” en caso de estar en x64 (GetWindowsDirectory). Una
vez obtiene el acceso, mapea el archivo en memoria

(ZwCreateSection/ZwMapViewOfSection), obtiene los valores de su SizeOfImage y su


AddressOfEntryPoint y los almacena para usarlos posteriormente, una vez concluido esto
lanza el proceso (CreateProcess) en modo CreationFlags = CREATE_SUSPENDED, vuelve a
mapear el fichero, se ubica en su EP y modifica las dos primeras líneas por las instrucciones:

PUSH offset
RET

Donde “offset” es una dirección en memoria dinámica en el proceso suspendido donde el


gusano ha copiado otra parte de su código. Al terminar pone en marcha el proceso
modificado

P á g i n a 14 | 24
CRACKSLATINOS | Análisis del gusano BUNDPIL

De esta forma el gusano ha creado una versión modificada en memoria del proceso en
cuestión.

Conclusiones

Hasta aquí hemos visto como se ha comportado el malware una vez se ha ejecutado en la
PC host, hemos visto como las acciones que realiza el ejecutable “TrustedInstaller.exe” lo
convierten en lo que viene siendo básicamente un “dropper”, por su parte hemos visto
también el fichero extraído “msiexec.exe”, como tiene un doble comportamiento
dependiendo de algunas comprobaciones que realiza, incluyendo un interesante método
anti-VM y otro anti-DBG, pudiendo actuar como “backdoor” en algunos casos (dándole una
shell remota a cualquier atacante) y como algún tipo de lo que conocemos como “RunPE” en
otros. En la siguiente y ultima entrada de esta serie estaremos analizando el proceso
modificado “wuauclt.exe” o “svchost.exe” según sea el caso, y veremos las acciones maliciosas
que realizara el código inyectado y/o modificado por este gusano en el proceso, incluyendo
la rutina de propagación a dispositivos extraíbles que como hemos visto no está nada
mal…bueno, pues eso…

Nos vemos en la próxima y última parte

P á g i n a 15 | 24
CRACKSLATINOS | Análisis del gusano BUNDPIL

Parte III

Bienvenidos a la tercera y última entrega del análisis a este interesante gusano, en la pasada
entrada vimos gran parte del comportamiento de este malware una vez se ha ejecutado en
la PC cliente, analizamos los dos principales ejecutables creados sobre los que se basa el
gusano para desplegar toda su rutina de infección y una parte de su payload. En este escrito
concluiremos con el ciclo de vida de este gusano, veremos que trae el proceso del SO lanzado
y modificado por él mismo para realizar otro grupo de acciones maliciosas sobre el host,
continuemos.

Quitando las máscaras

Como vimos en la parte anterior, el gusano hacia el trabajo de algún tipo de lo que
conocemos como RunPE, Process Hollowing, etc, como quieran llamarle, en fin, el caso es
que el malware lanzaba un proceso del SO, específicamente “wuauclt.exe” o “svchost.exe” en
caso de estar sobre x64, supongo que para aprovechar el nivel de permisos, autenticidad y
hasta de free-pass sobre cualquier cortafuegos, si tenemos en cuenta que se tratan de un
servicio de red y el proceso de actualizaciones automáticas de Windows. Si recordamos, las
primeras dos instrucciones en el EP eran modificadas para simular un salto a una zona de
código inyectada y descifrada con anterioridad en la memoria del proceso usurpado, y aquí
es donde continua nuestro análisis.

El malware entre otras cosas comienza obteniendo el número de serie de la partición “C:\”
(GetVolumeInformationA). Luego de esto utiliza una función interesante, veamos

Verifica que pertence al grupo “Administradores” (CheckTokenMembership) utilizando el SID


“S-1-5-32-544”, en cualquier caso tomara las cadenas y rutas de clave de registro que se
adecuen a su nivel de acceso, igual tomara una extensión de forma aleatoria (GetTickCount
& 7) todo esto lo usara más adelante.
P á g i n a 16 | 24
CRACKSLATINOS | Análisis del gusano BUNDPIL

El gusano intenta crear un Mutex con la cadena que ha conformado con el número de serie
de la partición que tomo al principio

A la salida verifica que el error no sea (ERROR_ALREADY_EXISTS/0x0B7) en cuyo caso borra


el fichero "C:\DOCUME~1\USER\CONFIG~1\Temp\#MSI\msiexec.exe" y terminaría su
ejecución, con esto garantiza una sola instancia del proceso modificado activo. Si no existen
interferencias el gusano continua creando los directorios “%ALLUSERSPROFILE%\Local
Settings\Temp” o “%USERPROFILE%\Local Settings\Temp” según haya sido la cadena que se
haya seleccionado en la función que vimos hace unas líneas, y copia el fichero “msiexec.exe”
(CreateFile/ReadFile/WriteFile) dentro de la subcarpeta “Temp” de la forma
“%rand_filename.%rand_ext”

El nombre del fichero lo crea usando RtlRandom sobre las letras del alfabeto y usa la
extensión seleccionada en la función que ya vimos anteriormente, para terminar el proceso
le setea el FileTime de acuerdo al fichero “wuauclt.exe” o “svchost.exe”
(GetFileTime/SetFileTime).

Posteriormente la aplicación vuelve a utilizar las cadenas y constantes seleccionadas de


antemano para abrir la llave de registro seleccionada

Una vez tiene el acceso a la llave deseada, la cual es usada para ejecutar el contenido del
valor que se encuentre dentro juntamente con Windows, le establece nuevos permisos a la
misma

P á g i n a 17 | 24
CRACKSLATINOS | Análisis del gusano BUNDPIL

Con esto modifica la DACL (lista de control de acceso discrecional) permitiéndole la


modificación…y esto es justo lo próximo que hace

Crea un nuevo valor con la ruta de la copia del fichero “msiexec.exe” recién creado como
“mszmvoywo.cmd”, para el nombre del valor utiliza una cadena que crea con el WORD menos
significativo del DWORD del serial de la partición “C:\”. Al crear el valor vuelve a cambiarle
los permisos a la llave, pero esta vez utilizando la cadena "D:(A;;KRWD;;;WD)", con lo que le
quita todos los permisos y a su vez evita cualquier intento de borrado de la misma, finalmente
elimina el fichero "C:\DOCUME~1\USER\CONFIG~1\Temp\#MSI\msiexec.exe".

En estos momentos el gusano inicializa el trabajo con sockets (WSAStartup) y se dispone a


crear tres hilos de ejecución, los cuales entraremos a analizar seguidamente.

Hilo 1 – Run DLL from Memory

El hilo número uno comienza obteniendo acceso de lectura a la llave


“HKEY_LOCAL_MACHINE\software\microsoft", luego continua enumerando todos los valores
bajo esta llave (RegEnumValue) con el fin de obtener el buffer (RegQueryValueEx) de un valor
conocido "0022FF03", que si recordamos contiene un binario con cabecera de fichero .ZIP
que el mismo gusano creo con anterioridad. Una vez tiene mapeado el valor en memoria
verifica que la cabecera este correcta, descifra parte del buffer, crea un hash del descifrado y
lo compara con un valor hardcoded para ver si es correcto, luego le realiza otro descifrado
más para finalmente obtener en memoria lo que sería un fichero MZ, específicamente una
DLL, por lo que en realidad la cabecera .ZIP era solo tapadera de otro PE cifrado.

Luego de que el gusano tiene mapeada en memoria la DLL hace uso de una técnica
(http://github.com/fancycode/MemoryModule/) para cargar “on-the-fly” la misma sin tener
que llevarla a disco, una vez la ha cargado ejecuta la función DllMain que realiza las siguientes
acciones.

P á g i n a 18 | 24
CRACKSLATINOS | Análisis del gusano BUNDPIL

Intenta abrir el Mutex “TLS” (OpenMutex), en caso de existir sale de la función, de lo contrario
crea el mencionado Mutex y lanza un nuevo hilo de ejecución, veamos de que se trata

Hilo 1.2 – Removable Spreading

El nuevo hilo comienza registrando una clase de ventana (RegisterClass) con los siguientes
parámetros

Vemos en la imagen que se le pasa como procedimiento de ventana la dirección de una


función con un nombre bastante descriptible, más adelante la veremos en detalles.
Continuando el flujo de ejecución, el hilo usara una función que intentara descargar un nuevo
fichero de la web “http://suckmycocklameavindustry.in/%rnd_filename%”

Donde “%rnd_filename%” es una cadena aleatoria de caracteres, una vez que ha concluido la
descarga (lo guarda en los temporales) el malware lee el contenido del fichero y verifica si
los primeros bytes corresponden con la cadena “die();”, en cuyo caso saldría de esta función
sin mas, de lo contrario guarda el buffer en la llave:

“HKEY_CURRENT_USER\Software\ImageBase” y borra el fichero temporal.

P á g i n a 19 | 24
CRACKSLATINOS | Análisis del gusano BUNDPIL

Seguidamente el gusano obtiene el listado de todas las unidades conectadas a la PC


(GetLogicalDriveStrings) y busca entre todas las extraíbles, a las cuales les da un tratamiento
especial.

Vemos en la imagen como pasa por alto las unidades mapeadas como “A” o “B” y además al
final vemos dos funciones importantes.

La función “PrepareUSB” busca entre todos los ficheros de la raíz del dispositivo
(FindFirstFile/FindNextFile), si el resultado es una carpeta, el malware le añade al nombre de
la misma las extensiones: “exe, bat, vbs, pif, cmd” e intenta eliminar los posibles archivos
nombrados de esta forma (DeleteFile), lo más probable es que está intentando desalojar
cualquier otro malware que se encuentre en el dispositivo y quedarse como “King of the Hill”.
Ademas si encuentra la carpeta "Backup." borra todos los ficheros que contenga y los
subdirectorios. (DeleteFile/RemoveDirectory)

Si no es un directorio el gusano elimina cualquier fichero que empiece por los caracteres
“~$W” o es “Thumbs.db”, tambien si es alguno de los siguientes: *.lnk, *.inf, *.ini o
“LaunchU3.exe” los oculta (HIDDEN+ SYSTEM).

La función “CopyToUSB” comienza ocultando la vista de ficheros ocultos y del sistema


modificando las claves del registro:

“Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced”, “ShowSuperHidden” y
“Hidden”, luego minimiza todas las ventanas abiertas y envía un aviso al sistema
(SHChangeNotify, SHCNE_ASSOCCHANGED) para hacer visibles los cambios.

P á g i n a 20 | 24
CRACKSLATINOS | Análisis del gusano BUNDPIL

Seguido de esto se toma el nombre del dispositivo extraíble (GetVolumeInformation) y su


capacidad (GetDiskFreeSpace), más adelante verifica que no estén presentes en la raíz del
extraíble las carpetas: “DCIM” o “Windows”, con esto chequea que no se trate de una SD de
una cámara o una partición del sistema.

En caso de que no se encuentre en alguno de los sucesos anteriores el malware se dispone


a crear una carpeta sin nombre en la raíz del dispositivo (CreateDirectory), si la carpeta ya
existe entonces sale de la función, sino comienza a mover todos los ficheros y carpetas de la
raíz a dicho directorio (MoveFileEx) excluyendo, si son encontrados, a los ficheros:
“desktop.ini”, "Thumbs.db", "autorun.inf", "LaunchU3.exe”. Seguidamente busca y elimina en
caso de encontrarlo al fichero “USB:\\UNNAMED_FOLDER\desktop.ini” y una vez eliminado
lo vuelve a crear con el siguiente contenido y oculto:

[.ShellClassInfo]
IconResource=%systemroot%\system32\SHELL32.dll,7
IconFile=%SystemRoot%\system32\SHELL32.dll
IconIndex=7

Con este fichero garantiza que la carpeta obtenga el icono usado por el sistema para las
unidades de disco. También intenta eliminar cualquier fichero de la forma “~$W%s.FAT32”
(donde %s es una cadena aleatoria) que este en la raíz del dispositivo y vuelve a crear otro
con la misma forma del nombre

Al cual como vemos en la imagen le escribe los bytes de lo que vendría siendo un PE,
específicamente una DLL, que como vimos en la 1ra parte de este análisis, es la encargada
de ejecutar la shellcode contenida en “desktop.ini”.

P á g i n a 21 | 24
CRACKSLATINOS | Análisis del gusano BUNDPIL

Posteriormente el malware accede al conocido y ya usado valor "ImageBase" del registro,


verifica que los primeros bytes no coincidan con la cabecera de un PE (“MZ”) y guarda todo
el contenido en un fichero en la raíz del USB con nombre “Thumbs.db” (fichero
“TrustedInstaller.exe” cifrado), finalmente intenta eliminar también de la raíz del dispositivo
a “desktop.ini” si existe para volverlo a crear y ponerle dentro la shellcode que será usada
para la ejecución del gusano. Para concluir se crea el acceso directo que acompaña los
ficheros en el USB, veamos como

En la imagen podemos ver como se conforma el nombre del acceso directo con los datos
recogidos anteriormente del dispositivo extraíble, en caso de no haberlos podido obtener
antes crea un nombre genérico “My Removable Device.lnk”, en caso contrario lo crea de la
forma "%s (%I64uGB).lnk" y ambos con el destino marcado: "~$W%s.FAT32,_ldr@16
desktop.ini RET TLS """, finalmente llama a una función que se encarga de crear el acceso
directo como tal valiéndose de objetos COM (CoCreateInstance).

Para terminar el malware acaba creando la ventana que usara para instalar su filtro de
mensajes del sistema (CreateWindowEx), usando como ClassName y WindowName la cadena
“abc”, luego de esto se queda en el loop de mensajes

(GetMessage/TranslateMessage/DispatchMessage).

WNDPROC (Filtro USB)

El procedimiento de ventana que habíamos visto que se pasaba a RegisterClass


anteriormente, lo que hace es establecer un filtro haciendo que la ventana reciba los
mensajes del SO WM_DEVICECHANGE y monitoree los eventos DBT_DEVICEARRIVAL y
DBT_DEVICEREMOVECOMPLETE

P á g i n a 22 | 24
CRACKSLATINOS | Análisis del gusano BUNDPIL

Con esto garantiza que cada vez que un dispositivo extraíble sea insertado o retirado al
gusano es notificado de ello y puede tomar las acciones de contaminación que ya vimos. Esta
vez acepta tanto DRIVE_REMOVABLE como DRIVE_FIXED, en caso de alguno de los anteriores
empieza borrando cualquier “autorun.inf” que se encuentre en la raíz del dispositivo para
quitar cualquier otro malware que utilice esta técnica para iniciarse y asegurarse que el
extraíble es solo suyo. Luego ya continua con las dos funciones que vimos más arriba
“PrepareUSB” y “CopyToUSB” para garantizar la contaminación a dispositivos extraíbles,
termina despues haciendo una llamada a RegisterDeviceNotification para mantenerse
recibiendo las notificaciones de los dispositivos y asi concluye.

Hilo 2

El hilo numero dos se basa en enumerar los valores contenidos en la ruta


“HKEY_LOCAL_MACHINE\ software\microsoft” y una vez obtenido el buffer de cada llave
obtenida, los cuales deben contener rutas a librerías DLL descargadas por el mismo gusano,
utiliza LoadLibrary para cargarlas en memoria y con GetProcAddress busca el inicio de una
función dentro de las DLL las cuales ejecuta unas líneas mas abajo.

Hilo 3 - Downloader

El hilo número tres realiza básicamente las funciones de un downloader. Se conecta a las
webs especificadas y hace peticiones POST/GET, veamos

Ahí está el listado de páginas a las cuales el gusano hace peticiones para continuar
descargando, ejecutando malware (librerías y ejecutables) y/o para mantenerse actualizado
a sí mismo.

http://xdqzpbcgrvkj.ru/in.php
http://anam0rph.su/in.php
http://orzdwjtvmein.in/in.php
http://ygiudewsqhct.in/in.php
http://bdcrqgonzmwuehky.nl/in.php
http://somicrososoft.ru/in.php

P á g i n a 23 | 24
CRACKSLATINOS | Análisis del gusano BUNDPIL

El hilo tres se continuara creando una y otra vez cada 10 segundos, garantizando que las
descargas se mantengan activas en todo momento.

Conclusiones

Hasta aqui ha llegado el analisis de este gusano. Como dije al principio de esta serie, hemos
visto un malware a mi juicio muy bien hecho, empezando por sus capas de proteccion, su
metodo de ejecucion, sus metodos de infeccion y propagacion, su codigo bien pensado y
estructurado, ademas de todas las funcionalidades que se le implementaron, debido a esto,
ademas, me atreveria a decir que el malware pudo haber sido obra de varios autores.

Conclusiones Finales

Espero que hayas disfrutado leyendo esta serie de articulos como yo he disfrutado
escribiendolos y compartiendolos con ustedes, aqui ademas les dejo los ficheros del malware
para aquel que desee echarles un vistazo por su cuenta, recuerden que se trata de una
muestra de virus totalmente funcional, por lo que recuerda tomar las precauciones necesarias
al manipular dicha muestra. El compactado esta protegido por la contraseña "malware" (sin
comillas).

Bueno, ya saben, nos vemos en otra....quien sabe ;) ...

P á g i n a 24 | 24