सेगा मेगा ड्राइव के लिए एक सरल क्रैकम हल करना

सभी को नमस्कार

Sega Mega Drive लिए खेलों को उलटने के मेरे व्यापक अनुभव के बावजूद, मैंने कभी भी इसके लिए क्रैक करने का फैसला नहीं किया, और वे इंटरनेट पर मेरे सामने नहीं आए। लेकिन, दूसरे दिन एक मज़ाकिया क्रैक था जो हल करना चाहता था। मैं आपके साथ निर्णय साझा करता हूं ...

विवरण

टास्क और रम का विवरण खुद यहां डाउनलोड किया जा सकता है ।

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

• इड़ा के लिए रम लोडर
• डिबगर
• RAM / VDP मेमोरी देखें और बदलें
• VDP पर लगभग पूरी जानकारी प्रदर्शित करें

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

निर्णय

किसी भी शोगी गेम की शुरूआत Reset वेक्टर के निष्पादन के साथ होती है। इसका एक सूचक रम की शुरुआत से दूसरे DWORD में पाया जा सकता है।

हम पता 0x27A पर शुरू होने वाले अज्ञात कार्यों के एक जोड़े को देखते हैं। आइये देखते हैं क्या है।

sub_2EA ()

मैं अपने अनुभव से कहता हूं कि यह आमतौर पर VBLANK के पूरा होने के लिए प्रतीक्षा करने के कार्य जैसा दिखता है। आइए देखते हैं कि byte_FF0026 वेरिएबल में कहां-कहां कॉल हैं:

हम देखते हैं कि शून्य बिट VBLANK व्यवधान में सेट किया गया है। तो हम चर को vblank_ready , और जहाँ यह जाँच की जाती है वह wait_for_vblank ।

उप_60 ई ()

अगला, sub_60E फ़ंक्शन कोड द्वारा कहा जाता है। आइये देखते हैं क्या है:

VDP_CTRL को पहला कमांड क्या लिखता है, VDP कंट्रोल कमांड है। यह जानने के लिए कि वह क्या कर रही है, हम इस कमांड पर खड़े होते हैं और J कुंजी दबाते हैं:

हम देखते हैं कि CRAM (जिस स्थान पर पट्टियाँ संग्रहीत हैं) में प्रवेश को आरंभीकृत किया जाता है। इसका मतलब यह है कि सभी बाद के फ़ंक्शन कोड बस किसी प्रकार का प्रारंभिक पैलेट सेट करते हैं। तदनुसार, फ़ंक्शन को init_cram कहा जा सकता है।

उप_71A ()

हम देखते हैं कि कुछ कमांड को फिर से VDP_CTRL स्थानांतरित कर दिया गया है, फिर J दबाएं और पता करें कि यह कमांड वीडियो वीडियो में रिकॉर्डिंग को आरंभ करता है:

इसके अलावा, यह समझने के लिए कि वीडियो मेमोरी में वहां क्या स्थानांतरित किया गया है, इसका कोई मतलब नहीं है। इसलिए, हम केवल फ़ंक्शन load_vdp_data ।

उप_C60 ()

लगभग यही बात यहाँ पिछले फ़ंक्शन के रूप में होती है, इसलिए, विवरण में जाने के बिना, हम बस load_vdp_data2 फ़ंक्शन को कॉल करते हैं।

उप_8डीए ()

पहले से ही अधिक कोड है। और इसके अलावा, इस फ़ंक्शन में एक और फ़ंक्शन कहा जाता है। चलो वहीं देखते हैं - sub_D08 ।

sub_D08 ()

हम देखते हैं कि रजिस्टर D0 VDP_CTRL लिए कमांड D1 VDP_CTRL - जो मान VRAM में भरेगा, और D2 और D3 - भराव की चौड़ाई और ऊंचाई (क्योंकि यह दो चक्रों को पूरा करता है: आंतरिक और बाहरी)। Fill_vram_by_addr फ़ंक्शन को कॉल करें।

उप_8डीए ()

