Snaffler

इसका उद्देश्य क्या है?

Snaffler पेंटेस्टर्स और रेड टीमर्स के लिए एक उपकरण है, जो एक बड़े, उबाऊ घास के ढेर (एक विशाल Windows/AD वातावरण) में स्वादिष्ट कैंडी सुइयाँ (मुख्यतः क्रेडेंशियल्स, लेकिन यह लचीला है) खोजने में मदद करता है।

यह अन्य काम करने वाले लोगों के लिए भी उपयोगी हो सकता है, लेकिन यह स्पष्ट रूप से एक "ऑडिट" उपकरण होने के लिए नहीं बनाया गया है।

मैं यह सब पढ़ना नहीं चाहता!!!

उफ़, ठीक है। लेकिन हम परिणामों के लिए जिम्मेदार नहीं हैं। हमने आपके लिए यह सब लिखा है, लेकिन कोई बात नहीं। हम नाराज़ नहीं हैं, बस निराश हैं।

snaffler.exe -s -o snaffler.log

यह क्या करता है?

मोटे तौर पर - यह Active Directory से विंडोज कंप्यूटरों की एक सूची प्राप्त करता है, फिर उन सभी तक अपने स्नैफली उपांग फैलाता है ताकि पता चल सके कि किनमें फ़ाइल शेयर हैं, और क्या आप उन्हें पढ़ सकते हैं।

फिर और भी अधिक स्नैफली उपांग उन शेयरों में सभी फ़ाइलों की गणना करते हैं और मशीनों के लिए सीखी गई कृत्रिम बुद्धिमत्ता (L.A.I.M.) का उपयोग करके यह पता लगाते हैं कि आप जैसे गंदे छोटे हैकर को कौन सी फ़ाइलें चाहिए।

वास्तव में यह कोई ML काम नहीं करता, क्योंकि इसे सही ढंग से करने के लिए प्रशिक्षण डेटा की आवश्यकता होगी, और उसके लिए भारी समय लगेगा जो हमारे पास नहीं है। इसके बजाय, सभी अच्छे "ML" प्रोजेक्ट्स की तरह, यह ढेर सारे if स्टेटमेंट्स और रेगेक्सेन का उपयोग करता है।

यह कैसा दिखता है?

इस तरह!

मैं इसका उपयोग कैसे करूँ?

यदि आप "सचमुच EXE को डोमेन से जुड़ी मशीन पर डोमेन उपयोगकर्ता के संदर्भ में चलाते हैं" (जैसा कि लोगों को Grouper2 के साथ करने के लिए कहा गया था, इससे पहले कि वे इसे सभी वर्बोज़/डीबग स्विच के साथ चलाते ताकि यह कई सौ मेगाबाइट स्टैक ट्रेस चिल्लाए), तो यह मूलतः कुछ नहीं करेगा। यह उन लोगों के लिए हमारा प्रैंक^TM है जो README फ़ाइलें नहीं पढ़ते, क्योंकि हम राक्षस हैं।

हालाँकि... यदि आप सही मंत्र जोड़ते हैं, तो यह पूर्वोक्त L.A.I.M. को सक्षम करेगा और वे फ़ाइल पथ जहाँ कैंडी मिल सकती है, प्रकट हो जाएँगे।

मुख्य मंत्र हैं:

-o परिणामों को फ़ाइल में आउटपुट करना सक्षम करता है। यदि आप -s का उपयोग नहीं कर रहे हैं तो संभवतः आप यह चाहेंगे। उदा. -o C:\users\thing\snaffler.log

-s परिणामों को जैसे ही मिलें, stdout पर आउटपुट करना सक्षम करता है। यदि आप -o का उपयोग नहीं कर रहे हैं तो संभवतः आप यह चाहेंगे।

-v वर्बोसिटी स्तर को नियंत्रित करता है, विकल्प हैं Trace (सबसे अधिक वर्बोज़), Degub (कम वर्बोज़, कम गब्स), Info (कम वर्बोज़, डिफ़ॉल्ट), और Data (केवल परिणाम)। उदा. -v debug

-m Snaffler के लिए एक आउटपुट निर्देशिका को सक्षम और असाइन करता है ताकि वह स्वचालित रूप से अपनी पसंद की किसी भी मिली फ़ाइल की प्रतिलिपि (या Snaffle... यदि आप चाहें) ले सके।

