CRACKL @ B प्रतियोगिता 2010. पहले कार्य का विश्लेषण

2010 समाप्त हो रहा था, संसाधन पर वैश्विक सुधार चल रहे थे। ये परेशान समय थे। और इस कठोर समय में, एक स्थानीय टूर्नामेंट बनाने का विचार उभर रहा है। यह विचार स्थानीय समुदाय द्वारा बहुत खुशी से प्राप्त किया गया था। कुछ समय बाद, 3 कार्य बनाए गए (हालांकि 5 की योजना बनाई गई थी), जूरी सदस्यों और रेटिंग प्रणाली का चयन किया गया था। और इसलिए, यह शुरू हो गया है।

प्रस्तावना

पहला असाइनमेंट PE_Kill द्वारा KeyGenMe था। कार्य KeyGen लिखना था, जो कि एक नाम के लिए कई कुंजी उत्पन्न करना था। लेखक का मूल विवरण इस प्रकार है:

यहाँ KeyGenMe है। नाम खुद के लिए बोलता है - आपको एक प्रमुख जनरेटर लिखने की आवश्यकता है,
जिसे KeyGenMe में सफलतापूर्वक टेस्ट किया जाएगा। किसी भी नाम के लिए, जनरेटर चाहिए
कई अद्वितीय सीरियल नंबर दें। KeyGenMe को एक साधारण होममेड के साथ पैक किया गया है
पैकर।

मैं चेतावनी देना चाहूंगा। KeyGenMe उतना जटिल नहीं है जितना यह लग सकता है, लेकिन तुच्छ नहीं
और एक गैर-मानक दृष्टिकोण की आवश्यकता है। एक छोटा प्लस अनपैक किया जाएगा
KeyGenMe विकल्प।

सौभाग्य है

के विश्लेषण

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

• OllyDbg में आयात करने के लिए .map फ़ाइल बनाना;
• चेक बटन के क्लिक को संसाधित करने का कार्य ढूँढना।

फ़ाइल का पूरा विश्लेषण पूरा होने के बाद, एक .map फ़ाइल बनाएँ।


और हमें बटन क्लिक हैंडलर का पता लगता है।


OllyDbg में .map फ़ाइल का उपयोग करने के लिए, आपको मैपिम्प प्लगइन को स्थापित करना होगा । डिफ़ॉल्ट रूप से, .map फ़ाइल उसी फ़ोल्डर में सहेजी जाती है जिसमें से प्रोग्राम खोला गया था और प्रोग्राम के समान नाम के साथ, यदि सब कुछ सही ढंग से किया गया है और प्लग-इन स्थापित है, तो जब आप ओलक में कीजन खोलते हैं, तो एक संदेश दिखाई देना चाहिए जो आपको .map फ़ाइल डाउनलोड करने के लिए कहेंगे। "हाँ" और सब कुछ ठीक है। यदि कुछ गलत है, तो आप इसे मुख्य मेनू के माध्यम से मैन्युअल रूप से डाउनलोड कर सकते हैं।
पूरी तैयारी की जाती है। चेक बटन पर क्लिक करने के लिए प्रसंस्करण कार्य के पते पर ऑलिवडग पर जाएं, जिसे आपको आईडीआर के साथ याद रखना / लिखना / कॉपी करना होगा। और हम देखते हैं कि शुरुआत में नाम और धारावाहिक कैसे प्राप्त होते हैं (यह इतना महत्वपूर्ण नहीं है), लेकिन सबसे दिलचस्प हिस्सा चलता है।

अर्थात् TKeyEngine.Create, TKyeEngine वर्ग का एक उदाहरण चीजों के तर्क के अनुसार बनाया गया है, यह वर्ग पूरे सर्किट का दिल है। दो फ़ंक्शन इसका पालन करते हैं, दूसरे का परिणाम इसके कॉल के तुरंत बाद की स्थितियों में से एक में शामिल है। यहां वे सभी संपन्न हुए। तो, उनमें से प्रत्येक के बारे में थोड़ा और विस्तार।

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

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

MOV addr, 0046BED9 @loop: FIND addr, #EB033BC?7?# CMP $RESULT, 0 JE @exit MOV addr, $RESULT FILL addr, 5, 90 ADD addr, 5 JMP @loop @exit: RET 

