PE_Kill द्वारा क्रैकमे # 1 विश्लेषण

प्रस्तावना

मैं लंबे समय से कुछ भी शोध नहीं कर रहा था, इसलिए सेवानिवृत्त होने के लिए बोल रहा हूं। लेकिन तब मैं PE_Kill'a के कई शिल्पों के अगले शिल्प से भली-भांति परिचित था। क्योंकि मैं CRACKL @ B कॉन्टेस्ट 2010 के फ्रेमवर्क में अपने पिछले काम को हल करने के लिए हुआ था, जो बदले में काफी दिलचस्प था, मैंने उनके नए "दिमाग की उपज" को देखने का फैसला किया।

आपको कट के नीचे क्या इंतजार है: CRC32 नकली, RC4 के लिए ब्रूट कुंजी, RSA के लिए फ़ैक्टरीकरण, साथ ही एमडी 4 के लिए टकराव का उपयोग और एक ही हैश के साथ दो अलग-अलग संदेशों की पीढ़ी। यह सब और बहुत कुछ कटौती के तहत।

लेख एक शुरुआत के लिए अभिप्रेत नहीं है, मैं सभी कार्यों को नहीं चबाऊंगा। जिसका उद्देश्य keygen लिखना है।

परिचय

जैसा कि ऊपर उल्लेख किया गया है, लंबे समय तक मैंने कट नहीं किया। इसलिए, मुझे कुछ समय "स्विंगिंग" में बिताना पड़ा। इसके अलावा अपने टूलकिट को आंशिक रूप से पुनर्स्थापित करें, जैसा कि मेरे पास केवल OllyDbg और IDA बचा है। बाद का उपयोग नहीं किया जाएगा। और प्रतियोगिता से अपने कार्य को याद करते हुए, मुझे कुछ दिलचस्प की उम्मीद थी जो मुझे अपने मस्तिष्क को सामान्य से बहुत अधिक सक्रिय कर देगा। और मुझसे गलती नहीं हुई।

लड़ाई में

प्राप्त खुफिया

खैर, शुरुआत के लिए हमें खुद ही क्रैकमे की जरूरत है। हम इसे ओलीडबग में खोलते हैं और देखते हैं कि यह UPX का उपयोग करके पैक किया गया है, ठीक है, अब वे किसी को डराने की संभावना नहीं है। मैंने कम से कम प्रतिरोध का रास्ता अपनाया, और इसे क्वनपैक के साथ खोल दिया । इसके अलावा, वर्षों से विकसित मेरी तकनीक के बाद, मैंने विभिन्न क्रिप्टो, हैश और हेक्सो एल्गोरिदम के उपयोग के लिए इसका विश्लेषण करने का निर्णय लिया। ऐसा करने के लिए, मैंने SnD Reverser Tool का उपयोग किया, जिसने मुझे सूचित किया कि मुझे CRC32 , RC4 , MD4 मिला । अब, यह सब जानते हुए, आप अधिक सक्रिय क्रियाएं शुरू कर सकते हैं।

शत्रु रेखाओं के पीछे

तो, स्थैतिक विश्लेषण समाप्त करने के बाद, हम गतिशील विश्लेषण के लिए आगे बढ़ते हैं, अर्थात्। बहस पर आते हैं। फिर से, OllyDbg (इसके बाद - ओल्का) में क्रैकमे (बाद में - दरार) खोलें, लेकिन मूल नहीं, बल्कि अनपैक्ड। Ctrl + G दबाएं और GetDlgItemTextA दर्ज करें, इसलिए हम इस फ़ंक्शन की शुरुआत में जाएंगे, एक ब्रेकपॉइंट डालेंगे और इसे शुरू करेंगे। परीक्षण के लिए नाम और एक निश्चित लाइसेंस दर्ज करें और चेक पर क्लिक करें। इसलिए हमने अपने ब्रेकपॉइंट पर शुरू किया, Alt + F9 दबाएं और नाम प्राप्त करने के लिए फ़ंक्शन को कॉल करने के तुरंत बाद अपनी दरार के कोड में प्रवेश करें।

