lunes, 19 de octubre de 2009

Análisis simple de un troyano (también simple)

El fin de semana coloqué mi pendrive en mi PC y encontré dos archivos sospechosos en el raíz:

strongkey-rc1.3-build-208.exe (48640 Bytes)
autorun.inf (177 Bytes)

Llamaron rápidamente mi atención ya que acostumbro a guardar mis archivos en directorios y no suelo usar ejecutables del tipo .exe porque uso Ubuntu en mis computadoras.

Recordé que días atrás había prestado el pendrive a un usuario que usa Window$ XP. No necesitaba ser Sherlock Holmes ni un especialista en seguridad para deducir que estaba frente a un troyano o algún otro engendro informático.

Lo primero que hice es buscar en Google para saber si ya alguien había reportado algo sobre este archivo ejecutable. Bien, según el sitio Zona Virus no era más que una variante del troyano Buzus y que había invadido el área informática de sanidad en España, principalmente en Madrid en los primeros meses del 2009.

Como estaba en lo cierto, aproveché a pegarle un vistazo al pequeño monstruo y ver de que se trataba.

Dividí este pequeño análisis en dos partes:
  • Análisis estático: Consiste en analizar el código binario del archivo ejecutable sin ejecutarlo.
  • Análisis dinámico: Implica ejecutar el código para estudiar el comportamiento en el sistema donde es ejecutado, incluyendo su interacción con otros sistemas (locales o remotos)
¡Cuidado!: Hay que tener ciertas precauciones antes de decidirse a estudiar código malicioso. Ambos análisis requieren de un ambiente controlado y aislado, de modo que la ejecución del código (deliverada o no) no infecte sistemas en producción.


1) Análisis estático

El análisis estático lo llevé a cabo desde una PC con Ubuntu 9.10. Es de suponer que el troyano sólo afecta a sistemas operativos del tipo Microsoft Windows, así que puedo copiar los dos archivos sospechosos a un directorio en mi computadora para realizar este análisis sin temor a infectarla.

Hecho esto, vamos a calcular el hash MD5 de ambos archivos. El hash consiste en un cálculo criptográfico del contenido del archivo. Podemos imaginarlo como una especie de "huella dactilar" que identifica unívocamente a cada archivo. Este valor es muy útil para compararlo con el hash de otros archivos sospechosos. Dos archivos con el mismo hash implica que tienen el mismo contenido en su interior, independientemente de su nombre o extensión.

Dentro del directorio donde almacené los dos archivos, el cálculo del hash MD5 se realiza de la siguiente manera:

Para el archivo autorun.inf:

$ md5sum autorun.inf
bf87d7cc3d5675ee9aa05ac45b6474ca autorun.inf

Para el archivo strongkey-rc1.3-build-208.exe:

$ md5sum strongkey-rc1.3-build-208.exe
c5cc7291d72adfc96a489fc93d35a0cd strongkey-rc1.3-build-208.exe

La cadena que nos devuelve el comando md5sum, a la izquierda del nombre del archivo es el famoso hash.

Ahora, procedemos al análisis de cada archivo.


a) Archivo autorun.inf

El archivo autorun.inf permite la ejecución de una determinada acción al momento que el sistema operativo detecta que se ha insertado un medio extraíble, como un CD, DVD o una memoria flash.

Si editamos el autorun.inf vemos:

[autorun]
shellexecute=strongkey-rc1.3-build-208.exe
action=Open folder to view files
shell\default=Open
shell\default\command=strongkey-rc1.3-build-208.exe
shell=default

Se observa que es un típico script de auto arranque de Microsoft Windows. Al insertar el dispositivo infectado (en nuestro caso, el pendrive) el sistema operativo ejecutará el archivo strongkey-rc1.3-build-208.exe.

Un análisis detallado de cada una de las opciones de un archivo autorun.inf pueden encontrarla en el sitio de Microsoft Developer Network.

Al menos sabemos que este troyano se instala al insertar un dispositivo extraíble con los archivos autorun.inf y strongkey-rc1.3-build-208.exe en el raíz de dicho dispositivo.

Como corolario, debemos aprender que en sistemas operativos de Microsoft Windows debería estar deshabilitada la opción AutoRun para que este tipo de archivos maliciosos no nos afecten. Para aprender como deshabilitar dicha opción, también podemos consultar el sitio de Microsoft Developer Network.


b) strongkey-rc1.3-build-208.exe

El análisis de este archivo es un poco más interesante, ya que es el que tiene la carga explosiva. No vamos a realizar un análisis exhaustivo, solamente usaremos algunas herramientas disponibles en GNU/Linux para escudriñar en el código.


b.1) Identificación del tipo de archivo

La primera herramienta que vamos a usar es el comando file que permite obtener información acerca del tipo de datos que contiene un archivo.

$ file strongkey-rc1.3-build-208.exe

strongkey-rc1.3-build-208.exe: PE32 executable for MS Windows (GUI) Intel 80386 32-bit

Bueno, no hemos hecho más que confirmar que el archivo es un ejecutable de Microsoft Windows.


b.2) Búsqueda de cadenas de texto en el código

