🃏 👴🏿 🍻 हम PHDays 9 के साथ सर्वश्रेष्ठ रिवर्सल समस्या का समाधान करते हैं 🧑🏻‍🤝‍🧑🏻 🧒🏿 👩🏿‍🤝‍👨🏾

आपका स्वागत है!

मेरा नाम Marat Gayanov है, मैं आपके साथ Best Reverser कॉन्टेस्ट की समस्या के अपने समाधान को साझा करना चाहता हूं, ताकि यह दिखाया जा सके कि इस केस के लिए कीजेन कैसे बनाया जाए।

विवरण

इस प्रतियोगिता में, प्रतिभागियों को सेगा मेगा ड्राइव ( best_reverser_phd9_rom_v4.bin ) के लिए ROM गेम्स प्रदान किए जाते हैं।

कार्य: ऐसी कुंजी लेने के लिए जो प्रतिभागी के ईमेल पते के साथ मिलकर मान्य मानी जाएगी।

तो समाधान ...

उपकरण

आईडीए प्रो 6.8
Smd_ida_tools प्लगइन

कुंजी लंबाई की जाँच करना

कार्यक्रम हर कुंजी को स्वीकार नहीं करता है: आपको पूरे क्षेत्र को भरने की आवश्यकता है, ये 16 वर्ण हैं। यदि कुंजी छोटी है, तो आपको एक संदेश दिखाई देगा: “गलत लंबाई! फिर से कोशिश करो… ”।

आइए इस लाइन को प्रोग्राम में खोजने का प्रयास करें, जिसके लिए हम बाइनरी सर्च (Alt-B) का उपयोग करेंगे। हम क्या पाएंगे?

हम केवल यही नहीं, बल्कि आस-पास की अन्य सेवा लाइनों को भी देखेंगे: “गलत कुंजी! फिर से कोशिश करें ... "और" आप सबसे अच्छे हैं! "

मैं सुविधा के लिए WRONG_LENGTH_MSG , YOU_ARE_THE_BEST_MSG और WRONG_KEY_MSG सेट करता WRONG_LENGTH_MSG ।

पता 0x0000FDFA पढ़ने पर एक ब्रेक 0x0000FDFA - पता करें कि कौन संदेश "गलत लंबाई" के साथ काम करता है! फिर से कोशिश करो… ”। और डिबगर चलाएं (यह कुंजी में प्रवेश करने से पहले कई बार बंद हो जाएगा, बस प्रत्येक स्टॉप पर F9 दबाएं)। अपना ईमेल, कुंजी ABCD दर्ज करें।

डिबगर 0x00006FF0 tst.b (a1)+ : की ओर जाता है

ब्लॉक में ही कुछ भी दिलचस्प नहीं है। यह बहुत अधिक दिलचस्प है जो यहां नियंत्रण स्थानांतरित करता है। हम कॉल स्टैक को देखते हैं:

यहाँ क्लिक करें और प्राप्त करें - निर्देश के लिए 0x00001D2A jsr (sub_6FC0).l ।

हम देखते हैं कि सभी संभावित संदेश एक ही स्थान पर पाए गए थे। लेकिन पता करें कि WRONG_KEY_LEN_CASE_1D1C ब्लॉक में नियंत्रण कहाँ स्थानांतरित किया गया है। हम ब्रेक सेट नहीं करेंगे, बस ब्लॉक पर जाने वाले तीर पर कर्सर ले जाएँ। कॉलर 0x000017DE loc_17DE पर स्थित है (जिसका मैं नाम बदलकर CHECK_KEY_LEN ):

पते पर एक ब्रेक लगाएं 0x000017EC cmpi.b 0x20 (a0, d0.l) (इस संदर्भ में निर्देश यह देखता है कि कुंजी वर्ण सरणी के अंत में कोई खाली वर्ण है या नहीं), पुनः आरंभ करें, मेल और ABCD कुंजी दर्ज करें। डिबगर बंद हो जाता है और दिखाता है कि दर्ज की गई कुंजी पता 0x00FF01C7 पर स्थित है (रजिस्टर में उस पल में संग्रहीत है)

यह एक अच्छी खोज है, इसके माध्यम से हम सब कुछ हड़प लेंगे। लेकिन पहले, सुविधा के लिए मुख्य बाइट्स को चिह्नित करें:

इस स्थान से स्क्रॉल करते हुए, हम देखते हैं कि कुंजी के आगे मेल संग्रहीत है:

हम गहरा और गहरा गोता लगाते हैं, और यह कुंजी की शुद्धता के लिए एक मानदंड खोजने का समय है। बल्कि, कुंजी की पहली छमाही।

कुंजी की पहली छमाही की शुद्धता के लिए मानदंड

प्रारंभिक गणना

यह मानना तर्कसंगत है कि लंबाई की जांच करने के तुरंत बाद, कुंजी के साथ अन्य संचालन का पालन होगा। जाँच के तुरंत बाद ब्लॉक पर विचार करें:

यह ब्लॉक प्रारंभिक कार्य से गुजर रहा है। get_hash_2b फ़ंक्शन (मूल में sub_1526 था) को दो बार कहा जाता है। सबसे पहले, कुंजी के पहले बाइट का पता इसे प्रेषित किया जाता है (रजिस्टर a0 में पता होता है KEY_BYTE_0 ), दूसरी बार - पाँचवा ( KEY_BYTE_4 )।

मैंने फंक्शन को इस तरह नाम दिया क्योंकि यह 2-बाइट हैश की तरह कुछ समझता है। यह सबसे समझ में आने वाला नाम है जिसे मैंने उठाया।

मैं फ़ंक्शन पर विचार नहीं करूंगा, लेकिन मैं तुरंत इसे अजगर में लिखूंगा। वह साधारण चीजें करती है, लेकिन स्क्रीनशॉट के साथ उसका विवरण बहुत सारी जगह लेगा।

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

तो get_hash_2b फ़ंक्शन:

 # key_4s -    def get_hash_2b(key_4s): #    def transform(b): # numbers -. if b <= 0x39: r = b - 0x30 # Letter case and @ else: # @ABCDEF if b <= 0x46: r = b - 0x37 else: # WXYZ if b >= 0x57: r = b - 0x57 # GHIJKLMNOPQRSTUV else: r = 0xff - (0x57 - b) + 1 # a9+b return r #    key_4b = bytearray(key_4s, encoding="ascii") #     codes = [transform(b) for b in key_4b] #      part0 = (codes[0] & 0xff) << 0xc part1 = (codes[1] << 0x8) & 0xf00 part2 = (codes[2] << 0x4) & 0xf0 hash_2b = (part0 | part1) & 0xffff hash_2b = (hash_2b | part2) & 0xffff hash_2b = (hash_2b | (codes[3] & 0xf)) return hash_2b

तुरंत एक हैश डिकोडिंग फ़ंक्शन लिखें:

 #    4-  def decode_hash_4s(hash_2b): #    def transform(b): if b <= 0x9: return b + 0x30 if b <= 0xF: return b + 0x37 if b >= 0x0: return b + 0x57 return b - 0xa9 #         b0 = transform(hash_2b >> 12) b1 = transform((hash_2b & 0xfff) >> 8) b2 = transform((hash_2b & 0xff) >> 4) b3 = transform(hash_2b & 0xf) #  key_4s = [chr(b0), chr(b1), chr(b2), chr(b3)] key_4s = "".join(key_4s) return key_4s

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

 key_4s == decode_hash_4s(get_hash_2b(key_4s))

get_hash_2b के संचालन की जाँच करें। फ़ंक्शन निष्पादित होने के बाद हम रजिस्टर d0 की स्थिति में रुचि रखते हैं। हम 0x000017FE , 0x00001808 पर ब्रेक 0x00001808 , जिस कुंजी को हम ABCDEFGHIJKLMNOP दर्ज करते हैं।

मान 0xABCD , 0xEF01 रजिस्टर d0 में दर्ज किए गए हैं। और क्या get_hash_2b ?

 >>> first_hash = get_hash_2b("ABCD") >>> hex(first_hash) 0xabcd >>> second_hash = get_hash_2b("EFGH") >>> hex(second_hash) 0xef01

सत्यापन पास हुआ।

फिर xor eor.w d0, d5 उत्पादन किया xor eor.w d0, d5 है, परिणाम d5 में दर्ज किया जाता है:

 >>> hex(0xabcd ^ 0xef01) 0x44cc

इस तरह के हैश को प्राप्त करना 0x44CC और इसमें प्रारंभिक गणना शामिल है। इसके अलावा, सब कुछ केवल अधिक जटिल हो जाता है।