-l Snaffle करने के लिए फ़ाइलों का अधिकतम आकार (बाइट्स में)। डिफ़ॉल्ट 10000000 है, जो लगभग 10MB के बराबर है।

-i कंप्यूटर और शेयर खोज को अक्षम करता है, फ़ाइल खोज करने के लिए एक निर्देशिका के पथ की आवश्यकता होती है।

-n कंप्यूटर खोज को अक्षम करता है, होस्ट या इनपुट फ़ाइल की अल्पविराम से अलग की गई सूची लेता है ताकि शेयर और फ़ाइल खोज कर सके। ध्यान दें कि यदि कोई फ़ाइल प्रदान कर रहे हैं, तो इनपुट एक पथ होना चाहिए, उदाहरण के लिए C:\targets.txt या .\targets.txt।

-y आउटपुट को TSV-प्रारूपित करता है।

-b उन LAIM नियमों को छोड़ देता है जो कम दिलचस्प चीज़ें ढूँढेंगे, इसे 0 और 3 के बीच एक संख्या के साथ ट्यून करें।

-f Snaffler को DFS (वितरित फ़ाइल सिस्टम) के माध्यम से फ़ाइल शेयर खोजने तक सीमित करता है - यह डिफ़ॉल्ट की तुलना में काफी चालाक होना चाहिए, जबकि कई संगठनों में सबसे बड़े फ़ाइल शेयरों को कवर करता है।

-a फ़ाइल गणना को छोड़ देता है, आपको केवल लक्ष्य होस्ट पर सूचीबद्ध शेयरों की एक सूची देता है।

-u Snaffler को AD से खाता नामों की एक सूची खींचने, सबसे दिलचस्प दिखने वाले चुनने और फिर उन्हें एक खोज नियम में उपयोग करने के लिए बनाता है।

-d कंप्यूटर खोजने के लिए डोमेन ताकि शेयरों की खोज की जा सके ताकि फ़ाइलों की खोज की जा सके। आसान है।

-c डोमेन कंप्यूटरों की सूची क्वेरी करने के लिए डोमेन कंट्रोलर।

-r फ़ाइलों के अंदर दिलचस्प स्ट्रिंग्स खोजने के लिए अधिकतम फ़ाइल आकार (बाइट्स में)। डिफ़ॉल्ट 500k है।

-j फ़ाइलों में पाए गए स्ट्रिंग्स के दोनों ओर कितने बाइट्स संदर्भ दिखाना है, उदा. -j 200

-z एक कॉन्फ़िग फ़ाइल का पथ जो उपरोक्त सभी को परिभाषित करता है, और भी बहुत कुछ! अधिक विवरण के लिए नीचे देखें। -z generate दें तो एक नमूना कॉन्फ़िग फ़ाइल उत्पन्न होगी जिसे .\default.toml कहा जाता है।

-t आप जिस प्रकार का लॉग आउटपुट करना चाहते हैं। वर्तमान में समर्थित विकल्प plain और JSON हैं। डिफ़ॉल्ट plain है।

-x उपयोग करने के लिए थ्रेड्स की अधिकतम संख्या। इसे 4 से नीचे न सेट करें अन्यथा चीज़ें खराब हो जाएँगी।

-p .toml प्रारूपित नियमों से भरी एक निर्देशिका का पथ। Snaffler इन सभी को डिफ़ॉल्ट नियमसेट के स्थान पर लोड करेगा।

इस लॉग आउटपुट का क्या मतलब है?

उम्मीद है कि यह एनोटेटेड उदाहरण मदद करेगा:

इस लॉग प्रविष्टि को मोटे तौर पर बाएँ से दाएँ पढ़ा जाना चाहिए:

• लगभग 7:37 बजे
• Snaffler को एक फ़ाइल मिली जो वह सोचता है कि आपके ध्यान देने योग्य है
• इसे "Red" दर्जा दिया, दूसरा सबसे दिलचस्प स्तर
• यह "KeepConfigRegexRed" नामक एक नियम से मेल खाता है
• आप इसे पढ़ सकते हैं, लेकिन संशोधित नहीं कर सकते
• जो रेगेक्स मेल खाया वह लाल बॉक्स में है
• यह 208kB है
• इसे अंतिम बार 10 जनवरी 2020 को दोपहर लगभग सवा तीन बजे संशोधित किया गया था।
• फ़ाइल बैंगनी रंग में दिए गए पथ पर मिल सकती है