La otra herramienta es el comando string que viene con el paquete build-essential en las distribuciones GNU/Linux basadas en Debian. Este comando nos mostrará todas las cadenas de texto que existen en el interior del código.

$ strings strongkey-rc1.3-build-208.exe | more

Aquí la cosa se pone más interesante. Entre las tantas cadenas de texto encontradas, estas son las más significativas que encontré:

ExitProcess
lstrcatA
GetModuleHandleA
GetProcAddress
OpenProcess
GlobalAlloc
KERNEL32.dll
calloc
memset
strlen
free
strcat
strcpy
_except_handler3
MSVCRT.dll
_exit
_XcptFilter
exit
_acmdln
__getmainargs
_initterm
__setusermatherr
_adjust_fdiv
__p__commode
__p__fmode
__set_app_type
_controlfp
RegCloseKey
RegQueryValueExA
RegOpenKeyA
ADVAPI32.dll
GetStartupInfoA

En negrita remarqué los nombres de tres bibliotecas de enlaces dinámicos (Dynamic Link Library o DLL) que al parecer el troyano utiliza para llamar a funciones predifinidas del sistema.

KERNEL32.dll: Contiene funciones para el manejo de memoria e interrupciones y de operaciones de entrada/salida. Cuando se inicia Windows, carga la biblioteca en un espacio de memoria protegida.

Las funciones de KERNEL32.dll que este troyano parece utilizar, según se visualiza en la salida del comando strings, son:

GetModuleHandleA
GetProcAddress
OpenProcess
GlobalAlloc
GetStartupInfoA


ADVAPI32.dll:
Es una biblioteca que contiene funciones avanzadas de seguridad y de manejo del registro de Microsoft Windows.

Las funciones que al parecer se utilizan son:

RegCloseKey
RegQueryValueExA
RegOpenKeyA

Las mismas permiten cerrar, consultar y abrir entradas en el registro de Microsoft Windows. Por lo tanto, esto indicaría que el troyano tiene acceso a la registry y podría modificarla.

MSVCRT.dll: Esta biblioteca contiene funciones usadas para correr programas escritos en Microsoft Visual C++.

calloc
memset
strlen
free
strcat
strcpy
_except_handler3

Podemos sospechar entonces que el troyano fue escrito en Visual C++.

b.3) Escaneo local de virus

Vamos a revisar el archivo con un antivirus instalado en la PC donde tenemos el archivo almacenado. En mi caso, desde Ubuntu utilizo ClamAV.

# clamscan strongkey-rc1.3-build-208.exe

strongkey-rc1.3-build-208.exe: Trojan.Agent-118608 FOUND

----------- SCAN SUMMARY -----------
Known viruses: 628264
Engine version: 0.95.2
Scanned directories: 0
Scanned files: 1
Infected files: 1
Data scanned: 0.04 MB
Data read: 0.04 MB (ratio 1.00:1)
Time: 2.488 sec (0 m 2 s)
----------------------------------

Vemos que ClamAV identifica al troyano como Trojan.Agent-118608.


b.4) Escaneo de virus usando servicios vía Web

Si bien ya tenemos identificado el troyano por ClamAV, es muy útil subir el archivo bajo estudio a alguno de los sitios públicos en Internet que prestan el servicio de escaneo de virus. Generalmente, dichos sitios usan varios antivirus para el escaneo y ofrecen informes muy completos del espécimen.

Uno de estos sitios es Virus Total:

Al subir el archivo strongkey-rc1.3-build-208.exe, y luego de unos segundos, obtuve la siguiente respuesta:


Como observamos, alguien me ha ganado de mano y alguien ya ha subido un archivo con el mismo hash MD5 el día 14 de junio de 2009.

Haciendo click en el botón "Ver informe anterior" podemos ver el informe de lo que se encontró. Uds. también pueden verlo en este enlace.

El informe es bastante detallado y, sobre todo, extenso como para agregarlo en este blog. Así que les pido que miren ese enlace.



En la primera sección del informe vemos un encabezado que nos habla del análisis del archivo dllcache-exe.txt. Noten que no es el mismo nombre que el que subimos. Con ese nombre han registrado previamente al archivo donde se encuentra el troyano.

Luego sigue una serie de nombres con que se conoce a dicho troyano, según distintos antivirus. Así por ejemplo, para AVG es el BackDoor.Generic11.UTM y figura en su base de datos de firmas desde el 27 de julio de 2009. En cambio McAfee lo denomina BackDoor-DOQ.gen.e y está en sus firmas desde la misma fecha que el AVG.

Luego sigue una sección con información adicional donde figura el tamaño del archivo en bytes y el hash MD5 que, como ya vimos, es igual al que calculé al principio. También hay otros hash calculados pero por otros métodos como SHA1 y SHA256 que no he usado aquí por el solo hecho de no llenar de información esta entrada.

Finalmente se muestran las salidas de una serie de herramientas que corren bajo Windows para el estudio de archivos ejecutables como PEInfo, TrID o PEiD (entre otras). Son freeware y corren sólo en Windows. Como el análisis estático lo realicé sobre Linux descarté el uso de las mismas (aunque pueden correr con Wine) pero son muy recomendables.

