yampelo/beagleBeagle ist ein Tool für Incident Response und digitale Forensik, das Sicherheitslogs und Daten in Graphen umwandelt.
Beagle ist ein Tool für Incident Response und digitale Forensik, das Datenquellen und Logs in Graphen umwandelt. Unterstützte Datenquellen umfassen FireEye HX Triages, Windows-EVTX-Dateien, SysMon-Logs und rohe Windows-Arbeitsspeicherabbilder. Die resultierenden Graphen können an Graphdatenbanken wie Neo4J oder DGraph gesendet oder lokal als Python-NetworkX-Objekte gespeichert werden.
Beagle kann entweder direkt als Python-Bibliothek oder über eine bereitgestellte Weboberfläche genutzt werden.
Die Bibliothek kann entweder als Sequenz funktionaler Aufrufe aus einer einzelnen Datenquelle verwendet werden.
>>> from beagle.datasources import SysmonEVTX
>>> graph = SysmonEVTX("malicious.evtx").to_graph()
>>> graph
<networkx.classes.multidigraph.MultiDiGraph at 0x12700ee10>
Als Graph, der aus einer Reihe mehrerer Artefakte erzeugt wird
>>> from beagle.datasources import SysmonEVTX, HXTriage, PCAP
>>> from beagle.backends import NetworkX
>>> nx = NetworkX.from_datasources(
datasources=[
SysmonEVTX("malicious.evtx"),
HXTriage("alert.mans"),
PCAP("traffic.pcap"),
]
)
>>> G = nx.graph()
<networkx.classes.multidigraph.MultiDiGraph at 0x12700ee10>
Oder indem jeder Zwischenschritt des Datenquellen-zu-Graph-Prozesses streng aufgerufen wird.
>>> from beagle.backends import NetworkX
>>> from beagle.datasources import SysmonEVTX
>>> from beagle.transformers import SysmonTransformer
>>> datasource = SysmonEVTX("malicious.evtx")
# Transformatoren nehmen eine Datenquelle und transformieren jedes Ereignis
# in ein Tupel aus einem oder mehreren Knoten.
>>> transformer = SysmonTransformer(datasource=datasource)
>>> nodes = transformer.run()
# Transformatoren geben ein Array von Knoten aus.
[
(<SysMonProc> process_guid="{0ad3e319-0c16-59c8-0000-0010d47d0000}"),
(<File> host="DESKTOP-2C3IQHO" full_path="C:\Windows\System32\services.exe"),
...
]
# Backends nehmen die Knoten und wandeln sie in Graphen um
>>> backend = NetworkX(nodes=nodes)
>>> G = backend.graph()
<networkx.classes.multidigraph.MultiDiGraph at 0x126b887f0>
Graphen konzentrieren sich auf die Aktivitäten einzelner Prozesse und dienen hauptsächlich dazu, Analysten bei der Untersuchung von Aktivitäten auf Hosts zu helfen, nicht zwischen ihnen.
Beagle ist als Docker-Image verfügbar:
docker pull yampelo/beagle
mkdir -p data/beagle
docker run -v "$PWD/data/beagle":"/data/beagle" -p 8000:8000 yampelo/beagle
Es ist auch als Bibliothek verfügbar. Die vollständige API-Dokumentation ist unter https://beagle-graphs.readthedocs.io abrufbar.
pip install pybeagle
Hinweis: Derzeit wird nur Python 3.6+ unterstützt.
Rekall wird nicht automatisch installiert. Um Rekall zu installieren, führen Sie stattdessen den folgenden Befehl aus:
pip install pybeagle[rekall]
Jeder Eintrag in der Konfigurationsdatei kann mithilfe von Umgebungsvariablen geändert werden, die dem folgenden Format folgen: BEAGLE__{SECTION}__{KEY}. Um beispielsweise den VirusTotal-API-Schlüssel zu ändern, der bei der Verwendung des Docker-Images verwendet wird, würden Sie den Parameter -e verwenden und die Variable BEAGLE__VIRUSTOTAL__API_KEY setzen:
docker run -v "data/beagle":"/data/beagle" -p 8000:8000 -e "BEAGLE__VIRUSTOTAL__API_KEY=$API_KEY" beagle
Umgebungsvariablen und Verzeichnisse können mit Docker Compose einfach definiert werden:
version: "3"
services:
beagle:
image: yampelo/beagle
volumes:
- /data/beagle:/data/beagle
ports:
- "8000:8000"
environment:
- BEAGLE__VIRUSTOTAL__API_KEY=$key$
Das Docker-Image von Beagle wird mit einer Weboberfläche geliefert, die sowohl die Umwandlung von Daten in Graphen als auch deren Verwendung zur Untersuchung von Daten umschließt.
Das Upload-Formular umschließt den Graphenerstellungsprozess und verwendet automatisch NetworkX als Backend. Abhängig von den Parametern, die die Datenquelle erfordert, fordert das Formular entweder einen Dateiupload oder eine Texteingabe an. Zum Beispiel:
Jeder erstellte Graph wird lokal in dem Ordner gespeichert, der unter dem Schlüssel dir im Abschnitt storage der Konfiguration definiert ist. Dies kann durch Setzen der Umgebungsvariable BEAGLE__STORAGE__DIR geändert werden.
Optional kann jedem Graph ein Kommentar hinzugefügt werden, um ihn besser zu beschreiben.
Jede Datenquelle extrahiert automatisch Metadaten aus dem bereitgestellten Parameter. Die Metadaten und der Kommentar sind später sichtbar, wenn die vorhandenen Graphen der Datenquelle angezeigt werden.
Durch Klicken auf eine Datenquelle in der Seitenleiste wird eine Tabelle aller analysierten Graphen für diese Datenquelle angezeigt.
Das Anzeigen eines Graphen in Beagle bietet eine Weboberfläche, die es Analysten ermöglicht, schnell durch einen Vorfall zu navigieren.
Die Oberfläche ist in zwei Hauptteile unterteilt: den linken Teil, der verschiedene Perspektiven des Graphen enthält (Graph, Baum, Tabelle usw.), und den rechten Teil, der es Ihnen ermöglicht, Knoten und Kanten nach Typ zu filtern, nach Knoten zu suchen und die Eigenschaften eines Knotens zu erweitern. Außerdem können Sie Aktionen, die Sie am Graphen durchführen, rückgängig machen und wiederholen.
Jedes Element im Graphen, das einen Trennstrich darüber hat, ist zusammenklappbar:
Knoten im Graphen zeigen die ersten 15 Zeichen eines bestimmten Feldes an. Bei einem Prozessknoten ist dies beispielsweise der Prozessname.
Kanten zeigen lediglich den Kantentyp an.
Ein einmaliger Klick auf einen Knoten oder eine Kante fokussiert dieses Element und zeigt seine Informationen im Bereich „Knoteninfo“ in der rechten Seitenleiste an.
Ein Doppelklick auf einen Knoten zieht alle benachbarten Knoten hinzu. Ein benachbarter Knoten ist jeder Knoten, der durch eine Kante mit dem angeklickten Knoten verbunden ist. Wenn es keine Nachbarn gibt, die hinzugezogen werden können, ist keine Änderung im Graphen sichtbar.
Ein langer einmaliger Klick auf einen Knoten blendet ihn sowie alle Kanten, die von ihm abhängen, aus dem Graphen aus.
Ein Rechtsklick auf einen Knoten öffnet ein Kontextmenü, das es Ihnen ermöglicht, Graph-Mutators auszuführen. Mutators sind Funktionen, die den Graphzustand übernehmen und einen neuen Zustand zurückgeben.
Zwei äußerst nützliche Mutators sind:
Das Zurückverfolgen eines Knotens ist äußerst nützlich und ähnelt der Root-Cause-Infektion in Logdateien.
Das Erweitern der Nachkommen eines Knotens ermöglicht es Ihnen, sofort alles anzuzeigen, was aufgrund dieses Knotens passiert ist. Diese Aktion zeigt den Teilgraphen, der an dem ausgewählten Knoten verwurzelt ist.
Manchmal ist ein Knoten oder eine Kante für den aktuellen Vorfall nicht relevant. Sie können Kanten- und Knotentypen ein- und ausschalten. Sobald der Typ umgeschaltet wird, werden die Knoten oder Kanten dieses Typs aus dem sichtbaren Graphen entfernt.
Das Ausschalten eines Knotentyps verhindert, dass dieser Knotentyp bei der Verwendung von Mutators oder beim Hinzuziehen von Nachbarn verwendet wird.
Jede Aktion im Graphen ist sofort umkehrbar! Mit den Schaltflächen „Rückgängig“ und „Wiederholen“ können Sie jede durchgeführte Aktion rückgängig machen. Die „Zurücksetzen“-Schaltfläche setzt den Graphzustand auf den Zeitpunkt des Ladens zurück, sodass Sie ein Neuladen vermeiden.
Während Sie den aktuellen Zustand des Graphen mit den obigen Aktionen ändern, möchten Sie möglicherweise die aktuell sichtbaren Knoten und Kanten auch in einer anderen Perspektive betrachten. Die Registerkarten oben auf dem Graphbildschirm ermöglichen es Ihnen, die Daten in verschiedene Ansichten umzuwandeln:
Jede der Perspektiven unterstützt das Fokussieren auf Knoten durch Klicken.
Der Grapherstellungsprozess kann programmatisch mit der Python-Bibliothek durchgeführt werden. Der Grapherstellungsprozess besteht aus drei Schritten:
DataSource-Klassen parsen Datenquellen und geben Ereignisse einzeln aus.Transformer-Klassen nehmen diese Eingaben und wandeln sie in verschiedene Node-Klassen um, wie z. B. Process.Backend-Klassen nehmen das Array von Knoten, platzieren sie in einer Graphstruktur und senden sie an einen gewünschten Ort.Das Python-Paket kann über pip installiert werden:
pip install pybeagle
Das Erstellen eines Graphen erfordert das Verketten dieser Schritte. Dies kann für Sie mit der Funktion to_graph() erledigt werden.
from beagle.datasources import HXTriage
# Standardmäßig verwendet to_graph() NetworkX und den ersten Transformer.
G = HXTriage('test.mans').to_graph()
<networkx.classes.multidigraph.MultiDiGraph at 0x12700ee10>
Es kann auch explizit in jedem Schritt durchgeführt werden. Mit den funktionalen Aufrufen können Sie auch definieren, welches Backend Sie verwenden möchten, z. B. um Daten an DGraph zu senden.
from beagle.datasources import HXTriage
from beagle.backends import DGraph
from beagle.transformers import FireEyeHXTransformer
# Die Daten werden an die in der Konfigurationsdatei konfigurierte DGraph-Instanz gesendet.
backend = HXTriage('test.mans').to_graph(backend=DGraph)
# Kann auch den Transformer angeben:
backend = HXTriage('test.mans').to_transformer(transformer=FireEyeHXTransformer).to_graph(backend=DGraph)
Beim Aufruf der Methoden to_graph oder to_transformer können Sie beliebige Argumente an diese Klassen übergeben:
from beagle.datasources import HXTriage
from beagle.backends import Graphistry
# An Graphistry senden, Daten zuerst anonymisieren und die URL zurückgeben.
graphistry_url = HXTriage('test.mans').to_graph(backend=Graphistry, anonymize=True, render=False)
Sie können auch jeden Schritt des obigen Prozesses manuell aufrufen und auf die Zwischenausgaben zugreifen.
>>> from beagle.backends import NetworkX
>>> from beagle.datasources import HXTriage
>>> from beagle.transformers import FireEyeHXTransformer
>>> datasource = HXTriage("test.mans")
>>> transformer = FireEyeHXTransformer(datasource=datasource)
>>> nodes = transformer.run()
>>> backend = NetworkX(nodes=nodes)
>>> G = backend.graph()
Wenn Sie jeden Schritt manuell aufrufen möchten, müssen Sie sicherstellen, dass die Transformer-Klasseninstanz mit der Ausgabe der bereitgestellten DataSource-Klasse kompatibel ist.
Jede Datenquelle definiert die Liste der Transformatoren, mit denen sie kompatibel ist. Diese kann über das Attribut .transformers abgerufen werden:
>>> from beagle.datasources import HXTriage
>>> HXTriage.transformers
[beagle.transformers.fireeye_hx_transformer.FireEyeHXTransformer]
Standardmäßig werden Kanten nicht verdichtet. Das bedeutet, dass ein Prozessknoten u 5000 Mal in einen Dateiknoten v schreibt, dann werden 5000 Kanten zwischen diesen Knoten vorhanden sein. Dies kann einen Analysten vor allem bei der Visualisierung der Daten überfordern.
Sie können alle 5000 Kanten zu einer einzigen Kante für diesen Aktionstyp (in diesem Fall 'geschrieben') verdichten, indem Sie dem Backend den Parameter consolidate_edges=True übergeben. Zum Beispiel:
SysmonEVTX("data/sysmon/autoruns-sysmon.evtx").to_graph(NetworkX, consolidate_edges=False)
# Graph enthält 826 Knoten und 2469 Kanten.
SysmonEVTX("data/sysmon/autoruns-sysmon.evtx").to_graph(NetworkX, consolidate_edges=True)
# Graph enthält 826 Knoten und 1396 Kanten
Standardmäßig verdichtet die Weboberfläche die Kanten.
Die Verwendung des NetworkX-Backends ermöglicht es Ihnen, den resultierenden Graphen als JSON-Objekt zu speichern und für später aufzubewahren. Sie können die statische Methode NetworkX.from_json verwenden, um ihn wieder zu laden.
import json
from beagle.datasources import SysmonEVTX
from beagle.backends import NetworkX
# Ein nx.MultiDiGraph-Objekt zurückerhalten
graph = SysmonEVTX("malicious.evtx").to_graph()
# Das Objekt in JSON konvertieren
graph_json = NetworkX.graph_to_json(graph)
with open("my_graph.json", "w") as f:
json.dump(graph_json, f)
# Später:
# G ist dasselbe nx.MultiDiGraph-Objekt, das von .to_graph() erzeugt wurde.
G = NetworkX.from_json("my_graph.json")