हैश कहाँ जाता है

यदि हम यह नहीं जानते कि कार्यक्रम हैश के साथ कैसे काम करता है, तो हम आगे नहीं बढ़ सकते। निश्चित रूप से यह d5 से मेमोरी तक चलता है, क्योंकि रजिस्टर कहीं और काम आता है। हम इस तरह की घटना को ट्रेस ( d5 देखने) के माध्यम से पा सकते हैं, लेकिन मैनुअल नहीं, बल्कि स्वचालित। निम्नलिखित स्क्रिप्ट मदद करेगा:

 #include <idc.idc> static main() { auto d5_val; auto i; for(;;) { StepOver(); GetDebuggerEvent(WFNE_SUSP, -1); d5_val = GetRegValue("d5"); //    d5 if (d5_val != 0xFFFF44CC){ break; } } }

आपको याद दिला दूं कि हम अब आखिरी ब्रेक 0x00001808 eor.w d0, d5 । स्क्रिप्ट पेस्ट करें ( Shift-F2 ), Run क्लिक करें

निर्देश 0x00001C94 move.b (a0, a1.l), d5 पर बंद हो जाएगा। 0x00001C94 move.b (a0, a1.l), d5 , लेकिन इस क्षण तक d5 पहले ही साफ़ हो चुका है। हालाँकि, हम देखते हैं कि d5 से मान को निर्देश 0x00001C56 move.w d5,a6 d5 ले जाया जाता है। 0x00001C56 move.w d5,a6 : इसे 0x00FF0D46 (2 बाइट्स) पते पर मेमोरी में लिखा जाता है।

याद रखें: हैश 0x00FF0D46 पर संग्रहीत है।

हम उन निर्देशों को 0x00FF0D46-0x00FF0D47 हैं जो 0x00FF0D46-0x00FF0D47 से पढ़े जाते हैं (हम पढ़ने के लिए ब्रेक सेट करते हैं)। पकड़े गए 4 ब्लॉक:

सही / सही का चयन कैसे करें?

शुरुआत में वापस जाएं:

यह ब्लॉक निर्धारित करता है कि कार्यक्रम LOSER_CASE या WINNER_CASE :

हम देखते हैं कि रजिस्टर में d1 जीतने के लिए शून्य होना चाहिए।

शून्य सेट कहां है? बस स्क्रॉल करें:

यदि loc_1EEC ब्लॉक में संतुष्ट है:

 *(a6 + 0x24) == *(a6 + 0x22)

तब हमें d5 में शून्य मिलता है।

यदि हम निर्देश 0x00001F16 beq.w loc_20EA , तो हम देखेंगे कि a6 + 0x24 = 0x00FF0D6A और मान 0x4840 वहाँ संग्रहीत है। और a6 + 0x22 = 0x00FF0D68 में संग्रहीत किया जाता है।

यदि हम विभिन्न कुंजियों में प्रवेश करते हैं, तो हम देखेंगे कि 0xCB4C - । कुंजी की पहली छमाही को केवल तभी स्वीकार किया जाएगा जब 0x00FF0D6A में भी 0xCB4C । यह कुंजी की पहली छमाही की शुद्धता के लिए मानदंड है।

हमें पता चलता है कि 0x00FF0D6A में कौन से ब्लॉक लिखे गए हैं - रिकॉर्ड पर ब्रेक लगाएं, फिर से मेल और की दर्ज करें।

और हमें यह loc_EAC ब्लॉक मिलेगा (वास्तव में उनमें से 3 हैं, लेकिन पहले दो सिर्फ 0x00FF0D6A बाहर शून्य):

यह ब्लॉक sub_E3E फ़ंक्शन के अंतर्गत आता है।

कॉल स्टैक के माध्यम से हमें पता चलता है कि sub_E3E फ़ंक्शन sub_E3E ब्लॉक में कहा जाता loc_1F94 , loc_203E :

याद रखें हमें पहले 4 ब्लॉक मिले थे? loc_1F94 हमने वहां देखा - यह मुख्य कुंजी प्रसंस्करण एल्गोरिथ्म की शुरुआत है।

पहला महत्वपूर्ण लूप loc_1F94