... और शेष पंक्ति (ग्रे में) फ़ाइल से संदर्भ का एक छोटा सा अंश है जहाँ मिलान हुआ।

इस मामले में हमें ASP.NET validationKey और decryptionKey मान मिले हैं, जो हमें कुछ डीसीरियलाइज़ेशन हैकरी के माध्यम से वेब ऐप पर RCE करने दे सकते हैं। वाह!

नोट: यह स्क्रीनशॉट बनाने के बाद, Sh3r4 ने प्रत्येक पंक्ति में वर्तमान उपयोगकर्ता और होस्टनेम जोड़ने के लिए एक चीज़ जोड़ी। मैं स्क्रीनशॉट फिर से नहीं बनाना चाहता।

यह कैसे तय करता है कि कौन सी फ़ाइलें अच्छी हैं और कौन सी उबाऊ?

"इतना सरल कि लगभग झूठ जैसा" उत्तर:

प्रत्येक L.A.I.M. जादू फ़ाइल खोजने की विधि ऐसी चीज़ें करती है:

• सटीक फ़ाइल एक्सटेंशन मिलान द्वारा खोज, जिसका अर्थ है कि कोई भी फ़ाइल जिसका एक्सटेंशन प्रासंगिक शब्द सूची से मेल खाता है, वापस कर दी जाएगी। यह फ़ाइल एक्सटेंशन के लिए है जो लगभग हमेशा कैंडी रखते हैं, जैसे .kdbx, .vmdk, .ppk, आदि।

• (केस-असंवेदनशील) सटीक फ़ाइल नाम मिलान द्वारा खोज। यह फ़ाइल नामों के लिए है जो लगभग हमेशा कैंडी रखते हैं, जैसे id_rsa, shadow, NTDS.DIT, आदि।

• सटीक फ़ाइल एक्सटेंशन मिलान (एक और शब्द सूची) के बाद मिलान करने वाली फ़ाइलों की सामग्री को कुछ कीवर्ड्स (एक और शब्द सूची) के लिए 'ग्रेप' करना। यह उन फ़ाइल एक्सटेंशन के लिए है जो कभी-कभी कैंडी रखते हैं लेकिन जहाँ आप जानते हैं कि छानने के लिए बहुत सारा भूसा हो सकता है। उदाहरण के लिए, web.config में कभी-कभी डेटाबेस क्रेडेंशियल्स होते हैं, लेकिन अक्सर उबाऊ IIS कॉन्फ़िग बकवास और कोई पासवर्ड नहीं होता। यह (उदाहरण के लिए) .config में समाप्त होने वाली किसी भी चीज़ को ढूँढ़ेगा, फिर इसे उन स्ट्रिंग्स के लिए ग्रेप करेगा जिनमें शामिल हैं लेकिन इन्हीं तक सीमित नहीं हैं: connectionString, password, PRIVATE KEY, आदि।

वास्तविक उत्तर:

Snaffler "क्लासिफ़ायर" की एक प्रणाली का उपयोग करता है, जिनमें से प्रत्येक शेयर या फ़ोल्डर या फ़ाइल या फ़ाइल सामग्री की जाँच करता है, कुछ वस्तुओं को अगले क्लासिफ़ायर को भेजता है, और दूसरों को त्याग देता है। प्रत्येक क्लासिफ़ायर यह तय करने के लिए नियमों के एक सेट का उपयोग करता है कि वह अपने द्वारा वर्गीकृत वस्तुओं के साथ क्या करे।

ये नियम बहुत सरल हो सकते हैं, जैसे "यदि फ़ाइल का एक्सटेंशन .kdbx है, तो मुझे इसके बारे में बताएं", या "यदि पथ में windows\sxs है तो उस पथ के भीतर उपनिर्देशिकाओं और फ़ाइलों को देखना बंद करें"।

नियम रेगुलर एक्सप्रेशन का भी उपयोग कर सकते हैं, जो अपेक्षाकृत परिष्कृत पैटर्न-मिलान की अनुमति देते हैं। यह विशेष रूप से तब उपयोगी होता है जब फ़ाइल सामग्री की जाँच की जाती है, हालाँकि ऐसे रेगेक्सेन से सावधान रहना चाहिए जो प्रदर्शन को महत्वपूर्ण रूप से प्रभावित करते हैं। बड़े वातावरणों में इन नियमों की लाखों बार जाँच की जा सकती है, इसलिए छोटे प्रदर्शन मुद्दे काफी बढ़ सकते हैं।

