yampelo/beagleBeagle एक घटना प्रतिक्रिया और डिजिटल फोरेंसिक उपकरण है जो सुरक्षा लॉग और डेटा को ग्राफ़ में बदलता है।
बीगल एक घटना प्रतिक्रिया और डिजिटल फोरेंसिक उपकरण है जो डेटा स्रोतों और लॉग को ग्राफ़ में रूपांतरित करता है। समर्थित डेटा स्रोतों में FireEye HX Triages, Windows EVTX फ़ाइलें, SysMon लॉग और रॉ Windows मेमोरी इमेज शामिल हैं। परिणामी ग्राफ़ को Neo4J या DGraph जैसे ग्राफ़ डेटाबेस पर भेजा जा सकता है, या उन्हें स्थानीय रूप से Python NetworkX ऑब्जेक्ट के रूप में रखा जा सकता है।
बीगल को सीधे पायथन लाइब्रेरी के रूप में या प्रदान किए गए वेब इंटरफ़ेस के माध्यम से उपयोग किया जा सकता है।
लाइब्रेरी का उपयोग एकल डेटासोर्स से फ़ंक्शनल कॉल के अनुक्रम के रूप में किया जा सकता है।
>>> from beagle.datasources import SysmonEVTX
>>> graph = SysmonEVTX("malicious.evtx").to_graph()
>>> graph
<networkx.classes.multidigraph.MultiDiGraph at 0x12700ee10>
कई आर्टिफैक्ट के सेट से उत्पन्न ग्राफ़ के रूप में
>>> 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>
या डेटा स्रोत से ग्राफ़ प्रक्रिया के प्रत्येक मध्यवर्ती चरण को सख्ती से कॉल करके।
>>> from beagle.backends import NetworkX
>>> from beagle.datasources import SysmonEVTX
>>> from beagle.transformers import SysmonTransformer
>>> datasource = SysmonEVTX("malicious.evtx")
# Transformers take a datasource, and transform each event
# into a tuple of one or more nodes.
>>> transformer = SysmonTransformer(datasource=datasource)
>>> nodes = transformer.run()
# Transformers output an array of nodes.
[
(<SysMonProc> process_guid="{0ad3e319-0c16-59c8-0000-0010d47d0000}"),
(<File> host="DESKTOP-2C3IQHO" full_path="C:\Windows\System32\services.exe"),
...
]
# Backends take the nodes, and transform them into graphs
>>> backend = NetworkX(nodes=nodes)
>>> G = backend.graph()
<networkx.classes.multidigraph.MultiDiGraph at 0x126b887f0>
ग्राफ़ व्यक्तिगत प्रक्रियाओं की गतिविधि के आसपास केंद्रित होते हैं, और मुख्य रूप से विश्लेषकों को होस्ट पर गतिविधि की जांच करने में मदद करने के लिए होते हैं, न कि उनके बीच।
बीगल डॉकर फ़ाइल के रूप में उपलब्ध है:
docker pull yampelo/beagle
mkdir -p data/beagle
docker run -v "$PWD/data/beagle":"/data/beagle" -p 8000:8000 yampelo/beagle
यह लाइब्रेरी के रूप में भी उपलब्ध है। पूर्ण API दस्तावेज़ीकरण https://beagle-graphs.readthedocs.io पर उपलब्ध है।
pip install pybeagle
नोट: वर्तमान में केवल Python 3.6+ समर्थित है।
Rekall स्वचालित रूप से स्थापित नहीं है। Rekall स्थापित करने के लिए निम्नलिखित कमांड चलाएँ:
pip install pybeagle[rekall]
कॉन्फ़िगरेशन फ़ाइल में किसी भी प्रविष्टि को पर्यावरण चर का उपयोग करके संशोधित किया जा सकता है जो निम्नलिखित प्रारूप का पालन करते हैं: BEAGLE__{SECTION}__{KEY}। उदाहरण के लिए, डॉकर इमेज का उपयोग करते समय VirusTotal API Key बदलने के लिए, आप -e पैरामीटर का उपयोग करेंगे और BEAGLE__VIRUSTOTAL__API_KEY वेरिएबल सेट करेंगे:
docker run -v "data/beagle":"/data/beagle" -p 8000:8000 -e "BEAGLE__VIRUSTOTAL__API_KEY=$API_KEY" beagle
पर्यावरण चर और निर्देशिकाओं को docker compose का उपयोग करके आसानी से परिभाषित किया जा सकता है
version: "3"
services:
beagle:
image: yampelo/beagle
volumes:
- /data/beagle:/data/beagle
ports:
- "8000:8000"
environment:
- BEAGLE__VIRUSTOTAL__API_KEY=$key$
बीगल की डॉकर इमेज एक वेब इंटरफ़ेस के साथ आती है जो डेटा को ग्राफ़ में बदलने और उनका उपयोग करके डेटा की जांच करने की प्रक्रिया को लपेटता है।
अपलोड फ़ॉर्म ग्राफ़ निर्माण प्रक्रिया को लपेटता है, और स्वचालित रूप से NetworkX को बैकएंड के रूप में उपयोग करता है। डेटा स्रोत द्वारा आवश्यक पैरामीटर के आधार पर, फ़ॉर्म या तो फ़ाइल अपलोड के लिए संकेत देगा, या टेक्स्ट इनपुट के लिए। उदाहरण के लिए:
बनाया गया कोई भी ग्राफ़ कॉन्फ़िगरेशन में storage अनुभाग के dir कुंजी के अंतर्गत परिभाषित फ़ोल्डर में स्थानीय रूप से संग्रहीत किया जाता है। इसे BEAGLE__STORAGE__DIR पर्यावरण चर सेट करके संशोधित किया जा सकता है।
वैकल्पिक रूप से, किसी भी ग्राफ़ में बेहतर वर्णन में मदद के लिए एक टिप्पणी जोड़ी जा सकती है।
प्रत्येक डेटा स्रोत स्वचालित रूप से प्रदान किए गए पैरामीटर से मेटाडेटा निकालेगा। मेटाडेटा और टिप्पणी बाद में डेटासोर्स के मौजूदा ग्राफ़ देखते समय दिखाई देती हैं।
साइडबार पर डेटासोर्स पर क्लिक करने से उस डेटासोर्स के लिए सभी पार्स किए गए ग्राफ़ की एक तालिका प्रस्तुत होती है।
बीगल में ग्राफ़ देखना एक वेब इंटरफ़ेस प्रदान करता है जो विश्लेषकों को किसी घटना के आसपास तुरंत घूमने की अनुमति देता है।
इंटरफ़ेस दो मुख्य भागों में विभाजित है, बायां भाग जिसमें ग्राफ़ के विभिन्न दृष्टिकोण (ग्राफ़, ट्री, टेबल, आदि) होते हैं, और दायां भाग जो आपको प्रकार के अनुसार नोड और एज को फ़िल्टर करने, नोड खोजने और नोड के गुणों का विस्तार करने की अनुमति देता है। यह आपको ग्राफ़ पर किए गए ऑपरेशन को पूर्ववत और पुनर्क्रिया करने की भी अनुमति देता है।
ग्राफ़ में कोई भी तत्व जिसके ऊपर एक विभाजक है, संक्षिप्त किया जा सकता है:
ग्राफ़ में नोड एक विशिष्ट फ़ील्ड के पहले 15 अक्षर प्रदर्शित करते हैं। उदाहरण के लिए, एक प्रक्रिया नोड के लिए, यह प्रक्रिया का नाम होगा।
एज केवल एज प्रकार दिखाते हैं।
नोड या एज पर एक एकल क्लिक उस नोड पर फ़ोकस करेगा और दाएं साइडबार में "नोड जानकारी" पैनल में उसकी जानकारी प्रदर्शित करेगा।
नोड पर डबल क्लिक किसी भी पड़ोसी नोड को खींच लाएगा। पड़ोसी नोड कोई भी नोड होता है जो क्लिक किए गए नोड से एक एज द्वारा जुड़ा होता है। यदि खींचने के लिए कोई पड़ोसी नहीं हैं, तो ग्राफ़ में कोई बदलाव नहीं दिखेगा।
नोड पर एक लंबा एकल क्लिक इसे ग्राफ़ से छिपा देगा, साथ ही उस पर निर्भर किसी भी एज को भी।
नोड पर राइट क्लिक करने से एक संदर्भ मेनू प्रकट होता है जो आपको ग्राफ़ म्यूटेटर चलाने की अनुमति देता है। म्यूटेटर ऐसे फ़ंक्शन होते हैं जो ग्राफ़ स्थिति लेते हैं और एक नई स्थिति लौटाते हैं।
दो अत्यंत उपयोगी म्यूटेटर हैं:
कभी-कभी, कोई नोड या एज वर्तमान घटना से प्रासंगिक नहीं हो सकता है, आप एज और नोड प्रकारों को चालू और बंद कर सकते हैं। जैसे ही प्रकार टॉगल किया जाता है, उस प्रकार के नोड या एज दृश्य ग्राफ़ से हटा दिए जाते हैं।
किसी नोड प्रकार को बंद करने से उस नोड प्रकार का उपयोग म्यूटेटर का उपयोग करते समय, या पड़ोसियों को खींचते समय रोका जाता है।
ग्राफ़ में कोई भी कार्रवाई तुरंत प्रतिवर्ती है! पूर्ववत/पुनर्क्रिया बटन का उपयोग करके आप अपने द्वारा की गई किसी भी कार्रवाई को पूर्ववत कर सकते हैं। रीसेट बटन ग्राफ़ स्थिति को लोड होने के समय पर सेट करता है, जिससे आपको रीफ्रेश करने की आवश्यकता नहीं होती।
जैसे-जैसे आप उपरोक्त कार्रवाई का उपयोग करके ग्राफ़ की वर्तमान स्थिति बदलते हैं, आप दृश्य नोड और एज के वर्तमान सेट को एक अलग दृष्टिकोण से देखना चाह सकते हैं। ग्राफ़ स्क्रीन के शीर्ष पर टैब आपको डेटा को विभिन्न दृश्यों में बदलने की अनुमति देते हैं:
प्रत्येक दृष्टिकोण नोड पर क्लिक करके उन पर फ़ोकस करने का समर्थन करता है।
ग्राफ़ निर्माण प्रक्रिया को पायथन लाइब्रेरी का उपयोग करके प्रोग्रामेटिक रूप से किया जा सकता है। ग्राफ़ निर्माण प्रक्रिया तीन चरणों से बनी है:
DataSource वर्ग इवेंट को एक-एक करके पार्स और उत्पन्न करते हैं।Transformer वर्ग उन इनपुट को लेते हैं और उन्हें विभिन्न Node वर्गों जैसे Process में रूपांतरित करते हैं।Backend वर्ग नोड की सरणी लेते हैं, उन्हें ग्राफ़ संरचना में रखते हैं, और उन्हें वांछित स्थान पर भेजते हैं।पायथन पैकेज को pip के माध्यम से स्थापित किया जा सकता है:
pip install pybeagle
ग्राफ़ बनाने के लिए इन्हें एक साथ जोड़ना आवश्यक है। यह आपके लिए to_graph() फ़ंक्शन का उपयोग करके किया जा सकता है।
from beagle.datasources import HXTriage
# By default, using the to_graph() class uses NetworkX and the first transformer.
G = HXTriage('test.mans').to_graph()
<networkx.classes.multidigraph.MultiDiGraph at 0x12700ee10>
इसे प्रत्येक चरण में स्पष्ट रूप से भी किया जा सकता है। फ़ंक्शनल कॉल का उपयोग करके, आप यह भी परिभाषित कर सकते हैं कि आप किस बैकएंड का उपयोग करना चाहते हैं, उदाहरण के लिए, DGraph को डेटा भेजने के लिए
from beagle.datasources import HXTriage
from beagle.backends import DGraph
from beagle.transformers import FireEyeHXTransformer
# The data will be sent to the DGraph instance configured in the
# configuration file
backend = HXTriage('test.mans').to_graph(backend=DGraph)
# Can also specify the transformer
backend = HXTriage('test.mans').to_transformer(transformer=FireEyeHXTransformer).to_graph(backend=DGraph)
to_graph या to_transformer विधियों को कॉल करते समय, आप उन वर्गों में कोई भी तर्क पास कर सकते हैं:
from beagle.datasources import HXTriage
from beagle.backends import Graphistry
# Send the graphistry, anonymize the data first, and return the URL
graphistry_url = HXTriage('test.mans').to_graph(backend=Graphistry, anonymize=True, render=False)
आप उपरोक्त प्रक्रिया में प्रत्येक चरण को मैन्युअल रूप से भी लागू कर सकते हैं, मध्यवर्ती आउटपुट तक पहुँच सकते हैं
>>> 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()
यदि आप प्रत्येक चरण को मैन्युअल रूप से कॉल करना चाहते हैं, तो आपको यह सुनिश्चित करना होगा कि Transformer वर्ग का इंस्टेंस प्रदान किए गए DataSource वर्ग के आउटपुट के साथ संगत है।
प्रत्येक डेटा स्रोत उन ट्रांसफॉर्मर की सूची को परिभाषित करता है जिनके साथ वह संगत है, और इसे .transformers विशेषता के माध्यम से एक्सेस किया जा सकता है:
>>> from beagle.datasources import HXTriage
>>> HXTriage.transformers
[beagle.transformers.fireeye_hx_transformer.FireEyeHXTransformer]
डिफ़ॉल्ट रूप से, एज संघनित नहीं होते हैं, इसका मतलब है कि यदि कोई प्रक्रिया नोड u एक फ़ाइल नोड v को 5000 बार लिखता है, तो उन नोड के बीच 5000 एज होंगे। कभी-कभी, विशेष रूप से डेटा को विज़ुअलाइज़ करने का प्रयास करते समय, यह एक विश्लेषक को अभिभूत कर सकता है।
आप बैकएंड वर्ग को consolidate_edges=True पैरामीटर पास करके उस प्रकार की कार्रवाई (इस मामले में लिखा) के लिए सभी 5000 एज को एक एकल एज में संघनित कर सकते हैं, उदाहरण के लिए:
SysmonEVTX("data/sysmon/autoruns-sysmon.evtx").to_graph(NetworkX, consolidate_edges=False)
# Graph contains 826 nodes and 2469 edges.
SysmonEVTX("data/sysmon/autoruns-sysmon.evtx").to_graph(NetworkX, consolidate_edges=True)
# Graph contains 826 nodes and 1396 edges
डिफ़ॉल्ट रूप से, वेब इंटरफ़ेस एज को संघनित करेगा।
NetworkX बैकएंड का उपयोग करके आप परिणामी ग्राफ़ को JSON ऑब्जेक्ट के रूप में सहेज सकते हैं, इसे बाद के लिए संग्रहीत कर सकते हैं। आप इसे वापस लोड करने के लिए NetworkX.from_json स्टेटिक विधि का उपयोग कर सकते हैं।
import json
from beagle.datasources import SysmonEVTX
from beagle.backends import NetworkX
# Get back a nx.MultiDiGraph object
graph = SysmonEVTX("malicious.evtx").to_graph()
# Convert the object to JSON
graph_json = NetworkX.graph_to_json(graph)
with open("my_graph.json", "w") as f:
json.dump(graph_json, f)
# Later on:
# G is the same nx.MultiDiGraph object generated by `.to_graph()`
G = NetworkX.from_json("my_graph.json")