हम पिछले फ़ंक्शन पर लौटते हैं। D0 रजिस्टर में मान VDP_CTRL लिए कमांड के रूप में प्रसारित होने के VDP_CTRL , मान पर J कुंजी दबाएँ। हमें मिलता है:

फिर से, सेगा को गेम को उलटने के अनुभव से, मैं कह सकता हूं कि यह कमांड मैपिंग टाइल्स की रिकॉर्डिंग को शुरू करता है। 90% मामलों में $Fxxx , $Exxx , $Fxxx , $Exxx पर शुरू होने वाले पते, इन समान मैपिंग वाले क्षेत्रों के पते होंगे। मैपिंग क्या हैं:
ये वे मान हैं जिनके साथ आप यह निर्दिष्ट कर सकते हैं कि स्क्रीन पर यह या उस टाइल को कहाँ प्रदर्शित किया जाए (एक टाइल 8x8 पिक्सेल का एक वर्ग है)।

इसलिए फ़ंक्शन को init_tile_mappings कहा जा सकता है।

उप_सीडीसी ()

पहला कमांड $F000 के पते पर रिकॉर्ड की शुरुआत करता है। एक नोट: " मैपिंग " के पते के बीच, अभी भी एक क्षेत्र है जहां स्प्राइट टेबल संग्रहीत है (ये उनके स्थान हैं, जहां वे इंगित करते हैं, टाइल आदि) यह पता करें कि किस क्षेत्र को डीबग किया जा सकता है। लेकिन अभी के लिए, हमें इसकी आवश्यकता नहीं है, तो चलिए फ़ंक्शन को init_other_mappings ।

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

VBLANK

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

हम देखते हैं कि दो चर बढ़ रहे हैं (जो अजीब है, उनमें से प्रत्येक के लिंक की सूची में यह बिल्कुल खाली है)। लेकिन, चूंकि उन्हें प्रति फ्रेम एक बार अपडेट किया जाता है, आप उन्हें timer2 और timer2 कह सकते हैं।

अगला, sub_2FE फ़ंक्शन को sub_2FE । आइये देखते हैं क्या है:

sub_2FE ()

और वहां - IO_CT1_DATA पोर्ट (पहले जॉयस्टिक के लिए जिम्मेदार) के साथ काम करते हैं। पोर्ट एड्रेस को रजिस्टर A0 में लोड किया जाता है, और sub_310 फ़ंक्शन को पास किया sub_310 है। हम वहां जाते हैं:

उप_310 ()

मेरा अनुभव मुझे फिर से मदद करता है। यदि आप जॉयस्टिक के साथ काम करने वाले कोड को देखते हैं, और दो चर स्मृति में हैं, तो एक स्टोर pressed keys , और दूसरा held keys रखता held keys , अर्थात। बस दबाया और चाबी का आयोजन किया। तो चलिए इन चरों को कहते हैं: pressed_keys और held_keys । और फिर फ़ंक्शन को update_joypad_state कहा जा सकता है।

sub_2FE ()

फ़ंक्शन को read_joypad रूप में कॉल करें।

हैंडलर लूप

अब सब कुछ बहुत स्पष्ट दिखता है:

तो यह चक्र दबाए गए कुंजी का जवाब देता है, और इसी क्रिया को करता है। आइए लूप में कहे गए प्रत्येक फंक्शंस से गुजरें।

उप_4 डी 4 ()

बहुत कोड है। चलिए पहले फ़ंक्शन से शुरू करते हैं: sub_60C ।

उप_60 सी ()

वह कुछ नहीं करती है - ऐसा पहली बार में लग सकता है। बस वर्तमान फ़ंक्शन से लौट रही है rts । लेकिन, क्योंकि इस पर केवल जंप ( bsr ) होता है, जिसका अर्थ है कि rts हमें हैंडलर लूप में वापस कर देगा। मैं इस फ़ंक्शन को retn_to_loop ।

उप_4 डी 4 ()

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