Por ejemplo, en el reporte de Virus Total podemos ver la información que ofrece PEInfo:

PEInfo: PE Structure information

( base data )
entrypointaddress.: 0x2EA6
timedatestamp.....: 0x4A3570D0 (Sun Jun 14 23:51:12 2009)
machinetype.......: 0x14C (Intel I386)

( 4 sections )
name viradd virsiz rawdsiz ntrpy md5
.text 0x1000 0x202C 0x2200 5.79 1e268a5ceadedcc8d0b79bfa2af2f7f4
.rdata 0x4000 0x316 0x400 3.88 010662858fc64ef80a3d482194d7f509
.data 0x5000 0x3D0 0x400 5.29 97c886537dbe96f514ecfe19c2c13a50
.tls 0x6000 0x0 0x9000 7.99 59484c1385d17bfdb85e856e88825614

( 3 imports )

> advapi32.dll: RegCloseKey, RegOpenKeyA, RegQueryValueExA > kernel32.dll: GetProcAddress, GetModuleHandleA, lstrcatA, GlobalAlloc, OpenProcess, ExitProcess, GetStartupInfoA > msvcrt.dll: strcpy, _except_handler3, _exit, _XcptFilter, strcat, _acmdln, __getmainargs, _initterm, __setusermatherr, _adjust_fdiv, __p__commode, __p__fmode, __set_app_type, _controlfp, free, strlen, memset, calloc, exit

( 0 exports )

Si se fijan, en el reporte aparecen las bibliotecas que utiliza el troyano (que habíamos descubierto con el comando strings) y las funciones que utiliza de estas (que las conocimos hurgando en Internet). Como verán, no estuvo tan mal mi método como primera aproximación.

Otros sitios interesantes para escanear en línea son ThreatExpert y VirusScan.org. En el caso del primero, el archivo no figuraba en la base de datos así que recibí un mail con un agradecimiento y un informe adjunto de lo que se encontró. Dicho informe puede visualizarse en este enlace. Pueden ver el informe de VirusScan.org desde este otro enlace.


2) Análisis dinámico

Esta es la parte más interesante del asunto pero, la más peligrosa ya que debemos infectar una computadora con el troyano. Como ya comenté, necesitamos trabajar en un entorno aislado de manera que no afecte nuestro proceder con otros sistemas (propios o agenos).

Para ello, usé una máquina virtual corriendo Windows XP Service Pack 2 (no tenía uno más actualizado). Como plataforma de virtualización usé VirtualBox, corriendo desde mi PC con Ubuntu.

A la máquina virtual le asigné 4 GB de disco rígido, 256 MB de memoria, 1 procesador... nada especial. Sin embargo, para garantizar su aislamiento, tuve la precausión de inhabilitar todos los adaptadores de red.

También configuré un directorio compartido entre la máquina anfitrión y la virtual de manera de poder pasar archivos entre ellas. Pero, para que esto funcione, hay que instalar en la virtual el paquete Guest Additions for Windows. El directorio compartido es visible por la máquina virtual aún sin ningún adaptador de red habilitado. En dicho directorio coloqué el archivo strongkey-rc1.3-build-208.exe que contiene el troyano y algunas herramientas que nombraré a continuación.


2.1) Algunos ingredientes necesarios

Dentro de la máquina virtual necesité las siguientes herramientas:

a) RegShot: Permite tomar el estado del registro de Windows, compararlo con otro estado previo y mostrar las diferencias.

b) TCPView: Muestra las conexiones UDP y TCP de manera bastante más detallada que el comando netstat de Windows.

El primero es distribuido bajo GPL mientras que TCPView es privativp (pero freeware).

Ninguna de estas utilidades requiere instalación, así que las coloqué en el directorio compartido ya nombrado y desde allí las ejecuté.

TCPView forma parte de un conjunto de herramientas para sistemas operativos Microsoft Windows conocido como Sysinternals Suite. Aquellos que les interese jugar al forense (como a mí) o administran sistemas en Windows les recomiendo que prueben estas utilidades.

En la máquina anfitrión va a ser necesario un analizador de protocolos o sniffer. En mi caso, usé Wireshark.

Una vez todo dispuesto es necesario guardar una instantánea del estado de la máquina virtual antes de infectarla. De este modo, es posible volver a dicho estado y empezar de nuevo con una máquina "limpia".


2.2) La previa

2.2.1) Regshot
Ejecuté regshot desde el directorio compartido. Primeramente lo configuré en nuestro idioma seleccionando el desplegable correspondiente.

Teniendo ya configurado la aplicación en español tomé una "fotografía" del estado del registro de Windows, previo a la infección con el troyano. Simplemente pulsando el botón
1er. Foto y luego en Foto + guardar...


Elegimos un nombre y un lugar donde guardar el estado actual del registro.

2.2.3) TCPView
Sin cerrar la ventana de regshot ejecuto TCPView en la máquina virtual, desde la carpeta compartida donde lo guardé. Si es la primera vez que lo ejecutamos, vamos a tener que aceptar los términos de la licencia:


Luego, sin la ejecución de programas que realicen conexiones via TCP/IP, deberíamos ver algo como lo siguiente en el TCPView:

Vemos los procesos que están escuchando en distintos puertos TCP o UDP a la espera de alguna conexión.

2.2.4) Wireshark
En la máquina anfitrión abro Wireshark con permisos de root (ya que me lo exige en Ubuntu para levantar la interface de red en modo promiscuo).

Para evitar capturar tráfico que nada tiene que ver con la actividad de nuestro troyano (broadcast, ARP, etc) apliqué un filtro de captura de modo de tomar sólo el tráfico proveniente o que tenga con destino la dirección IP de la máquina virtual (192.168.1.100).


2.4) La inevitable infección
Bien, una vez cumplidos con todos estos preparativos ya me fue posible infectar la máquina virtual. Para ello, simplemente hice un doble click sobre el archivo en estudio.

Desde el punto de vista de un usuario normal, nada sospechoso ocurre. Pero en la ventana de captura de Wireshark empiezan a aparecer paquetes que muestran actividad de red que nadie ha demandado. En a ventana de TCPView aparecen innumerables intentos de conexiones a distintas direcciones IP, como se observa a continuación:



Luego de unos minutos, volvemos a la ventana de regshot que dejamos abierta en la máquina virtual y pulsamos sobre el botón 2da. Foto y luego en Foto + guardar para tomar una imágen del registro de Windows posterior a la infección.


Finalmente, pulsamos el botón Comparar para descubrir que es lo que cambió en el registro de Windows desde la infección:

Esto nos genera un archivo de texto que guardé en la carpeta compartida.


2.5) Análisis de los cambios en el registro de Windows

Si abrimos el archivo generado por el regshot vamos a ver que al infectar la máquina virtual el troyano ha agregado un número considerable de claves al registro de Windows. Es bastante complejo realizar un análisis completo de estos cambios y no es mi idea llevarlo a cabo. Símplemente, vamos a mostrar lo que creo más relevante.

a) Para ejecutarse cuando se inicia el sistema, el troyano agrega la siguiente clave:

HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\netmon: "C:\WINDOWS\system\dllcache.exe"

b) El troyano ha agregado claves en el registro para que se ejecute un proceso llamado dllcache cuando la máquina infectada intente arrancar en Modo seguro o Modo a prueba de fallas.

HKLM\SYSTEM\ControlSet001\Control\SafeBoot\Minimal\dllcache
HKLM\SYSTEM\ControlSet001\Control\SafeBoot\Network\dllcache
[...]
HKLM\SYSTEM\CurrentControlSet\Control\SafeBoot\Minimal\dllcache
HKLM\SYSTEM\CurrentControlSet\Control\SafeBoot\Network\dllcache
[...]
HKLM\SYSTEM\ControlSet001\Control\SafeBoot\Minimal\dllcache\: "Service"
HKLM\SYSTEM\ControlSet001\Control\SafeBoot\Network\dllcache\: "Service"
[...]
HKLM\SYSTEM\CurrentControlSet\Control\SafeBoot\Minimal\dllcache\: "Service"
HKLM\SYSTEM\CurrentControlSet\Control\SafeBoot\Network\dllcache\: "Service"

c) Autoriza a la aplicación dllcache.exe traspasar al firewall de Windows si este está activo:

HKLM\SYSTEM\ControlSet001\Services\SharedAccess\Parameters\FirewallPolicy\StandardProfile\AuthorizedApplications\List\C:\WINDOWS\system\dllcache.exe: "C:\WINDOWS\system\dllcache.exe:*:Microsoft Enabled"
[...]
HKLM\SYSTEM\CurrentControlSet\Services\SharedAccess\Parameters\FirewallPolicy\StandardProfile\AuthorizedApplications\List\C:\WINDOWS\system\dllcache.exe: "C:\WINDOWS\system\dllcache.exe:*:Microsoft Enabled"

d) El troyano registra el archivo sysdrv32.sys, ubicado en C:\WINDOWS\system32\drivers\, como un manejador de un supuesto dispositivo de Entrada/Salida. Este inicia un servicio llamado "Play Port I/O Driver", tanto en el arranque en Modo seguro como en Modo normal:

HKLM\SYSTEM\ControlSet001\Enum\Root\LEGACY_SYSDRV32\0000\Control\*NewlyCreated*: 0x00000000
HKLM\SYSTEM\ControlSet001\Enum\Root\LEGACY_SYSDRV32\0000\Control\ActiveService: "sysdrv32"
HKLM\SYSTEM\ControlSet001\Enum\Root\LEGACY_SYSDRV32\0000\Service: "sysdrv32"
HKLM\SYSTEM\ControlSet001\Enum\Root\LEGACY_SYSDRV32\0000\Legacy: 0x00000001
HKLM\SYSTEM\ControlSet001\Enum\Root\LEGACY_SYSDRV32\0000\ConfigFlags: 0x00000000
HKLM\SYSTEM\ControlSet001\Enum\Root\LEGACY_SYSDRV32\0000\Class: "LegacyDriver"
HKLM\SYSTEM\ControlSet001\Enum\Root\LEGACY_SYSDRV32\0000\ClassGUID: "{8ECC055D-047F-11D1-A537-0000F8753ED1}"
HKLM\SYSTEM\ControlSet001\Enum\Root\LEGACY_SYSDRV32\0000\DeviceDesc: "Play Port I/O Driver"
HKLM\SYSTEM\ControlSet001\Enum\Root\LEGACY_SYSDRV32\NextInstance: 0x00000001
[...]
HKLM\SYSTEM\ControlSet001\Services\sysdrv32\Type: 0x00000001
HKLM\SYSTEM\ControlSet001\Services\sysdrv32\Start: 0x00000003
HKLM\SYSTEM\ControlSet001\Services\sysdrv32\ErrorControl: 0x00000001
HKLM\SYSTEM\ControlSet001\Services\sysdrv32\ImagePath: "\??\C:\WINDOWS\system32\drivers\sysdrv32.sys"
HKLM\SYSTEM\ControlSet001\Services\sysdrv32\DisplayName: "Play Port I/O Driver"
HKLM\SYSTEM\ControlSet001\Services\sysdrv32\Group: "SST wanport drivers"
HKLM\SYSTEM\ControlSet001\Services\sysdrv32\Enum\0: "Root\LEGACY_SYSDRV32\0000"
HKLM\SYSTEM\ControlSet001\Services\sysdrv32\Enum\Count: 0x00000001
HKLM\SYSTEM\ControlSet001\Services\sysdrv32\Enum\NextInstance: 0x00000001
HKLM\SYSTEM\ControlSet001\Services\sysdrv32\Security\Security: 01 00 14 80 90 00 00 00 9C 00 00 00 14 00 00 00 30 00 00 00 02 00 1C 00 01 00 00 00 02 80 14 00 FF 01 0F 00 01 01 00 00 00 00 00 01 00 00 00 00 02 00 60 00 04 00 00 00 00 00 14 00 FD 01 02 00 01 01 00 00 00 00 00 05 12 00 00 00 00 00 18 00 FF 01 0F 00 01 02 00 00 00 00 00 05 20 00 00 00 20 02 00 00 00 00 14 00 8D 01 02 00 01 01 00 00 00 00 00 05 0B 00 00 00 00 00 18 00 FD 01 02 00 01 02 00 00 00 00 00 05 20 00 00 00 23 02 00 00 01 01 00 00 00 00 00 05 12 00 00 00 01 01 00 00 00 00 00 05 12 00 00 00
[...]
HKLM\SYSTEM\CurrentControlSet\Enum\Root\LEGACY_SYSDRV32\0000\Control\*NewlyCreated*: 0x00000000
HKLM\SYSTEM\CurrentControlSet\Enum\Root\LEGACY_SYSDRV32\0000\Control\ActiveService: "sysdrv32"
HKLM\SYSTEM\CurrentControlSet\Enum\Root\LEGACY_SYSDRV32\0000\Service: "sysdrv32"
HKLM\SYSTEM\CurrentControlSet\Enum\Root\LEGACY_SYSDRV32\0000\Legacy: 0x00000001
HKLM\SYSTEM\CurrentControlSet\Enum\Root\LEGACY_SYSDRV32\0000\ConfigFlags: 0x00000000
HKLM\SYSTEM\CurrentControlSet\Enum\Root\LEGACY_SYSDRV32\0000\Class: "LegacyDriver"
HKLM\SYSTEM\CurrentControlSet\Enum\Root\LEGACY_SYSDRV32\0000\ClassGUID: "{8ECC055D-047F-11D1-A537-0000F8753ED1}"
HKLM\SYSTEM\CurrentControlSet\Enum\Root\LEGACY_SYSDRV32\0000\DeviceDesc: "Play Port I/O Driver"
HKLM\SYSTEM\CurrentControlSet\Enum\Root\LEGACY_SYSDRV32\NextInstance: 0x00000001
[...]
HKLM\SYSTEM\CurrentControlSet\Services\sysdrv32\Type: 0x00000001
HKLM\SYSTEM\CurrentControlSet\Services\sysdrv32\Start: 0x00000003
HKLM\SYSTEM\CurrentControlSet\Services\sysdrv32\ErrorControl: 0x00000001
HKLM\SYSTEM\CurrentControlSet\Services\sysdrv32\ImagePath: "\??\C:\WINDOWS\system32\drivers\sysdrv32.sys"
HKLM\SYSTEM\CurrentControlSet\Services\sysdrv32\DisplayName: "Play Port I/O Driver"
HKLM\SYSTEM\CurrentControlSet\Services\sysdrv32\Group: "SST wanport drivers"
HKLM\SYSTEM\CurrentControlSet\Services\sysdrv32\Enum\0: "Root\LEGACY_SYSDRV32\0000"
HKLM\SYSTEM\CurrentControlSet\Services\sysdrv32\Enum\Count: 0x00000001
HKLM\SYSTEM\CurrentControlSet\Services\sysdrv32\Enum\NextInstance: 0x00000001
HKLM\SYSTEM\CurrentControlSet\Services\sysdrv32\Security\Security: 01 00 14 80 90 00 00 00 9C 00 00 00 14 00 00 00 30 00 00 00 02 00 1C 00 01 00 00 00 02 80 14 00 FF 01 0F 00 01 01 00 00 00 00 00 01 00 00 00 00 02 00 60 00 04 00 00 00 00 00 14 00 FD 01 02 00 01 01 00 00 00 00 00 05 12 00 00 00 00 00 18 00 FF 01 0F 00 01 02 00 00 00 00 00 05 20 00 00 00 20 02 00 00 00 00 14 00 8D 01 02 00 01 01 00 00 00 00 00 05 0B 00 00 00 00 00 18 00 FD 01 02 00 01 02 00 00 00 00 00 05 20 00 00 00 23 02 00 00 01 01 00 00 00 00 00 05 12 00 00 00 01 01 00 00 00 00 00 05 12 00 00 00