उसके बाद नाम की लंबाई के दो चेक हैं, पहला यह कि नाम दर्ज किया गया था, और दूसरा अर्थहीन है। दूसरे चेक में, यदि नाम की लंबाई 50 है, तो हमें सूचित किया जाता है कि नाम लंबा और निकास है। यह व्यर्थ क्यों है, लेकिन क्योंकि नाम इस प्रकार प्राप्त होता है:

GetDlgItemTextA(hDlg, IDC_NAME, szName, 50); 

और इसका मतलब यह है कि अधिकतम यह 50 से अधिक वर्णों की लंबाई के साथ एक स्ट्रिंग है, जहां 50 वां वर्ण लाइन के अंत का चरित्र है, और हमारे पास यह है कि लाइन कभी भी 49 वर्णों से अधिक नहीं होगी। इसी तरह, एक लाइसेंस के साथ, लेकिन यह महत्वपूर्ण नहीं है। आखिरकार यह पोषित कार्य आता है, जिसमें सभी सबसे दिलचस्प होते हैं, मैंने इसे बुलाया - चेकलीसेंस।

दुश्मन की खाइयों में

और इसलिए हम दिल में हैं। कार्यों के पहले जोड़े ऊपरी मामले में लाइसेंस वर्णों का अनुवाद है, और फिर लाइसेंस का अनुवाद बाइट्स की एक सरणी में है और लाइसेंस की लंबाई के लिए पहले से ही जाँच है।

लाइन फीड फ़ंक्शन में, यह देखा जाएगा कि यह वर्णमाला (0–9, एएफ) के खिलाफ लाइसेंस की जांच करता है, अर्थात। एक लाइसेंस किसी प्रकार का डेटा सरणी है जिसे हेक्स स्ट्रिंग में अनुवादित किया गया है, और अंत में यह जांचा जाता है कि प्राप्त सरणी की लंबाई 0 × 90 बाइट्स है या नहीं। यह इस प्रकार है कि लाइसेंस की लंबाई 0 × 90 * 2 = 0 × 120 (288) वर्ण होनी चाहिए।
इस सब के बाद, हम मुख्य समारोह में लौटते हैं। अगला इस सरणी के पहले 0 × 8C बाइट्स के नियंत्रण योग की गणना है (इसके बाद हम इस सरणी को कहेंगे - लाइसेंस) 4 बाइट संख्या के साथ, जो लाइसेंस के अंत में स्थित है।

और फिर नाम के साथ जोड़तोड़ के 10 सर्कल हैं, प्रत्येक सर्कल का परिणाम 4 बाइट संख्याओं के एक अलग तत्व में रखा गया है। आगे देखते हुए मैं कहूंगा कि यह सरणी RC4 के लिए महत्वपूर्ण होगी, इसलिए मैं इसे कुंजी कहूंगा।

दौर ०-२:

राउंड 1 को छोड़कर सभी सर्किल एक बार उपयोग किए जाते हैं, इसलिए उन्हें इनलाइन फ़ंक्शन के रूप में कंपाइलर द्वारा माना जाता था, लेकिन राउंड 1 स्वयं को डेटा के नियंत्रण योग को प्राप्त करने के लिए फ़ंक्शन के रूप में अंत में दो बार उपयोग किया जाएगा।

राउंड 3-4:


दौर 5-7:


दौर 8-9:


जैसा कि आप देख सकते हैं, राउंड 9 लाइसेंस के नियंत्रण योग की गणना के समान है, जो शुरुआत में था।
इस सब के बाद, सरल जोड़तोड़ के साथ, हम कुंजी से उसी कुंजी के बाद के xsor के लिए मान पाते हैं। साथ ही, आरसी 4 का उपयोग करके लाइसेंस की बहुत पहले 0 × 8C बाइट्स को डिक्रिप्ट करने के बाद एक और परीक्षण में इस मूल्य का उपयोग किया जाएगा और नाम से हमें प्राप्त की गई कुंजी के साथ। और एक और हेरफेर में, जिसके परिणाम हमें आगे की आवश्यकता होगी।


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

और यहां वह चेक है जहां इस मूल्य की आवश्यकता थी। डिक्रिप्शन के बाद, हमारे पास लाइसेंस होना चाहिए [34] (यदि हम लाइसेंस को 4 बाइट मानों की एक सरणी के रूप में मानते हैं, जो हम करना जारी रखेंगे) मान XorKey के समान है। यह इस दरार में सबसे आसान हिस्सा समाप्त करता है। आगे क्या होता है, इसने मुझे और अधिक समय और प्रयास दिया।
इसके बाद लाइसेंस के 8 बाइट्स की CRC32 गिनती आती है, जो 0xFFB97FE0 होनी चाहिए। यदि सब ठीक हो जाता है, तो ये 8 बाइट्स आगे RC4 कलन विधि का उपयोग करके दो हार्डकोड मानों को डिक्रिप्ट करने की कुंजी के रूप में काम करते हैं और आउटपुट पर दो चेहरे प्राप्त करने चाहिए। तो, यहाँ पहली दिलचस्प जगह है जो दरार में है। Googling, मुझे RC4 के लिए कोई टकराव नहीं मिला जो मुझे कुंजी खोजने में मदद करेगा, क्योंकि इसे भंग करने का निर्णय लिया गया था। लेकिन माथे में 8 बाइट्स चिपकना थोड़ा मूर्खतापूर्ण और लंबा है। यह अच्छा है कि मैं पहले से ही एक नकली सीआरसी 32 से निपट गया और मुझे एहसास हुआ कि किस रास्ते पर जाना है। उन लोगों के लिए, जो कुछ शब्दों में यह नहीं जानते हैं कि यह इस प्रकार है: "किसी भी डेटा से आपको सीआरसी 32 की आवश्यकता हो सकती है, बस 4 आवश्यक बाइट्स जोड़ना / बदलना"। आप इसके बारे में और अधिक यहाँ पढ़ सकते हैं। यहाँ से हमारे पास यह है कि अब हमें 8 बाइट्स नहीं, बल्कि 4 को ब्रूट करने की आवश्यकता है, जो हमारे जीवन को बहुत आसान बना देता है। मैंने विभिन्न तकनीकों, मल्टीथ्रेडिंग, समानांतर कंप्यूटिंग का उपयोग करते हुए प्रचुर मात्रा में ब्रूट्स नहीं लिखने का फैसला किया। मैंने एक साधारण सिंगल-थ्रेडेड ब्रूट लिखा है, जो 15 मिनट में मेरे AMD II X2 250 पर एक कुंजी मिला।
ऐसा मेरा ब्रूट जैसा दिखता है:

 int main() { uint32_t key[2] = {0, 0}; uint8_t *pkey = (uint8_t *)&key; rc4_key skey; uint32_t rc4_data[2]; do { fix_crc_end(pkey, 8, 0xFFB97FE0); prepare_key(pkey, 8, &skey); rc4_data[0] = 0xE6C5D5E1; rc4_data[1] = 0x41C98EAB; rc4((uint8_t *)rc4_data, 8, &skey); if (rc4_data[0] == 0xFACE0001 && rc4_data[1] == 0xFACE0002) { printf("Key: "); for (int i = 0; i < 8; i++) { printf("%02X", *pkey++); } printf("\n"); break; } } while (key[0]++ <= 0xFFFFFFFF); printf("\n\n\t\tFin!\n"); return 0; } 