अगला, हमारे पास एक बड़ी मात्रा में कोड है जो किसी भी तरह से sprite_pos_x और sprite_pos_y संसाधित करता है, जो केवल एक ही बात कह सकता है - वर्णमाला में चयनित वर्ण के आसपास चयन स्प्राइट को प्रदर्शित करने के लिए यह आवश्यक है।

तो अब आप फ़ंक्शन को update_selection रूप में सुरक्षित रूप से नाम दे सकते हैं। चलो आगे बढ़ते हैं।

यदि कुछ दबाए गए कुंजी के बिट्स सेट हैं, और कुछ फ़ंक्शन को कॉल करता है तो कोड जांचता है। आइए उन पर नजर डालते हैं।

उप_D28 ()

किसी प्रकार का शैतानी जादू। सबसे पहले, WORD को word_FF0018 चर से लिया गया है, फिर एक दिलचस्प निर्देश निष्पादित किया जाता है:

 bsr.w *+4 

यह निर्देश केवल निर्देश का पालन करता है।

अगला एक और जादू है:

 move.l d0,(sp) rts 

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

अब आपको यह समझने की आवश्यकता है कि चर में यह मान क्या है, जो तब गुजरता है। लेकिन पहले, इस चर को jmp_addr ।

और कार्यों को यह कहा जाएगा:

• sub_D38 : goto_to_d0
• sub_D28 : jump_to_var_addr

jmp_addr

पता करें कि यह चर कहां आबाद है। हम संदर्भों की सूची देखते हैं:

इस चर को लिखने के लिए केवल एक जगह है। आइए उसे देखें।

उप_3 ए 4 ()

यहां, स्प्राइट के समन्वय पर निर्भर करता है (याद रखें कि यह चयनित चरित्र का पता सबसे अधिक संभावना है), यह या वह मान दर्ज किया गया है। हम निम्नलिखित कोड कोड देखते हैं:

मौजूदा मूल्य को 4 बिट्स द्वारा दाईं ओर स्थानांतरित किया जाता है, एक नया मान कम बाइट में रखा जाता है, और परिणाम फिर से चर में दर्ज किया जाता है। सिद्धांत रूप में, हमारे jmp_addr चर वर्णों को संग्रहीत करते हैं जिन्हें हम कुंजी इनपुट स्क्रीन पर दर्ज कर सकते हैं। ध्यान दें कि चर का आकार WORD ।

वास्तव में, sub_3A4 फ़ंक्शन को update_jmp_addr कहा जा सकता है।

उप_414 ()

अब हमारे पास लूप में केवल एक फ़ंक्शन बचा है, जो मान्यता प्राप्त नहीं है। और इसे sub_414 कहा जाता है।

इसका कोड update_jmp_addr फ़ंक्शन के कोड जैसा दिखता है, केवल अंत में हमारे पास एक sub_45E फ़ंक्शन sub_45E । चलो वहाँ देखो।

उप_45E ()

हम देखते हैं कि नंबर #$4B1E2003 D0 रजिस्टर में दर्ज किया गया है, जिसे बाद में VDP_CTRL को भेज दिया VDP_CTRL , जिसका अर्थ है कि हम दूसरे VDP नियंत्रण कमांड के साथ काम कर रहे हैं। हम J दबाते हैं, हम $Cxxx मैपिंग के साथ क्षेत्र में रिकॉर्ड की एक कमांड प्राप्त करते हैं।

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

डिबगर चलाएं

मैं smd Smd Ida Tools से डीबगर का उपयोग करूंगा, लेकिन वास्तव में, कुछ Gens KMod या Gens ReRecording पर्याप्त होगी। मुख्य बात यह है कि स्मृति में पतों के प्रदर्शन के साथ एक विशेषता है।

मेरे सिद्धांत की पुष्टि की गई है। तो चर byte_FF0014 को अब key_length जा सकता है।