Ante tanta evidencia, me vi tentado en dirigirme a C:\WINDOWS\system para buscar el archivo dllcache.exe. Sin embargo, no existía dicho ejecutable ni estaba como archivo oculto.

Algo similar ocurría con el supuesto manejador sysdrv32.sys en C:\WINDOWS\system32\drivers.

Desde la ventana de TCPView seguía viendo actividad de red generada por un proceso inexistente. Haciendo click con el botón derecho sobre cualquiera de estas y seleccionando Process Propierties vemos lo siguiente:


Nuevamente, aparece el misterioso C:\WINDOWS\system\dllcache.exe que no es visible a simple vista.

Para sacarme la duda, reinicié la máquina virtual desde un CD con Knoppix. Monté el disco virtual como sólo lectura y me dirigí a /media/hda1/WINDOWS/system y ahí estaba:


Por lo tanto, no estaba loco y con lo cual me quedaba un poco más tranquilo.

Calculando el hash MD5 de dllcache.exe obtuve:

$ md5sum /media/hda1/WINDOWS/system/dllcache.exe
c5cc7291d72adfc96a489fc93d35a0cd /media/hda1/WINDOWS/system/dllcache.exe

que es idéntico al hash calculado para el archivo strongkey-rc1.3-build-208.exe, desde donde infecté a la máquina virtual. Luego, ambos archivos son iguales.

Podemos deducir que el troyano una vez ejecutado se copia en C:\WINDOWS\system\ bajo el nombre dllcache.exe.

Siempre desde Knoppix, cambié a /media/hda1/WINDOWS/system32/drivers para ver si estaba el archivo sysdrv32.sys. Por supuesto, ahí estaba:

Calculé el hash MD5 de dicho archivo:

$ md5sum /media/hda1/WINDOWS/system32/drivers/mediarsysdrv32.sys
0e219b74e2c68a34ca09d8fe114f6d11 /media/hda1/WINDOWS/system32/drivers/sysdrv32.sys

Noten que el hash es distindo al de dllcache.dll, por lo que es distinto a este archivo. Por supuesto, el tamaño es distinto: sysdrv32.sys ocupa 11656 bytes, mientras que dllcache.exe ocupa 48640 bytes.

Adelantándome un poco, el troyano en ningún momento fue capás de bajar ningún archivo de Internet. Como no existe la generación expontánea o autogénesis entre bits y bytes, el archivo sysdrv32.sys no puede provenir de otro lado que de dllcache.exe, la imágen exacta de strongkey-rc1.3-build-208.exe desde donde infecté a la máquina virtual.

Seguidamente obtuve una copia desde Knoppix de sysdrv32.sys para poder realizar un análisis estático del mismo.

No voy a repetir aquí todo este análisis para no aburrilos. Lo ciertoes que en la búsqueda de cadenas de textos obtuve las siguientes interesantes:

[...]
tcpip.sys
tcpip.sys
[...]
RSDS
gz54
b:\driver_new\i386\tcpz-x86.pdb
IoDeleteDevice
IoDeleteSymbolicLink
RtlInitUnicodeString
ExFreePoolWithTag
_stricmp
ExAllocatePoolWithTag
ZwQuerySystemInformation
RtlGetVersion
MmIsAddressValid
RtlQueryRegistryValues
KeDelayExecutionThread
IofCompleteRequest
PsCreateSystemThread
KeInitializeSpinLock
IoCreateSymbolicLink
IoCreateDevice
KeTickCount
KeBugCheckEx
ntoskrnl.exe
KfReleaseSpinLock
KfAcquireSpinLock
HAL.dll
[...]

Cuando revisé el archivo con ClamAV obtuve el siguietnte resultado:

$ clamscan sysdrv32.sys

sysdrv32.sys: Backdoor.Agent-10 FOUND

----------- SCAN SUMMARY -----------
Known viruses: 657374
Engine version: 0.95.3
Scanned directories: 0
Scanned files: 1
Infected files: 1
Data scanned: 0.01 MB
Data read: 0.01 MB (ratio 1.00:1)
Time: 2.692 sec (0 m 2 s)

Al subir el archivo a TheaterExpert obtuve el siguiente reporte donde se hace hincapié en que (entre otras cosas) tiene funcionalidades de rootkit de modo tal que puede esconderse por sí mismo en el sistema de archivos.