तथ्य यह है कि loc_1F94 एक चक्र कोड से दिखाई देता है: इसे 0x00001FBA d4,loc_1F94 बार निष्पादित किया जाता है (निर्देश 0x00001FBA d4,loc_1F94 ):

क्या देखना है:

एक sub_5EC फ़ंक्शन है।
निर्देश 0x00001FB4 jsr (a0) सब_E3E फ़ंक्शन को कॉल करता है (इसे एक साधारण ट्रेस के साथ देखा जा सकता है)।

यहाँ क्या हो रहा है:

sub_5EC फ़ंक्शन d0 रजिस्टर के लिए इसके निष्पादन का परिणाम लिखता है (यह नीचे एक अलग अनुभाग में चर्चा की गई है)।
बाइट पते sp+0x33 ( 0x00FFFF79 , डीबगर हमें बताता है) को रजिस्टर d1 में संग्रहीत किया जाता है, यह कुंजी हैश पते ( 0x00FF0D47 ) से दूसरे बाइट के बराबर है। यह साबित करना आसान है यदि आप रिकॉर्ड पर 0x00FFFF79 पर ब्रेक 0x00FFFF79 : यह निर्देशों पर काम करेगा 0x00001F94 move.b 1(a2), 0x2F(sp) । इस समय रजिस्टर a2 पते को 0x00FF0D46 - हैश पते, यानी 0x1(a2) = 0x00FF0D46 + 1 - हैश के दूसरे बाइट का पता 0x1(a2) = 0x00FF0D46 + 1 करता है।
रजिस्टर d0 को d0^d1 लिखा जाता है।
परिणामी xor'a परिणाम sub_E3E फ़ंक्शन को दिया जाता है, जिसका व्यवहार इसकी पिछली गणना (नीचे दिखाया गया है) पर निर्भर करता है।
दोहराएँ।

यह चक्र कितनी बार चलता है?

इसका पता लगाएं। निम्नलिखित स्क्रिप्ट चलाएँ:

 #include <idc.idc> static main() { auto pc_val, d4_val, counter=0; while(pc_val != 0x00001F16) { StepOver(); GetDebuggerEvent(WFNE_SUSP, -1); pc_val = GetRegValue("pc"); if (pc_val == 0x00001F92){ counter++; d4_val = GetRegValue("d4"); print(d4_val); } } print(counter); }

0x00001F92 subq.l 0x1,d4 - यहाँ यह निर्धारित किया जाता है कि लूप से ठीक पहले 0x00001F92 subq.l 0x1,d4 क्या होगा:

हम सब_5ईसी फ़ंक्शन से निपटते हैं।

sub_5EC

महत्वपूर्ण टुकड़ा कोड:

जहाँ 0x2c(a2) हमेशा 0x00FF1D74 ।
इस टुकड़े को छद्म कोड में इस तरह से फिर से लिखा जा सकता है:

 d0 = a2 + 0x2C *(a2+0x2C) = *(a2+0x2C) + 1 #*(0x00FF1D74) = *(0x00FF1D74) + 1 result = *(d0) & 0xFF

यही है, 0x00FF1D74 से 4 बाइट्स पते हैं, क्योंकि उन्हें एक पॉइंटर की तरह माना जाता है।

अजगर में sub_5EC फ़ंक्शन को फिर से कैसे sub_5EC ?

या मेमोरी डंप करें और उसके साथ काम करें।
या बस सभी दिए गए मानों को लिखें।

दूसरी विधि मुझे अधिक पसंद है, लेकिन क्या होगा अगर, अलग प्राधिकरण डेटा के साथ, लौटाए गए मान अलग-अलग हैं? इसे देखें।

स्क्रिप्ट इसमें मदद करेगी:

 #include <idc.idc> static main() { auto pc_val=0, d0_val; while(pc_val != 0x00001F16){ pc_val = GetRegValue("pc"); if (pc_val == 0x00001F9C) StepInto(); else StepOver(); GetDebuggerEvent(WFNE_SUSP, -1); if (pc_val == 0x00000674){ d0_val = GetRegValue("d0") & 0xFF; print(d0_val); } } }

मैं सिर्फ आउटपुट के लिए कंसोल की तुलना अलग-अलग कुंजी, मेल के साथ करता हूं।