खैर, इस आपत्ति को पूरा करने से पहले, कुछ क्रियाएं हुईं - यह है कि 16 बाइट्स की एक सरणी को बाद के "सरल" जोड़तोड़ के लिए नाम के साथ बनाया गया है, कमजोर दिमाग वाले लोग जो इतने कोड नहीं देखते थे जिन्हें विश्लेषण करने की आवश्यकता थी। आतंक। लेकिन "शैतान इतना भयानक नहीं है जितना कि वह चित्रित है।" एक अधिक विस्तृत विश्लेषण से पता चला है कि यह एक गहरी शब्दार्थ भार नहीं उठाता है। मैं 10001 * 16 पुनरावृत्तियों में स्विच के साथ इस बड़े लूप के बारे में बात कर रहा हूं।

यह चीर करने के लिए पर्याप्त है। यह सच है, कोड का यह चीर-फाड़ का टुकड़ा 12k लाइनों से अधिक होगा, लेकिन 6k लाइनों से थोड़ा कम रहने के बाद नोड्स से इसे साफ करने के बाद। लेकिन इससे पहले कि आप इसे चीर दें, आप इसे और अधिक सही रूप में ला सकते हैं। क्योंकि चूँकि पूरा सर्किट वर्ग के एक उदाहरण के साथ काम करता है, यह सरणी सूचक के सापेक्ष 5 बाइट्स के बदलाव के साथ कहीं अंदर है। इसलिए, आपको तामझाम के बिना केवल एक सरणी को हमारे रिप्ड कोड में स्थानांतरित करने के लिए सही करने की आवश्यकता है। इसके लिए मैंने यह पटकथा लिखी।

 MOV addr, 0046BED9 @loop: OPCODE addr CMP $RESULT_2, 3 JB @next MOV temp, addr ADD temp, $RESULT_2 SUB temp, 2 MOV val, [temp], 1 CMP val, 43, 1 JE @ok CMP val, 53, 1 JNE @next @ok: INC temp MOV val, [temp], 1 SUB val, 5 MOV [temp], val, 1 @next: ADD addr, $RESULT_2 CMP addr, 004707A1 JA @exit JMP @loop @exit: RET 

तब आप पूरी बात को चीर सकते हैं। यह सब संभव हो गया था asm डालने की मदद से, लेकिन कुछ परेशानियाँ थीं जिन्हें मैं स्वीकार्य समय में हल नहीं कर सकता था, इसलिए इस सभी को asm फ़ाइल में एक अलग फ़ंक्शन के रूप में रखने और इसे परियोजना से जोड़ने का निर्णय लिया गया, जिसने तुरंत सभी समस्याओं को हल कर दिया। फट कोड पर दो और ठोकरें हैं, यह आकार में एक बाइट के एक स्थानीय चर का उपयोग करता है और स्टैक की शुरुआत में स्थित नहीं है, लेकिन सिर्फ गलत जगह और यहां ईबीपी -5 में, यह सब बदलना संभव होगा, लेकिन फिर से मैं सबसे छोटे पथ के साथ चला गया प्रतिरोध ने स्थानीय आवश्यकताओं (जैसे संरेखण) के लिए 8 बाइट्स का एक ढेर आवंटित किया। और दूसरी गड़बड़ी यह है कि अभी भी एक अन्य फ़ंक्शन के लिए कॉल है, लेकिन यह एक छोटी 2 टीम है, मैन्युअल रूप से रिप / रीराइट करें (मुझे यह भी पता नहीं है कि कौन तेज है) और कॉल नामों को अपने साथ बदलें। यह सब, पीछे के रास्ते का एक चौथाई है।

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

पहला इसमें हाइफ़न की लंबाई और स्थान के लिए एक जांच है, जिसमें से यह पता लगाना संभव होगा कि धारावाहिक क्या है:
XXXXX-XXXXX-XXXXX-XXXXX-XXXXX-XXXXX-XXXXX-XXXXX


फिर हाइफ़न इसे से काट दिया जाता है और परिणामस्वरूप स्ट्रिंग को डिकोड किया जाता है। डिकोडिंग फ़ंक्शन एक मानक एल्गोरिथ्म है जिसे मैंने जल्दी से पता नहीं लगाया है। मुख्य सुराग यह है कि धारावाहिक के पात्रों को वर्णमाला के खिलाफ जांचा जाता है।

इस वर्णमाला को देखते हुए, यह पता चला कि यह बेस 32 है , एक डिकोडिंग फ़ंक्शन है। जिसके बाद हमारे पास 25 बाइट्स के आकार के साथ एक सरणी है, और जिसे फिर तीन भागों में विभाजित किया गया है, पहला 16 बाइट्स का एक सरणी है, दूसरा 1 बाइट का मान है, और तीसरा 8 बाइट्स का एक सरणी है।

 typedef struct _KEY { unsigned char SomeBytes[16]; unsigned char SomeCount; unsigned int CipherText[2]; } KEY, *LPKEY; 