असली शक्ति Snaffler की कई नियमों को श्रृंखला में जोड़ने और शाखाबद्ध श्रृंखला बनाने की क्षमता में है। यह हमें "सस्ते" नियमों जैसे फ़ाइल नाम और एक्सटेंशन की जाँच का उपयोग करके यह तय करने की अनुमति देता है कि "महंगे" नियमों का उपयोग कब करना है, जैसे फ़ाइलों की सामग्री में रेगेक्सेन चलाना, प्रमाणपत्रों को पार्स करना यह देखने के लिए कि क्या उनमें निजी कुंजियाँ हैं, आदि। यही कारण है कि Snaffler जहाँ आवश्यक हो, फ़ाइलों की काफी गहराई से जाँच प्राप्त कर सकता है, जबकि C# जैसी उच्च-स्तरीय भाषा में लिखे गए उपकरण के लिए आश्चर्यजनक रूप से तेज़ भी है।

उदाहरण के लिए, एक बहुत ही सरल नियमसेट में शामिल हो सकता है:

• छवि फ़ाइलों से जुड़े एक्सटेंशन वाली सभी फ़ाइलों को त्यागने का नियम
• .dmp फ़ाइल एक्सटेंशन वाली सभी फ़ाइलों को खोजने और उन्हें snaffle करने का नियम
• एक नियम श्रृंखला जहाँ:
  • पहला नियम .ps1 फ़ाइल एक्सटेंशन वाली फ़ाइलों की तलाश करता है, और सभी मिलान करने वाली फ़ाइलों को दूसरे और तीसरे दोनों नियमों को भेजता है।
  • दूसरा नियम PowerShell कोड में हार्ड-कोडेड क्रेडेंशियल्स खोजने के लिए डिज़ाइन किए गए रेगेक्सेन का उपयोग करके फ़ाइलों के अंदर देखता है।
  • तीसरा नियम cmd.exe कमांड में हार्ड-कोडेड क्रेडेंशियल्स खोजने के लिए डिज़ाइन किए गए रेगेक्सेन का उपयोग करके फ़ाइलों के अंदर देखता है, जैसा कि .bat या .cmd फ़ाइलों में पाया जा सकता है, क्योंकि ये भी अक्सर PowerShell स्क्रिप्ट के भीतर उपयोग किए जाते हैं।

यह दृष्टिकोण हमें अपेक्षाकृत प्रबंधनीय और सुपाठ्य नियमसेट बनाए रखने की भी अनुमति देता है, और अंतिम-उपयोगकर्ता (आप) के लिए डिफ़ॉल्ट को अनुकूलित करना या अपने स्वयं के नियमसेट विकसित करना भी बहुत आसान बनाता है।

मैं नियम नहीं लिखना चाहता, यह कठिन और उबाऊ लगता है।

आप सही कह रहे हैं, यह था।

Snaffler के साथ .exe में पके हुए डिफ़ॉल्ट नियमों का एक सेट आता है। आप उन्हें ./Snaffler/SnaffRules/DefaultRules में देख सकते हैं।

मैं एक शक्तिशाली बोरियत का टाइटन हूँ, एक सामान्यता का स्वामी, मैं अपना स्वयं का नियमसेट लिखना चाहता हूँ।

कोई समस्या नहीं, आप विशाल अजीब व्यक्ति हैं। आपके पास 2 विकल्प हैं।

1. DefaultRules निर्देशिका में नियमों को संपादित या बदलें, फिर एक नया Snaffler बनाएँ। उस निर्देशिका में .toml फ़ाइलें .exe में संसाधनों के रूप में पक जाएँगी, और रनटाइम पर तब लोड हो जाएँगी जब आप कोई अन्य नियम उपयोग करने के लिए निर्दिष्ट नहीं करते।
2. एक निर्देशिका बनाएँ और उसमें अपनी कुछ नियम फ़ाइलें रखें, फिर -p .\path\to\rules के साथ Snaffler चलाएँ। Snaffler उस निर्देशिका में सभी .toml फ़ाइलों को पार्स करेगा और परिणामी नियमसेट का उपयोग करेगा। यह तब भी काम करेगा यदि आप उन सभी को एक बड़ी .toml फ़ाइल में रखते हैं।