अलग-अलग कुंजियों के साथ स्क्रिप्ट को कई बार चलाने पर, हम देखेंगे कि sub_5EC फ़ंक्शन हमेशा सरणी से अगला मान लौटाता है:

 def sub_5EC_gen(): dump = [0x92, 0x8A, 0xDC, 0xDC, 0x94, 0x3B, 0xE4, 0xE4, 0xFC, 0xB3, 0xDC, 0xEE, 0xF4, 0xB4, 0xDC, 0xDE, 0xFE, 0x68, 0x4A, 0xBD, 0x91, 0xD5, 0x0A, 0x27, 0xED, 0xFF, 0xC2, 0xA5, 0xD6, 0xBF, 0xDE, 0xFA, 0xA6, 0x72, 0xBF, 0x1A, 0xF6, 0xFA, 0xE4, 0xE7, 0xFA, 0xF7, 0xF6, 0xD6, 0x91, 0xB4, 0xB4, 0xB5, 0xB4, 0xF4, 0xA4, 0xF4, 0xF4, 0xB7, 0xF6, 0x09, 0x20, 0xB7, 0x86, 0xF6, 0xE6, 0xF4, 0xE4, 0xC6, 0xFE, 0xF6, 0x9D, 0x11, 0xD4, 0xFF, 0xB5, 0x68, 0x4A, 0xB8, 0xD4, 0xF7, 0xAE, 0xFF, 0x1C, 0xB7, 0x4C, 0xBF, 0xAD, 0x72, 0x4B, 0xBF, 0xAA, 0x3D, 0xB5, 0x7D, 0xB5, 0x3D, 0xB9, 0x7D, 0xD9, 0x7D, 0xB1, 0x13, 0xE1, 0xE1, 0x02, 0x15, 0xB3, 0xA3, 0xB3, 0x88, 0x9E, 0x2C, 0xB0, 0x8F] l = len(dump) offset = 0 while offset < l: yield dump[offset] offset += 1 0x02, 0x15, 0xB3, 0xA3, def sub_5EC_gen(): dump = [0x92, 0x8A, 0xDC, 0xDC, 0x94, 0x3B, 0xE4, 0xE4, 0xFC, 0xB3, 0xDC, 0xEE, 0xF4, 0xB4, 0xDC, 0xDE, 0xFE, 0x68, 0x4A, 0xBD, 0x91, 0xD5, 0x0A, 0x27, 0xED, 0xFF, 0xC2, 0xA5, 0xD6, 0xBF, 0xDE, 0xFA, 0xA6, 0x72, 0xBF, 0x1A, 0xF6, 0xFA, 0xE4, 0xE7, 0xFA, 0xF7, 0xF6, 0xD6, 0x91, 0xB4, 0xB4, 0xB5, 0xB4, 0xF4, 0xA4, 0xF4, 0xF4, 0xB7, 0xF6, 0x09, 0x20, 0xB7, 0x86, 0xF6, 0xE6, 0xF4, 0xE4, 0xC6, 0xFE, 0xF6, 0x9D, 0x11, 0xD4, 0xFF, 0xB5, 0x68, 0x4A, 0xB8, 0xD4, 0xF7, 0xAE, 0xFF, 0x1C, 0xB7, 0x4C, 0xBF, 0xAD, 0x72, 0x4B, 0xBF, 0xAA, 0x3D, 0xB5, 0x7D, 0xB5, 0x3D, 0xB9, 0x7D, 0xD9, 0x7D, 0xB1, 0x13, 0xE1, 0xE1, 0x02, 0x15, 0xB3, 0xA3, 0xB3, 0x88, 0x9E, 0x2C, 0xB0, 0x8F] l = len(dump) offset = 0 while offset < l: yield dump[offset] offset += 1

तो sub_5EC तैयार है।

sub_E3E पंक्ति में sub_E3E ।

sub_E3E

महत्वपूर्ण टुकड़ा कोड:

समझने:

    ,   d2,     .  a2   0xFF0D46, a2 + 0x34 = 0xFF0D7A d0 = *(a2 + 0x34) *(a2 + 0x34) = *(a2 + 0x34) + 1   ,   a0    a0 = d0 *(a0) = d2    offset,     d2.  a2   0xFF0D46, a2 + 0x24 = 0xFF0D6A -  ,     (. )  0x00000000,     d0 = *(a2 + 0x24) d2 = d0 ^ d2 d2 = d2 & 0xFF d2 = d2 + d2  - 2    0x00011FC0 + d2,   ROM,   0x00011FC0 + d2  a0 = 0x00011FC0 d2 = *(a0 + d2)       8  d0 = d0 >> 8  d2 = d0 ^ d2     *(a2 + 0x24) = d2