जैसा कि आप संरचना के तीसरे तत्व को देख सकते हैं, मेरा एक सार्थक नाम है, आगे देखकर मैं कहूंगा कि एक एन्क्रिप्टेड स्ट्रिंग होना चाहिए जिसकी तुलना सबसे हाल के परीक्षण में संदर्भ स्ट्रिंग के साथ की गई है। तो, धारावाहिक का सत्यापन और घटकों में इसका अपघटन पूरा हो गया है। इस फ़ंक्शन से बाहर निकलते समय, एक जांच होगी कि KEY.SomeCount 32 से अधिक है, यदि ऐसा है, तो हम आगे बढ़ते हैं। अगला एक छोटा सा चक्र है जिसमें स्वैप WORD'S KEY.SomeBytes और नाम से प्राप्त सरणी का अनुसरण करता है, यह कोड को फैलाने के लिए अधिक कार्य करता है, क्योंकि इसका कोई तार्किक अर्थ नहीं है, क्योंकि अगला एक ही सरणी और उनके संबंधित तत्वों के साथ काम करता है, पहला पहले के साथ, दूसरा दूसरे के साथ, आदि।
और फिर दूसरा स्विच आता है। उन लोगों के लिए जिनकी पहली इच्छा पूरी नहीं हुई, दूसरे ने और लोगों को भी मात दी। अपने आप से, यह सरल है, प्रत्येक बाइट मान के लिए, एक फ़ंक्शन को एक ही प्रोटोटाइप के अनुसार कहा जाता है, लेकिन यहां फ़ंक्शन सभी के लिए अलग-अलग हैं।

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

प्रत्येक बिट के लिए इस तरह के फ़ंक्शन का अपना कार्य होता है, लेकिन सबसे महत्वपूर्ण बात यह है कि यदि कोई विशिष्ट बिट है, तो इन सभी जोड़तोड़ों का परिणाम KEY.CIFTText में एक निश्चित स्थिति में रखा जाता है और एक अलग काउंटर बढ़ जाता है, बशर्ते कि यह आठ से अधिक हो (टी .e। 8 प्रतिस्थापन KEY.CipherText में किए गए थे) एक त्रुटि के साथ फ़ंक्शन को समाप्त करता है। एक और काउंटर भी है जो प्रत्येक ऑपरेशन के साथ बढ़ता है, अर्थात। यदि थोड़ा सेट किया जाता है, तो बहुत पहले के अलावा, जब हमें एक बाइट मिलती है, जिस पर ये सभी इशारे होते हैं। इन सभी का विश्लेषण करते समय, एक भेद्यता प्रकट की गई थी जिसने इन सभी जोड़तोड़ों को पूरी तरह से अनदेखा करने की अनुमति दी थी। यह इस तथ्य में निहित है कि यदि KEY.CipherText को लिखने के लिए ज़िम्मेदार बिट सेट नहीं है, तो KEY.CipherText कभी नहीं बदलेगा, जो बहुत अच्छा है, यह आपको KEY.CipherText को उसके मूल रूप में छोड़ने की अनुमति देता है, जिस तरह से हमने इसे सेट किया है।

और यही है, आपको प्रत्येक बाइट मान के लिए एक मुखौटा तालिका बनाने की आवश्यकता है जिसमें इस बिट को ध्यान में नहीं रखा जाएगा। आपको बिट को सेट होने से रोकने की आवश्यकता है जिस पर बाइट शुरुआत में प्राप्त की जाती है, यह दूसरे काउंटर के लिए बिट्स को सुविधाजनक रूप से गिनने के लिए आवश्यक है (हमें एक चेक के लिए इसकी आवश्यकता है)। प्रत्येक बाइट मूल्य के लिए बिट्स खोजने की इस दिनचर्या से बचने के लिए, मैंने एक छोटी सी स्क्रिप्ट लिखी जो आवश्यक बिट्स को ढूंढती है, उनसे आवश्यक मास्क भी बनाता है और इसे तालिका में लिखता है।

 MOV addr, 004707FC ALLOC 100 CMP $RESULT, 0 JE @error MOV table, $RESULT PUSHA MOV c, 0 @loop: FIND addr, #751190909090900FB643260FB6440326884304# CMP $RESULT, 0 JE @exit MOV cl, [$RESULT - 1], 1 MOV addr, $RESULT ADD addr, 13 FIND addr, #751E90909090900FB643260FB65304885403269090909090FE4326# CMP $RESULT, 0 JE @exit MOV bl, [$RESULT - 1], 1 OR bl, cl NOT bl MOV [table + c], bl, 1 MOV addr, $RESULT ADD addr, 20 INC c CMP c, 100 JE @exit JMP @loop @exit: POPA DM table, 100, "table.bin" FREE table, 100 @error: RET 