मुझे सही कुंजी मिली, अब मैं उन कुंजियों को उत्पन्न कर सकता हूं जो उपरोक्त सभी उत्तीर्ण चेक पास करेंगे। यह सब जानते हुए, आप लाइसेंस के सामान्य रूप की कल्पना कर सकते हैं:

 typedef struct _LICENSE { unsigned char M1[0x40]; unsigned char M2[0x40]; unsigned int FaceKey1; unsigned int FaceKey2; unsigned int AfterXorKey; unsigned int LicenseCheckSum; } LICENSE, *LPLICENSE; 

अंतिम 4 मान पहले से ही पार्स हैं, केवल लाइसेंस के पहले 0 × 80 बाइट्स बने हुए हैं, आगे देखते हुए मैं कहूंगा कि ये 0 × 40 बाइट्स के दो संदेश हैं।

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

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

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

उसके बाद एक जाँच होती है कि पहले संदेश का 6 वाँ तत्व दूसरे के समान तत्व के बराबर होगा। और यह भी कि यह मान जब ShiftCount बिट द्वारा दाईं ओर शिफ्ट किया जाता है तो नीट बाइट की आवश्यकता कम होती है। इन सभी दो मूल्यों को हमने ऊपर प्राप्त किया।

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

और सबसे अंत में पहले और दूसरे संदेशों के एमडी 4 हैश हैं, और यदि वे समान हैं, तो हमने सफलतापूर्वक परीक्षण पास कर लिया है। लेकिन रुको, अगर इन संदेशों में दो कार्यों के लिए एक अलग चेकसम होना चाहिए, तो संदेश अलग-अलग होने चाहिए, लेकिन साथ ही उनके पास एक ही हैश होना चाहिए, जो यहां फिट नहीं है।
और यहाँ Google फिर से "md4 टक्कर" के साथ खेलने के लिए आता है, और वहाँ वास्तव में MD4 के लिए टकराव पर infa है, और यह अलग है, स्वैच्छिक लेख हैं, लेकिन सतही हैं। और इन लेखों में से एक में मुझे पता चलता है कि चीनी 0 × 40 बाइट्स के दो अलग-अलग संदेश एक ही हैश के साथ बनाने में सक्षम थे, यहाँ है। अब हम निम्नलिखित क्वेरी "md4 टक्कर स्रोतों" के साथ Google करते हैं और सच्चाई यह है कि इस तरह के दो संदेश खोजने के लिए स्रोत कोड हैं, लेकिन वे लिनक्स के तहत लिखे गए थे, जहां यादृच्छिक फ़ंक्शन एक 4-बाइट नंबर देता है, और विंडोज़ में यह सिर्फ 0 और RAND_MAX देता है ( 32767)। क्योंकि मुझे लंबे समय से जो समस्या थी, वह मेरे लिए गलत संदेश क्यों देती है। संकेत के बाद, मैंने डेल्फी के साथ यादृच्छिक फ़ंक्शन को फिर से लिखा, और यह एक धमाके के साथ काम किया।

लेखन कीजन

