घिद्रा के साथ एक साधारण "दरार" तोड़ना - भाग 1

बहुत से लोग शायद पहले से ही जानते हैं कि यह किस प्रकार का जानवर है - घिद्रा ("हाइड्रा") और यह पहले से क्या कार्यक्रम खाता है, हालांकि इस उपकरण को सार्वजनिक रूप से हाल ही में - इस साल मार्च में उपलब्ध कराया गया था। मैं हाइड्रा, इसकी कार्यक्षमता आदि के विवरण के साथ पाठकों को परेशान नहीं करूंगा। जो लोग विषय में हैं, मुझे यकीन है, यह सब पहले से ही अध्ययन किया है, और जो अभी तक विषय में नहीं हैं - वे इसे किसी भी समय कर सकते हैं, क्योंकि अब इंटरनेट पर विस्तृत जानकारी प्राप्त करना आसान है। वैसे, हाइड्रा के पहलुओं में से एक (इसके लिए प्लगइन्स का विकास) पहले से ही हैबे (उत्कृष्ट लेख!) पर शामिल किया गया है, मैं केवल मुख्य लिंक दूंगा:

• एनएसए की वेबसाइट पर आधिकारिक पेज
• जीथब प्रोजेक्ट
• हैकर पत्रिका में पहली समीक्षा
• घिद्रा में कार्यक्रमों के साथ महान YouTube चैनल

तो, हाइड्रा एक मुफ्त क्रॉस-प्लेटफ़ॉर्म इंटरएक्टिव डिस्सेम्बलर और डीकॉम्पिलर है जो एक मॉड्यूलर संरचना के साथ है, लगभग सभी मुख्य सीपीयू आर्किटेक्चर के लिए समर्थन के साथ और असंतुष्ट कोड, मेमोरी, बरामद (विघटित) कोड, डिबगिंग प्रतीकों और बहुत कुछ के साथ काम करने के लिए एक लचीला ग्राफिकल इंटरफ़ेस है ।

आइए इस हाइड्रा के साथ कुछ तोड़ने की कोशिश करें!

चरण 1. दरार का पता लगाएं और उसका अध्ययन करें

एक "शिकार" के रूप में हम एक सरल "क्रैकमे" प्रोग्राम पाते हैं। मैं सिर्फ crackmes.one पर गया , खोज में कठिनाई स्तर = 2-3 ("सरल" और "मध्यम"), कार्यक्रम की स्रोत भाषा = "C / C ++" और मंच = "Multiplatform", जैसा कि नीचे स्क्रीनशॉट में दिखाया गया है:



खोज ने 2 परिणाम लौटाए (नीचे हरे रंग में)। पहली दरार 16-बिट निकली और मेरे Win10 64-बिट पर शुरू नहीं हुई, लेकिन दूसरी ( seveb द्वारा level_2 ) सामने आई। आप इसे इस लिंक से डाउनलोड कर सकते हैं।

दरार को डाउनलोड और अनपैक करें; संग्रह के लिए पासवर्ड, जैसा कि साइट पर संकेत दिया गया है, यह क्रेकम्स.डे है । संग्रह में हमें लिनक्स और विंडोज से संबंधित दो निर्देशिकाएं मिलती हैं। मेरी मशीन पर, मैं विंडोज डायरेक्टरी में जाता हूं और इसमें मुझे केवल "एक्जीक्यूटेबल" - Level_2.exe मिलते हैं । आइए दौड़ें और देखें कि वह क्या चाहती है:



यह एक bummer की तरह लगता है! स्टार्टअप पर, कार्यक्रम कुछ भी प्रदर्शित नहीं करता है। हम इसे फिर से चलाने की कोशिश करते हैं, इसे एक पैरामीटर के रूप में एक मनमाना स्ट्रिंग पारित करते हैं (अचानक, यह एक कुंजी की प्रतीक्षा कर रहा है?) - और फिर कुछ भी नहीं ... लेकिन निराशा न करें। मान लेते हैं कि हमें लॉन्च पैरामीटर को एक कार्य के रूप में भी पता लगाना है! यह हमारे "स्विस चाकू" को उजागर करने का समय है - हाइड्रा।

चरण 2. हाइड्रा और प्रारंभिक विश्लेषण में एक परियोजना बनाना

मान लीजिए कि आपके पास पहले से ही हाइड्रा स्थापित है। यदि अभी तक नहीं, तो सब कुछ सरल है।


