Kampagnenzuordnungsbeweise analysieren

Beweise für die Kampagnenzuordnung analysieren

Überblick

Die Kampagnenzuordnungsanalyse umfasst die systematische Auswertung von Beweisen, um zu bestimmen, welcher Bedrohungsakteur oder welche Gruppe für eine Cyber-Operation verantwortlich ist. Diese Fähigkeit behandelt die Sammlung und Gewichtung von Zuordnungsindikatoren mithilfe des Diamond Models und der ACH (Analyse konkurrierender Hypothesen), die Analyse von Infrastrukturüberschneidungen, TTP-Konsistenz, Ähnlichkeiten von Malware-Code, operativen Zeitmustern und Sprachartefakten, um vertrauensgewichtete Zuordnungsbewertungen zu erstellen.

Wann verwenden

• Bei der Untersuchung von Sicherheitsvorfällen, die eine Analyse von Kampagnenzuordnungsbeweisen erfordern
• Beim Erstellen von Erkennungsregeln oder Bedrohungsjagdabfragen für diesen Bereich
• Wenn SOC-Analysten strukturierte Verfahren für diesen Analysetyp benötigen
• Bei der Validierung der Sicherheitsüberwachungsabdeckung für zugehörige Angriffstechniken

Voraussetzungen

• Python 3.9+ mit attackcti, stix2, networkx Bibliotheken
• Zugang zu Threat-Intelligence-Plattformen (MISP, OpenCTI)
• Verständnis des Diamond Model of Intrusion Analysis
• Vertrautheit mit MITRE ATT&CK Bedrohungsgruppenprofilen
• Kenntnisse in Malware-Analyse und Infrastruktur-Tracking-Techniken

Schlüsselkonzepte

Kategorien von Zuordnungsbeweisen

1. Infrastrukturüberschneidung: Gemeinsame C2-Server, Domains, IP-Bereiche, Hosting-Anbieter
2. TTP-Konsistenz: Übereinstimmende ATT&CK-Techniken und Untertechniken über Kampagnen hinweg
3. Ähnlichkeit von Malware-Code: Gemeinsame Codebasen, Compiler, PDB-Pfade, Verschlüsselungsroutinen
4. Operative Muster: Timing (Arbeitszeiten, Zeitzonen), Zielmuster, operatives Tempo
5. Sprachartefakte: Eingebettete Zeichenfolgen, Variablennamen, Fehlermeldungen in bestimmten Sprachen
6. Viktimologie: Konsistenz des Zielsektors, der Geografie und des organisatorischen Profils

Vertrauensniveaus

• Hohe Zuversicht: Mehrere unabhängige Beweiskategorien konvergieren auf denselben Akteur
• Mäßige Zuversicht: Mehrere Beweiskategorien stimmen überein, es bleiben Unklarheiten
• Niedrige Zuversicht: Begrenzte Beweise, mögliche Falschmeldungen oder gemeinsame Toolnutzung

Analyse konkurrierender Hypothesen (ACH)

Strukturierte Analysemethode, die Beweise gegen mehrere konkurrierende Hypothesen bewertet. Jedes Beweisstück wird als konsistent, inkonsistent oder neutral in Bezug auf jede Hypothese bewertet. Die Hypothese mit den wenigsten inkonsistenten Beweisen wird bevorzugt.

Arbeitsablauf

Schritt 1: Zuordnungsbeweise sammeln

from stix2 import MemoryStore, Filter
from collections import defaultdict

class AttributionAnalyzer:
    def __init__(self):
        self.evidence = []
        self.hypotheses = {}

    def add_evidence(self, category, description, value, confidence):
        self.evidence.append({
            "category": category,
            "description": description,
            "value": value,
            "confidence": confidence,
            "timestamp": None,
        })

    def add_hypothesis(self, actor_name, actor_id=""):
        self.hypotheses[actor_name] = {
            "actor_id": actor_id,
            "consistent_evidence": [],
            "inconsistent_evidence": [],
            "neutral_evidence": [],
            "score": 0,
        }

    def evaluate_evidence(self, evidence_idx, actor_name, assessment):
        """Bewertet Beweise gegen eine Hypothese: consistent/inconsistent/neutral."""
        if assessment == "consistent":
            self.hypotheses[actor_name]["consistent_evidence"].append(evidence_idx)
            self.hypotheses[actor_name]["score"] += self.evidence[evidence_idx]["confidence"]
        elif assessment == "inconsistent":
            self.hypotheses[actor_name]["inconsistent_evidence"].append(evidence_idx)
            self.hypotheses[actor_name]["score"] -= self.evidence[evidence_idx]["confidence"] * 2
        else:
            self.hypotheses[actor_name]["neutral_evidence"].append(evidence_idx)

    def rank_hypotheses(self):
        """Ordnet Hypothesen nach Zuordnungspunktzahl."""
        ranked = sorted(
            self.hypotheses.items(),
            key=lambda x: x[1]["score"],
            reverse=True,
        )
        return [
            {
                "actor": name,
                "score": data["score"],
                "consistent": len(data["consistent_evidence"]),
                "inconsistent": len(data["inconsistent_evidence"]),
                "confidence": self._score_to_confidence(data["score"]),
            }
            for name, data in ranked
        ]

    def _score_to_confidence(self, score):
        if score >= 80:
            return "HIGH"
        elif score >= 40:
            return "MODERATE"
        else:
            return "LOW"

