Karton

Python, Redis और S3 पर आधारित वितरित मैलवेयर प्रोसेसिंग फ्रेमवर्क।

विचार

Karton लचीले और हल्के मैलवेयर विश्लेषण बैकएंड बनाने के लिए एक मजबूत फ्रेमवर्क है। इसका उपयोग मैलवेयर* विश्लेषण प्रणालियों को बहुत कम प्रयास में एक मजबूत पाइपलाइन में जोड़ने के लिए किया जा सकता है।

हम लंबे समय से ऑटोमेशन के काम में हैं। हमें अधिक से अधिक खतरों का सामना करना पड़ रहा है, और घटनाओं से निपटने के लिए हमें सब कुछ स्वचालित करना पड़ता है। इस कारण से, हम अक्सर कई स्क्रिप्ट्स को बत्तख डक्ट टेप और WD-40 से जोड़कर रख देते हैं। ये स्क्रिप्ट्स विश्लेषकों द्वारा क्षणिक उत्साह में लिखी जाती हैं, नाजुक और बदसूरत - लेकिन वे काम करती हैं, और ऐसी इंटेल पैदा करती हैं जिसे संग्रहीत, आगे संसाधित, अन्य प्रणालियों को भेजा या अन्य संगठनों के साथ साझा किया जाना चाहिए।

हमें एक ऐसा तरीका चाहिए था जिससे हम अपनी PoC स्क्रिप्ट्स को आसानी से अपनी विश्लेषण पाइपलाइन में डाल सकें। हम उनके निष्पादन की निगरानी करना, लॉगिंग को केंद्रीकृत करना, मजबूती में सुधार करना, विकास की जड़ता को कम करना चाहते थे... इसी उद्देश्य के लिए, हमने Karton बनाया।

* हालांकि Karton को मैलवेयर विश्लेषण को ध्यान में रखकर डिज़ाइन किया गया था, यह हर माइक्रोसर्विस-उन्मुख प्रोजेक्ट में अच्छी तरह काम करता है।

इंस्टॉलेशन

इंस्टॉलेशन एक ही pip install कमांड जितना आसान है:

pip3 install karton-core

पूरा बैकएंड वातावरण सेटअप करने के लिए आपको S3-संगत स्टोरेज और Redis की भी आवश्यकता होगी, विवरण के लिए docs देखें।

उदाहरण उपयोग

karton का उपयोग करने के लिए आपको Karton से इनहेरिट करने वाली क्लास प्रदान करनी होगी।

from karton.core import Karton, Task, Resource


class GenericUnpacker(Karton):
    """
    Performs sample unpacking
    """

    identity = "karton.generic-unpacker"
    filters = [
        {
            "type": "sample", 
            "kind": "runnable", 
            "platform": "win32"
        }
    ]

    def process(self, task: Task) -> None:
        # Get sample object
        packed_sample = task.get_resource("sample")
        # Log with self.log
        self.log.info(f"Hi {packed_sample.name}, let me analyze you!")
        ...
        # Send our results for further processing or reporting
        task = Task(
            {
                "type": "sample", 
                "kind": "raw"
            },
            payload={
                "parent": packed_sample, 
                "sample": Resource(filename, unpacked)
            },
        )
        self.send_task(task)


if __name__ == "__main__":
    GenericUnpacker.main()

कमांड लाइन

यह पैकेज "karton" नामक एक कमांड-लाइन उपयोगिता भी प्रदान करता है। आप इसका उपयोग सरल प्रबंधन कार्यों के लिए कर सकते हैं (लेकिन यह पूरी तरह से सक्षम प्रबंधन उपकरण के रूप में डिज़ाइन नहीं किया गया है)।

$ karton configure  # create a new configuration file

$ karton list -s  # list current binds
karton name                                        version    karton
------------------------------------------------------------------------
karton.yaramatcher                                 1.2.0      5.3.0
karton.autoit-ripper                               1.2.1      5.3.3
karton.mwdb-reporter                               1.3.0      5.3.2

$ karton logs  # start streaming all system logs

$ karton delete karton.something  # remove unused bind (will be GCed by system during the next operation)

Karton सिस्टम्स

कुछ Karton सिस्टम्स सार्वभौमिक हैं और सभी के लिए उपयोगी हैं। हमने उन्हें समुदाय के साथ साझा करने का निर्णय लिया।

karton