यहाँ कुछ एनोटेटेड उदाहरण हैं जो उम्मीद है कि चीज़ों को बेहतर ढंग से समझाने में मदद करेंगे। यदि यह बहुत कठिन लगता है, तो आप हमारे नियमों का उपयोग कर सकते हैं और वे शायद आपको कुछ अच्छी चीज़ें ढूँढ़ देंगे।

यह एक ऐसे नियम का उदाहरण है जो Snaffler को एक निश्चित नाम वाली निर्देशिका के नीचे सभी फ़ाइलों और उपनिर्देशिकाओं को अनदेखा करने के लिए बनाएगा।```toml [[ClassifierRules]] EnumerationScope = "DirectoryEnumeration" # This defines which phase of the discovery process we're going to apply the rule. # In this case, we're looking at directories. # Valid values include ShareEnumeration, DirectoryEnumeration, FileEnumeration, ContentsEnumeration RuleName = "DiscardLargeFalsePosDirs" # This can be whatever you want. We've been following a rough naming scheme, but you can call it "Stinky" if you want. ¯_(ツ)_/¯ MatchAction = "Discard"# What to do with things that match the rule. In this case, we want to discard anything that matches this rule. # Valid options include: Snaffle (keep), Discard, Relay (example of this below), and CheckForKeys (example below) Description = "File paths that will be skipped entirely." # Not used in the code, just a place for notes really. MatchLocation = "FilePath" # What part of the file/dir/share to look at to check for a match. In this case we're looking at the whole path. # Valid options include: ShareName, FilePath, FileName, FileExtension, FileContentAsString, FileContentAsBytes, # although obviously not all of these will apply in all EnumerationScopes. WordListType = "Contains" # What matching logic to apply, valid options are: Exact, Contains, EndsWith, StartsWith, or Regex. # Under the hood these all get turned into regexen one way or another. MatchLength = 0 WordList = [

A list of strings or regex patterns to use to match. If using regex patterns, WordListType must be Regex.

"\\\\puppet\\\\share\\\\doc",
"\\\\lib\\\\ruby",
"\\\\lib\\\\site-packages",
"\\\\usr\\\\share\\\\doc",
"node_modules",
"vendor\\\\bundle",
"vendor\\\\cache",
"\\\\doc\\\\openssl",
"Anaconda3\\\\Lib\\\\test",
"WindowsPowerShell\\\\Modules",
"Python27\\\\Lib"

] Triage = "Green" # If we find a match, what severity rating should we give it. Valid values are Black, Red, Yellow, Green. This value is ignored for Discard MatchActions.

यह नियम दूसरी ओर फ़ाइल एक्सटेंशन को देखेगा, और हम जिन्हें पसंद नहीं करते उन्हें तुरंत हटा देगा।

इस मामले में मैं ज्यादातर फोंट, इमेज, CSS, आदि को हटा रहा हूँ।```toml
[[ClassifierRules]]
EnumerationScope = "FileEnumeration" # We're looking at the actual files, not the shares or dirs or whatever.
RuleName = "DiscardExtExact" # just a name
MatchAction = "Discard" # We're discarding these
MatchLocation = "FileExtension" # This time we're only looking at the file extension part of the file's name.
WordListType = "Exact" # and we only want exact matches. 
WordList = [".bmp", ".eps", ".gif", ".ico", ".jfi", ".jfif", ".jif", ".jpe", ".jpeg", ".jpg", ".png", ".psd", ".svg", ".tif", ".tiff", ".webp", ".xcf", ".ttf", ".otf", ".lock", ".css", ".less"] # list of file extensions.