इस चक्र के बाद, बिट काउंटर की तुलना KEY.SomeCount के मान से की जाती है, यदि वे समान हैं, तो हम पहले से ही फिनिश लाइन पर हैं। अगला उस फ़ंक्शन पर कॉल है जिसमें KEY.CipherText डेटा के रूप में और कुंजी के रूप में नाम के साथ एक सरणी स्थानांतरित किया गया है, अंदर कुछ और प्रविष्टियां होंगी जब तक कि हम वांछित फ़ंक्शन को प्राप्त नहीं करते हैं, इसमें स्थिरांक द्वारा यह तुरंत स्पष्ट हो गया था कि यह एल्गोरिदम के टीईए परिवार से कुछ था। जहां डेल्टा का उपयोग किया जाता है, वहां XTEA के साथ कुछ होना निर्धारित किया गया था। जैसा कि यह निकला, मूल एल्गोरिथ्म में केवल एक मामूली बदलाव के साथ।

जैसा कि स्क्रीन से देखा जा सकता है, मैंने यह पता लगाने के लिए प्रत्येक चरण को अलग किया कि संशोधन कहाँ किया गया था। यह इस तथ्य में शामिल था कि कोष्ठक की स्थिति दो स्थानों में बदल गई थी, अर्थात्। प्राथमिकता कार्रवाई।
मूल:

 void xtea_decipher(unsigned int num_rounds, uint32_t *v, uint32_t const *k) { unsigned int i; uint32_t v0=v[0], v1=v[1], delta=0x9E3779B9, sum=delta*num_rounds; for (i=0; i < num_rounds; i++) { v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + k[(sum>>11) & 3]); sum -= delta; v0 -= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + k[sum & 3]); } v[0]=v0; v[1]=v1; } 

संशोधित:

 void xtea_decipher(unsigned int num_rounds, uint32_t *v, uint32_t const *k) { unsigned int i; uint32_t v0=v[0], v1=v[1], delta=0x9E3779B9, sum=delta*num_rounds; for (i=0; i < num_rounds; i++) { v1 -= ((((v0 << 4) ^ (v0 >> 5)) + v0) ^ sum) + k[(sum>>11) & 3]; sum -= delta; v0 -= ((((v1 << 4) ^ (v1 >> 5)) + v1) ^ sum) + k[sum & 3]; } v[0]=v0; v[1]=v1; } 

तो, सब कुछ बीत चुका है, यह फिनिश लाइन को पार करने के लिए बना हुआ है। जिसके स्थान पर CRACKLAB शब्द के साथ डिक्रिप्शन के बाद डेटा की तुलना है, जिसका अर्थ है कि इस शब्द को एन्क्रिप्ट करने की आवश्यकता है।
बस इतना ही, keygen लिखें।

परिणाम

Keygen लिखने के लिए, हमें आवश्यकता होगी: एक नाम के साथ एक सरणी बनाने के लिए रिप्ड कोड, Base32Encoding के कार्यान्वयन, संशोधित XTEA के कार्यान्वयन, एक मुखौटा तालिका, और हमारे कोड में कुछ कोड जोड़ें। सबसे पहले, हम तालिका के डंप का अनुवाद एक सरणी में करते हैं जिसे कोड में डाला जा सकता है, हर कोई ऐसा कर सकता है जैसे वह फिट देखता है। क्रमांकन पीढ़ी एल्गोरिथ्म के निम्नलिखित रूप हैं:

1. नाम => name_array [16]
2. मोर्फ (name_array)
3. KEY.SomeBytes [i] = यादृच्छिक () और तालिका [name_array [i]]
4. KEY.SomeCount = बिट्सकाउंट (KEY.SomeBytes)
5. KEY.CipherText = xtea_encode ("CRACKLAB")
6. SerialBase = Base32Encode (KEY)
7. सीरियल = इन्सर्टडेफ़िस (सीरियलबसे)

मेरी कीजन: github.com/reu-res/CRACKLAB-Contest-2010

अगले लेख में मैं दूसरे कार्य का विश्लेषण करूंगा, जो शायद इससे अधिक दिलचस्प होगा। ध्यान दें! वहां आपको वीएम (ठीक है, लेखक ने ऐसा कहा) की चर्चा मिलेगी, जिसके कार्यान्वयन में साधारण कार्यान्वयन से भिन्नता है जो एक दूसरे के लिए संरचना में समान हैं। जल्द मिलते हैं।