Lab 11.2: Detección de Malware mediante Análisis de Memoria

Objetivos de Aprendizaje

Al final de este laboratorio, usted será capaz de:

Identificar técnicas de malware en memoria
Utilizar herramientas de detección de anomalías
Comprender la inyección de procesos
Analizar un volcado de memoria básico
Reconocer los indicadores de compromiso en memoria

Duración Estimada

55 minutos

Prerrequisitos

Lab 11.1 completado
VM Windows 10/11 aislada
Process Explorer, Process Monitor
Derechos de administrador

Contexto Profesional

La detección de malware en memoria es crítica porque:

El malware "fileless" no escribe en disco
El análisis de memoria revela comportamientos activos
Es una competencia esencial en respuesta a incidentes

ADVERTENCIA

Este laboratorio utiliza técnicas únicamente con fines educativos. Ejecute solo en VMs aisladas y de prueba.

Parte 1: Técnicas de Malware en Memoria

Paso 1.1: Visión general

Técnica	Descripción	Detección
Process Injection	Inyectar código en otro proceso	Regiones RWX anómalas
DLL Injection	Cargar una DLL maliciosa	DLL no firmada/desconocida
Process Hollowing	Reemplazar el código de un proceso	Imagen no coincide con el disco
Reflective Loading	Cargar DLL sin pasar por la API	DLL sin archivo correspondiente
Fileless Malware	Código solo en memoria	Scripts codificados, PowerShell sospechoso

Paso 1.2: Indicadores clave

Señales de alerta:

Regiones de memoria RWX (Read-Write-Execute)
Procesos del sistema lanzados desde ubicaciones incorrectas
DLLs no firmadas en procesos sensibles
Hilos sin módulo asociado
Conexiones de red anómalas desde procesos legítimos

Parte 2: Detección con Process Explorer

Paso 2.1: Configuración avanzada

Inicie Process Explorer como administrador
Options > Verify Image Signatures
View > Select Columns > Añada "Verified Signer"

Paso 2.2: Identificar procesos no firmados

Los procesos en rosa/violeta tienen una firma no verificada.

Procesos que DEBEN estar firmados por Microsoft:

svchost.exe
csrss.exe
lsass.exe
services.exe
winlogon.exe
explorer.exe

Pregunta 1: ¿Todos sus procesos del sistema están firmados por Microsoft?

Paso 2.3: Verificar las rutas

Procesos legítimos y sus rutas:
- svchost.exe    -> C:\Windows\System32\
- csrss.exe      -> C:\Windows\System32\
- lsass.exe      -> C:\Windows\System32\
- services.exe   -> C:\Windows\System32\
- explorer.exe   -> C:\Windows\

Script de verificación:

# Verificar las rutas de los procesos críticos
$criticalProcesses = @{
    "svchost" = "C:\Windows\System32\svchost.exe"
    "csrss" = "C:\Windows\System32\csrss.exe"
    "lsass" = "C:\Windows\System32\lsass.exe"
    "services" = "C:\Windows\System32\services.exe"
    "winlogon" = "C:\Windows\System32\winlogon.exe"
}

Write-Host "=== VERIFICACIÓN PROCESOS CRÍTICOS ===" -ForegroundColor Cyan

foreach ($proc in $criticalProcesses.Keys) {
    $running = Get-Process -Name $proc -ErrorAction SilentlyContinue
    
    foreach ($p in $running) {
        $expectedPath = $criticalProcesses[$proc]
        $actualPath = $p.Path
        
        if ($actualPath -ne $expectedPath) {
            Write-Host "[ALERTA] $proc" -ForegroundColor Red
            Write-Host "  Esperado: $expectedPath"
            Write-Host "  Encontrado:  $actualPath"
        } else {
            Write-Host "[OK] $proc - $actualPath" -ForegroundColor Green
        }
    }
}

Pregunta 2: ¿El script detecta anomalías?

Parte 3: Detección de Inyección de DLL

Paso 3.1: Listar las DLLs de un proceso

Process Explorer:

Seleccione un proceso
View > Show Lower Pane
View > Lower Pane View > DLLs

PowerShell:

# Listar las DLLs de un proceso
$proc = Get-Process notepad
$proc.Modules | Select-Object ModuleName, FileName, Size

# Buscar DLLs sospechosas (no en System32 o Program Files)
$proc.Modules | Where-Object {
    $_.FileName -notlike "C:\Windows\*" -and
    $_.FileName -notlike "C:\Program Files*"
} | Select-Object ModuleName, FileName

Paso 3.2: DLLs sospechosas a buscar

Indicador	Descripción
DLL en Temp	Ubicación anómala
DLL en AppData	Potencialmente malicioso
DLL no firmada	Falta de verificación
Nombre aleatorio	Posible malware
Tamaño muy pequeño	Stub/loader