यह रिपॉजिटरी। इसमें karton.system सेवा है - मुख्य सेवा, जो सिस्टम के भीतर कार्यों को वितरित करने के लिए जिम्मेदार है। इसमें karton.core मॉड्यूल भी है, जिसका उपयोग अन्य सिस्टम्स द्वारा लाइब्रेरी के रूप में किया जाता है।

karton-dashboard

कार्य और कतार प्रबंधन और निगरानी के लिए एक छोटा Flask डैशबोर्ड।

karton-classifier

"राउटर"। यह सैंपल्स/फाइलों को पहचानता है और फाइल प्रारूप के आधार पर विभिन्न कार्य प्रकार उत्पन्न करता है। इसके कारण, अन्य सिस्टम्स केवल एक विशिष्ट प्रारूप वाले कार्यों को सुन सकते हैं (उदाहरण के लिए, केवल zip आर्काइव)।

karton-archive-extractor

जेनेरिक आर्काइव अनपैकर। सिस्टम में अपलोड किए गए आर्काइव निकाले जाएंगे, और प्रत्येक फाइल को अलग-अलग संसाधित किया जाएगा।

karton-config-extractor

मैलवेयर एक्सट्रैक्टर। यह मैलवेयर सैंपल्स और विश्लेषणों से स्थिर कॉन्फ़िगरेशन निकालने के लिए Yara नियमों और Python मॉड्यूल का उपयोग करता है। यह एक मछली पकड़ने की छड़ी है, मछली नहीं - हम मॉड्यूल स्वयं साझा नहीं करते। लेकिन अपना खुद का लिखना आसान है!

karton-mwdb-reporter

पाइपलाइन का एक बहुत महत्वपूर्ण हिस्सा। रिपोर्टर विश्लेषण के दौरान उत्पन्न सभी फाइलें, टैग, टिप्पणियां और अन्य इंटेल MWDB को सबमिट करता है। यदि आप अभी तक MWDB का उपयोग नहीं करते हैं या अन्य बैकएंड पसंद करते हैं, तो अपना खुद का रिपोर्टर लिखना आसान है।

karton-yaramatcher

पाइपलाइन में सभी फाइलों पर स्वचालित रूप से Yara नियम चलाता है, और सैंपल्स को उचित रूप से टैग करता है। नियम शामिल नहीं हैं ;)।

karton-asciimagic

Karton सिस्टम जो सामान्य विधियों से एन्कोड की गई फाइलों को डिकोड करता है, जैसे hex, base64, आदि। (आप विश्वास नहीं करेंगे कि यह कितना सामान्य है)।

karton-autoit-ripper

AutoIt-Ripper के चारों ओर एक छोटा रैपर जो कंपाइल किए गए AutoIt एक्जीक्यूटेबल्स से एम्बेडेड AutoIt स्क्रिप्ट्स और संसाधन निकालता है।

DRAKVUF Sandbox

DRAKVUF इंजन के साथ स्वचालित ब्लैक-बॉक्स मैलवेयर विश्लेषण प्रणाली, जिसके लिए गेस्ट OS पर एजेंट की आवश्यकता नहीं होती।

---

इस प्रकार इन सिस्टम्स का उपयोग एक बुनियादी मैलवेयर विश्लेषण पाइपलाइन बनाने के लिए किया जा सकता है:

Karton फ्रेमवर्क को शामिल करने वाले समुदाय प्रोजेक्ट्स

c3rb3ru5d3d53c/karton-unpacker

एक मॉड्यूलर Karton फ्रेमवर्क सेवा जो Qiling फ्रेमवर्क का उपयोग करके UPX और अन्य जैसे सामान्य पैकर्स को अनपैक करती है।

c3rb3ru5d3d53c/mwcfg / c3rb3ru5d3d53c/mwcfg-modules

MalDuck के लिए एक फीचर-समृद्ध मॉड्यूलर मैलवेयर कॉन्फ़िगरेशन एक्सट्रैक्शन उपयोगिता

raw-data/karton-die-classifier

Karton फ्रेमवर्क के लिए Detect-It-Easy क्लासिफायर

raw-data/karton-retdec-unpacker

Karton फ्रेमवर्क के लिए RetDec अनपैकर मॉड्यूल

W3ndige/aurora / W3ndige/karton-similarity

मॉड्यूलरिटी को ध्यान में रखकर बनाया गया मैलवेयर समानता प्लेटफॉर्म।

splintersfury/driver_analyzer

एक स्केलेबल Windows ड्राइवर भेद्यता विश्लेषक पाइपलाइन।