हम हाइड्रा लॉन्च करते हैं और खोले गए प्रोजेक्ट मैनेजर में तुरंत एक नया प्रोजेक्ट बनाते हैं; मैंने इसे क्रैकमे 3 नाम दिया (यानी, क्रैकमे और क्रैकमे 2 प्रोजेक्ट मेरे लिए पहले ही बन चुके हैं)। परियोजना, वास्तव में, फाइलों की एक निर्देशिका है, आप इसमें किसी भी फाइल को अध्ययन करने के लिए जोड़ सकते हैं (उदाहरण के लिए, dll, आदि)। हम तुरंत अपना लेवल २.२०१ जोड़ देंगे ( फ़ाइल | आयात या सिर्फ मैं कुंजी):



हम देखते हैं कि, आयात करने से पहले, हाइड्रा ने Win32 OS और x86 प्लेटफॉर्म के लिए हमारे प्रयोगात्मक क्वैक को 32-बिट पीई (पोर्टेबल निष्पादन योग्य) के रूप में पहचाना। आयात के बाद, हमारी प्रतीक्षा और भी अधिक जानकारी के लिए:



यहां, उपरोक्त बिट गहराई के अलावा, हम अभी भी एंडियनस ऑर्डर में रुचि ले सकते हैं, जो हमारे मामले में लिटिल (कम से उच्च बाइट तक) है, जिसे इंटेल 86 वें प्लेटफॉर्म के लिए उम्मीद की जानी थी।

प्रारंभिक विश्लेषण के साथ, हम कर रहे हैं।

चरण 3. स्वचालित विश्लेषण करें

हाइड्रा में कार्यक्रम का एक पूर्ण स्वचालित विश्लेषण शुरू करने का समय। यह संबंधित फ़ाइल (Level_2.exe) पर डबल-क्लिक करके किया जाता है। एक मॉड्यूलर संरचना होने से, हाइड्रा प्लग-इन प्रणाली के साथ अपनी सभी बुनियादी कार्यक्षमता प्रदान करता है जिसे स्वतंत्र रूप से जोड़ा / अक्षम या विकसित किया जा सकता है। वही विश्लेषण के साथ है - प्रत्येक प्लगइन अपने प्रकार के विश्लेषण के लिए जिम्मेदार है। इसलिए, पहले, हमें इस विंडो से सामना करना पड़ता है जहाँ आप रुचि के विश्लेषण के प्रकारों का चयन कर सकते हैं:


हमारे उद्देश्यों के लिए, यह डिफ़ॉल्ट सेटिंग्स को छोड़ने और विश्लेषण चलाने के लिए समझ में आता है। विश्लेषण स्वयं काफी तेज़ी से किया जाता है (इसमें मुझे लगभग 7 सेकंड लगते हैं), हालांकि मंचों पर उपयोगकर्ताओं को शिकायत है कि बड़ी परियोजनाओं के लिए, हाइड्रा आईडीए प्रो में गति खो देता है। यह सच हो सकता है, लेकिन छोटी फ़ाइलों के लिए यह अंतर महत्वपूर्ण नहीं है।

तो, विश्लेषण पूरा हो गया है। इसके परिणाम कोड ब्राउज़र विंडो में प्रदर्शित होते हैं:



यह खिड़की हाइड्रा में काम करने के लिए मुख्य है, इसलिए आपको इसे और अधिक सावधानी से अध्ययन करना चाहिए।

चरण 4. कार्यक्रम एल्गोरिथ्म सीखना - मुख्य () फ़ंक्शन

ठीक है, चलो हमारे दरार-कार्यक्रमों के प्रत्यक्ष विश्लेषण के लिए आगे बढ़ें। ज्यादातर मामलों में, आपको कार्यक्रम के प्रवेश बिंदु की खोज करके शुरू करना चाहिए, अर्थात। मुख्य कार्य जिसे शुरू होने पर बुलाया जाता है। यह जानते हुए कि हमारी दरार C / C ++ में लिखी गई थी, हम अनुमान लगाते हैं कि मुख्य फ़ंक्शन का नाम मुख्य () या ऐसा कुछ होगा :) ऐसा कहा और किया जाता है। प्रतीक के पेड़ (बाएं पैनल में) के फिल्टर में "मुख्य" दर्ज करें और फ़ंक्शन अनुभाग में फ़ंक्शन _main () देखें। माउस क्लिक के साथ उस पर जाएं।

मुख्य () फ़ंक्शन का अवलोकन और अस्पष्ट कार्यों का नाम बदलना

