Lab 11.2: Detecção de Malwares por Análise de Memória

Objetivos de Aprendizagem

Ao final deste laboratório, você será capaz de:

Identificar técnicas de malware em memória
Utilizar ferramentas de detecção de anomalias
Compreender a injeção de processos
Analisar um dump de memória básico
Reconhecer indicadores de comprometimento em memória

Duração Estimada

55 minutos

Pré-requisitos

Lab 11.1 completo
VM Windows 10/11 isolada
Process Explorer, Process Monitor
Direitos de administrador

Contexto Profissional

A detecção de malwares em memória é crítica porque:

Malwares "fileless" não escrevem no disco
A análise de memória revela comportamentos ativos
É uma competência essencial em resposta a incidentes

AVISO

Este laboratório utiliza técnicas apenas para fins educativos. Execute somente em VMs isoladas e de teste.

Parte 1: Técnicas de Malware em Memória

Etapa 1.1: Visão Geral

Técnica	Descrição	Detecção
Process Injection	Injetar código em outro processo	Regiões RWX anormais
DLL Injection	Carregar uma DLL maliciosa	DLL não assinada/desconhecida
Process Hollowing	Substituir o código de um processo	Imagem não corresponde ao disco
Reflective Loading	Carregar DLL sem passar pela API	DLL sem arquivo correspondente
Fileless Malware	Código apenas em memória	Scripts codificados, PowerShell suspeito

Etapa 1.2: Indicadores-chave

Sinais de alerta:

Regiões de memória RWX (Read-Write-Execute)
Processos do sistema iniciados de local incorreto
DLLs não assinadas em processos sensíveis
Threads sem módulo associado
Conexões de rede anormais de processos legítimos

Parte 2: Detecção com Process Explorer

Etapa 2.1: Configuração avançada

Inicie o Process Explorer como administrador
Options > Verify Image Signatures
View > Select Columns > Adicione "Verified Signer"

Etapa 2.2: Identificar processos não assinados

Os processos em rosa/violeta possuem assinatura não verificada.

Processos que DEVEM ser assinados pela Microsoft:

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

Pergunta 1: Todos os seus processos do sistema estão assinados pela Microsoft?

Etapa 2.3: Verificar os caminhos

Processos legítimos e seus caminhos:
- 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 verificação:

# Verificar os caminhos dos processos 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 "=== VERIFICAÇÃO PROCESSOS 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
        }
    }
}

Pergunta 2: O script detecta alguma anomalia?

Parte 3: Detecção de DLL Injection

Etapa 3.1: Listar as DLLs de um processo

Process Explorer:

Selecione um processo
View > Show Lower Pane
View > Lower Pane View > DLLs

PowerShell:

# Listar as DLLs de um processo
$proc = Get-Process notepad
$proc.Modules | Select-Object ModuleName, FileName, Size

# Procurar DLLs suspeitas (fora de System32 ou Program Files)
$proc.Modules | Where-Object {
    $_.FileName -notlike "C:\Windows\*" -and
    $_.FileName -notlike "C:\Program Files*"
} | Select-Object ModuleName, FileName

Etapa 3.2: DLLs suspeitas a procurar

Indicador	Descrição
DLL em Temp	Localização anormal
DLL em AppData	Potencialmente maliciosa
DLL não assinada	Falta de verificação
Nome aleatório	Possível malware
Tamanho muito pequeno	Stub/loader

Etapa 3.3: Script de detecção de DLL

# Detecção de DLLs suspeitas
Write-Host "=== ANÁLISE DLLs SUSPEITAS ===" -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 "[SUSPEITO] $procName carregou: $($dll.FileName)" -ForegroundColor Red
            }
        }
    }
}

Write-Host "`nAnálise finalizada." -ForegroundColor Green

Pergunta 3: Alguma DLL suspeita foi carregada?

Parte 4: Detecção de Process Hollowing

Etapa 4.1: Conceito

Process Hollowing:

Criar um processo legítimo em modo suspenso
Esvaziar ("hollow") sua memória
Injetar código malicioso
Retomar a execução

Resultado: O processo parece legítimo, mas executa código malicioso.

Etapa 4.2: Indicadores de detecção

Indicador	Descrição
Imagem ≠ Memória	O código em memória difere do arquivo
PEB modificado	Process Environment Block alterado
Seções anormais	Tamanho/permissões inesperadas

Etapa 4.3: Verificação básica

# Comparar o tamanho da imagem em memória vs no disco
# Necessita ferramentas avançadas para detecção real