यहाँ एक वास्तव में सरल नियम का उदाहरण है जो उन चीजों के लिए है जिन्हें हम पसंद करते हैं और रखना चाहते हैं।```toml [[ClassifierRules]] EnumerationScope = "FileEnumeration" # Still looking at files RuleName = "KeepExtExactBlack" # Just a name MatchAction = "Snaffle" # This time we are 'snaffling' these. This usually just means send it to the output, # but if you turn on the appropriate option it will also grab a copy. MatchLocation = "FileExtension" # We're looking at file extensions again WordListType = "Exact" # With Exact Matches WordList = [".kdbx", ".kdb", ".ppk", ".vmdk", ".vhdx", ".ova", ".ovf", ".psafe3", ".cscfg", ".kwallet", ".tblk", ".ovpn", ".mdf", ".sdf", ".sqldump"] # and a bunch of fun file extensions. Triage = "Black" # these are all big wins if we find them, so we're giving them the most severe rating.

यह मूलतः एक ही है, लेकिन हम पूरे फ़ाइल नाम को देख रहे हैं। सरल!```toml
[[ClassifierRules]]
EnumerationScope = "FileEnumeration"
RuleName = "KeepFilenameExactBlack"
MatchAction = "Snaffle"
MatchLocation = "FileName"
WordListType = "Exact"
WordList = ["id_rsa", "id_dsa", "NTDS.DIT", "shadow", "pwd.db", "passwd"]
Triage = "Black"

यह थोड़ा चालाक है, इसे देखो...```toml [[ClassifierRules]] EnumerationScope = "FileEnumeration" # we're looking for files... RuleName = "KeepCertContainsPrivKeyRed" MatchLocation = "FileExtension" # specifically, ones with certain file extensions... WordListType = "Exact" WordList = [".der", ".pfx"] # specifically these ones... MatchAction = "CheckForKeys" # and any that we find, we're going to parse them as x509 certs, and see if the file includes a private key! Triage = "Red" # cert files aren't very sexy, and you'll get huge numbers of them in most wintel environments, but this check gives us a way better SNR!

ठीक है, यहाँ वह शक्तिशाली चीज़ आती है। हमारे पास यहाँ एक श्रृंखला में दो नियम हैं।

पहले नियम से मेल खाने वाले एक्सटेंशन वाली फ़ाइलें दूसरे नियम को भेजी जाएंगी, जो एक विशिष्ट शब्द सूची में चीज़ों के लिए उन्हें "grep" (अर्थात् String.Contains()) करेगा।

आप इन्हें अपनी इच्छानुसार एक साथ जोड़ सकते हैं, हालाँकि मुझे लगता है कि यदि आप इसके साथ बहुत अधिक इनसेप्शन-जैसा हो जाते हैं तो आपको कुछ प्रदर्शन समस्याएँ दिखाई देने लगेंगी।```toml
[[ClassifierRules]]
EnumerationScope = "FileEnumeration" # this one looks at files...
RuleName = "ConfigGrepExtExact"
MatchLocation = "FileExtension" # specifically the extensions...
WordListType = "Exact"
WordList = [".yaml", ".xml", ".json", ".config", ".ini", ".inf", ".cnf", ".conf"] # these ones.
MatchAction = "Relay" # Then any files that match are handed downstream...
RelayTargets = ["KeepConfigGrepContainsRed"] # To the rule with this RuleName! This can also be an array of RuleNames if you want to get real wild and start writing branching rulesets.

[[ClassifierRules]]
RuleName = "KeepConfigGrepContainsRed" # Anyway, this is the target rule. Following a naming convention really helps to make sure you're using the right targets.
EnumerationScope = "ContentsEnumeration" # this one looks at file content!
MatchAction = "Snaffle" # it keeps files that match
MatchLocation = "FileContentAsString" # it's looking at the contents as a string (rather than a byte array)
WordListType = "Contains" # it's using simple matching
WordList = ["password=", " connectionString=\"", "sqlConnectionString=\"", "validationKey=", "decryptionKey=", "NVRAM config last updated"]
Triage = "Red"

उम्मीद है कि यह विचार स्पष्ट कर देगा। मेरा सुझाव है कि आप कुछ डिफ़ॉल्ट नियम लें और उनके साथ प्रयोग करें जब तक आपको लगे कि आप इसे अच्छी तरह से समझ गए हैं।

"UltraSnaffler" क्या है???

बहुत से लोग उन फ़ाइल फ़ॉर्मेटों के अंदर देखने की क्षमता चाहते थे जो सिर्फ़ सादा टेक्स्ट नहीं थे, जैसे Word दस्तावेज़, PDF, .eml, आदि। दुर्भाग्य से, उस कार्यक्षमता को लागू करने वाली सबसे आसान लाइब्रेरी ने Snaffler.exe के अंतिम फ़ाइल आकार को लगभग 1200% तक बढ़ा दिया, जो कई लोकप्रिय इन-मेमोरी निष्पादन तकनीकों के लिए खराब था, जिनकी फ़ाइल आकार की ऊपरी सीमाएँ थीं जिनके साथ उनका उपयोग किया जा सकता था।

