मुझे पूरी तरह से तोड़ दो (ZeroNightsCrackme, भाग 2)

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

17 फरवरी, एक पत्र एक नई दरार के साथ आया। यह उनके निर्णय के बारे में है (और न केवल) जो मैं इस लेख में बताऊंगा।

दरार के पैरामीटर समान हैं:

• फ़ाइल: ZeroNightsCrackMe.exe
• प्लेटफ़ॉर्म: विंडोज 7 (64 बिट)
• पैकर: कोई नहीं
• विरोधी डिबगिंग: टक्कर नहीं
• समाधान: मेल / सीरियल वैलिड जोड़ी

उपकरण:

• ओलीडबग 2.01
• कुछ ग्रे पदार्थ

आइए समाधान के लिए नीचे उतरें ...

हम शिकार पर जाते हैं

हमेशा की तरह, हम प्रायोगिक लॉन्च करते हैं और सतह विश्लेषण करते हैं। प्रतिक्रिया पिछली दरार के समान है।


अंजीर। 1

दरार के साथ अतीत के काम के सिद्धांत को जानने के बाद, हम प्रमुख बिंदुओं की खोज करते हैं और पाते हैं:

1. एक फ़ंक्शन जो इनपुट डेटा को संसाधित करता है।
2. सत्यापन तालिका सत्यापन एल्गोरिथ्म।
3. मान्यता तालिका।
4. सत्यापन तालिका भरने के लिए एल्गोरिथम।
5. सत्यापन तालिका को भरने के लिए एल्गोरिथ्म के लिए डेटा।
6. सीरियल कोड को आंतरिक प्रतिनिधित्व में बदलने के लिए एल्गोरिदम।
7. रूपांतरण तालिका।
8. वैध चरित्र सीमा।

फिर हम पिछले संस्करण के साथ सभी प्रमुख बिंदुओं की तुलना करते हैं और अंतर पाते हैं।

जानवरों की पगडंडियों के साथ

इनपुट प्रोसेसिंग फंक्शन

सबसे पहले, हम दर्ज किए गए डेटा को संसाधित करने का कार्य पाते हैं। यह काफी सरलता से किया जाता है। Disassembler विंडो में राइट-क्लिक करें और "Search for => सभी संदर्भित स्ट्रिंग्स" चुनें :


अंजीर। 2

अगला, लाइन पर क्लिक करें "अच्छा काम, सीरियल वैध है !!!" और यहां प्राप्त करें:


अंजीर। 3

वांछित फ़ंक्शन अधिक होगा (मेरे मामले में, यह कॉल 0x9b12b0 है )। तीन मापदंडों उसे पारित कर रहे हैं। Arg2 में , Arg1 सीरियल कोड का आकार और सीरियल कोड के लिए एक पॉइंटर क्रमशः प्रेषित किया जाता है, और ECX में ईमेल को एक पॉइंटर रजिस्टर किया जाता है।

सत्यापन तालिका सत्यापन एल्गोरिथ्म

हम फ़ंक्शन के अंदर जाते हैं और बहुत नीचे की ओर जाते हैं, सत्यापन तालिका (पुराने संस्करण के समान) की जांच के लिए एक एल्गोरिथ्म है:


अंजीर। 4

मान्यता तालिका पता

हम एल्गोरिथम की शुरुआत में एक ब्रेकपॉइंट सेट करते हैं और निष्पादन पर दरारें चलाते हैं (बेशक, किसी भी डेटा को दर्ज करने और चेक बटन पर क्लिक करने के बाद)।


अंजीर। 5. परीक्षण डेटा दर्ज करें


अंजीर। 6. सत्यापन तालिका पर रोक

अब हम तालिका का पता स्वयं निर्धारित करेंगे। आप इसे “CMP DWORD PTR SS: [ECX * 4 + EBP-28], 1” लाइन पर जाकर और गंतव्य पते को देखकर कर सकते हैं।


अंजीर। 7. सत्यापन तालिका का पता निर्धारित करना

मेरे मामले में, तालिका का पता 0x36f308 (लाल रंग में हाइलाइट किया गया) है।