sub_E3E फ़ंक्शन इन चरणों में sub_E3E :

सरणी के लिए इनपुट तर्क सहेजें।
ऑफसेट ऑफसेट की गणना करें।
0x00011FC0 + offset (ROM) के पते पर 2 बाइट्स खींचें।
परिणाम = ( >> 8) ^ (2 0x00011FC0 + offset) ।

इस रूप में sub_E3E फ़ंक्शन की कल्पना करें:

 def sub_E3E(prev_sub_E3E_result, d2, d2_storage): def calc_offset(): return 2 * ((prev_sub_E3E_result ^ d2) & 0xff) d2_storage.append(d2) offset = calc_offset() with open("dump_00011FC0", 'rb') as f: dump_00011FC0_4096b = f.read() some = dump_00011FC0_4096b[offset:offset + 2] some = int.from_bytes(some, byteorder="big") prev_sub_E3E_result = prev_sub_E3E_result >> 8 return prev_sub_E3E_result ^ some

dump_00011FC0 सिर्फ एक फाइल है जहाँ मैंने ४० ९ ६ बाइट्स को [0x00011FC0:00011FC0+4096] से बचाया।

1FC4 के आसपास गतिविधि

हमने अभी तक 0x00001FC4 पते को नहीं देखा है, लेकिन इसे ढूंढना आसान है, क्योंकि पहले चक्र के तुरंत बाद ब्लॉक लगभग चला जाता है।

यह ब्लॉक पता 0x00FF0D46 (रजिस्टर a2 ) पर सामग्री को बदलता है, और यही वह जगह है जहाँ कुंजी हैश संग्रहीत है, इसलिए हम अब इस ब्लॉक का अध्ययन कर रहे हैं। देखते हैं कि यहां क्या होता है।

वह स्थिति जो यह निर्धारित करती है कि बाईं या दाईं शाखा का चयन किया गया है: ( ) & 0b1 != 0 । यानी, हैश का पहला बिट चेक किया गया है।
यदि आप दोनों शाखाओं को देखते हैं, तो आप देखेंगे:
- दोनों ही मामलों में, दाईं ओर 1 बिट में बदलाव होता है।
- बाईं शाखा में हैश ऑपरेशन 0x8000 किया 0x8000 ।
- दोनों मामलों में, प्रोसेस्ड हैश मान 0x00FF0D46 पते पर लिखा जाता है, यानी हैश को एक नए मान के साथ बदल दिया जाता है।
- आगे की गणना महत्वपूर्ण नहीं है, क्योंकि, मोटे तौर पर, (a2) में कोई लेखन कार्य नहीं हैं (कोई निर्देश नहीं है जहां दूसरा ऑपरेंड (a2) )।

इस तरह एक ब्लॉक की कल्पना करो:

 def transform(hash_2b): new = hash_2b >> 1 if hash_2b & 0b1 != 0: new = new | 0x8000 return new

दूसरा महत्वपूर्ण लूप loc_203E है

loc_203E - लूप, क्योंकि 0x0000206C bne.s loc_203E

यह चक्र हैश की गणना करता है और यहां इसकी मुख्य विशेषता है: jsr (a0) sub_E3E फ़ंक्शन के लिए एक कॉल है जिसे हमने पहले ही जांच लिया है - यह अपने स्वयं के काम के पिछले परिणाम और कुछ इनपुट तर्क पर निर्भर करता है (यह ऊपर रजिस्टर d2 माध्यम से पारित किया गया था, और यहां d0 माध्यम से) )।

आइए d0 कि d0 रजिस्टर के माध्यम से उसे क्या दिया गया है।

हम पहले ही निर्माण 0x34(a2) - sub_E3E फ़ंक्शन पास किए गए तर्क को बचाता है। इसका मतलब है कि पहले से पारित तर्क इस लूप में उपयोग किए जाते हैं। लेकिन सभी नहीं।

कोड भाग को डिक्रिप्ट करें:

   2    a2+0x1C move.w 0x1C(a2), d0  neg.l d0   a0       sub_E3E movea.l 0x34(a2), a0 ,  d0  2    a0-d0(   d0 ) move.b (a0, d0.l), d0

