Implementando Análise do Modelo Diamante

Visão Geral

O Modelo Diamante de Análise de Intrusão oferece uma estrutura estruturada para analisar intrusões cibernéticas, examinando quatro características principais: Adversário, Capacidade, Infraestrutura e Vítima. Esta habilidade abrange a implementação programática do Modelo Diamante para classificar e correlacionar eventos de intrusão, construir linhas de atividade ligando eventos relacionados, criar grafos de atividade-ataque e gerar inteligência pronta para pivô a partir de dados de intrusão.

Quando Usar

• Ao implantar ou configurar capacidades de análise do modelo diamante em seu ambiente
• Ao estabelecer controles de segurança alinhados aos requisitos de conformidade
• Ao construir ou melhorar a arquitetura de segurança para este domínio
• Ao realizar avaliações de segurança que exigem esta implementação

Pré-requisitos

• Python 3.9+ com networkx, stix2, graphviz bibliotecas
• Compreensão do núcleo e meta-características do Modelo Diamante
• Acesso a dados de inteligência de ameaças (eventos MISP/OpenCTI)
• Familiaridade com MITRE ATT&CK para mapeamento de capacidades

Conceitos Chave

Características Principais do Modelo Diamante

• Adversário: O ator de ameaça ou operador que realiza a intrusão
• Capacidade: As ferramentas, técnicas e malware utilizados (mapeia para ATT&CK)
• Infraestrutura: Servidores C2, domínios, endereços de e-mail, provedores de hospedagem
• Vítima: Organização alvo, sistema, pessoa ou ativo de dados

Meta-Características

• Timestamp: Quando o evento ocorreu
• Fase: Estágio da cadeia de ataque (reconhecimento, entrega, exploração, etc.)
• Resultado: Sucesso, falha ou desconhecido
• Direção: Adversário-para-infraestrutura, infraestrutura-para-vítima, etc.
• Metodologia: Engenharia social, exploração técnica, ameaça interna
• Recursos: Recursos financeiros, humanos, técnicos necessários

Linhas de Atividade e Grupos

• Linha de Atividade: Sequência de eventos Diamante de uma única operação de adversário
• Grupo de Atividade: Agrupamento de linhas de atividade atribuídas ao mesmo adversário

Fluxo de Trabalho

Passo 1: Definir Estrutura de Dados do Evento Diamante

from dataclasses import dataclass, field
from datetime import datetime
from typing import Optional
import json
import uuid

@dataclass
class DiamondEvent:
    adversary: str = ""
    capability: str = ""
    infrastructure: str = ""
    victim: str = ""
    timestamp: str = ""
    phase: str = ""
    result: str = ""
    direction: str = ""
    methodology: str = ""
    confidence: int = 0
    notes: str = ""
    event_id: str = field(default_factory=lambda: str(uuid.uuid4())[:8])
    mitre_techniques: list = field(default_factory=list)
    iocs: list = field(default_factory=list)

    def to_dict(self):
        return {
            "event_id": self.event_id,
            "adversary": self.adversary,
            "capability": self.capability,
            "infrastructure": self.infrastructure,
            "victim": self.victim,
            "timestamp": self.timestamp,
            "phase": self.phase,
            "result": self.result,
            "direction": self.direction,
            "methodology": self.methodology,
            "confidence": self.confidence,
            "mitre_techniques": self.mitre_techniques,
            "iocs": self.iocs,
            "notes": self.notes,
        }

Passo 2: Construir Linha de Atividade a partir de Eventos

import networkx as nx

class DiamondAnalysis:
    def __init__(self):
        self.events = []
        self.graph = nx.DiGraph()

    def add_event(self, event: DiamondEvent):
        self.events.append(event)
        self.graph.add_node(event.event_id, **event.to_dict())

    def build_activity_thread(self):
        """Liga eventos cronologicamente em linhas de atividade."""
        sorted_events = sorted(self.events, key=lambda e: e.timestamp)
        for i in range(len(sorted_events) - 1):
            self.graph.add_edge(
                sorted_events[i].event_id,
                sorted_events[i + 1].event_id,
                relationship="followed_by",
            )

    def find_pivots(self):
        """Encontra pontos de pivô onde eventos compartilham infraestrutura ou capacidades."""
        pivots = {"infrastructure": {}, "capability": {}, "adversary": {}}

        for event in self.events:
            if event.infrastructure:
                pivots["infrastructure"].setdefault(event.infrastructure, []).append(event.event_id)
            if event.capability:
                pivots["capability"].setdefault(event.capability, []).append(event.event_id)

…