Analisis de DLLs y Handles en Memoria: dlllist, handles y Deteccion de Inyeccion

Las DLLs como ventana al comportamiento del proceso

Las Dynamic Link Libraries (DLLs) son el mecanismo fundamental de Windows para compartir codigo entre procesos. Cada proceso carga docenas de DLLs: las del sistema operativo (kernel32.dll, ntdll.dll, user32.dll), las de frameworks (.NET, Visual C++ Runtime), y las especificas de la aplicacion.

Para un analista forense, las DLLs cargadas por un proceso revelan sus capacidades. Si un proceso notepad.exe tiene cargada ws2_32.dll (Winsock, la libreria de red), algo no cuadra porque el bloc de notas no necesita conectarse a la red. Si un proceso tiene cargada crypt32.dll sin razon aparente, puede estar cifrando datos.

Los handles, por su parte, muestran los recursos activos del proceso: ficheros abiertos, conexiones, mutexes y claves de registro que esta manipulando.

Plugin dlllist: DLLs cargadas por un proceso

vol -f memory.raw windows.dlllist

Para un proceso especifico:

vol -f memory.raw windows.dlllist --pid 4321

Salida tipica:

PID    Process      Base             Size     Name                 Path
4321   svchost.exe  0x7ff600000000   0x1c000  svchost.exe          C:\Windows\System32\svchost.exe
4321   svchost.exe  0x7ffb12340000   0x1f8000 ntdll.dll            C:\Windows\System32\ntdll.dll
4321   svchost.exe  0x7ffb10560000   0x110000 kernel32.dll         C:\Windows\System32\kernel32.dll
4321   svchost.exe  0x7ffb0f780000   0x2e0000 KERNELBASE.dll       C:\Windows\System32\KERNELBASE.dll
4321   svchost.exe  0x7ffb09120000   0x9e000  ws2_32.dll           C:\Windows\System32\ws2_32.dll
4321   svchost.exe  0x7ffb08340000   0x15000  wininet.dll          C:\Windows\System32\wininet.dll

La columna Path es critica. Cada DLL tiene una ubicacion esperada:

• DLLs del sistema: C:\Windows\System32\ o C:\Windows\SysWOW64\ (32 bits en 64 bits)
• DLLs de .NET: C:\Windows\Microsoft.NET\
• DLLs de aplicaciones: en la carpeta de la aplicacion

Una DLL con ruta en C:\Users\, C:\Temp\, o un directorio inusual es sospechosa.

Como funciona la carga de DLLs en Windows

Cuando un proceso llama a LoadLibrary o cuando el loader del sistema carga DLLs al iniciar el proceso, la DLL se registra en tres listas dentro del PEB (Process Environment Block):

1. InLoadOrderModuleList: orden en que se cargaron.
2. InMemoryOrderModuleList: orden por direccion de memoria.
3. InInitializationOrderModuleList: orden en que se inicializaron (DllMain llamado).

dlllist recorre InLoadOrderModuleList. Si un atacante desenlaza manualmente una DLL de esta lista (para ocultarla), dlllist no la mostrara. Pero la DLL sigue mapeada en memoria y su presencia puede detectarse con otros metodos.

Plugin ldrmodules: deteccion de DLLs desenlazadas

vol -f memory.raw windows.ldrmodules --pid 4321

ldrmodules cruza las tres listas del PEB con las regiones de memoria del proceso (VADs). Muestra tres columnas booleanas que indican si la DLL aparece en cada lista:

PID    Process      Base             InLoad  InInit  InMem   MappedPath
4321   svchost.exe  0x7ff600000000   True    False   True    \Windows\System32\svchost.exe
4321   svchost.exe  0x7ffb12340000   True    True    True    \Windows\System32\ntdll.dll
4321   svchost.exe  0x7ffb10560000   True    True    True    \Windows\System32\kernel32.dll
4321   svchost.exe  0x000001234000   False   False   False   -

Interpretacion:

• True/True/True: DLL cargada normalmente. Esperado.
• True/False/True: el ejecutable principal del proceso. InInit es False porque el propio EXE no tiene DllMain. Normal.
• False/False/False con MappedPath vacio: una region de memoria mapeada que no aparece en ninguna lista del PEB. Si contiene una cabecera PE, es una DLL cargada de forma no estandar (reflective loading o inyeccion manual).

