Realizando Forense de Memória com Plugins do Volatility3

Visão Geral

Volatility3 (v2.26.0+, lançamento com paridade de recursos em maio de 2025) é o framework padrão para forense de memória, substituindo o descontinuado Volatility2. Ele analisa dumps de RAM do Windows, Linux e macOS para detectar processos maliciosos, injeção de código, rootkits, coleta de credenciais e conexões de rede que a forense baseada em disco não consegue revelar. Plugins chave incluem windows.malfind (detectando regiões de memória RWX indicando injeção), windows.psscan (encontrando processos ocultos), windows.dlllist (enumerando módulos carregados), windows.netscan (conexões de rede ativas) e windows.handles (handles de arquivos/registro abertos). O Concurso de Plugins de 2024 introduziu o ETW Scan para extrair dados do Event Tracing for Windows da memória.

Quando Usar

• Ao realizar avaliações de segurança que envolvem forense de memória com plugins do volatility3
• Ao seguir procedimentos de resposta a incidentes para eventos de segurança relacionados
• Ao realizar testes de segurança ou atividades de auditoria agendadas
• Ao validar controles de segurança através de testes práticos

Pré-requisitos

• Python 3.9+ com o framework volatility3 instalado
• Arquivos de dump de memória (.raw, .dmp, .vmem, .lime)
• Tabelas de símbolos do Windows (arquivos ISF, download automático)
• Compreensão da arquitetura de memória de processos do Windows
• Integração YARA para varredura de padrões em memória

Fluxo de Trabalho

Etapa 1: Análise de Processos para Detecção de Malware

#!/usr/bin/env python3
"""Automação de forense de memória baseada em Volatility3 para análise de malware."""
import subprocess
import json
import sys
import os


class Vol3Analyzer:
    """Automatiza a execução de plugins do Volatility3 para análise de malware."""

    def __init__(self, dump_path, vol3_path="vol"):
        self.dump_path = dump_path
        self.vol3 = vol3_path
        self.results = {}

    def run_plugin(self, plugin, extra_args=None):
        """Executa um plugin do Volatility3 e captura a saída."""
        cmd = [
            self.vol3, "-f", self.dump_path,
            "-r", "json", plugin,
        ]
        if extra_args:
            cmd.extend(extra_args)

        try:
            result = subprocess.run(
                cmd, capture_output=True, text=True, timeout=300
            )
            if result.returncode == 0:
                return json.loads(result.stdout)
        except (subprocess.TimeoutExpired, json.JSONDecodeError) as e:
            print(f"  [!] {plugin} falhou: {e}")
        return None

    def detect_process_injection(self):
        """Usa malfind para detectar regiões de código injetado."""
        print("[+] Executando windows.malfind (detecção de injeção de código)")
        results = self.run_plugin("windows.malfind")

        injected = []
        if results:
            for entry in results:
                injected.append({
                    "pid": entry.get("PID"),
                    "process": entry.get("Process"),
                    "address": entry.get("Start VPN"),
                    "protection": entry.get("Protection"),
                    "hexdump": entry.get("Hexdump", "")[:200],
                })
                print(f"  [!] Injeção no PID {entry.get('PID')} "
                      f"({entry.get('Process')}) em {entry.get('Start VPN')}")

        self.results["injected_processes"] = injected
        return injected

    def find_hidden_processes(self):
        """Compara pslist vs psscan para encontrar processos ocultos."""
        print("[+] Executando comparação de processos (pslist vs psscan)")

        pslist = self.run_plugin("windows.pslist")
        psscan = self.run_plugin("windows.psscan")

        if not pslist or not psscan:
            return []

        list_pids = {e.get("PID") for e in pslist}
        scan_pids = {e.get("PID") for e in psscan}

        hidden = scan_pids - list_pids
        if hidden:
            print(f"  [!] {len(hidden)} processos ocultos encontrados!")
            for entry in psscan:
                if entry.get("PID") in hidden:
                    print(f"    PID {entry['PID']}: {entry.get('ImageFileName')}")

        self.results["hidden_processes"] = list(hidden)
        return list(hidden)

    def analyze_network(self):
        """Extrai conexões de rede ativas."""
        print("[+] Executando windows.netscan")
        results = self.run_plugin("windows.netscan")

        connections = []
        if results:
            for entry in results:
                conn = {
                    "pid": entry.get("PID"),

…