डिस्सेम्बलर लिस्टिंग में, संबंधित कोड अनुभाग तुरंत प्रदर्शित होता है, और दाईं ओर हम इस फ़ंक्शन का डिकम्पोज्ड सी-कोड देखते हैं। हाइड्रा की एक अन्य सुविधाजनक विशेषता चयन का सिंक्रनाइज़ेशन है: जब एक माउस एएसएम कमांड की एक सीमा का चयन करता है, तो डिकम्पाइलर में संबंधित कोड अनुभाग हाइलाइट किया जाता है और इसके विपरीत। इसके अलावा, यदि मेमोरी देखने वाली खिड़की खुली है, तो आवंटन मेमोरी के साथ सिंक्रनाइज़ है। जैसा कि वे कहते हैं, सभी सरल सरल है!

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

तो, यहाँ मुख्य () फ़ंक्शन है, जो हाइड्रा "विच्छेदित" इस प्रकार है:


ऐसा लगता है कि सब कुछ सामान्य लगता है - चर, मानक सी-प्रकार, स्थितियां, लूप, फ़ंक्शन कॉल की परिभाषा। लेकिन कोड पर करीब से नज़र डालते हुए, हम देखते हैं कि किसी कारण से कुछ कार्यों के नाम परिभाषित नहीं किए गए थे और उनकी जगह छद्म- फ़ंक्शन _text () ( डिकम्पॉइलर विंडो में - .text) ()। आइए इन कार्यों को परिभाषित करके शुरू करें।

पहली कॉल के शरीर पर डबल-क्लिक करना

  _Dest = (char *)_text(0x100,1); 

हम देखते हैं कि यह मानक कॉलोक () फ़ंक्शन के चारों ओर एक आवरण फ़ंक्शन है, जिसका उपयोग डेटा के लिए मेमोरी आवंटित करने के लिए किया जाता है। तो चलो calloc2 () के लिए इस फ़ंक्शन का नाम बदलें। फ़ंक्शन हेडर पर कर्सर सेट करते हुए, संदर्भ मेनू पर कॉल करें और नाम बदलें फ़ंक्शन (गर्म कुंजी - एल ) का चयन करें और खुलने वाले क्षेत्र में एक नया नाम दर्ज करें:



हम देखते हैं कि फ़ंक्शन को तुरंत नाम दिया गया था। हम मुख्य () बॉडी (टूलबार या Alt + <- बैक बटन) पर जाते हैं और हम देखते हैं कि यहां रहस्यमय _text () calloc2 () पहले से ही खड़ा है। बहुत बढ़िया!

हम अन्य सभी आवरण कार्यों के साथ भी ऐसा ही करते हैं: हम एक-एक करके उनकी परिभाषा में जाते हैं, वे जो करते हैं, उसे देखते हैं, उनका नाम बदलते हैं (मैंने सी-फ़ंक्शंस के मानक नामों में सूचकांक 2 जोड़ा) और मुख्य फ़ंक्शन पर वापस जाएं।

हम मुख्य () फ़ंक्शन कोड को समझते हैं

ठीक है, हमने कुछ अजीब कार्य किए। हम मुख्य फ़ंक्शन के कोड का अध्ययन करना शुरू करते हैं। चर घोषणाओं को छोड़ दें, तो हम देखते हैं कि फ़ंक्शन वैरिएबल iVar2 का मान लौटाता है, जो कि शून्य (फ़ंक्शन की सफलता का संकेत) केवल तभी होता है जब स्ट्रिंग द्वारा निर्दिष्ट शर्त संतुष्ट होती है

 if (_Argc == 3) { ... } 

_Argc कमांड लाइन मापदंडों (तर्कों) की संख्या है जो मुख्य () को पारित किया गया है। यही है, हमारे कार्यक्रम "खाती है" 2 तर्क (पहला तर्क, हमें याद है, हमेशा निष्पादन योग्य फ़ाइल का पथ है)।

ठीक है, चलो आगे बढ़ते हैं। यहाँ हम 256 वर्णों का C-string ( चार सरणी) बनाते हैं:

 char *_Dest; _Dest = (char *)calloc2(0x100,1); //  new char[256]  C++ 

अगला हमारे पास 3 पुनरावृत्तियों का एक लूप है। इसमें, हम पहले जाँचते हैं कि bVar1 ध्वज सेट है या नहीं, और यदि निम्न कमांड लाइन तर्क (स्ट्रिंग) को _est में कॉपी करें :

 while (i < 3) { /*    .  */ if (bVar1) { /*   */ memset2(_Dest,0,0x100); /*    _Dest    */ strncpy2(_Dest,_Argv[i],0x100); break; } ... } 

यह ध्वज निम्न तर्क को पार्स करते समय सेट किया गया है:

 n_strlen = strlen2(_Argv[i]); if (((n_strlen == 2) && (((int)*_Argv[i] & 0x7fffffffU) == 0x2d)) && (((int)_Argv[i][1] & 0x7fffffffU) == 0x66)) { bVar1 = true; } 