Las entradas con False en InLoad son las mas interesantes forense. Pueden ser:

• DLLs inyectadas por malware.
• DLLs desenlazadas intencionalmente de las listas del PEB.
• Regiones de memoria mapeadas que contienen codigo ejecutable.

Handles: los recursos que usa un proceso

vol -f memory.raw windows.handles --pid 4321

Para filtrar por tipo de handle:

vol -f memory.raw windows.handles --pid 4321 --object-type File
vol -f memory.raw windows.handles --pid 4321 --object-type Mutant
vol -f memory.raw windows.handles --pid 4321 --object-type Key
vol -f memory.raw windows.handles --pid 4321 --object-type Process

Handles de tipo File

Los ficheros abiertos por un proceso revelan que datos esta leyendo, escribiendo o exfiltrando:

Offset        PID    Process      Type    HandleValue  Name
0xfa800...    4321   malware.exe  File    0x1c4        \Device\HarddiskVolume2\Users\Admin\Documents\passwords.xlsx
0xfa800...    4321   malware.exe  File    0x1c8        \Device\HarddiskVolume2\Users\Admin\Desktop\output.zip

Un proceso accediendo a ficheros de credenciales, bases de datos, o creando archivos ZIP en el escritorio es sospechoso.

Handles de tipo Mutant (Mutex)

Los mutexes son mecanismos de sincronizacion que muchas familias de malware usan como "marcador" para evitar ejecutarse dos veces en el mismo sistema. Cada familia suele tener un mutex especifico y conocido:

Offset        PID    Process      Type     HandleValue  Name
0xfa800...    4321   svchost.exe  Mutant   0x1d0        \Sessions\1\BaseNamedObjects\{A8B9C0D1-E2F3-4567-8901-ABCDEF012345}

Las bases de datos de IOCs de familias de malware incluyen nombres de mutex. MalwareBazaar, MITRE ATT&CK y los reportes de amenazas documentan estos valores. Un mutex conocido en un proceso es evidencia directa.

Handles de tipo Key (Registro)

Las claves de registro que un proceso tiene abiertas indican donde esta leyendo configuracion o donde ha establecido persistencia:

Offset        PID    Process      Type  HandleValue  Name
0xfa800...    4321   svchost.exe  Key   0x1e0        \REGISTRY\MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run

Un proceso sospechoso con un handle abierto a CurrentVersion\Run probablemente esta configurando persistencia.

Handles de tipo Process

Si un proceso tiene handles a otros procesos, puede estar preparandose para inyectar codigo, leer memoria de otros procesos, o manipular procesos del sistema:

Offset        PID    Process      Type     HandleValue  Name
0xfa800...    4321   malware.exe  Process  0x1f0        explorer.exe Pid 3100
0xfa800...    4321   malware.exe  Process  0x1f4        lsass.exe Pid 700

Un proceso desconocido con handle a lsass.exe es una senal critica: puede estar volcando credenciales (al estilo Mimikatz).

Tecnicas de inyeccion de DLLs

Classic DLL Injection

El atacante usa OpenProcess para obtener un handle al proceso victima, VirtualAllocEx para reservar memoria en el proceso remoto, WriteProcessMemory para copiar la ruta de la DLL maliciosa, y CreateRemoteThread para ejecutar LoadLibrary en el proceso victima.

En memoria, la DLL inyectada aparece normalmente en dlllist porque fue cargada con LoadLibrary (aunque en el contexto del proceso victima). La anomalia es que la ruta de la DLL no corresponde a una ubicacion esperada.

Reflective DLL Injection

La DLL se carga manualmente en memoria sin usar LoadLibrary. El codigo de carga (reflective loader) esta integrado en la propia DLL, que se mapea, resuelve sus imports y ejecuta su DllMain sin intervencion del loader de Windows.

En memoria:

• La DLL NO aparece en dlllist ni en ldrmodules (las listas del PEB).
• La DLL SI aparece como una region de memoria con permisos RWX en los VADs.
• malfind la detectara como una region sospechosa con cabecera MZ.