अंजीर। 8. सत्यापन तालिका डंप

सत्यापन तालिका भरने एल्गोरिथ्म

हम एल्गोरिथ्म को उसी तरह से खोजते हैं, जिसे दरार के साथ अतीत को हल करते समय प्रदर्शित किया गया था:

• दरार के साथ जारी रखें (ओल्का में F9 दबाएं);
• हमने इनपुट डेटा प्रोसेसिंग फ़ंक्शन पर ब्रेकडाउन डाला, मेरे मामले में यह कॉल 9b12b0 (छवि 3) है;
• हम दरारें और पॉप-अप विंडो (सफलता या विफलता के बारे में बात) में स्विच करते हैं, "ओके" पर क्लिक करें (जिससे दरार के साथ काम करना जारी है);
• इसके बाद, सीरियल नंबर रिकॉल शुरू करने के लिए "चेक" बटन पर क्लिक करें, जिसके बाद आपको कॉल कॉल 0x9b1230 पर रोकना चाहिए;
• कॉल कॉल 0x9b12b0 पर खड़े होकर, रिकॉर्ड 0x36f308 पर रिकॉर्ड पर ब्रेक लगाएं;
• और F9 को फिर से दबाएं।

यदि सब कुछ सही ढंग से किया गया था, तो आप खुद को यहां पाएंगे:


अंजीर। 9. सत्यापन तालिका को भरने के लिए एल्गोरिथ्म

यदि आप पुराने के साथ नए एल्गोरिथ्म की तुलना करते हैं, तो आप देखेंगे कि वे अलग हैं:


अंजीर। 10. पुराना एल्गोरिथ्म ( पिछले लेख से स्क्रीनशॉट)

पायथन में "नए एल्गोरिथ्म" की प्रस्तुति इस प्रकार है:

def create_table(first_part, second_part): result = [] curr_second = 0 out_index = 0 while(out_index < 3): inner_index = 0 while(inner_index < 3): curr_first = 0 accumulator = 0 index = 0 while(index < 3): first = first_part[inner_index + curr_first] second = second_part[index + curr_second] hash = 0 if (first != 0): while (first != 0): if (first & 1): hash ^= second second += second first = first >> 1 accumulator ^= hash index += 1 curr_first += 3 result.append(accumulator & 0xff) inner_index += 1 out_index += 1 curr_second += 3 return result 

आइए इस एल्गोरिदम द्वारा उपयोग किए जाने वाले डेटा को खोजने के लिए आगे बढ़ते हैं।

सत्यापन तालिका को भरने के लिए एल्गोरिथ्म के लिए डेटा

एल्गोरिथ्म कोड का विश्लेषण करने के बाद, दो स्थान पाए गए जहां इसके संचालन के लिए डेटा आया था:


अंजीर। 11. नए एल्गोरिथ्म को संचालित करता है जिसके साथ आता है

ऊपर उन्हें एक ग्रे आयत के साथ हाइलाइट किया गया है। मेरे मामले में, 0x9b11b0 और 0x9b11b2 के पते पर, निम्न सरणियों को एक्सेस किया जा रहा है:

• 0x00758628 (चित्र 12)
• 0x00758908 (चित्र 13)

अंजीर। 12


अंजीर। 13

प्रत्येक सरणी में 9 तत्व होते हैं , एक-एक बाइट।

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

पुराने संस्करण और नए के बीच का अंतर

पुराने संस्करण में, दरारें सीरियल कोड के साथ काम करती हैं:

1. सीरियल कोड को दो भागों में विभाजित किया गया था।
2. प्रत्येक भाग का आंतरिक प्रतिनिधित्व किया गया।
3. फिर प्रत्येक भाग मिश्रित (मिश्रित) था।
4. उसके बाद, सत्यापन तालिका को भरने के लिए दोनों भागों को एल्गोरिथ्म में स्थानांतरित किया गया था।