समाधान UltraSnaffler था, जो सिर्फ़ एक दूसरी .sln फ़ाइल है जो आवश्यक lib और प्रासंगिक कोड को सक्षम करती है। UltraSnaffler.sln बनाएँ, UltraSnaffler प्राप्त करें।

चेतावनी: Snaffler के डिफ़ॉल्ट नियमों में वे शामिल नहीं हैं जो Office दस्तावेज़ों या PDF के अंदर देखेंगे, क्योंकि हमने पाया कि ऐसे नियम लिखना वाकई मुश्किल था जो किसी सामान्य कॉर्पोरेट वातावरण में रन पूरा करने में सालों न लगें। सावधान रहें, इन दस्तावेज़ों के अंदर देखना पुराने सादे टेक्स्ट फ़ाइलों की तुलना में बहुत धीमा है, और एक सामान्य वातावरण में कम मूल्य वाले Office दस्तावेज़ों और PDF का एक बहुत बड़ा ढेर होगा।

कॉन्फ़िग फ़ाइल कैसे काम करती है?

यह वास्तव में मेरी राय में बहुत अच्छा है।

यदि आप Snaffler कमांड लाइन के अंत में -z generate जोड़ते हैं, तो Snaffler कॉन्फ़िगरेशन ऑब्जेक्ट (आपके आर्गुमेंट्स द्वारा सेट किए गए कॉन्फ़िगरेशन के जो भी पहलू हैं) को एक .toml कॉन्फ़िग फ़ाइल में सीरियलाइज़ करेगा, जिसे आप फिर आसानी से (या नहीं) हाथ से संपादित कर सकते हैं और फिर अपनी सुविधानुसार पुनः उपयोग कर सकते हैं

उदाहरण के लिए, यदि आप ऐसा करते हैं:

Snaffler.exe -s -o C:\mydir\snaffler.log -v trace -i \\host.lol.domain\share -p C:\users\someguy\myrules -z generate