निचला रेखा एक सरल क्रिया है: प्रत्येक पुनरावृत्ति पर, सरणी के अंत से संग्रहीत तर्क को d0 लेते हैं। यही है, अगर 4 को d0 में संग्रहीत किया जाता है, तो हम चौथे तत्व को अंत से लेते हैं।

यदि हां, तो वास्तव में d0 क्या d0 ? यहां मैंने स्क्रिप्ट्स के बिना किया, लेकिन इस ब्लॉक की शुरुआत में एक ब्रेक लगाते हुए, बस उन्हें लिख दिया। यहाँ वे हैं: 0x04, 0x04, 0x04, 0x1C, 0x1A, 0x1A, 0x06, 0x42, 0x02 ।

अब हमारे पास एक पूर्ण कुंजी हैश गणना फ़ंक्शन लिखने के लिए सब कुछ है।

पूर्ण हैश गणना समारोह

 def finish_hash(hash_2b): #    def transform(hash_2b): new = hash_2b >> 1 if hash_2b & 0b1 != 0: new = new | 0x8000 return new main_cycle_counter = [17, 2, 2, 3, 4, 38, 10, 30, 4] second_cycle_counter = [2, 2, 2, 2, 2, 4, 2, 4, 28] counters = list(zip(main_cycle_counter, second_cycle_counter)) d2_storage = [] storage_offsets = [0x04, 0x04, 0x04, 0x1C, 0x1A, 0x1A, 0x06, 0x42, 0x02] prev_sub_E3E_result = 0x0000 sub_5EC = sub_5EC_gen() for i in range(9): c = counters[i] for _ in range(c[0]): d0 = next(sub_5EC) d1 = hash_2b & 0xff d2 = d0 ^ d1 curr_sub_E3E_result = sub_E3E(prev_sub_E3E_result, d2, d2_storage) prev_sub_E3E_result = curr_sub_E3E_result storage_offset = storage_offsets.pop(0) for _ in range(c[1]): d2 = d2_storage[-storage_offset] curr_sub_E3E_result = sub_E3E(prev_sub_E3E_result, d2, d2_storage) prev_sub_E3E_result = curr_sub_E3E_result hash_2b = transform(hash_2b) return curr_sub_E3E_result

स्वास्थ्य की जाँच

डीबगर में, हम 0x0000180A move.l 0x1000,(sp) के पते पर 0x0000180A move.l 0x1000,(sp) (हैश गणना के तुरंत बाद)।
0x00001F16 beq.w loc_20EA (निरंतर 0xCB4C साथ अंतिम हैश की तुलना) को संबोधित करने के लिए ब्रेक।
कार्यक्रम में, कुंजी ABCDEFGHIJKLMNOP Enter , Enter Enter ।
डीबगर 0x0000180A पर 0x0000180A , और हम देखते हैं कि मान 0xFFFF44CC d5 रजिस्टर 0x44CC , 0x44CC पहला हैश है।
हम आगे डिबगर शुरू करते हैं।
हम 0x00001F16 पर 0x00001F16 और देखते हैं कि 0x00FF0D6A पर 0x00FF0D6A स्थित है - अंतिम हैश
अब हमारे finish_hash (hash_2b) फ़ंक्शन को देखें:
```
 >>> r = finish_hash(0x44CC) >>> print(hex(r)) 0x4840 
```

हम सही कुंजी 1 की तलाश कर रहे हैं

सही कुंजी यह कुंजी है जिसका अंतिम हैश 0xCB4C (ऊपर पाया गया) है। इसलिए सवाल: फाइनल के लिए 0xCB4C बनने के लिए पहला हैश क्या होना चाहिए?

अब यह पता लगाना आसान है:

 def find_CB4C(): result = [] for hash_2b in range(0xFFFF+1): final_hash = finish_hash(hash_2b) if final_hash == 0xCB4C: result.append(hash_2b) return result >>> r = find_CB4C() >>> print(r)

कार्यक्रम के आउटपुट से पता चलता है कि केवल एक ही विकल्प है: पहला हैश 0xFEDC होना चाहिए।

हमें किन वर्णों की आवश्यकता है ताकि उनका पहला हैश 0xFEDC ?