अंत में, हमें कुछ इस तरह मिला:

 Serial |- part_1 |- part_2 part_1 = intermediate_view(part_1) part_2 = intermediate_view(part_2) part_1 = mix(part_1) part_2 = mix(part_2) valid_table = algo(part_1, part_2) 

नए संस्करण में, चीजें थोड़ी जटिल हो गईं:

1. सीरियल कोड दो भागों में विभाजित है।
2. इसका प्रत्येक भाग आंतरिक अभ्यावेदन में अनुवादित है।
3. पहला भाग + निश्चित सरणी (3, 5, 7, 5, 7, 3, 7, 3, 5) एल्गोरिथ्म में स्थानांतरित किया गया है।
4. दूसरा भाग + निश्चित सरणी (3, 5, 7, 5, 7, 3, 7, 3, 5) एल्गोरिथ्म में स्थानांतरित किया गया है।
5. सत्यापन तालिका को भरने के लिए एल्गोरिदम को आइटम 3-4 का परिणाम दिया जाता है।

परिणामस्वरूप, हमें कुछ ऐसा मिलता है:

 Serial |- part_1 |- part_2 part_1 = intermediate_view(part_1) part_2 = intermediate_view(part_2) part_1 = mix(part_1) part_2 = mix(part_2) salt = [3, 5, 7, 5, 7, 3, 7, 3, 5] part_a = algo(part_1, salt) part_b = algo(part_2, salt) valid_table = algo(part_a, part_b) 

यह इस प्रकार है कि हमारे पास एक निश्चित सरणी पर निर्भरता है ।

सीरियल कोड को आंतरिक प्रतिनिधित्व में बदलने के लिए एल्गोरिदम

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

रूपांतरण तालिका और मान्य सीमा

तालिका और मान्य श्रेणी पुराने संस्करण के समान हैं।

घात लगाकर भागने की तैयारी

अब जब सभी आवश्यक तत्व इकट्ठे हो गए हैं, तो आप हल करना शुरू कर सकते हैं।

हमारे कार्यों की एल्गोरिथ्म निम्नानुसार है:

1. एल्गो (part_a, part_b) के लिए , उन part_a और part_b को खोजें जो परिणाम देते हैं [1, 0, 0, 0, 1, 0, 0, 0, 1]।
2. Part_a = algo (part_1, नमक) के लिए , एक part_1 खोजें जो part_a के बराबर परिणाम उत्पन्न करता है ।
3. Part_b = algo (part_2, नमक) के लिए , एक part_2 ढूँढें जो part_b के बराबर परिणाम उत्पन्न करता है ।

आइए शुरुआत अल्गो (part_a, part_b) से करें

यदि आप पहला लेख पढ़ते हैं, तो शायद याद रखें कि आवश्यक तालिका [1, 0, 0, 0, 1, 0, 0, 1] को संकलित करने के लिए, आपके पास बाइट्स होने चाहिए जो या तो " शून्य " , या " इकाइयाँ " ।

दरार के पुराने संस्करण में, इन बाइट्स को खोजना बहुत सरल था। जो कुछ किया जाना था वह पूरे उपलब्ध वर्णमाला के माध्यम से छांटना और इसके लिए कुछ सरल ऑपरेशन लागू करना था।

नए संस्करण में, यह करना अधिक कठिन है (लेकिन यह केवल पहली नज़र में है और नीचे मैं समझाऊंगा कि क्यों)। पुराने संस्करण में, हम एक तत्व पर पुनरावृति कर सकते हैं। नए संस्करण में, हमें तीन तत्वों पर पुनरावृति करनी होगी, क्योंकि वे सभी परस्पर जुड़े हुए हैं।

और इसलिए, नया संस्करण जटिल क्यों लगता है, लेकिन केवल पहली नज़र में?

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

ठीक है, ठीक है, कम शब्द अधिक व्यवसाय हैं।