एक और चर है: dword_FF0010 , जिसका उपयोग केवल वर्तमान फ़ंक्शन में किया जाता है, और इसकी सामग्री, D0 में प्रारंभिक कमांड को जोड़ने के बाद (याद रखें, यह #$4B1E2003 नंबर था), #$4B1E2003 को भेजा जाता है। add_to_vdp_cmd सोचने के बिना, मैंने चर का नाम add_to_vdp_cmd रखा।

तो यह कार्य क्या करता है? मुझे एक धारणा है कि वह प्रवेशित चरित्र को आकर्षित करती है। यह जाँचना सरल है - डिबगर लॉन्च करके और sub_45E फ़ंक्शन को कॉल करने से पहले और बाद में राज्य की तुलना करें:

करने के लिए:

के बाद:

मैं सही था - यह फ़ंक्शन दर्ज किए गए चरित्र को आकर्षित करता है। हम इसे do_draw_input_char कहते हैं, और इसे ( sub_414 ) कॉल करने वाला फ़ंक्शन draw_input_char ।

अब क्या

आइए अब जांच लें कि चर जिसे हमने jmp_addr कहा है, jmp_addr वास्तव में दर्ज की गई कुंजी को संग्रहीत करता है। हम एक ही Memory Watch उपयोग करेंगे:

जैसा कि आप देख सकते हैं, अनुमान सही था। यह हमें क्या देता है? हम किसी भी पते पर जा सकते हैं। लेकिन कौन सा? कार्यों की सूची में, सभी को सभी के बाद हल किया जाता है:

तब तक मैंने कोड को स्क्रॉल करना शुरू कर दिया जब तक मुझे यह नहीं मिला:

प्रशिक्षित आंख ने $4E, $75 के अनुक्रम को असंबद्ध बाइट्स के अंत में देखा। यह rts अनुदेश का rts , अर्थात फ़ंक्शन से वापस लौटें। तो ये असंबद्ध बाइट्स कुछ फ़ंक्शन का कोड हो सकते हैं। आइए उन्हें एक कोड के रूप में नामित करने का प्रयास करें, C दबाएं:

जाहिर है, यह एक फ़ंक्शन कोड है। कोड को फ़ंक्शन करने के लिए आप उस पर P दबा सकते हैं। इस नाम को याद रखें: sub_D3C

फिर विचार उठता है: क्या होगा यदि आप sub_D3C पर sub_D3C ? यह अच्छा लगता है, हालांकि यहां एक भी कूद स्पष्ट रूप से पर्याप्त नहीं होगी, क्योंकि word_FF0020 चर के लिए अधिक लिंक नहीं थे।

फिर एक और विचार मेरे पास आया: क्या होगा अगर हम एक और ऐसे अनलॉक्ड कोड की तलाश करें? Binary search डायलॉग (Alt + B) खोलें, इसमें अनुक्रम 4E 75 दर्ज करें, बॉक्स को चेक करें Find all occurrences :

खोज शुरू करने के लिए क्लिक करें, हमें निम्नलिखित परिणाम मिलते हैं।

रम में कम से कम दो और स्थानों में एक फ़ंक्शन कोड हो सकता है, आपको उन्हें जांचना होगा। हम पहले विकल्पों पर क्लिक करते हैं, थोड़ा ऊपर स्क्रॉल करते हैं, और फिर हमें अपरिभाषित बाइट्स का एक क्रम दिखाई देता है। उन्हें एक समारोह के रूप में निरूपित करें? हाँ! P बाइट्स शुरू होने पर P :

कूल! अब हमारे पास sub_34C फ़ंक्शन है। हम पाए गए विकल्पों में से अंतिम के साथ एक ही चीज़ को दोहराने की कोशिश करते हैं, और ... हमें एक बमर मिलता है। 4E 75 से पहले इतने सारे बाइट्स हैं कि यह स्पष्ट नहीं है कि फ़ंक्शन कहाँ शुरू होता है। और, जाहिर है, उपरोक्त सभी बाइट्स कोड नहीं हैं, क्योंकि बहुत सारे डुप्लिकेट बाइट्स।

फ़ंक्शन की शुरुआत निर्धारित करें

हमारे लिए फ़ंक्शन की शुरुआत ढूंढना सबसे आसान होगा यदि हम पाते हैं कि डेटा कहाँ समाप्त होता है। यह कैसे करना है? वास्तव में जटिल नहीं है:

1. हम डेटा की शुरुआत से पहले ट्विस्ट करते हैं (कोड से उनका लिंक होगा)
2. हम लिंक का अनुसरण करते हैं और एक चक्र की तलाश करते हैं जिसमें इस डेटा का आकार दिखाई दे
3. सरणी को चिह्नित करें

तो, हम पहले पैराग्राफ का प्रदर्शन करते हैं ...:

... और हम तुरंत देखते हैं कि हमारे सरणी से एक चक्र में 4 बाइट्स डेटा को एक बार (क्योंकि move.l ) से VDP_DATA । आगे हम 2047 नंबर देखते हैं। सबसे पहले, यह लग सकता है कि सरणी का अंतिम आकार 2047 * 4 , लेकिन dbf आधारित लूप +1 पुनरावृत्ति को अधिक निष्पादित करता है, क्योंकि अंतिम तुलना मूल्य 0 नहीं, बल्कि -1 ।

कुल: सरणी का आकार 2048 * 4 = 8192 । सरणी के रूप में बाइट को अस्वीकार करें। ऐसा करने के लिए, * क्लिक करें और आकार निर्दिष्ट करें:

हम सरणी के अंत में मुड़ते हैं, और हम वहां बाइट्स देखते हैं, जो कोड के बिल्कुल बाइट्स हैं:

अब हमारे पास sub_2D86 फ़ंक्शन है, और इस दरार को हल करने के लिए हमारे पास सब कुछ है! आइए देखें कि नवनिर्मित फ़ंक्शन क्या करता है।

sub_2D86 ()

और यह सिर्फ रजिस्टर D1 में मूल्य #$4147 डालता है और sub_34C फ़ंक्शन को कॉल करता है। उसे देख लो।

उप_34 सी ()

हम देखते हैं कि यहाँ word_FF0020 चर का मूल्य word_FF0020 । यदि आप इसके लिंक को देखते हैं, तो हम एक अन्य स्थान देखेंगे जहां इस चर में रिकॉर्ड हो रहा है, और यह ठीक उसी जगह होगा जहां मैं jmp_addr चर के माध्यम से कूदना चाहता था। यह कूबड़ की पुष्टि करता है कि sub_D3C निश्चित रूप से sub_D3C पर कूदने की sub_D3C ।

लेकिन आगे जो हुआ वह मेरे लिए समझने में बहुत आलसी था, इसलिए मैंने रम को GHIDRA में फेंक दिया, इस समारोह को पाया, और विघटित कोड को देखा:

 void FUN_0000034c(void) { ushort in_D1w; short sVar1; ushort *puVar2; if (((ushort)(in_D1w ^ DAT_00ff0020 ^ 0x5e4e) == 0x5a5a) && ((ushort)(in_D1w ^ DAT_00ff0020 ^ 0x4a44) == 0x4e50)) { write_volatile_4(0xc00004,0x4c060003); sVar1 = 0x22; puVar2 = &DAT_00002d94; do { write_volatile_2(VDP_DATA,in_D1w ^ DAT_00ff0020 ^ *puVar2); sVar1 = sVar1 + -1; puVar2 = puVar2 + 1; } while (sVar1 != -1); } return; } 

हम देखते हैं कि अजीब नाम in_D1w साथ चर in_D1w , और चर DAT_00ff0020 भी है, जो कि इसके पते के साथ word_FF0020 उल्लिखित word_FF0020 जैसा दिखता word_FF0020 ।

in_D1w हमें बताता है कि यह मान रजिस्टर D1 से लिया गया है, या इसके छोटे WORD आधे से, और रजिस्टर D1 फ़ंक्शन पर सेट करता है जो इसे पास करता है। #$4147 याद है? इसलिए आपको इस रजिस्टर को फ़ंक्शन के इनपुट तर्क के रूप में नामित करना होगा।

ऐसा करने के लिए, विघटित कोड वाली विंडो में, फ़ंक्शन नाम पर राइट-क्लिक करें, और Edit Function Signature मेनू का चयन Edit Function Signature :

यह इंगित करने के लिए कि फ़ंक्शन एक विशिष्ट रजिस्टर के माध्यम से एक तर्क लेता है, अर्थात्, वर्तमान कॉल कन्वेंशन के लिए मानक विधि द्वारा नहीं, आपको Use Custom Storage का Use Custom Storage करने और हरे रंग के साथ आइकन पर क्लिक करने की आवश्यकता है:

नए इनपुट तर्क के लिए एक स्थिति दिखाई देती है। हम उस पर डबल-क्लिक करते हैं, और हमें तर्क के प्रकार और माध्यम को इंगित करने वाला एक संवाद मिलता है:

विघटित कोड में, हम देखते हैं कि in_D1w ushort प्रकार का है, जिसका अर्थ है कि हम इसे टाइप फ़ील्ड में निर्दिष्ट करेंगे। फिर Add बटन पर क्लिक करें:

एक तर्क के माध्यम को इंगित करने के लिए एक स्थिति दिखाई देगी, हमें Location में D1w रजिस्टर निर्दिष्ट करने की आवश्यकता है, और OK क्लिक करें:

विघटित कोड रूप लेगा:

 void FUN_0000034c(ushort param_1) { short sVar1; ushort *puVar2; if (((ushort)(param_1 ^ DAT_00ff0020 ^ 0x5e4e) == 0x5a5a) && ((ushort)(param_1 ^ DAT_00ff0020 ^ 0x4a44) == 0x4e50)) { write_volatile_4(0xc00004,0x4c060003); sVar1 = 0x22; puVar2 = &DAT_00002d94; do { write_volatile_2(VDP_DATA,param_1 ^ DAT_00ff0020 ^ *puVar2); sVar1 = sVar1 + -1; puVar2 = puVar2 + 1; } while (sVar1 != -1); } return; } 

हम param_1 कि हमारा param_1 मान स्थिर है, कॉलिंग फ़ंक्शन द्वारा पारित किया गया है और #$4147 बराबर है। तो फिर DAT_00ff0020 का मान क्या होना चाहिए? हम मानते हैं:

 0x4147 ^ DAT_00ff0020 ^ 0x5e4e = 0x5a5a 0x4147 ^ DAT_00ff0020 ^ 0x4a44 = 0x4e50 

क्योंकि xor - ऑपरेशन प्रतिवर्ती है, सभी स्थिर संख्याओं को एक दूसरे के साथ झगड़ा किया जा सकता है और चर DAT_00ff0020 का वांछित मान प्राप्त कर सकते हैं।

 DAT_00ff0020 = 0x4147 ^ 0x5e4e ^ 0x5a5a = 0x4553 DAT_00ff0020 = 0x4147 ^ 0x4a44 ^ 0x4e50 = 0x4553 

यह पता चला है कि चर का मान 0x4553 होना चाहिए। ऐसा लगता है कि मैंने पहले से ही ऐसी जगह देखी है जहां इस तरह का मूल्य निर्धारित है ...

निष्कर्ष और निर्णय

हम निम्नलिखित परिणामों पर पहुंचे:

1. सबसे पहले आपको एड्रेस 0x0D3C , इसके लिए आपको कोड 0D3C
2. फ़ंक्शन पर 0x2D86 , जो #$4147 को पंजीकृत करने के लिए D1 का मान सेट करता है, इसके लिए आपको कोड 2D86 दर्ज करना 2D86

प्रयोगात्मक रूप से, हमें उस कुंजी का पता चलता है जिसे दर्ज की गई कुंजी की जांच करने के लिए दबाए जाने की आवश्यकता है: B हम कोशिश करते हैं:

धन्यवाद!