DFIR-MESI

Digital Forensics & Incident Response — Guia Completo de Instalação e Configuração

O DFIR-MESI é uma plataforma integrada de resposta a incidentes cibernéticos de ransomware que combina três ferramentas de segurança com detecção comportamental pré-criptografia, resposta automatizada e análise forense assistida por Inteligência Artificial em linguagem natural.

A instalação é organizada em 4 etapas sequenciais. Cada etapa possui um script dedicado que automatiza o processo.

Pré-requisitos

Servidor

DNS

Configure os seguintes registros A apontando para o IP do servidor:

iris.seudominio.com             → IP_DO_SERVIDOR
velociraptor.seudominio.com     → IP_DO_SERVIDOR
wazuh.seudominio.com            → IP_DO_SERVIDOR
mcp-wazuh.seudominio.com        → IP_DO_SERVIDOR
mcp-velociraptor.seudominio.com → IP_DO_SERVIDOR
mcp-iris.seudominio.com         → IP_DO_SERVIDOR

Endpoints Windows

• Windows 10/11 ou Windows Server 2016+
• PowerShell 5.1+
• .NET Framework 4.0+ (para compilação do Active Response)
• Acesso de Administrador

Requisitos mínimos de hardware

Os agentes DFIR-MESI têm baixo consumo em operação normal (idle), mas as coletas forenses automáticas consomem recursos significativos durante a execução. Recomenda-se que os endpoints tenham ao menos 4 GB de RAM e 2 GB de disco livre para os agentes e logs.

Consumo de recursos dos agentes

Arquitetura

O diagrama completo da arquitetura está disponível como arquivo HTML interativo:

A infraestrutura é organizada em camadas: Firewall (UFW) → Nginx Reverse Proxy → Docker Containers → Endpoints. Todos os serviços rodam em containers Docker isolados, com o Nginx fazendo terminação SSL e proxy reverso. Os MCP Servers permitem interação com os serviços via Claude AI em linguagem natural.

O que o script faz

O script automatiza completamente a instalação dos três serviços principais, configuração do Docker, Nginx com SSL e Firewall. O processo leva aproximadamente 15-20 minutos.

Execução

chmod +x install-dfir-mesi.sh
sudo ./install-dfir-mesi.sh

Interação durante a instalação

O script solicitará as seguintes informações:

• Domínio principal — ex: exemplo.com.br
• IP público — detectado automaticamente, confirmação manual
• Subdomínios — padrão: iris, velociraptor, wazuh
• Email Let's Encrypt — para emissão dos certificados SSL
• Modo — Produção (Let's Encrypt) ou Desenvolvimento (Self-signed)

Credenciais

Ao final da instalação, as credenciais são exibidas na tela e salvas em:

/opt/dfir-mesi/config.env

🔑 Primeiro Acesso

Após a instalação, acesse os serviços pelos subdomínios configurados. As credenciais iniciais estão em /opt/dfir-mesi/config.env.

DFIR-IRIS

URL:     https://iris.seudominio.com
User:    administrator
Pass:    (ver config.env)

Velociraptor

URL:     https://velociraptor.seudominio.com
User:    admin
Pass:    (definida durante instalação)

Wazuh Dashboard

URL:     https://wazuh.seudominio.com
User:    admin
Pass:    SecretPassword

Criar conta de serviço no IRIS

A API Key gerada nesta etapa é necessária para a Etapa 3 (integrações) e Etapa 4 (MCP). Siga os passos abaixo antes de prosseguir.

1. Criar Customer

Acesse Advanced → Access control → Customers → Add Customer. Defina o nome da organização (ex: DFIR-MESI Francci Corp) e clique em Save.

2. Criar Service Account

• Acesse Advanced → Access control → Users → Add User
• Full name: DFIR-MESI Integration Service
• Login: dfir-mesi-integration
• Email: um email válido (ex: [email protected])
• Marque a opção Use as service account
• Clique em Save

3. Associar ao Customer

Edite o usuário criado, vá na aba Customers, clique em Manage e associe ao Customer criado no passo anterior. Anote o Customer ID (se for o primeiro Customer adicionado, o ID tende a ser 2).

4. Adicionar aos Grupos

Na aba Groups, clique em Manage e adicione o usuário de serviço aos grupos Administrators e Analysts. Ambos os grupos são necessários para que as integrações tenham permissão de criar cases, adicionar IOCs, assets e executar todas as operações via API.

5. Copiar a API Key

Na aba Info do usuário de serviço, copie o valor do campo User API Key. Esta chave será utilizada nas Etapas 3 e 4 para autenticar as integrações e os MCP Servers com o IRIS.

Componentes instalados

Execução

# PowerShell como Administrador

# Opção 1: Com parâmetros
.\dfir-mesi-windows-agents.ps1 -WazuhManager "SEU_IP_SERVIDOR" -VelociraptorServer "velociraptor.seudominio.com"

# Opção 2: Interativo (solicita os dados)
.\dfir-mesi-windows-agents.ps1

Parâmetros

Active Response

O script instala um sistema de resposta automática a ransomware que inclui um wrapper em C# compilado como EXE (resolve problema de pipe stdin do Wazuh), capacidade de suspensão de processos via kernel32.dll, whitelist de processos protegidos (explorer, powershell, etc.), criação automática de VSS snapshots e alertas desktop para todos os usuários conectados.

Integrações disponíveis

Execução

chmod +x configure-dfir-mesi.sh
sudo ./configure-dfir-mesi.sh

# Selecione a integração desejada:
# [1] Regras de Detecção de Ransomware (Wazuh)
# [2] Integração Wazuh → IRIS
# [3] Webhook Velociraptor → IRIS
# [4] Todas as customizações acima
# [5] Verificar status das customizações

Integração 1: Regras de Detecção de Ransomware

Instala 39 regras customizadas de detecção no Wazuh Manager, focadas em indicadores comportamentais pré-criptografia. As regras cobrem deleção de Shadow Copies, execução de ferramentas de criptografia, modificações em massa de arquivos e uso de ferramentas comuns de ransomware.

Arquivos e destino

Procedimento manual

# 1. Clonar o repositório de regras
git clone https://github.com/SEU-USUARIO/dfir-mesi-rules.git /tmp/dfir-mesi-rules

# 2. Copiar as regras para o container Wazuh Manager
docker cp /tmp/dfir-mesi-rules/rules/. wazuh-wazuh.manager-1:/var/ossec/etc/rules/

# 3. Ajustar permissoes e proprietario dos arquivos
docker exec wazuh-wazuh.manager-1 chmod 660 /var/ossec/etc/rules/local_ransomware_rules.xml
docker exec wazuh-wazuh.manager-1 chmod 660 /var/ossec/etc/rules/local_ransomware_wmi_chain.xml
docker exec wazuh-wazuh.manager-1 chown wazuh:wazuh /var/ossec/etc/rules/local_ransomware_rules.xml
docker exec wazuh-wazuh.manager-1 chown wazuh:wazuh /var/ossec/etc/rules/local_ransomware_wmi_chain.xml

# 4. Reiniciar o Wazuh Manager para carregar as regras
docker exec wazuh-wazuh.manager-1 /var/ossec/bin/wazuh-control restart

# 5. Verificar se as regras foram carregadas
docker exec wazuh-wazuh.manager-1 /var/ossec/bin/wazuh-logtest

Integração 2: Wazuh → IRIS

Configura o script custom-iris.py dentro do container Wazuh Manager para criar Cases automaticamente no IRIS quando os alertas das regras de ransomware (IDs 100600–100660) são disparados. Envia notificação Slack imediatamente após a criação do case.

Arquivos e destino

Procedimento manual

# 1. Clonar o repositório de integrações
git clone https://github.com/SEU-USUARIO/dfir-mesi-integrations.git /tmp/dfir-mesi-int

# 2. Editar as variáveis hardcoded no script ANTES de copiar
nano /tmp/dfir-mesi-int/custom-iris.py
# Alterar: IRIS_URL, IRIS_API_KEY, WEBHOOK_URL, SLACK_WEBHOOK_URL

# 3. Copiar o script para o container
docker cp /tmp/dfir-mesi-int/custom-iris.py \
  wazuh-wazuh.manager-1:/var/ossec/integrations/custom-iris.py

# 4. Criar o shell wrapper 'custom-iris' (sem extensão .py) — obrigatório
docker exec wazuh-wazuh.manager-1 bash -c \
  'printf "#!/bin/sh\nexec /var/ossec/integrations/custom-iris.py \"\$@\"\n" \
  > /var/ossec/integrations/custom-iris'

# 5. Configurar permissões (script Python e shell wrapper)
docker exec wazuh-wazuh.manager-1 chmod 750 \
  /var/ossec/integrations/custom-iris.py \
  /var/ossec/integrations/custom-iris
docker exec wazuh-wazuh.manager-1 chown root:wazuh \
  /var/ossec/integrations/custom-iris.py \
  /var/ossec/integrations/custom-iris

# 6. Extrair o ossec.conf atual do container
docker cp wazuh-wazuh.manager-1:/var/ossec/etc/ossec.conf /tmp/ossec.conf

# 7. Inserir o bloco de integração antes de </ossec_config>
nano /tmp/ossec.conf

# Bloco correto (ATENÇÃO: name=custom-iris, sem .py; sem <api_key>;
# hook_url aponta para o endpoint Docker interno; rule_id em vez de level):
#
#   <integration>
#     <name>custom-iris</name>
#     <hook_url>https://iriswebapp_nginx:8443</hook_url>
#     <rule_id>100600,100601,100602,100603,100604,100610,100611,100612,
#              100613,100614,100620,100621,100622,100630,100640,100650,
#              100651,100652,100660</rule_id>
#     <alert_format>json</alert_format>
#   </integration>
#
# Salvar: Ctrl+O, Enter, Ctrl+X

# 8. Devolver o ossec.conf para o container
docker cp /tmp/ossec.conf wazuh-wazuh.manager-1:/var/ossec/etc/ossec.conf

# 9. Ajustar permissões e proprietário
docker exec wazuh-wazuh.manager-1 chmod 660 /var/ossec/etc/ossec.conf
docker exec wazuh-wazuh.manager-1 chown root:wazuh /var/ossec/etc/ossec.conf

# 10. Persistir o ossec.conf no volume do host (sobrevive a docker compose down/up)
cp /tmp/ossec.conf /opt/wazuh-docker/single-node/config/wazuh_cluster/wazuh_manager.conf

# 11. Reiniciar o Wazuh Manager
docker exec wazuh-wazuh.manager-1 /var/ossec/bin/wazuh-control restart

Configuração do Slack (notificações)

As Integrações 2 e 3 enviam notificações automáticas via Slack. É necessário criar um Incoming Webhook no Slack e configurar a URL em ambos os scripts (custom-iris.py e custom-velociraptor.py) antes de prosseguir.

Passo a passo

• Acesse https://api.slack.com/apps e clique em Create New App → From scratch
• Dê um nome (ex: IRIS Alerts) e selecione o workspace
• No menu lateral, clique em Incoming Webhooks e ative o toggle
• Clique em Add New Webhook to Workspace e selecione o canal de destino (ex: #iris-alerts)
• Copie a Webhook URL gerada (formato: https://hooks.slack.com/services/T.../B.../xxx)

Testar a conexão

curl -X POST -H 'Content-type: application/json' \
  --data '{"text":"🔔 Teste DFIR-MESI → Slack OK!"}' \
  https://hooks.slack.com/services/TXXXXXXXX/BXXXXXXXX/xxxxxxxxxxxxxxxx

Integração 3: Wazuh → Velociraptor → IRIS

Configura o script custom-velociraptor.py dentro do container Wazuh Manager. Quando um alerta de ransomware é detectado, o script executa coletas forenses no Velociraptor via docker exec (Windows.Triage.Targets + Windows.Triage.HighValueMemory), registra as evidências no Case do IRIS e envia notificação via Slack com todas as regras que deram match.

Arquivos e destino

Variáveis hardcoded em custom-velociraptor.py

Pré-requisito: instalar Docker CLI no container Wazuh

# No host — baixar e instalar o binário estático do Docker dentro do container Wazuh
curl -fsSL https://download.docker.com/linux/static/stable/x86_64/docker-27.5.1.tgz \
  | tar xz --strip-components=1 -C /tmp docker/docker
docker cp /tmp/docker wazuh-wazuh.manager-1:/usr/local/bin/docker
docker exec wazuh-wazuh.manager-1 chmod +x /usr/local/bin/docker

# Garantir permissão do socket no host
chmod 666 /var/run/docker.sock

# Verificar acesso ao Docker dentro do container
docker exec wazuh-wazuh.manager-1 docker ps --format "{{.Names}}" | head -5

Pré-requisito: gerar wazuh-api.yaml no Velociraptor

# Gerar a API key do Velociraptor para o Wazuh (executado dentro do container Velociraptor)
docker exec velociraptor \
  velociraptor config api_client \
    --name=wazuh-integration \
    --role=administrator \
    /data/wazuh-api.yaml

# Verificar que o arquivo foi criado
docker exec velociraptor ls -la /data/wazuh-api.yaml

Pré-requisito: criar diretórios internos no container Wazuh

docker exec wazuh-wazuh.manager-1 mkdir -p /opt/dfir-mesi/alerts /opt/dfir-mesi/logs
docker exec wazuh-wazuh.manager-1 chown wazuh:wazuh /opt/dfir-mesi/alerts /opt/dfir-mesi/logs

Pré-requisito: conectar container Wazuh às redes iris_frontend e dfir-network

# Conectar redes adicionais ao container Wazuh (em execução)
docker network connect iris_frontend wazuh-wazuh.manager-1
docker network connect dfir-network wazuh-wazuh.manager-1

# Verificar todas as redes do container
docker inspect wazuh-wazuh.manager-1 \
  --format '{{range $k,$v := .NetworkSettings.Networks}}{{$k}}{{"\n"}}{{end}}'
# Saída esperada: wazuh_default / iris_frontend / dfir-network

Procedimento manual — instalação do script

# 1. Editar variáveis hardcoded ANTES de copiar (ver tabela acima)
nano /tmp/dfir-mesi-int/custom-velociraptor.py

# 2. Copiar o script para o container
docker cp /tmp/dfir-mesi-int/custom-velociraptor.py \
  wazuh-wazuh.manager-1:/var/ossec/integrations/custom-velociraptor.py

# 3. Criar o shell wrapper 'custom-velociraptor-forwarder' — obrigatório
docker exec wazuh-wazuh.manager-1 bash -c \
  'printf "#!/bin/sh\nexec /var/ossec/integrations/custom-velociraptor.py \"\$@\"\n" \
  > /var/ossec/integrations/custom-velociraptor-forwarder'

# 4. Configurar permissões
docker exec wazuh-wazuh.manager-1 chmod 750 \
  /var/ossec/integrations/custom-velociraptor.py \
  /var/ossec/integrations/custom-velociraptor-forwarder
docker exec wazuh-wazuh.manager-1 chown root:wazuh \
  /var/ossec/integrations/custom-velociraptor.py \
  /var/ossec/integrations/custom-velociraptor-forwarder

# 5. Extrair o ossec.conf atual
docker cp wazuh-wazuh.manager-1:/var/ossec/etc/ossec.conf /tmp/ossec.conf

# 6. Inserir os blocos abaixo antes de </ossec_config>
nano /tmp/ossec.conf

# Bloco de integração (ATENÇÃO: name=custom-velociraptor-forwarder; sem <api_key>):
#
#   <integration>
#     <name>custom-velociraptor-forwarder</name>
#     <hook_url>https://iriswebapp_nginx:8443</hook_url>
#     <rule_id>100600,100601,100602,100603,100604,100610,100611,100612,
#              100613,100614,100620,100621,100622,100630,100640,100650,
#              100651,100652,100660</rule_id>
#     <alert_format>json</alert_format>
#   </integration>
#
# Bloco de Active Response (ransomware-response):
#
#   <active-response>
#     <command>ransomware-response.cmd</command>
#     <location>local</location>
#     <rules_id>100600,100601,100602,100610,100611,100620,100630,100640</rules_id>
#     <timeout>0</timeout>
#   </active-response>
#
# Salvar: Ctrl+O, Enter, Ctrl+X

# 7. Devolver o ossec.conf para o container
docker cp /tmp/ossec.conf wazuh-wazuh.manager-1:/var/ossec/etc/ossec.conf

# 8. Ajustar permissões
docker exec wazuh-wazuh.manager-1 chmod 660 /var/ossec/etc/ossec.conf
docker exec wazuh-wazuh.manager-1 chown root:wazuh /var/ossec/etc/ossec.conf

# 9. Persistir no volume do host
cp /tmp/ossec.conf /opt/wazuh-docker/single-node/config/wazuh_cluster/wazuh_manager.conf

# 10. Reiniciar o Wazuh Manager
docker exec wazuh-wazuh.manager-1 /var/ossec/bin/wazuh-control restart

Integração 4: Webhook Assets (Velociraptor → IRIS)

Implanta o serviço assets-webhook-service.py (porta 5555) que sincroniza automaticamente os clients do Velociraptor como assets nos Cases do IRIS quando um case é criado. O script auxiliar velociraptor-assets-sync.py é gerado dinamicamente pelo configure-dfir-mesi.sh — não faz parte do repositório de integrações.

Arquivos e destino

Procedimento manual

# 1. Copiar arquivos para o diretório do webhook
mkdir -p /opt/dfir-mesi/webhook
cp /tmp/dfir-mesi-int/webhook/assets-webhook-service.py /opt/dfir-mesi/webhook/
cp /tmp/dfir-mesi-int/webhook/docker-compose.yml /opt/dfir-mesi/webhook/
cp /tmp/dfir-mesi-int/webhook/Dockerfile /opt/dfir-mesi/webhook/

# 2. O velociraptor-assets-sync.py é gerado pelo configure-dfir-mesi.sh
# Se estiver executando manualmente, gere-o ou copie da sessão anterior
# Verifique que ele existe em /opt/dfir-mesi/webhook/velociraptor-assets-sync.py
ls -la /opt/dfir-mesi/webhook/velociraptor-assets-sync.py

# 3. Configurar o .env
cat > /opt/dfir-mesi/webhook/.env << 'EOF'
IRIS_URL=https://iriswebapp_nginx:8443
IRIS_API_KEY=SUA_IRIS_API_KEY
VELOCIRAPTOR_API_CONFIG=/config/api.config.yaml
WEBHOOK_PORT=5555
EOF

# 4. Verificar que o docker-compose.yml inclui as redes iris_frontend e dfir-network
grep -A5 'networks:' /opt/dfir-mesi/webhook/docker-compose.yml
# Deve conter: iris_frontend e dfir-network como redes externas

# 5. Validar sintaxe do docker-compose.yml
docker compose -f /opt/dfir-mesi/webhook/docker-compose.yml config --quiet

# 6. Iniciar o serviço
cd /opt/dfir-mesi/webhook && docker compose up -d

# 7. Verificar logs do container
docker logs dfir-assets-webhook --tail 20

# 8. Configurar o IRIS para chamar o webhook:
# IRIS → Admin → Modules → IrisWebHook
# Trigger: on_postload_case_create
# URL: http://dfir-assets-webhook:5555/webhook

# 9. Testar o endpoint manualmente
curl -s http://localhost:5555/health | python3 -m json.tool

Os MCP Servers (Model Context Protocol) permitem que o Claude AI interaja diretamente com os serviços de segurança em linguagem natural. Cada servidor expõe as funcionalidades da ferramenta correspondente via protocolo SSE (Server-Sent Events).

Fontes dos MCP Servers

Pré-requisitos específicos

• Etapa 1 concluída (serviços base rodando)
• DNS configurado para os subdomínios mcp-*
• API Key do IRIS (gerada via conta de serviço em IRIS → Advanced → Access control)

Execução

chmod +x install-mcp-servers.sh
sudo ./install-mcp-servers.sh

O que o script faz

Para cada MCP Server, o script cria um container Docker com Python 3.13, configura Nginx com headers SSE otimizados, obtém certificados SSL Let's Encrypt e configura comunicação interna com os serviços correspondentes.

Particularidades técnicas

• Wazuh MCP: clonado do repositório GenSecAI (v4.1), usa Streamable HTTP (/mcp) em vez de SSE legacy. Conecta ao Wazuh Manager e Indexer via rede Docker wazuh_default
• Velociraptor MCP: inclui patch para corrigir parameters → env no collect_artifact e gera api.config.yaml automaticamente
• IRIS MCP: servidor custom com 35 funções, KPIs (MTTD, MTTA, MTTC, MTTR), usa FastMCP e conecta via rede Docker iris_frontend

Verificação após instalação

Após a execução do script, verifique se os 3 MCP Servers estão operacionais:

# 1. Verificar containers rodando
docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}" | grep mcp

# 2. Testar Wazuh MCP (Streamable HTTP - endpoint /health)
curl -s https://mcp-wazuh.seudominio.com/health | python3 -m json.tool | grep status

# 3. Testar Velociraptor MCP (SSE - conexão fica aberta, Ctrl+C para sair)
timeout 3 curl -s https://mcp-velociraptor.seudominio.com/sse | head -3

# 4. Testar IRIS MCP (SSE - conexão fica aberta, Ctrl+C para sair)
timeout 3 curl -s https://mcp-iris.seudominio.com/sse | head -3

📖 Playbook de Resposta a Ransomware

O DFIR-MESI inclui um Playbook de Resposta a Incidentes de Ransomware organizado em 6 fases e 14 tarefas. Quando o script custom-iris.py cria um Case automaticamente no IRIS (alertas nível ≥12), as tarefas e diretórios de notas do playbook são criados junto com o case, prontos para guiar o analista durante toda a resposta ao incidente.

Fases e Tarefas

Criação automática

Cada tarefa do playbook inclui descrição detalhada, checklist operacional, queries MCP sugeridas para o Claude AI e referências aos frameworks de compliance. As 14 tarefas e os diretórios de notas correspondentes a cada fase são criados automaticamente quando o custom-iris.py dispara a abertura de um Case no IRIS.

Frameworks de referência

O playbook é mapeado para os seguintes frameworks, com citações diretas em cada tarefa:

• NIST SP 800-61r3 / CSF 2.0 (Govern → Recover)
• CISA #StopRansomware Guide
• CERT.BR — Guia de Ransomware
• ENISA Threat Landscape 2024
• FIRST CSIRT Framework v2.1
• NoMoreRansom Project

Coletas forenses automatizadas

Quando o Wazuh detecta um alerta de ransomware, o script custom-velociraptor.py dispara automaticamente duas coletas forenses no endpoint afetado via Velociraptor:

O fluxo completo é automatizado de ponta a ponta:

As evidências coletadas são registradas automaticamente no Case do IRIS com a descrição do artefato, e uma notificação Slack é enviada com todas as regras que foram disparadas, permitindo ao analista iniciar a análise forense imediatamente.

🤖 Configuração do Claude Desktop

Para interagir com os serviços via linguagem natural, configure o Claude Desktop Client com os MCP Servers.

Pré-requisitos

• Claude Desktop instalado
• Node.js 18+ instalado

Configuração

Edite o arquivo de configuração do Claude Desktop:

Adicione o seguinte conteúdo:

{
  "mcpServers": {
    "wazuh": {
      "command": "npx",
      "args": ["-y", "mcp-remote",
        "https://mcp-wazuh.seudominio.com/mcp"]
    },
    "velociraptor": {
      "command": "npx",
      "args": ["-y", "mcp-remote",
        "https://mcp-velociraptor.seudominio.com/sse"]
    },
    "iris": {
      "command": "npx",
      "args": ["-y", "mcp-remote",
        "https://mcp-iris.seudominio.com/sse"]
    }
  }
}

Reinicie o Claude Desktop após salvar. Os MCPs aparecerão como ferramentas disponíveis no chat.

Exemplos de uso

🧪 Testes de Validação

Verificar containers

sudo docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"

Testar endpoints MCP

# Wazuh MCP (Streamable HTTP - deve retornar JSON com status healthy)
curl -s https://mcp-wazuh.seudominio.com/health | python3 -m json.tool

# Velociraptor MCP (SSE - conexão fica aberta, Ctrl+C para sair)
timeout 3 curl -s --http1.1 -H "Accept: text/event-stream" \
  https://mcp-velociraptor.seudominio.com/sse | head -3

# IRIS MCP (SSE - conexão fica aberta, Ctrl+C para sair)
timeout 3 curl -s --http1.1 -H "Accept: text/event-stream" \
  https://mcp-iris.seudominio.com/sse | head -3

Conectar ao Claude.ai

No Claude.ai, acesse Settings → Connectors e adicione os 3 MCP Servers com as URLs:

Testar detecção de ransomware

No endpoint Windows com os agentes instalados:

# PowerShell como Administrador — dispara alerta no Wazuh (regra 100610/100611)
vssadmin delete shadows /all /quiet

Teste end-to-end: vssadmin → IRIS → Coletas → Slack

Este procedimento valida o fluxo completo das Integrações 1, 2, 3 e 4 de ponta a ponta. Execute em sequência e verifique cada etapa antes de prosseguir.

Fase 1 — Disparar o alerta no Wazuh (endpoint Windows)

# PowerShell como Administrador no endpoint Windows alvo
# Dispara a regra 100610 (VSS deletion) — mesmo comando usado em ransomware real
vssadmin delete shadows /all /quiet

# Alternativa sem efeito destrutivo real (shadow copies ausentes = erro benigno)
# O alerta ainda é gerado mesmo que não existam shadow copies

Fase 2 — Verificar alerta no Wazuh Manager (servidor)

# Acompanhar alertas em tempo real (aguardar até ~30 segundos)
docker exec wazuh-wazuh.manager-1 \
  tail -f /var/ossec/logs/alerts/alerts.json | \
  python3 -c "
import sys, json
for line in sys.stdin:
    try:
        a = json.loads(line)
        rid = a.get('rule',{}).get('id','')
        if str(rid).startswith('1006'):
            print(f'[ALERTA] Rule {rid} — {a[\"rule\"][\"description\"]}')
            print(f'  Agent: {a[\"agent\"][\"name\"]} ({a[\"agent\"][\"ip\"]})')
            print(f'  Command: {a.get(\"data\",{}).get(\"win\",{}).get(\"eventdata\",{}).get(\"commandLine\",\"N/A\")}')
    except: pass
"

Fase 3 — Verificar execução dos scripts de integração

# Logs do custom-iris.py (Integração 2)
docker exec wazuh-wazuh.manager-1 \
  tail -n 50 /var/ossec/logs/integrations.log | grep -E "iris|IRIS|case|error"

# Logs do custom-velociraptor-forwarder (Integração 3)
docker exec wazuh-wazuh.manager-1 \
  tail -n 50 /opt/dfir-mesi/logs/velociraptor-integration.log

# Verificar logs gerais de integração do Wazuh
docker exec wazuh-wazuh.manager-1 \
  tail -n 100 /var/ossec/logs/ossec.log | grep -i "integration\|custom-"

Fase 4 — Verificar Case criado no IRIS

# Via API do IRIS — listar os cases mais recentes
curl -sk -H "Authorization: Bearer SUA_IRIS_API_KEY" \
  "https://iriswebapp_nginx:8443/api/v1/cases/list" | \
  python3 -c "
import sys, json
data = json.load(sys.stdin)
cases = data.get('data', {}).get('cases', [])[:3]
for c in cases:
    print(f'Case #{c[\"case_id\"]}: {c[\"case_name\"]} — {c[\"status_name\"]} — {c[\"open_date\"]}')
"

# Ou acesse via browser: https://iris.seudominio.com → Cases → Last modified

Fase 5 — Verificar coletas forenses no Velociraptor

# Listar flows ativos/recentes para o client afetado
docker exec velociraptor \
  velociraptor -a /data/wazuh-api.yaml query \
  "SELECT client_id, session_id, request.artifacts AS artifacts, \
          state, create_time FROM flows(client_id=CXXXXX) \
   ORDER BY create_time DESC LIMIT 5" \
  --format json | python3 -m json.tool

# Verificar diretório de downloads no filestore
docker exec velociraptor \
  ls -lh /var/tmp/velociraptor/downloads/ 2>/dev/null | tail -5

# Ou acesse via browser: https://velociraptor.seudominio.com
# → Search → [hostname] → Collected Artifacts

Fase 6 — Verificar evidências registradas no IRIS

# Listar evidências do case criado (substitua CASE_ID)
curl -sk -H "Authorization: Bearer SUA_IRIS_API_KEY" \
  "https://iriswebapp_nginx:8443/api/v1/case/evidences/list?cid=CASE_ID" | \
  python3 -c "
import sys, json
data = json.load(sys.stdin)
evs = data.get('data', {}).get('evidences', [])
for e in evs:
    print(f'  [{e[\"date_added\"]}] {e[\"filename\"]} — {e[\"file_description\"]}')
"

Fase 7 — Verificar notificações Slack

Confirmar recebimento de duas mensagens no canal configurado:

Fase 8 — Verificar assets sincronizados no Case (Integração 4)

# Verificar assets registrados no case
curl -sk -H "Authorization: Bearer SUA_IRIS_API_KEY" \
  "https://iriswebapp_nginx:8443/api/v1/case/assets/list?cid=CASE_ID" | \
  python3 -c "
import sys, json
data = json.load(sys.stdin)
assets = data.get('data', {}).get('assets', [])
for a in assets:
    print(f'  {a[\"asset_name\"]} ({a[\"asset_type_name\"]}) — IP: {a.get(\"asset_ip\",\"N/A\")}')
"

# Verificar logs do webhook
docker logs dfir-assets-webhook --tail 20

Script de verificação completa

sudo ./configure-dfir-mesi.sh
# Selecione opção 5 (Verificar status)

📦 Repositórios

O código-fonte do projeto está organizado nos seguintes repositórios privados. Solicite acesso ao administrador do projeto.

Repositórios externos (open-source)

🔧 Troubleshooting

Problemas comuns

Comandos úteis

# Status de todos os containers
docker ps --format "table {{.Names}}\t{{.Status}}"

# Logs de um serviço específico
docker logs iriswebapp_app --tail=50
docker logs velociraptor --tail=50
docker logs wazuh-wazuh.manager-1 --tail=50

# Logs dos MCP Servers
docker logs wazuh-mcp-wrapper --tail=20
docker logs velociraptor-mcp-server --tail=20
docker logs iris-mcp-server --tail=20

# Reiniciar um serviço
cd /opt/dfir-mesi/iris-web && docker compose restart
cd /opt/dfir-mesi/velociraptor && docker compose restart
cd /opt/dfir-mesi/wazuh && docker compose restart

# Verificar Nginx / Firewall / SSL
nginx -t
ufw status verbose
certbot certificates

📚 Referências

Frameworks de Compliance

• NIST SP 800-61r3 — Computer Security Incident Handling Guide
• CISA #StopRansomware — Ransomware Guide
• CERT.BR — Centro de Estudos, Resposta e Tratamento de Incidentes
• ENISA Threat Landscape — European Union Agency for Cybersecurity
• ANPD/CNPD — Autoridade Nacional de Proteção de Dados (Brasil)

Documentação das ferramentas

• Wazuh — https://documentation.wazuh.com
• DFIR-IRIS — https://docs.dfir-iris.org
• Velociraptor — https://docs.velociraptor.app
• Model Context Protocol — https://modelcontextprotocol.io
• FastMCP — https://github.com/jlowin/fastmcp

Projeto DFIR-MESI

Desenvolvido como projeto acadêmico e operacional para automação de resposta a incidentes com integração de IA. Para mais informações, consulte a documentação acadêmica disponível nos repositórios do projeto.