Paso 3.3: Script de detección de DLL

# Detección de DLLs sospechosas
Write-Host "=== ANÁLISIS DLLs SOSPECHOSAS ===" -ForegroundColor Cyan

$suspiciousPaths = @(
    "*\Temp\*",
    "*\AppData\Local\Temp\*",
    "*\Downloads\*",
    "*\Desktop\*"
)

Get-Process | Where-Object { $_.Modules } | ForEach-Object {
    $procName = $_.Name
    $_.Modules | ForEach-Object {
        $dll = $_
        foreach ($path in $suspiciousPaths) {
            if ($dll.FileName -like $path) {
                Write-Host "[SOSPECHOSO] $procName carga: $($dll.FileName)" -ForegroundColor Red
            }
        }
    }
}

Write-Host "`nAnálisis finalizado." -ForegroundColor Green

Pregunta 3: ¿Se cargan DLLs sospechosas?

Parte 4: Detección de Process Hollowing

Paso 4.1: Concepto

Process Hollowing:

Crear un proceso legítimo en modo suspendido
Vaciar ("hollow") su memoria
Inyectar código malicioso
Reanudar la ejecución

Resultado: El proceso parece legítimo pero ejecuta código malicioso.

Paso 4.2: Indicadores de detección

Indicador	Descripción
Imagen ≠ Memoria	El código en memoria difiere del archivo
PEB modificado	Process Environment Block alterado
Secciones anómalas	Tamaño/permisos inesperados

Paso 4.3: Verificación básica

# Comparar el tamaño de la imagen en memoria vs en disco
# Requiere herramientas avanzadas para una detección real

Get-Process | Where-Object { $_.Path } | ForEach-Object {
    $proc = $_
    try {
        $fileSize = (Get-Item $proc.Path -ErrorAction Stop).Length
        $memorySize = $proc.WorkingSet64
        
        # Ratio muy alto puede indicar una anomalía
        $ratio = [math]::Round($memorySize / $fileSize, 2)
        
        if ($ratio -gt 100) {
            Write-Host "[INFO] $($proc.Name) - Ratio mem/file: $ratio" -ForegroundColor Yellow
        }
    } catch {}
}

Parte 5: Análisis con Process Monitor

Paso 5.1: Capturar la actividad

procmon64.exe /accepteula

Paso 5.2: Filtros útiles para detección

Cree filtros para detectar comportamientos sospechosos:

Filter > Filter...
Añada:
- Operation is WriteFile then Include
- Path contains \Temp\ then Include
- Process Name is powershell.exe then Include

Paso 5.3: Comportamientos a vigilar

Operación	Sospechoso si...
WriteFile	En Temp con extensión .exe/.dll
CreateFile	Creación en carpetas del sistema
RegSetValue	Modificación de claves Run
CreateRemoteThread	En otro proceso
VirtualAllocEx	Asignación en proceso remoto

Parte 6: Crear un Volcado de Memoria

Paso 6.1: Volcado de un proceso (método simple)

Task Manager:

Pestaña Detalles
Clic derecho en el proceso
"Crear archivo de volcado"

PowerShell:

# Usar procdump (Sysinternals)
# procdump64.exe -ma <PID> dump.dmp

# O vía comsvcs.dll (atención: detectado por los AV)
# Método utilizado por atacantes para volcar lsass

Paso 6.2: ¿Dónde se almacenan los volcados?

# Ubicación por defecto
$env:LOCALAPPDATA + "\Temp"

# Listar los volcados existentes
Get-ChildItem "$env:LOCALAPPDATA\Temp" -Filter "*.dmp" -ErrorAction SilentlyContinue

Paso 6.3: Analizar un volcado (básico)

Para un análisis profundo, se requieren herramientas como Volatility.

Con WinDbg (si está instalado):

windbg -z dump.dmp
!analyze -v
!process 0 0

Parte 7: Script de Detección Completo

# Script de detección de anomalías en memoria
# ===========================================

param(
    [switch]$Verbose
)

Write-Host @"
=====================================
  DETECCIÓN ANOMALÍAS MEMORIA
=====================================
"@ -ForegroundColor Cyan

$alerts = @()

# 1. Verificar las rutas de los procesos críticos
Write-Host "`n[1/5] Verificación procesos críticos..." -ForegroundColor Yellow

$criticalPaths = @{
    "svchost" = "C:\Windows\System32\svchost.exe"
    "lsass" = "C:\Windows\System32\lsass.exe"
    "csrss" = "C:\Windows\System32\csrss.exe"
    "services" = "C:\Windows\System32\services.exe"
}

foreach ($name in $criticalPaths.Keys) {
    Get-Process -Name $name -ErrorAction SilentlyContinue | ForEach-Object {
        if ($_.Path -and $_.Path -ne $criticalPaths[$name]) {
            $alerts += "[CRÍTICO] $name desde ruta incorrecta: $($_.Path)"
        }
    }
}