No queda claro, pero tal vez, nuestro troyano use las funcionalidades de esta parte de código también para ocultar al archivo dllcache.exe. Tal vez, algún lector que entienda más de rootkits en Windows me lo pueda aclarar.


2.6) Análisis de conexiones de red

He capturado unos cuantos minutos con Wireshark de la actividad de red que se regiustraba cuando el troyano estaba ejecutándose. Con TCPView se puso de manifiesto que el troyano intenta realizar numerosas conexiones de red desde un proceso que terminó siendo dllcache.exe.


a) Apertura del puerto TCP 8073 en la máquina infectada

En la PC infectada el troyano mantiene abierto el puerto TCP 8073 (dicho puerto es aleatorio) a la espera de conexiones desde otros hosts remotos.

Esto queda evidenciado desde la ventana de TCPView que ya hemos mostrado anteriormente.

Si desde un navegador intentamos ingresar a ese puerto, por ejemplo, desde la máquina anfitrión obtenemos un archivo con nombre aleatorio que no es más que una copia del troyano.

Por ejemplo:

$ wget http://192.168.1.100:8073 -O XXX.exe

Si calculo el hash MD5 del archivo XXX.exe obtenido:

$ md5sum XXX.exe
c5cc7291d72adfc96a489fc93d35a0cd XXX.exe

¡Qué es el mismo que el hash del archivo strongkey-rc1.3-build-208.exe y de dllcache.exe!

Como conclusión, y aunque sea bastante idiota, uno de los métodos de propagación es mediante un puerto aleatorio que se abre en la PC infectada.


b) Conexión al dominio ninjawarlord.com por el puerto TCP 4545

El troyano intenta resolver el dominio ninjaworlord.com usando el DNS configurado en la máquina infectada. Dicho dominio existía y fué resuelto como 75.150.126.241.

Luego, el troyano intenta conectarse a dicha dirección IP por el puerto TCP 4545. Haciendo un Follow TCP Stream en Wireshark obtenemos la siguiente conversación entre la máquina infectada y el host remoto:

Si se fijan bien, no es más que un diálogo IRC pero sobre el puerto 4545. Para identificarse en el host remoto usa los siguientes parámetros:

PASS h4xg4ng
NICK [00-ESP-XP-3713960]
USER SP2-ixo * 0 :DESKTOP

Finalmente, ingresa en la sala #ninjas:

JOIN :#ninjas

La idea de este backdoor que abre el troyano es la de poder recibir comandos en forma remota por medio de esta conexión IRC.

Sin embargo, he estado a la espera de algún comado remoto durante varios dias sin éxito. Lo único que se traficó por este puerto fueron comandos IRC del tipo PING y PONG entre el host remoto y la máquina infectada.

El dominio ninjawarlord.com tiene dos direcciones IP a las que responde. Esto lo verifiqué con dig desde la máquina anfitrión:

$ dig ninjawarlord.com
[...]
;; QUESTION SECTION:
;ninjawarlord.com. IN A

;; ANSWER SECTION:
ninjawarlord.com. 794 IN A 207.210.112.124
ninjawarlord.com. 794 IN A 75.150.126.241


Verificando el reverso de cada IP obtuve:


dig -x 75.150.126.241
[...]
;; QUESTION SECTION:
;241.126.150.75.in-addr.arpa. IN PTR

;; ANSWER SECTION:
241.126.150.75.in-addr.arpa. 3600 IN PTR 75-150-126-241-NewEngland.hfc.comcastbusiness.net.

;; AUTHORITY SECTION:
150.75.in-addr.arpa. 59033 IN NS DNS101.COMCAST.net.
150.75.in-addr.arpa. 59033 IN NS DNS102.COMCAST.net.
150.75.in-addr.arpa. 59033 IN NS DNS103.COMCAST.net.

;; ADDITIONAL SECTION:
DNS101.COMCAST.net. 162431 IN A 68.87.64.204
DNS102.COMCAST.net. 162433 IN A 68.87.66.204
DNS103.COMCAST.net. 162433 IN A 68.87.66.204

$ dig -x 207.210.112.124
[...]
;; QUESTION SECTION:
;124.112.210.207.in-addr.arpa. IN PTR

;; ANSWER SECTION:
124.112.210.207.in-addr.arpa. 21600 IN PTR efbupdate.com.

;; AUTHORITY SECTION:
124.112.210.207.in-addr.arpa. 3600 IN NS ns2.vpsland.com.
124.112.210.207.in-addr.arpa. 3600 IN NS ns1.vpsland.com.

;; ADDITIONAL SECTION:
ns1.vpsland.com. 157633 IN A 207.210.113.180
ns2.vpsland.com. 157633 IN A 209.190.29.89


Desde el sitio Whois.Ename si hago un whois para dicho dominio:


Domain Name : ninjawarlord.com

Registrant Contact Information :
JOYCEWANG
HEBEI TAGNGUO LTD.
li_wangshang@yeah.net
JIANKANG, 300452
tel:
fax:

Administrative Contact Information :
JOYCEWANG
HEBEI TAGNGUO LTD.
li_wangshang@yeah.net
JIANKANG, 300452
tel:
fax:

Technical Contact Information :
JOYCEWANG
HEBEI TAGNGUO LTD.
li_wangshang@yeah.net
JIANKANG, 300452
tel:
fax:

Billing Contact Information :
JOYCEWANG
HEBEI TAGNGUO LTD.
li_wangshang@yeah.net
JIANKANG, 300452
tel:
fax:

Status :
clientDeleteProhibited
clientTransferProhibited

Domain Name Server :
ns1.dnsexit.com
ns2.dnsexit.com
ns3.dnsexit.com
ns4.dnsexit.com

Registration Date :2009-4-27
Expiration Date : 2010-4-27

Todo parecería demostrar que el dominio está a nombre de una empresa China (HEBEI TAGNGUO LTD), pero alojada en servidores en Inglaterra.


c) Intentos de conexión a hosts remotos por el puerto 445

El puerto TCP 445 es conocido como Microsoft-DS y es un servicio que utiliza Microsoft Windows 2000, 2003 y XP para compartir archivos e impresoras en una red, utilizando el protocolo SMB (Server Message Block) a través de TCP/IP, en lugar de utilizar NetBIOS.

Por ese puerto, el troyano intenta acceder a direcciones IP cercanas al rango de la red local de la máquina infectada.

En mi caso, la dirección IP de la máquina virtual infectada tenía una máscara 255.255.255.0. El troyano intentaba conectarse direcciones IP aleatorias de la subred 255.255.0.0. Lo llamativo es que el bicharraco provoca una inundación de paquetes TCP del tipo SYN a dichas direcciones.

A continuación vemos una captura desde Wireshark de estos intentos de conexión:


Investigando en Internet un poco, di con que este troyano intenta explotar una vulnerabilidad de este protocolo que permitiría copiar al troyano y ejecutarlo en hosts remotos por el puerto 445. Esta vulnerabilidad fue publicada en el boletín Microsoft MS08-067 del 23 de octubre de 2008.


2.7) Eliminación del troyano

La extirpación del enjendro requiere de la eliminación de los archivos dllcache.exe y sysdrv32.sys ya comentados y, por supuesto, de todas las claves del registro de Windows modificadas por el troyano.

Lo difícil es lo primero, ya que ambos archivos están ocultos para los ojos de los usuarios Windows. Pero hemos visto que con un LiveCD como Knoppix estos quedan en evidencia y podríamos eliminarlos del disco tranquilamente.

Una vez eliminados ambos archivos podríamos reiniciar desde Windows y borrar las claves del registro que han sido agregadas por el troyano. También, sería necesario verificar que tenemos instalada las últimas actualizaciones lanzadas por Microsoft para evitar que otra PC que aun se encuentre infectada transmita al troyano infección a través de la red usando la vulnerabilidad comentada.

2.8) Conclusiones

Hemos aprendido durante esta entrada que:
  • Es posible mantener un troyano, virus o software malicioso aislado y estudiar su comportamiento.
  • En este caso, hemos visto que las características descriptas por sitios especializados para el troyano en estudio es posible deducirlas mediante el uso de herramientas de código abierto y algunas privativas pero freeware.
  • Un LiveCD descente como Knoppix puede servirnos para desactivar un software malicioso y poder tomar control del sistema infectado.
Espero que haya sido del agrado de uds este artículo y quedo en espera de sus comentarios.

7 comentarios:

Toni dijo...

Instructivo y sencillo de realizar y comprender. Puede que se necesite invertir el mismo tiempo que en volcar una imagen "limpia" (si se tiene) al sistema ya infectado, pero tu explicación invita a experimentar, pensar y querer profundizar un poquito más. Gracias por el artículo.

Anónimo dijo...

Te admiro por tu trabajo

Anónimo dijo...

Aunque básicamente conocia todas las herramientas y procedimientos nunca me habia parado a organizarlos y explicarlos tan bien como lo has hecho. Me surge una duda respecto a porque si tienes virtualizado el Windows sobre un Ubuntu cargas un Knoppix para acceder al HDA virtual y no lo haces directamente desde UBUNTU...

Federico Ch. Tomasczik dijo...

Lo de Knoppix (o cualquier otro LiveCD) es sólo para "limpiar" un sistema real y concreto (no uno virtual)

Creo que es un mal entendido por mi mala redacción.

Javier A. dijo...

hola, muy interesante el análisis, me gusto esta genial. te aclaro que un rootkit efectivamente es una herramienta que sirve para ocultar la infección de virus, en realidad en si no es un virus pero si es algo que vulnera (si, mas aun) la seguridad en sistemas windows, algunos antivirus no reconocen las amenazas justamente por este tipo de herramientas, existen utilidades que se especializan en buscar específicamente la presencia de estos rootkit. espero que te sirva un poco la aclaración de esos engendros :) ( no se tanto como tu de informática pero si se que son los rootkit)

alchemist dijo...

Me gusto mucho este post es un gran trabajo
aprendi mucho acerca del tema..

muchas gracias por tu trabajo

Fabian dijo...

Muy bueno