मैं keygen लिखने में सभी चरणों का वर्णन नहीं करूंगा, लेकिन केवल कुछ महत्वपूर्ण बिंदुओं पर ध्यान दें। पहले हम एक नाम के साथ RC4 के लिए एक कुंजी बनाते हैं, मैं इसे छोड़ देता हूं, इसमें कुछ भी जटिल नहीं है, आलसी के लिए आप इस पूरे हिस्से को सिर्फ चीर सकते हैं। इसके बाद, आपको कुंजी xor के लिए मान ढूंढना होगा और कुंजी को स्वयं को पोक करना होगा, जिसके बाद इस मान से ShiftCount और NeedByte का पता लगाएं। इस हिस्से को भी चीर दिया जा सकता है, वांछित बाइट को खोजने के लिए, आपको 256-बाइट टेबल को भी चीरना होगा। हम ऊपर दिए गए संरचना के अनुसार XorKey मान को लाइसेंस में लिखते हैं। आप दो मूल्यों को भी लिख सकते हैं जो चेहरे खोजने की कुंजी हैं, वे सभी के लिए स्थिर और समान होंगे। जिसके बाद आपको दो संदेश उत्पन्न करने की आवश्यकता है, लेकिन तथ्य यह है कि अगर आपको याद है, तो 6 वें तत्व का एक निश्चित प्रारूप होना चाहिए। संदेश निर्माण कार्य में स्वयं कोई पैरामीटर नहीं है, लेकिन चूंकि आपको इसके लिए दो मान पास करने की आवश्यकता है, ये हैं ShiftCount और NeedByte। हम प्रोटोटाइप को बदलते हैं और इस फ़ंक्शन के कोड में कुछ और लाइनें जोड़ते हैं। यह था:

 if(X0[ 5] != X1[ 5]) continue; 

और यह बन गया:

 if(X0[ 5] != X1[ 5]) continue; else if (((X0[5] >> c) & 0xFF) != b) continue; 

जहां सी शिफ्टकाउंट है, बी नीडबाइट है।
जिसके बाद संदेशों को क्रमशः X0 और X1 में रखा गया है। फिर हम इन संदेशों को एक बड़े में जोड़ते हैं और इसे RSACrypt में डालते हैं। डिक्रिप्शन स्वयं 0 × 20 बाइट्स के ब्लॉक में जाता है, इसलिए हम इसे एन्क्रिप्ट करेंगे। लेकिन इस वजह से, मुझे भी समस्याएं थीं, जो नहीं जानते हैं, फिर संदेश (एम हमारे ब्लॉक 0 × 20 बाइट्स हैं) सार्वजनिक कुंजी (एन) से कम होना चाहिए, यह दरारें को ध्यान में नहीं रखा जाना चाहिए, और यह सब कुछ डिक्रिप्ट करेगा। इसलिए, हमें इसे ध्यान में रखना चाहिए। मैंने एन्क्रिप्शन फ़ंक्शन में एक चेक जोड़ा, अगर एन <एम, तो हम बाहर निकलते हैं और नए संदेश उत्पन्न करते हैं, यही वजह है कि लाइसेंस उत्पादन समय 15 सेकंड तक देरी हो रही है। आरएसए का उपयोग करके सब कुछ सफलतापूर्वक एन्क्रिप्ट किया जाने के बाद, हम RC4 का उपयोग करके संरचना में अंतिम मान के बिना पूरे लाइसेंस को एन्क्रिप्ट करते हैं जो हमें नाम से प्राप्त हुई थी। और अंतिम चरण आरसी 4 का उपयोग करके एन्क्रिप्ट किए गए लाइसेंस के उस हिस्से की नियंत्रण राशि की गणना करना है और इसे संरचना के अंतिम मूल्य पर लिखना है और पूरे हेक्स-स्ट्रिंग को इस लाइसेंस में अनुवाद करना है।

वह सब है!

सामग्री

• www.rsdn.ru/article/files/classes/SelfCheck/crcrevrs.pdf - CRC32 नकली
• www.en.wikipedia.org/wiki/MD4#Collision_Attacks - MD4 टक्कर
• www.google.com
• www.wikipedia.org

स्रोत कोड

• github.com/reu-res/Keygen-for-CrackMe-1-by-PE_Kill - Bruter और keygen

PS Keygen सिरिलिक वर्णमाला को स्वीकार करता है, लेकिन यह इस बात पर निर्भर करता है कि कंसोल को कैसे कॉन्फ़िगर किया गया है। मैंने व्यक्तिगत रूप से इसे कंसोल से स्वीकार नहीं किया है, लेकिन अगर मैं हार्डकोड करता हूं, तो सब कुछ ठीक है। मैं खिड़कियों के नीचे फिर से लिखने के लिए आलसी था।