# 2. Buscar DLLs en ubicaciones sospechosas
Write-Host "[2/5] Análisis DLLs..." -ForegroundColor Yellow

$suspectDlls = @()
Get-Process | Where-Object { $_.Modules } | ForEach-Object {
    $_.Modules | Where-Object {
        $_.FileName -like "*\Temp\*" -or
        $_.FileName -like "*\Downloads\*"
    } | ForEach-Object {
        $alerts += "[SOSPECHOSO] DLL sospechosa: $($_.FileName)"
    }
}

# 3. Procesos con conexiones de red inusuales
Write-Host "[3/5] Análisis conexiones..." -ForegroundColor Yellow

$networkProcs = Get-NetTCPConnection -State Established -ErrorAction SilentlyContinue | 
    Where-Object { $_.RemoteAddress -notmatch "^(127\.|::1|0\.0\.0\.0)" }

foreach ($conn in $networkProcs) {
    $proc = Get-Process -Id $conn.OwningProcess -ErrorAction SilentlyContinue
    if ($proc.Name -in @("notepad", "calc", "mspaint")) {
        $alerts += "[SOSPECHOSO] $($proc.Name) tiene una conexión de red: $($conn.RemoteAddress):$($conn.RemotePort)"
    }
}

# 4. PowerShell con conexiones
Write-Host "[4/5] Verificación PowerShell..." -ForegroundColor Yellow

$psConnections = Get-NetTCPConnection -OwningProcess (Get-Process -Name powershell -ErrorAction SilentlyContinue).Id -ErrorAction SilentlyContinue |
    Where-Object { $_.State -eq "Established" }

if ($psConnections) {
    $alerts += "[INFO] PowerShell tiene conexiones de red activas"
}

# 5. Procesos con memoria RWX (requiere herramientas avanzadas)
Write-Host "[5/5] Verificación finalizada." -ForegroundColor Yellow

# Reporte
Write-Host "`n========== REPORTE ==========" -ForegroundColor Cyan

if ($alerts.Count -eq 0) {
    Write-Host "[OK] No se detectaron anomalías mayores" -ForegroundColor Green
} else {
    Write-Host "Alertas detectadas: $($alerts.Count)" -ForegroundColor Red
    foreach ($alert in $alerts) {
        if ($alert -match "CRÍTICO") {
            Write-Host "  $alert" -ForegroundColor Red
        } elseif ($alert -match "SOSPECHOSO") {
            Write-Host "  $alert" -ForegroundColor Yellow
        } else {
            Write-Host "  $alert" -ForegroundColor Gray
        }
    }
}

Write-Host "`n=============================" -ForegroundColor Cyan

Pregunta 4: Ejecute el script. ¿Qué alertas obtiene?

Entregables

Capturas de pantalla:
- Process Explorer con firmas verificadas
- DLLs de un proceso
- Resultado del script de detección
Respuestas a las 4 preguntas
Informe (2 páginas):
- Técnicas de malware en memoria
- Métodos de detección utilizados
- Resultados del análisis de su VM
- Recomendaciones

Criterios de Evaluación

Criterio	Puntos
Process Explorer	25%
Detección de DLLs	25%
Script de detección	30%
Informe y comprensión	20%

Recursos

Laboratorio desarrollado en el marco del curso Sistemas Operativos - MÓDULO 11

Objetivos de Aprendizaje​

Duración Estimada​

Prerrequisitos​

Contexto Profesional​

ADVERTENCIA​

Parte 1: Técnicas de Malware en Memoria​

Paso 1.1: Visión general​

Paso 1.2: Indicadores clave​

Parte 2: Detección con Process Explorer​

Paso 2.1: Configuración avanzada​

Paso 2.2: Identificar procesos no firmados​

Paso 2.3: Verificar las rutas​

Parte 3: Detección de Inyección de DLL​

Paso 3.1: Listar las DLLs de un proceso​

Paso 3.2: DLLs sospechosas a buscar​

Paso 3.3: Script de detección de DLL​

Parte 4: Detección de Process Hollowing​

Paso 4.1: Concepto​

Paso 4.2: Indicadores de detección​

Paso 4.3: Verificación básica​

Parte 5: Análisis con Process Monitor​

Paso 5.1: Capturar la actividad​

Paso 5.2: Filtros útiles para detección​

Paso 5.3: Comportamientos a vigilar​

Parte 6: Crear un Volcado de Memoria​

Paso 6.1: Volcado de un proceso (método simple)​

Paso 6.2: ¿Dónde se almacenan los volcados?​

Paso 6.3: Analizar un volcado (básico)​

Parte 7: Script de Detección Completo​

Entregables​

Criterios de Evaluación​

Recursos​