यहाँ एक जादुई "मंत्र" है जो आपको सभी अशक्त और एकल पात्रों को खोजने में मदद करेगा:

 data_zero, data_ones = [], [] for a in range(0, 256): part_a = [a, a, a, a, a, a, a, a, a] part_b = [a, a, a, a, a, a, a, a, a] result = create_table(part_a, part_b) if result == [0, 0, 0, 0, 0, 0, 0, 0, 0]: data_zero.append(a) elif result == [1, 1, 1, 1, 1, 1, 1, 1, 1]: data_ones.append(a) print("ZERO:", data_zero) print("ONES:", data_ones) 

अंजीर। 14

ठीक है, हमारे पास "शून्य" और "वाले" तत्वों का एक समूह है। वांछित तालिका [1, 0, 0, 1, 0, 0, 0, 1] कैसे प्राप्त करें?

सबसे चौकस / सरल व्यक्ति नोटिस कर सकते हैं (उदाहरण के लिए, पिछले लेख पर टिप्पणियों से) कि हम मैट्रिस से निपट रहे हैं, जब एक-दूसरे से गुणा किया जाता है, तो एक यूनिट मैट्रिक्स [1, 0, 0, 0, 1, 0, 1, 0, 0] देना चाहिए। 1]। इसलिए, एक इकाई मैट्रिक्स प्राप्त करने के लिए, हमें या तो दो यूनिट मैट्रेस या दो व्युत्क्रम की आवश्यकता होती है।

आवश्यक इकाई मैट्रिक्स प्राप्त करने के लिए, आप निम्न पैटर्न का उपयोग कर सकते हैं:

 #  part_a = [y, x, x, x, y, x, x, x, y] part_b = [y, x, x, x, y, x, x, x, y] result = algo(part_a, part_b) 

जहां y के स्थान पर - किसी भी एकल वर्ण को प्रतिस्थापित करें, और x के बजाय - कोई शून्य।

आप अन्य पैटर्न का उपयोग कर सकते हैं, आप उन्हें निम्नलिखित "मंत्र" का उपयोग करके पा सकते हैं:

 happy = [1,32] for byte_1 in happy: for byte_2 in happy: for byte_3 in happy: for byte_4 in happy: for byte_5 in happy: for byte_6 in happy: for byte_7 in happy: for byte_8 in happy: for byte_9 in happy: part_1 = [byte_1, byte_2, byte_3, byte_4, byte_5, byte_6, byte_7, byte_8, byte_9] part_2 = [byte_1, byte_2, byte_3, byte_4, byte_5, byte_6, byte_7, byte_8, byte_9] result = create_table(part_1, part_2) if result == [1, 0, 0, 0, 1, 0, 0, 0, 1]: print("%s | %s " % (part_2, part_1)) 

अंजीर। 15