Schritt 2: Analyse der Infrastrukturüberschneidung

def analyze_infrastructure_overlap(campaign_a_infra, campaign_b_infra):
    """Vergleicht die Infrastruktur zwischen zwei Kampagnen zur Zuordnung."""
    overlap = {
        "shared_ips": set(campaign_a_infra.get("ips", [])).intersection(
            campaign_b_infra.get("ips", [])
        ),
        "shared_domains": set(campaign_a_infra.get("domains", [])).intersection(
            campaign_b_infra.get("domains", [])
        ),
        "shared_asns": set(campaign_a_infra.get("asns", [])).intersection(
            campaign_b_infra.get("asns", [])
        ),
        "shared_registrars": set(campaign_a_infra.get("registrars", [])).intersection(
            campaign_b_infra.get("registrars", [])
        ),
    }

    overlap_score = 0
    if overlap["shared_ips"]:
        overlap_score += 30
    if overlap["shared_domains"]:
        overlap_score += 25
    if overlap["shared_asns"]:
        overlap_score += 15
    if overlap["shared_registrars"]:
        overlap_score += 10

    return {
        "overlap": {k: list(v) for k, v in overlap.items()},
        "overlap_score": overlap_score,
        "assessment": "STRONG" if overlap_score >= 40 else "MODERATE" if overlap_score >= 20 else "WEAK",
    }

Schritt 3: TTP-Vergleich über Kampagnen hinweg

from attackcti import attack_client

def compare_campaign_ttps(campaign_techniques, known_actor_techniques):
    """Vergleicht Kampagnen-TTPs mit bekannten Bedrohungsakteurprofilen."""
    campaign_set = set(campaign_techniques)
    actor_set = set(known_actor_techniques)

    common = campaign_set.intersection(actor_set)
    unique_campaign = campaign_set - actor_set
    unique_actor = actor_set - campaign_set

    jaccard = len(common) / len(campaign_set.union(actor_set)) if campaign_set.union(actor_set) else 0

    return {
        "common_techniques": sorted(common),
        "common_count": len(common),
        "unique_to_campaign": sorted(unique_campaign),
        "unique_to_actor": sorted(unique_actor),
        "jaccard_similarity": round(jaccard, 3),
        "overlap_percentage": round(len(common) / len(campaign_set) * 100, 1) if campaign_set else 0,
    }

Schritt 4: Zuordnungsbericht erstellen

def generate_attribution_report(analyzer):
    """Erstellt einen strukturierten Zuordnungsbewertungsbericht."""
    rankings = analyzer.rank_hypotheses()

    report = {
        "assessment_date": "2026-02-23",
        "total_evidence_items": len(analyzer.evidence),
        "hypotheses_evaluated": len(analyzer.hypotheses),
        "rankings": rankings,
        "primary_attribution": rankings[0] if rankings else None,
        "evidence_summary": [
            {
                "index": i,
                "category": e["category"],
                "description": e["description"],
                "confidence": e["confidence"],
            }
            for i, e in enumerate(analyzer.evidence)
        ],
    }

    return report

Validierungskriterien

• Die Beweissammlung deckt alle sechs Zuordnungskategorien ab
• Die ACH-Matrix bewertet Beweise ordnungsgemäß gegen konkurrierende Hypothesen
• Die Analyse der Infrastrukturüberschneidung identifiziert gemeinsame Indikatoren
• Der TTP-Vergleich verwendet ATT&CK-Technikkennungen für Präzision
• Die Vertrauensniveaus der Zuordnung sind ordnungsgemäß begründet
• Der Bericht enthält alternative Hypothesen und Überlegungen zu Falschmeldungen

Referenzen

• Diamond Model of Intrusion Analysis
• MITRE ATT&CK Groups
• Analysis of Competing Hypotheses
• Threat Attribution Framework