चूँकि 0xFEDC = __4_ ^ __4_ बाद, 0xFEDC = __4_ ^ __4_ , आपको केवल __4_ के __4_ को खोजने की आवश्यकता है, क्योंकि दूसरे का __4_ = __4_ ^ 0xFEDC । और फिर दोनों हैश को डीकोड करें।

एल्गोरिथ्म इस प्रकार है:

 def get_first_half(): from collections import deque from random import randint def get_pairs(): pairs = [] for i in range(0xFFFF + 1): pair = (i, i ^ 0xFEDC) pairs.append(pair) pairs = deque(pairs) pairs.rotate(randint(0, 0xFFFF)) return list(pairs) pairs = get_pairs() for pair in pairs: key_4s_0 = decode_hash_4s(pair[0]) key_4s_1 = decode_hash_4s(pair[1]) hash_2b_0 = get_hash_2b(key_4s_0) hash_2b_1 = get_hash_2b(key_4s_1) if hash_2b_0 == pair[0] and hash_2b_1 == pair[1]: return key_4s_0, key_4s_1

विकल्पों का एक गुच्छा, कोई भी चुनें।

हम सही कुंजी 2 की तलाश कर रहे हैं

कुंजी का पहला आधा हिस्सा तैयार है, दूसरे के बारे में क्या?

यह सबसे आसान हिस्सा है।

कोड का जिम्मेदार टुकड़ा 0x00FF2012 पर स्थित है, मुझे इसका पता मैनुअल ट्रेसिंग से लगा, जिसका पता 0x00001F16 beg.w loc_20EA (कुंजी की पहली छमाही का सत्यापन) है। रजिस्टर में a0 मेल एड्रेस है, loc_FF2012 एक चक्र है, क्योंकि bne.s loc_FF2012 इसे तब तक क्रियान्वित किया जाता है जब तक *(a0+d0) (मेल का अगला बाइट) नहीं हो जाता।

और jsr (a3) निर्देश पहले से ही परिचित get_hash_2b फ़ंक्शन को कॉल करता है, जो अब कुंजी के दूसरे छमाही के साथ काम करता है।

आइए कोड को स्पष्ट करें:

 while(d1 != 0x20){    d2++ d1 = d1 & 0xFF     d3 = d3 + d1 d0 = 0 d0 = d2    d1 = *(a0+d0) } d0 = get_hash_2b(key_byte_8) d3 = d0^d3 d0 = get_hash_2b(key_byte_12) d2 = d2 - 1 d2 = d2 << 8 d2 = d0^d2 if (d2 == d3) success_branch

रजिस्टर में d2 - ( -1) << 8 । d3 , मेल वर्णों के बाइट्स का योग।

शुद्धता मानदंड निम्नानुसार प्राप्त किया जाता है: __ ^ d2 == ___2 ^ d3 ।

हम कुंजी की दूसरी छमाही के चयन समारोह लिखते हैं:

 def get_second_half(email): from collections import deque from random import randint def get_koeff(): k1 = sum([ord(c) for c in email]) k2 = (len(email) - 1) << 8 return k1, k2 def get_pairs(k1, k2): pairs = [] for a in range(0xFFFF + 1): pair = (a, (a ^ k1) ^ k2) pairs.append(pair) pairs = deque(pairs) pairs.rotate(randint(0, 0xFFFF)) return list(pairs) k1, k2 = get_koeff() pairs = get_pairs(k1, k2) for pair in pairs: key_4s_0 = decode_hash_4s(pair[0]) key_4s_1 = decode_hash_4s(pair[1]) hash_2b_0 = get_hash_2b(key_4s_0) hash_2b_1 = get_hash_2b(key_4s_1) if hash_2b_0 == pair[0] and hash_2b_1 == pair[1]: return key_4s_0, key_4s_1

keygen

मेल एक कैप्सूल होना चाहिए।

 def keygen(email): first_half = get_first_half() second_half = get_second_half(email) return "".join(first_half) + "".join(second_half) >>> email = "M.GAYANOV@GMAIL.COM" >>> print(keygen(email)) 2A4FD493BA32AD75

आपका ध्यान के लिए धन्यवाद! सभी कोड यहाँ उपलब्ध है ।

हम PHDays 9 के साथ सर्वश्रेष्ठ रिवर्सल समस्या का समाधान करते हैं