प्रतिस्थापित करने के बाद, आप, उदाहरण के लिए, निम्न पैटर्न प्राप्त कर सकते हैं:

 patterns = [ # Pattern 0 [ [y1, x1, x1, x1, y2, x1, x1, x1, y3], [y1, x1, x1, x1, y2, x1, x1, x1, y3] ], # Pattern 1a [ [y1, x1, x1, x1, x1, y1, x1, y1, x1], [y1, x1, x1, x1, x1, y1, x1, y1, x1] ], # Pattern 1b [ [y1, x1, x2, x3, x4, y1, x5, y1, x6], [y1, x2, x1, x5, x6, y1, x3, y1, x4] ], # Pattern 2a [ [y1, x1, x1, x1, y1, x1, x1, x1, y1], [y1, x1, x1, x1, y1, x1, x1, x1, y1] ], # Pattern 2b [ [y1, x1, x2, x3, y2, x4, x5, x6, y3], [y1, x1, x2, x3, y2, x4, x5, x6, y3] ], # Pattern 3a [ [x1, x1, y1, x1, y1, x1, y1, x1, x1], [x1, x1, y1, x1, y1, x1, y1, x1, x1] ], # Pattern 3b [ [x1, x2, y1, x3, y2, x4, y3, x5, x6], [x6, x5, y3, x4, y2, x3, y1, x2, x1] ], # Pattern 4a [ [x1, y1, x1, y1, x1, x1, x1, x1, y1], [x1, y1, x1, y1, x1, x1, x1, x1, y1] ], # Pattern 4b [ [x1, y1, x2, y2, x3, x4, x5, x6, y3], [x3, y2, x4, y1, x1, x2, x6, x5, y3] ], # Pattern 5 [ [x1, x2, y1, y2, x3, x4, x5, y3, x6], [x4, y2, x3, x6, x5, y3, y1, x1, x2] ] ] 

अब जब हमें पता चला है कि आवश्यक पहचान मैट्रिक्स कैसे प्राप्त करें (यानी, सत्यापन टेबल), हम अन्य समस्याओं पर आगे बढ़ेंगे।

उपयुक्त part_a और part_b कैसे चुनें?

हम निम्नलिखित जानते हैं:

 part_a = algo(part_1, salt) part_b = algo(part_2, salt) valid_table = algo(part_a, part_b) 

यह निम्नानुसार है, उदाहरण के लिए, part_a part_1 और नमक पर निर्भर करता है। जो बदले में part_a के लिए संभव संयोजनों को नीचे बताती है । एक तार्किक सवाल उठता है।

हम किन संयोजनों का उपयोग कर सकते हैं?

मुझे लगता है कि कई लोगों ने पहले ही अनुमान लगा लिया है कि क्या करने की आवश्यकता है? यह सही है, अगले "जादू" का उपयोग करें!

यहाँ उनमें से एक है:

 # serial_data  email “support@reverse4you.org” serial_data = [52, 233, 91, 105, 65, 15, 50, 176, 90, 40, 225, 81, 207, 79, 34, 19] def get_items(first_part, second_part): result = [] inner_index = 0 while(inner_index < 3): curr_first = 0 accumulator = 0 index = 0 while(index < 3): first = first_part[inner_index + curr_first] second = second_part[index] hash = 0 if (first != 0): while (first != 0): if (first & 1): hash ^= second second += second first = first >> 1 accumulator ^= hash index += 1 curr_first += 3 result.append(accumulator & 0xff) inner_index += 1 return result a = 0x3 b = 0x5 c = 0x7 first_part = [a, b, c, b, c, a, c, a, b] second_part_new = [0, 0, 0] count = 0 result_table = [] for byte_1 in serial_data: second_part_new[0] = byte_1 for byte_2 in serial_data: second_part_new[1] = byte_2 for byte_3 in serial_data: second_part_new[2] = byte_3 res = get_items(first_part, second_part_new) print("index: %s, table: %s" % (count, res)) count += 1 print("Count: %s" % count) 

यदि आपका "वर्तनी" सफलतापूर्वक काम करता है, तो आप देखेंगे कि part_a और part_b के लिए केवल 4096 विकल्प उपलब्ध हैं (अधिक सटीक, "विकल्पों के तहत")।


अंजीर। 16

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

पहला शिकार (पहली वैध कुंजी)

यदि आप सावधान थे, तो आपने शायद देखा कि सभी 4096 विकल्पों को दो समूहों में विभाजित किया जा सकता है, "सभी तत्व समान हैं" और "सभी तत्व भी नहीं हैं" ।

सूचकांक: ००३५, तालिका: [११६, २२२, १ <२ ] <= सभी तत्व सम हैं
सूचकांक: ०५६०, तालिका: [१ , २ , ११६, २२२] <= सभी तत्व सम हैं
सूचकांक: 0770, तालिका: [222, 172, 116] <= सभी तत्व समान हैं

सूचकांक: 0117, तालिका: [1, 229, 111] <= सभी तत्व भी नहीं हैं
सूचकांक: 1287, तालिका: [229, 111, 1] <= सभी तत्व भी नहीं हैं
सूचकांक: 1872, तालिका: [111, 1, 229] <= सभी तत्व भी नहीं हैं

हालाँकि, यदि आप हमारे लिए उपलब्ध "पैटर्न" को देखते हैं, तो आप देखेंगे कि उन सभी को "प्रत्येक" विकल्प में "दोनों" और "नहीं भी" तत्वों की आवश्यकता है, जो है:

यहाँ दो मेट्रिक्स हैं जो हमें पहचान देते हैं:

part_a
[१ 65६, १ 65६, ६५] <= यहाँ तक कि और भी नहीं हैं
[१ 176६, ६५, १ 176६] <= यहाँ तक कि और भी नहीं हैं
[६५, १ 176६, १ 176६] <= यहाँ तक कि और भी नहीं हैं

part_b
[१ 65६, १ 65६, ६५] <= यहाँ तक कि और भी नहीं हैं
[१ 176६, ६५, १ 176६] <= यहाँ तक कि और भी नहीं हैं
[६५, १ 176६, १ 176६] <= यहाँ तक कि और भी नहीं हैं

valid_table = part_a * part_a
[१, ०, ०]
[०, १, ०]
[०, ०, १]

चूंकि "सम" और "सम" तत्वों के साथ कोई "विकल्प" नहीं हैं, इसलिए हम निष्कर्ष निकालते हैं कि दरार में कोई त्रुटि है। एक तार्किक सवाल उठता है।

गलती क्या है?

एक त्वरित विचार के बाद, हम यह निष्कर्ष निकालते हैं कि त्रुटि मैट्रिक्स में निहित है [0x3, 0x5, 0x7, 0x5, 0x7, 0x3, 0x7, 0x3, 0x5] । समान और विषम "विकल्प" प्राप्त करने के लिए आपको क्रमशः "0x2 " , "0x5" और "0x7" को "0x2" , "0x3" और "0x8" के साथ बदलने की आवश्यकता है, या एक अन्य विकल्प के साथ, जहां दो समान और एक विषम तत्व होगा, उदाहरण के लिए, ऐसे "0x4" , "0x7" और "0x8" (एक विकल्प के रूप में) पर।

यह त्रुटि Kaspersky Lab को बताई गई थी। उन्होंने कहा कि संस्करण (जिसकी हम वर्तमान में जांच कर रहे हैं) एक मसौदा है। जिसके बाद, उसी दिन, त्रुटि के बिना एक संस्करण सभी को भेजा गया था। सच है, नए संस्करण में, कोई निश्चित तालिकाएँ नहीं थीं और इसे इससे भी आसान हल किया गया था, लेकिन मैं इस बारे में थोड़ी देर बाद बोनस सेक्शन में बात करूँगा :)