Process Hollowing

El atacante crea un proceso legitimo en estado suspendido (por ejemplo svchost.exe), vacia su memoria (unmap de la imagen original), mapea el codigo malicioso en su lugar, ajusta el contexto del thread principal para apuntar al entry point malicioso, y reanuda el thread.

En memoria:

• pslist y pstree muestran un proceso con nombre legitimo.
• cmdline puede mostrar la ruta legitima.
• Pero el contenido real del proceso es diferente al ejecutable en disco.
• malfind detecta la discrepancia entre lo que hay en disco y lo que hay en memoria.

Para detectar process hollowing especificamente:

vol -f memory.raw windows.hollowfind

Este plugin (disponible en community3) compara las cabeceras PE del proceso en memoria con las del fichero en disco.

Deteccion de DLLs sospechosas: checklist

Por ubicacion

• DLL en C:\Users\ o subdirectorios: sospechosa.
• DLL en C:\Temp\, C:\ProgramData\ o rutas temporales: sospechosa.
• DLL en C:\Windows\System32\ con nombre no reconocido: investigar.
• DLL sin ruta (MappedPath vacio en ldrmodules): posible inyeccion.

Por nombre

• Nombres que imitan DLLs del sistema: kernel32.dll.bak, ntdll2.dll.
• Nombres genericos: update.dll, plugin.dll, helper.dll en procesos del sistema.
• Nombres con numeros o caracteres aleatorios: a3f2b1.dll.

Por proceso

• DLLs de red (ws2_32.dll, wininet.dll, winhttp.dll) en procesos que no deberian tener actividad de red.
• DLLs criptograficas (crypt32.dll, bcrypt.dll) en procesos simples.
• DLLs de depuracion (dbghelp.dll) en procesos de produccion.

Por discrepancia entre listas

• Presente en VAD pero no en las tres listas del PEB: posible reflective loading.
• Presente en InLoad pero no en InInit: puede ser normal (EXE principal) o sospechoso.

Extraccion de DLLs para analisis

Cuando identificas una DLL sospechosa, puedes extraerla del dump de memoria para analizarla con herramientas de malware analysis:

vol -f memory.raw windows.dumpfiles --pid 4321

Esto extrae los ficheros mapeados en memoria del proceso, incluyendo el ejecutable principal y las DLLs. Los ficheros se guardan en el directorio actual con nombres que incluyen el offset de memoria.

Para extraer una DLL especifica por su direccion base:

vol -f memory.raw windows.dumpfiles --virtaddr 0x000001234000

La DLL extraida puede analizarse con:

• strings para buscar cadenas indicativas.
• file para verificar el tipo.
• sha256sum para buscar el hash en bases de datos de malware como MalwareBazaar o VirusTotal.
• Herramientas de analisis estatico como Ghidra o IDA Pro.

Caso practico: DLL inyectada en explorer.exe

Ejecutamos dlllist para explorer.exe y encontramos una DLL inusual:

PID    Process       Base             Size     Name              Path
3100   explorer.exe  0x00007ff12340   0x4e000  msupdate64.dll    C:\ProgramData\Microsoft\msupdate64.dll

La ruta C:\ProgramData\Microsoft\ es inusual para una DLL cargada por explorer.exe. Las DLLs legitimas de Microsoft en ese directorio no incluyen una llamada "msupdate64.dll".

Verificamos con ldrmodules:

Base             InLoad  InInit  InMem   MappedPath
0x00007ff12340   True    True    True    \ProgramData\Microsoft\msupdate64.dll

Esta en las tres listas, lo que indica que fue cargada con LoadLibrary (DLL injection clasica). Extraemos y calculamos su hash:

vol -f memory.raw windows.dumpfiles --virtaddr 0x00007ff12340
sha256sum file.0x00007ff12340.dat

El hash puede buscarse en MalwareBazaar, VirusTotal o cualquier plataforma de threat intelligence para obtener atribucion.

Proximo paso

Con los procesos, DLLs y handles analizados, el siguiente articulo se centra en las conexiones de red en memoria: el plugin netscan, como identificar comunicaciones C2 y como correlacionar conexiones con procesos sospechosos.