Snaffler आपके सभी अनेक, अनेक आर्गुमेंट्स को पार्स करेगा, उन्हें एक कॉन्फ़िग ऑब्जेक्ट में बदलेगा, उस कॉन्फ़िग ऑब्जेक्ट को निम्नलिखित .toml कॉन्फ़िग फ़ाइल में सीरियलाइज़ करेगा:```toml PathTargets = ["\\host.lol.domain\share"] ComputerTargetsLdapFilter = "(objectClass=computer)" ScanSysvol = true ScanNetlogon = true ScanFoundShares = true InterestLevel = 0 DfsOnly = false DfsShareDiscovery = false DfsNamespacePaths = [] CurrentUser = "l0sslab\l0ss" RuleDir = "C:\users\someguy\myrules" MaxThreads = 60 ShareThreads = 20 TreeThreads = 20 FileThreads = 20 MaxFileQueue = 200000 MaxTreeQueue = 0 MaxShareQueue = 0 LogToFile = true LogFilePath = "C:\mydir\snaffler.log" LogType = "Plain" LogTSV = false Separator = 32 LogToConsole = true LogLevelString = "trace" ShareFinderEnabled = false LogDeniedShares = false DomainUserRules = false DomainUserMinLen = 6 DomainUserNameFormats = ["sAMAccountName"] DomainUserMatchStrings = ["sql", "svc", "service", "backup", "ccm", "scom", "opsmgr", "adm", "adcs", "MSOL", "adsync", "thycotic", "secretserver", "cyberark", "configmgr"] DomainUsersWordlistRules = ["KeepConfigRegexRed"] MaxSizeToGrep = 1000000 Snaffle = false MaxSizeToSnaffle = 10000000 MatchContextBytes = 200

आप देख सकते हैं कि यहाँ कई ऐसी चीज़ें हैं जिनके लिए आपने आर्गुमेंट्स नहीं दिए थे। वे मान डिफ़ॉल्ट कॉन्फ़िग आइटम हैं, जिनमें से कुछ को केवल सोर्स में या कॉन्फ़िग फ़ाइल के माध्यम से आसानी से संपादित किया जा सकता है, आमतौर पर इसलिए क्योंकि उनके लिए आर्गुमेंट जोड़ना उचित नहीं लगा।

## यह बेकार है, क्या आप इसे कम बेकार बनाने की योजना बना रहे हैं?

नहीं, तुम बेकार हो।

और हाँ, हम कर रहे हैं।

हम यह भी करने जा रहे हैं:
 - आर्काइव फ़ाइलों का पार्सिंग जोड़ना, आदर्श रूप से उन्हें एक और डायरेक्टरी मानना जिसमें अच्छी चीज़ों की तलाश की जा सके।
 - नियमों और रेगेक्स को बेहतर बनाना जारी रखना। **वर्डलिस्ट के लिए और शब्द! `string[]` `string` के सिंहासन के लिए!**

![वर्डलिस्ट के बारे में एक बेवकूफी भरा मजाक।](https://assets.kitploit.com/production/public/readmes/5041/ac1d2a65e3759820b6eaaf47c893ec06661ce5db74c26d60eb424fabfe29a11f.png)

## आपने किससे कोड चुराया?

शेयर एन्यूमरेशन बिट्स को शार्पशेयर्स से झपटा गया था (देखा मैंने वहाँ क्या किया?), जिसे अत्यंत उपयोगी ड्वाइट होह्नस्टीन ने लिखा था। (https://github.com/djhohnstein/SharpShares/)
ड्वाइट का GitHub प्रोफ़ाइल उस हार्डवेयर स्टोर के पीछे अद्भुत गलियारे जैसा है जहाँ बहुत सारे ऐसे उपकरण होते हैं जो आपको "अरे यार, मैं इसे वास्तव में इस्तेमाल करने का बहाना पाने के लिए इंतज़ार नहीं कर सकता..." जैसा महसूस कराते हैं, और आपको निश्चित रूप से इसे देखना चाहिए।

जबकि कोई कोड नहीं लिया गया (मुख्यतः क्योंकि यह Ruby है lol), हमने `plunder2` (http://joshstone.us/plunder2/) से बहुत सारे बढ़िया विचार चुराए।

वर्डलिस्ट को कुछ अन्य समान टूल्स जैसे trufflehog, shhgit, gitrobber और graudit में पाए गए शब्दों से भी क्यूरेट किया गया।

## क्या यह OPSEC सुरक्षित है? (जो भी इसका मतलब हो)

पफ़्फ़्ट, नहीं। यह बहुत शोरगुल वाला है।

देखो, इसे इस तरह समझो... अगर यह ऐसा माहौल है जहाँ आप BloodHound को उसके डिफ़ॉल्ट मोड में चलाने में आत्मविश्वास महसूस करेंगे, तो उह्ह, हाँ यार... यह वास्तव में चुपके से काम करने वाला है।

## मुझे लगा तुम इस चीज़ का उपयोग रेड टीम गिग्स पर करते हो?

*आह*

ठीक है, मैं तुम्हें असली जवाब देता हूँ।

डिफ़ॉल्ट मोड में, Snaffler कई मायनों में SharpHound जैसा ही दिखता है। यह AD से बहुत सारा LDAP बात करता है, फिर यह डोमेन में हर Windows मशीन से SMB बात करने की कोशिश करता है। इस तरह का व्यवहार लगभग निश्चित रूप से आपको उस संगठन में पकड़वा देगा जिसने अपनी चीज़ों को थोड़ा भी व्यवस्थित रखा है।

हालाँकि...

Snaffler के अधिक लक्षित विकल्प (विशेषकर `-i`) डिटेक्शन को ट्रिगर करने की संभावना *बहुत* कम रखते हैं।

मुझे विशेष रूप से एक ताजा समझौता किए गए सर्वर या वर्कस्टेशन पर `Snaffler.exe -s -i C:\` चलाना पसंद है, और मैंने अभी तक इस व्यवहार का पता लगते नहीं देखा है।

अभी तक।

## मैं कैसे मदद कर सकता हूँ या मदद ले सकता हूँ?

यदि आप Slack के माध्यम से चर्चा करना चाहते हैं तो आप हमें (@l0ss या @Sh3r4) BloodHound Slack पर पिंग कर सकते हैं, जो https://bloodhoundgang.herokuapp.com/ पर जुड़ने योग्य है, या #snaffler चैनल में योगदानकर्ताओं के एक समूह के साथ बातचीत कर सकते हैं।

आप हमें Twitter पर भी पिंग कर सकते हैं - @mikeloss और @sh3r4_hax

अन्यथा एक issue दर्ज करें; हम प्रयास करेंगे।