Get-Process | Where-Object { $_.Path } | ForEach-Object {
    $proc = $_
    try {
        $fileSize = (Get-Item $proc.Path -ErrorAction Stop).Length
        $memorySize = $proc.WorkingSet64
        
        # Ratio muito alto pode indicar anomalia
        $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álise com Process Monitor

Etapa 5.1: Capturar a atividade

procmon64.exe /accepteula

Etapa 5.2: Filtros úteis para detecção

Crie filtros para detectar comportamentos suspeitos:

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

Etapa 5.3: Comportamentos a observar

Operação	Suspeito se...
WriteFile	Em Temp com extensão .exe/.dll
CreateFile	Criação em pastas do sistema
RegSetValue	Modificação de Run keys
CreateRemoteThread	Em outro processo
VirtualAllocEx	Alocação em processo remoto

Parte 6: Criar um Dump de Memória

Etapa 6.1: Dump de um processo (método simples)

Task Manager:

Aba Detalhes
Clique com o botão direito no processo
"Criar arquivo de despejo"

PowerShell:

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

# Ou via comsvcs.dll (atenção: detectado por antivírus)
# Método usado por atacantes para dumpar lsass

Etapa 6.2: Onde os dumps são armazenados?

# Local padrão
$env:LOCALAPPDATA + "\Temp"

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

Etapa 6.3: Analisar um dump (básico)

Para análise aprofundada, ferramentas como Volatility são necessárias.

Com WinDbg (se instalado):

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

Parte 7: Script de Detecção Completo

# Script de detecção de anomalias de memória
# ==========================================

param(
    [switch]$Verbose
)

Write-Host @"
=====================================
  DETECÇÃO DE ANOMALIAS DE MEMÓRIA
=====================================
"@ -ForegroundColor Cyan

$alerts = @()

# 1. Verificar os caminhos dos processos críticos
Write-Host "`n[1/5] Verificação de processos 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 em caminho incorreto: $($_.Path)"
        }
    }
}

# 2. Procurar DLLs em locais suspeitos
Write-Host "[2/5] Análise de DLLs..." -ForegroundColor Yellow

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

# 3. Processos com conexões de rede incomuns
Write-Host "[3/5] Análise de conexões..." -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 += "[SUSPEITO] $($proc.Name) possui conexão de rede: $($conn.RemoteAddress):$($conn.RemotePort)"
    }
}

# 4. PowerShell com conexões
Write-Host "[4/5] Verificação 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 possui conexões de rede ativas"
}

# 5. Processos com memória RWX (necessita ferramentas avançadas)
Write-Host "[5/5] Verificação finalizada." -ForegroundColor Yellow

# Relatório
Write-Host "`n========== RELATÓRIO ==========" -ForegroundColor Cyan

if ($alerts.Count -eq 0) {
    Write-Host "[OK] Nenhuma anomalia maior detectada" -ForegroundColor Green
} else {
    Write-Host "Alertas detectados: $($alerts.Count)" -ForegroundColor Red
    foreach ($alert in $alerts) {
        if ($alert -match "CRÍTICO") {
            Write-Host "  $alert" -ForegroundColor Red
        } elseif ($alert -match "SUSPEITO") {
            Write-Host "  $alert" -ForegroundColor Yellow
        } else {
            Write-Host "  $alert" -ForegroundColor Gray
        }
    }
}

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

Pergunta 4: Execute o script. Quais alertas ele retorna?

Entregáveis

Capturas de tela:
- Process Explorer com assinaturas verificadas
- DLLs de um processo
- Resultado do script de detecção
Respostas às 4 perguntas
Relatório (2 páginas):
- Técnicas de malware em memória
- Métodos de detecção utilizados
- Resultados da análise da sua VM
- Recomendações

Critérios de Avaliação

Critério	Pontos
Process Explorer	25%
Detecção de DLLs	25%
Script de detecção	30%
Relatório e compreensão	20%

Recursos

Lab desenvolvido no âmbito do curso Sistemas Operacionais - MÓDULO 11

Objetivos de Aprendizagem​

Duração Estimada​

Pré-requisitos​

Contexto Profissional​

AVISO​

Parte 1: Técnicas de Malware em Memória​

Etapa 1.1: Visão Geral​

Etapa 1.2: Indicadores-chave​

Parte 2: Detecção com Process Explorer​

Etapa 2.1: Configuração avançada​

Etapa 2.2: Identificar processos não assinados​

Etapa 2.3: Verificar os caminhos​

Parte 3: Detecção de DLL Injection​

Etapa 3.1: Listar as DLLs de um processo​

Etapa 3.2: DLLs suspeitas a procurar​

Etapa 3.3: Script de detecção de DLL​

Parte 4: Detecção de Process Hollowing​

Etapa 4.1: Conceito​

Etapa 4.2: Indicadores de detecção​

Etapa 4.3: Verificação básica​

Parte 5: Análise com Process Monitor​

Etapa 5.1: Capturar a atividade​

Etapa 5.2: Filtros úteis para detecção​

Etapa 5.3: Comportamentos a observar​

Parte 6: Criar um Dump de Memória​

Etapa 6.1: Dump de um processo (método simples)​

Etapa 6.2: Onde os dumps são armazenados?​

Etapa 6.3: Analisar um dump (básico)​

Parte 7: Script de Detecção Completo​

Entregáveis​

Critérios de Avaliação​

Recursos​