यह सुनिश्चित करने के लिए कि आपने सही प्रतिस्थापन किया है (उदाहरण के लिए, यदि आप "0x2" , "0x3" और "0x8" ) के अलावा अन्य वर्ण सम्मिलित करने का निर्णय लेते हैं, तो आपको निम्नलिखित "वर्तनी" का उपयोग करना चाहिए:

 serial_data = [52, 233, 91, 105, 65, 15, 50, 176, 90, 40, 225, 81, 207, 79, 34, 19] a = 0x2 b = 0x3 c = 0x8 first_part = [a, b, c, b, c, a, c, a, b] second_part_new = [0, 0, 0] count = 0 result_table = [] for byte_1 in serial_data: second_part_new[0] = byte_1 for byte_2 in serial_data: second_part_new[1] = byte_2 for byte_3 in serial_data: second_part_new[2] = byte_3 res = get_items(first_part, second_part_new) print("index: %s, table: %s" % (count, res)) if (res[0] % 16 == 0 and res[1] % 16 == 0 and res[2] % 16 == 1) or\ (res[0] % 16 == 1 and res[1] % 16 == 0 and res[2] % 16 == 0) or\ (res[0] % 16 == 0 and res[1] % 16 == 1 and res[2] % 16 == 0): result_table.append(res) count += 1 print("Count:", count) print("Good:", result_table) 

यदि चारा सही ढंग से चुना गया था (जैसा कि हमारे मामले में, "0x2, 0x3, 0x8"), तो आपके जाल में ("अच्छा" फ़ील्ड) में कम से कम एक जानवर (तीन सरणियों से युक्त समूह) होगा। एक निश्चित मैट्रिक्स के लिए एक उदाहरण आउटपुट (तत्वों के साथ "0x2", "0x3" और "0x8") नीचे दिखाया गया है:


अंजीर। 17

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

सबसे चौकस लोगों ने पहले ही ध्यान दिया है कि "गुड" लाइन में आउटपुट को समूहों में विभाजित किया जा सकता है, जिनमें से प्रत्येक में तीन लाइनें होंगी।

[०, १४४, 81१]
[144१, ०, १४४]
[१४४, 0१, ०]

[१४४, १४५, ०]
[०, १४४, १४५]
[१४५, ०, १४४]

[०, १४४, २० ९]
[२० ९, ०, १४४]
[१४४, २० ९, ०]

और भी अधिक चौकस शायद देखा कि इन सभी पात्रों को "शून्य" और "एकल" वर्णों के सेट में शामिल किया गया है;)


अंजीर। 18

खैर, सबसे सरल (मुझे आशा है) पहले से ही बड़ी मेज पर दावत दे रहे हैं, क्योंकि वे बड़े जानवर को ट्रैक करने में सक्षम थे, उसे एक समान "मंत्र" के साथ फुसला कर:

 #   # [0, 144, 209] # [209, 0, 144] # [144, 209, 0] a = 144 b = 209 c = 0 #      part_a = [c, a, b, b, c, a, a, b, c] part_b = [a, b, c, c, a, b, b, c, a] # part_a1 = [0, 144, 209] # part_a2 = [209, 0, 144] # part_a3 = [144, 209, 0] # part_a = part_a1 + part_a2 + part_a3 # part_b1 = [144, 209, 0] # part_b2 = [0, 144, 209] # part_b3 = [209, 0, 144] # part_b = part_b1 + part_b2 + part_b3 result = create_table(part_a, part_b) print(result) 

यह वह जगह है जहां हम इसे दरार के साथ हल करना समाप्त करेंगे ... आंतरिक बाइट्स को सामान्य में कैसे परिवर्तित करें ताकि उन्हें दरार के साथ खिड़की में प्रवेश किया जा सके, मुझे लगता है कि आप इसे खुद के लिए समझेंगे।

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

बोनस (नई दरार का कीजन + विवरण)

उपलब्ध संस्करणों के साथ भ्रमित न होने के लिए, हम उनकी संख्या के बारे में कुछ स्पष्टता का परिचय देंगे:

• ZeroNightsCrackMe_v1 - यहां समीक्षा की गई।
• ZeroNightsCrackMe_v2 - एक मसौदा संस्करण है और इस लेख में ऊपर वर्णित है।
• ZeroNightsCrackMe_v3 - + keygen के नीचे सतही रूप से समीक्षा की गई है।

सत्यापन तालिका सत्यापन एल्गोरिथ्म और सत्यापन तालिका स्वयं

V1 और v2 के सभी पिछले संस्करणों की तरह।

सत्यापन तालिका भरने एल्गोरिथ्म

जैसा कि v2 के ड्राफ्ट संस्करण में (इस लेख में ऊपर चर्चा की गई है)।

सत्यापन तालिका भरने के लिए डेटा

ऑपरेशन का सिद्धांत v1 के पहले संस्करण के रूप में ही है, लेकिन अन्य मिक्सर का उपयोग किया जाता है।

सीरियल कोड को आंतरिक प्रतिनिधित्व, रूपांतरण तालिका और मान्य श्रेणी में परिवर्तित करने के लिए एल्गोरिदम

V1 और v2 के सभी पिछले संस्करणों की तरह।

नए संस्करण के लिए कीजन

संस्करण v2 और v3 के क्रैक इस धागे में पाए जा सकते हैं। वहां आपको डार्विन की ओर से v3 के नए संस्करण के लिए कीजेन भी मिलेंगे।

कीजेन आर्काइव पासवर्ड: Darwin_1iOi7q7IQ1wqWiiIIw

दरार के तीसरे संस्करण के लिए कीजन की जाँच:

> keygen_v3.py habrahabr.ru> result.txt


अंजीर। 19


अंजीर। 20

बहुत धन्यवाद अंत तक बहुत बहुत धन्यवाद! जल्द मिलते हैं!