पहली पंक्ति इस तर्क की लंबाई की गणना करती है। इसके अलावा, स्थिति यह जांचती है कि तर्क की लंबाई 2 होनी चाहिए, परपोषी वर्ण == "-" और अंतिम वर्ण == "च"। ध्यान दें कि डिकम्पायर कैसे बाइट मास्क का उपयोग करके स्ट्रिंग से पात्रों के निष्कर्षण को "अनुवादित" करता है।

संख्याओं के दशमलव मान और उसी समय संबंधित ASCII वर्ण, संबंधित हेक्साडेसिमल शाब्दिक पर कर्सर पकड़कर जासूसी की जा सकती है। ASCII मानचित्रण हमेशा काम नहीं करता है (?), इसलिए मैं इंटरनेट पर ASCII तालिका देखने की सलाह देता हूं। आप सीधे हाइड्रा में स्केलर को किसी भी संख्या प्रणाली से किसी अन्य (संदर्भ मेनू के माध्यम से -> रूपांतरित ) में भी परिवर्तित कर सकते हैं , इस मामले में यह संख्या चयनित संख्या प्रणाली (डिसेम्बलर में और डिकंपाइलर) में हर जगह प्रदर्शित होगी; लेकिन व्यक्तिगत रूप से, मैं काम के सामंजस्य के लिए कोड में हेक्स छोड़ना पसंद करता हूं, क्योंकि मेमोरी एड्रेस, ऑफसेट आदि। हेक्स हर जगह सेट हैं।

लूप आने के बाद यह कोड:

 if ((bVar1) && (*_Dest != 0)) { /*    1) "-f"  2)  -         */ _File = fopen2(_Dest,"rb"); if (_File == (FILE *)0x0) { /*  1    */ perror2("Failed to open file"); return 1; } ... } 

यहां मैंने तुरंत टिप्पणियां जोड़ दीं। हम तर्कों की वैधता की जांच करते हैं ("-f path_to_file") और संबंधित फ़ाइल खोलें (2 तर्क पास, जिसे हमने _Dest पर कॉपी किया था)। फ़ाइल को बाइनरी प्रारूप में पढ़ा जाएगा, जैसा कि फोपेन () फ़ंक्शन के "आरबी" पैरामीटर द्वारा इंगित किया गया है। यदि रीड विफल हो जाता है (उदाहरण के लिए, फ़ाइल अनुपलब्ध है), एक त्रुटि संदेश stderror स्ट्रीम में प्रदर्शित होता है और प्रोग्राम कोड 1 से बाहर निकलता है।

अगला सबसे दिलचस्प है:

  /* !!!     !!! */ ppcVar3 = _construct_key(_File); if (ppcVar3 == (char **)0x0) { /*    ,  "Nope" */ puts2("Nope."); _free_key((void **)0x0); } else { /*    -      */ printf2("%s%s%s%s\n",*ppcVar3 + 0x10d,*ppcVar3 + 0x219,*ppcVar3 + 0x325,*ppcVar3 + 0x431); _free_key(ppcVar3); } fclose2(_File); 

ओपन फाइल डिस्क्रिप्टर ( _File ) _construct_key () फ़ंक्शन को पास किया गया है, जो स्पष्ट रूप से मांगी गई कुंजी का सत्यापन करता है। यह फ़ंक्शन एक दो-आयामी बाइट सरणी ( चार ** ) देता है, जिसे ppcVar3 चर में संग्रहीत किया जाता है। यदि सरणी खाली है, तो संक्षिप्त "Nope" कंसोल पर प्रदर्शित होता है (जो कि, हमारी राय में, "Nope!") और मेमोरी फ़्री है। अन्यथा (यदि सरणी खाली नहीं है), तो स्पष्ट रूप से सही कुंजी प्रदर्शित की जाती है और मेमोरी को भी मुक्त कर दिया जाता है। फ़ंक्शन के अंत में, फ़ाइल डिस्क्रिप्टर बंद हो जाता है, मेमोरी फ़्री हो जाती है , और iVar2 का मान वापस आ जाता है ।

इसलिए, अब हमने महसूस किया कि हमें इसकी आवश्यकता है:

1) सही कुंजी के साथ एक बाइनरी फ़ाइल बनाएं;
2) तर्क "-f" के बाद दरार में अपना रास्ता गुजारें

लेख के दूसरे भाग में, हम फ़ंक्शन _construct_key () का विश्लेषण करेंगे, जो हमें पता चला, फ़ाइल में वांछित कुंजी की जांच करने के लिए जिम्मेदार है।