एक कार्यक्रम में अज्ञात प्रोसेसर रिवर्स इंजीनियरिंग

टीएल; डीआर: हमने सीपीयू पर किसी भी दस्तावेज के बिना पूरी तरह से अज्ञात सीपीयू वास्तुकला के लिए लिखे गए प्रोग्राम को रिवर्स-इंजीनियर किया (बिना एमुलेटर के, आईएसए के बिना, सब कुछ बिना) केवल दस घंटों में। लेख से आप जानेंगे कि हमने यह कैसे किया ...

पिछले सप्ताहांत में, सीएमयू पीपीपी टीम और मैंने ड्रैगन सेक्टर टीज़र सीटीएफ 2019 टीम में भाग लिया, ताकि सीएचआई 2020 की कठिन समय सीमा से आराम और दूर जा सकें । ड्रैगन सेक्टर एक दिलचस्प पोलिश टीम है जिसका इतिहास दिलचस्प CTFs के साथ है , इसलिए मैं सोच रहा था कि उनके पास स्टॉक में क्या है।

"Ummmfpu" को हल करने के लिए, एक कार्य जिसमें माइक्रोमेगा यूएम-एफपीयू फ्लोटिंग पॉइंट कोप्रोसेसर के लिए बायटेकोड की रिवर्स इंजीनियरिंग शामिल थी, मैंने सीपीयू साहसिक समस्या को हल करने के लिए एक प्रतियोगिता में भाग लेने का फैसला किया, जो उस समय किसी भी टीम द्वारा हल नहीं किया गया था (परिणामस्वरूप हम केवल वही थे जिन्होंने कार्य पूरा किया)।

यहाँ CPU साहसिक कार्य का विवरण दिया गया है:

60 के दशक में मेरे दादाजी कंप्यूटर के विकास में लगे थे। चीजों को अपने अटारी में डालते हुए, मुझे एक अजीब कार मिली। मशीन के बगल में "ड्रैगन एडवेंचर गेम" के रूप में चिह्नित पंच कार्डों का ढेर था। कुछ समय बाद, मैं इसे आधुनिक उपकरणों से जोड़ने में कामयाब रहा, लेकिन खेल बहुत जटिल है और मैं धोखा दिए बिना अंत तक नहीं पहुंच सकता। क्या आप मेरी मदद कर सकते हैं? मैं मशीन में उपयोग किए जाने वाले पंच कार्डों का एक प्रतिलेखन संलग्न कर रहा हूं। यह दावा किया जाता है कि मशीन में 4 सामान्य-उद्देश्य रजिस्टर, 1 किबिबाइट डेटा मेमोरी और 32 किबाइट कमांड मेमोरी है। गेम खेलने के लिए, सर्वर से इस प्रकार कनेक्ट करें: socat tcp4-connect:cpuadventure.hackable.software:1234 fd:0,rawer Hint: मशीन का प्रोसेसर अद्वितीय है, इस पर Google जानकारी की कोशिश न करें।

game.bin

सर्वर से जुड़े होने के बाद, हमें निम्नलिखित जानकारी मिली:

THERE IS A TAVERN HERE. INSIDE THE TAVERN, YOU SEE VALIS.

SELECT AN OPTION:

- GO (N)ORTH
- GO (E)AST
- (T)ALK TO VALIS
- (D)RINK
- SHOW (I)NVENTORY

YOUR CHOICE:

बहुत बढ़िया। यह एक पुराने स्कूल का साहसिक खेल है। इसे थोड़ा खेलने के बाद, हमें एहसास हुआ कि आप दुश्मनों से लड़ सकते हैं और अगर हम उसे खुश करते हैं तो इस वैलिस चरित्र से एक झंडा प्राप्त कर सकते हैं:

YOUR CHOICE: T

YOU ENTER THE TAVERN AND APPROACH VALIS.

- HEY, I WAS WONDERING IF YOU COULD HELP ME FIND THE FLAG?
- THE FLAG? MAYBE, BUT FIRST, I NEED A REDBULL.
- I... I DON'T HAVE A REDBULL.
- WELL THEN, MAKE YOURSELF USEFUL AND FIND ONE.

THERE IS A TAVERN HERE. INSIDE THE TAVERN, YOU SEE VALIS.

SELECT AN OPTION:

- GO (N)ORTH
- GO (E)AST
- (T)ALK TO VALIS
- (D)RINK
- SHOW (I)NVENTORY

YOUR CHOICE:

पहला कदम

मैंने बहुत लंबे समय तक गेम नहीं खेला, यह महसूस करते हुए कि इंजीनियर के लिए game.bin फ़ाइल को रिवर्स करना सबसे अधिक महत्वपूर्ण है। मैंने इसे एक हेक्स संपादक में खोला, जिससे बाइनरी वैल्यूज़ देखने की उम्मीद थी। जब मैंने यह देखा तो मेरे आश्चर्य की कल्पना कीजिए:

  110011111101000000111100000000010100000000100010100000000000000111101010000000101001111001111001111111111111100111110010000011 ... 

यह वस्तुतः एक द्विआधारी फ़ाइल है - एक पाठ फ़ाइल जिसमें एएससीआईआई के अक्षर 1 और 0. के अलावा कुछ भी नहीं है। हम जानते हैं कि यह प्रोसेसर के मशीन कोड की सबसे अधिक संभावना है, लेकिन 4 रजिस्टरों के अलावा, 1 मेमोरी डेटा और 32 काबी kibibyte ऑफ़ इंस्ट्रक्शन मेमोरी, इसके बारे में कुछ भी ज्ञात नहीं है । इसलिए, हमारा पहला गंभीर कार्य इस बाइनरी फ़ाइल के इकाई आकार को निर्धारित करना होगा (उदाहरण के लिए, क्या इसका 8-बिट आयाम है? या, शायद, इसमें 12-बिट या 18-बिट आयाम है, जैसा कि कुछ प्राचीन आर्किटेक्चर में है ?)

किसी अज्ञात फ़ाइल के आकार का पता लगाने के लिए, मैंने एक पुरानी चाल का उपयोग किया - मैंने टेक्स्ट बॉक्स का आकार बदल दिया जब तक कि लाइन ब्रेक की लंबाई संरेखण के अनुरूप नहीं थी। यह विधि कई XOR एन्क्रिप्टेड पाठ, अज्ञात (असम्पीडित) फ़ाइल स्वरूपों और एक अज्ञात CPU से कोड जैसी चीजों के लिए बढ़िया है:


टेक्स्ट बॉक्स का आकार बदलें

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

  10000011111110000001010100011111110100000101100010111000001001000101000100001000100001010001011000101000000001111111111100010000011110010100100001010100111100000110000010100000101000101000011110001111001101111001010100001010000111110100001010000110010011011110011111000000111011101000000001100000110000111101011010111011000100100010100000111000100011100011000000000101010101100010111000001010000001101010010000000011000001100 

चूंकि दोहराव के बीच की दूरी 885 है, हम इस निष्कर्ष पर पहुंचे कि आयाम 5 बिट होना चाहिए, अर्थात। अज्ञात CPU में 5-बिट बाइट्स होना चाहिए। प्रगति!

हमने 5-बिट पंच कार्ड एनकोडिंग की खोज की और जल्दी से बॉडोट कोड के साथ पुराने एन्कोडिंग पर बस गए। और वास्तव में - जब हमने कुछ टुकड़ों को डीकोड करने के लिए ऑनलाइन डिकोडर का उपयोग किया, तो हमें पठनीय पाठ मिला!

⇩DRAGON⇩HERE⇧; ⇩SHEPEAPPEARS⇩TO⇩BE⇩GUARDING⇩ SOME⇩KIND⇩OF⇩A⇩BOTTLE⇧; &।। ⇩␀THERE⇩IS⇩⇩⇩B

एलएसबी बॉडोट आईटीए-बढ़ाया 425-बिट कोड

फिर हमने बोडो कोड का उपयोग करके पूरी फ़ाइल को डीकोड करने की कोशिश की, लेकिन पहले 20 हजार बिट्स में हमें कचरा मिला, जिसके बाद एक पूरी तरह से पठनीय पाठ था। इससे हमें यह स्पष्ट हो गया कि फ़ाइल का पहला भाग "कोड" खंड से संबंधित है, इसके बाद "डेटा" अनुभाग है, जो निरंतर लाइनें है। हमने मान लिया कि मशीन शायद I / O के लिए बोडो कोड का उपयोग करती है, और इसलिए मेमोरी में बोडो एन्कोडिंग में निरंतर लाइनों को भी संग्रहीत करता है। कोड सेगमेंट को अधिक पठनीय बनाने के लिए, मैंने हेक्साडेसिमल एन्कोडिंग के समान बेस -32 एन्कोडिंग का उपयोग करके इसे एनकोड करने का निर्णय लिया, लेकिन वर्णमाला 0-9a-v के साथ इसका विस्तार किया। यह है कि बेस -32 द्वारा एन्कोड किए गए पहले भाग के साथ Game.bin फ़ाइल कैसी दिखती है और दूसरा भाग बोडो द्वारा डिकोड किया गया (पूर्ण फ़ाइल यहाँ पोस्ट की गई है: game.b32 ):

pv83pi70pk00p7a0qfgvpjg3f0kf13f28p5f3pv10pk40pn60f0sf1sf24p5f3r9c11qad0f0sf1df26p5f39c21qad0f05f1ff26p5f39c41qad0f08f1df26p5f39c81qad0f0hf1ef26p5f3r1c00qaq15c20qcl0f01f1of27p5f3p3g3psf35c10qal0f02f1nf27p5f3p3g3psf3rf0hf1nf27p5f3f05f16f27p5f3rf84f95101311fl0f510f84907qa40b518447qa40b514f84f95k9m0k9m0k9m0907qa40b511447qa40b512ruougf10f20g0i9g0i910931b320u2u1u0ro9f0o9f0ojh0o9f0o9f0o9f0olj0o9f0o9f0o9f0o9f0o9f0o9f0o9f0o9k1onp0o9f0o9f0o9f0o9f0onf0ot82odi0o9f0o9f0o9f0o9f0o9f0o9f0o9f0olg0o9f0f0gf1df24p5f3r9c11qa835548755
[...]
93e9n59ka8fo87r85g8ui8ml8ed87b9h89u291u82333333333456789abcdb01234567892)%c3BOTTLE OF SOPLICA PIGWOWAENEMY HEALTH:

YOU ATTACK

YOU APPROACH REDFORD.



YOU ENTER THE TAVERN AND APPROACH VALIS.
[...]

सादगी के लिए, मैं नीचे पांच-बिट इकाइयों को "बाइट्स" कहूंगा। टीम में एक दूसरे के बीच, हम उनके लिए अन्य नामों के साथ आए - मैंने उन्हें किबल्स, और ज़क - हैक्स कहा।

अज्ञात प्रोसेसर आर्किटेक्चर रिवर्स इंजीनियरिंग

अब हम मुश्किल हिस्से में उतरते हैं - रिवर्स इंजीनियरिंग 4000 बाइट्स कोड जो पूरी तरह से अनूठे अनूठे सीपीयू आर्किटेक्चर पर चलता है। कोड से, यह स्पष्ट रूप से पर्याप्त है कि यह चर लंबाई के निर्देशों का एक सेट होना चाहिए, क्योंकि इसमें ध्यान देने योग्य स्थिर दोहराव पैटर्न मिलना असंभव है। मैंने इस पर कुछ घंटे बिताए, बाद में मेरी टीम के सदस्य ज़ाचरी वेड (@ zwad3) मेरी मदद करने लगे। सबसे पहले, मैंने कोड के डुप्लिकेट टुकड़ों की तलाश शुरू की, यह सुझाव देते हुए कि वे अक्सर कम संख्या में निर्देशों का उपयोग करेंगे। मैंने कोड को छोटे दोहराए जाने वाले अनुक्रमों में विभाजित करना शुरू किया जो विश्लेषण के लिए अधिक सुविधाजनक थे। मैं कहना चाहूंगा कि यह एक कठोर प्रक्रिया थी, लेकिन वास्तव में, निम्नलिखित अस्पष्ट एल्गोरिथ्म का मुख्य रूप से उपयोग किया गया था:

• हम कोड के माध्यम से देखते हैं और देखते हैं कि क्या कुछ बहुत बार दोहराता है
• इस पुनरावृत्ति के बगल में एक नई पंक्ति सम्मिलित करने के लिए खोज और प्रतिस्थापन प्रक्रिया करें
• परिणामी विभाजन रेखाओं के बीच समानता / अंतर का अन्वेषण करें।
• लगभग एक घंटे के लिए इस प्रक्रिया को दोहराएं ...

उदाहरण के लिए, मेरे द्वारा खोजा गया एक पैटर्न "0f0.f" था, जहां "।" एक अज्ञात चरित्र को इंगित करता है। मैंने इस पैटर्न पर स्ट्रिंग को तोड़ दिया और निम्नलिखित प्राप्त किया:

pv83pi70pk00p7a0qfgvpjg3f0kf13f28p5f3pv10pk40pn60f0sf
1sf24p5f3r9c11qad0f0sf
1df26p5f39c21qad0f05f
1ff26p5f39c41qad0f08f
1df26p5f39c81qad0f0hf
1ef26p5f3r1c00qaq15c20qcl0f01f
1of27p5f3p3g3psf35c10qal0f02f

बहुत मददगार! दूसरी और तीसरी पंक्तियों से हम देखते हैं कि "... p5f3r9c ..." और "... p5f39c ..." हैं, और यह हमें संकेत देता है कि "r" एक एकल-बाइट वाला opcode है, अर्थात, "5f3" एक opcode का अंत है, और " 9 सी .. ”दूसरे की शुरुआत है। अंतिम दो पंक्तियों में हम "p5f3r1c ..." देखते हैं और इसका अर्थ है कि "1c .." एक और ओपकोड है, और "p3 ..." भी एक अन्य ओपकोड है।

मैंने समान निर्देशों का उपयोग करके, समान निर्देशों के समान अंतरों और अंतरों का उपयोग करते हुए, समान रूप से निर्देशों को विभाजित करना जारी रखा। अंत में, मुझे कुछ इस तरह मिला:

pv83
pi70
pk00
p7a0
qfgv
pjg3
f0k
f13
f28
p5f3
pv10
pk40
pn60
f0s
f1s
f24
p5f3
r
9c11
qad0
f0s
f1d
f26
p5f3
9c21
qad0
f05
f1f

मैंने माना कि "p" और "q" तीन बाइट्स ऑफ़ ऑपरेंड्स के निर्देश थे, "f0", "f1" और "f2" एक ऑपरेंड वाले निर्देश थे, और "9c" दो ऑपरेंड्स वाला एक निर्देश था। हालांकि, मुझे नहीं पता था कि इनमें से प्रत्येक निर्देश क्या है।

इसलिए मैंने उन सभी "पी" निर्देशों की निर्देशिका की, जिन्हें मैंने हाइलाइट किया था, और पाया कि इस समय "पी" के साथ सबसे लगातार निर्देश "पी 5 एफ 3" थे। इसके अलावा, उन स्थानों को देखते हुए जहां यह होता है, मैंने पाया कि यह हमेशा "f0", "f1" और "f2" निर्देशों से पहले होता है। सभी ऑपरेंड "f0", "f1" और "f2" को देखते हुए, मैंने देखा कि ऑपरेंड f2 हमेशा 4-8 की रेंज में होते हैं। यह याद रखते हुए कि सीपीयू में 32 केबी की प्रोग्राम मेमोरी है जिसे संबोधित करने के लिए 15 बिट्स की आवश्यकता होती है, मैंने मान लिया कि "f0", "f1" और "f2" ने कुछ पते को f2 के साथ उच्च बाइट के रूप में लोड किया है। जब मैंने इनमें से कुछ पतों को एक साथ जोड़ा, तो मैंने पाया कि वे सभी डेटा खंड में निरंतर रेखाओं की शुरुआत की ओर इशारा करते हैं। मुझे print फंक्शन मिला! इसने तुरंत कहा कि "p5f3" वास्तव में एक लाइन या कॉल को प्रिंट करने के लिए किसी तरह का निर्देश है; यदि आप तीन-बाइट ऑपरेंड को ध्यान में रखते हैं, तो सबसे अधिक संभावना है कि यह एक "कॉल" है। फिर से, "पी" निर्देशों को देखते हुए, मुझे महसूस हुआ कि ऑपरेंड के तीन बाइट्स डायरेक्ट ऑर्डर (छोटे-एंडियन) में पते को इंगित करते हैं, अर्थात, ऑपरेंड का अंतिम बाइट पते का उच्चतम बाइट है।

यह बहुत बड़ी सफलता थी! हमने अपने पहले निर्देश की पहचान कर ली है। यह देखने के बाद कि "f0" और "f1" कुछ अन्य स्थानों पर उपयोग किए जाते हैं, मैंने माना कि वे पते को लोड नहीं करते हैं, लेकिन चार रजिस्टरों में से एक (उदाहरण के लिए, f0 रजिस्टर 0 को लोड करता है) 5-बिट स्थिरांक के साथ प्रत्यक्ष पते के साथ। यह p5f3 के लिए तार्किक है - यह 3f5 फ़ंक्शन ("print_string") के लिए तीन रजिस्टर तर्क लोड करता है।

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

0: call 38v
4: call 7i
8: call k
c: call a7
g: q vgf

k: call 3gj
o: print 83k # 'SELECT AN OPTION\x0e:\r\n\r\n\x0f\x00'
15: call 1v
19: call 4k
1d: call 6n
1h: print 4ss # '\r\nYOUR CHOICE\x0e: \x0f\x00'
1u: ret

1v: unk 9
20: unk c
21: unk 1
22: unk 1
23: q 0da
27: print 6ds # '\x0e- \x0fGO \x0e(\x0fS\x0e)\x0fOUTH\r\n\x00'
2k: unk 9
2l: unk c
2m: unk 2
2n: unk 1
2o: q 0da
2s: print 6f5 # '\x0e- \x0fGO \x0e(\x0fN\x0e)\x0fORTH\r\n\x00'
39: unk 9
3a: unk c
3b: unk 4
3c: unk 1
3d: q 0da
3h: print 6d8 # '\x0e- \x0fGO \x0e(\x0fE\x0e)\x0fAST\r\n\x00'
3u: unk 9
3v: unk c
40: unk 8
41: unk 1
42: q 0da
46: print 6eh # '\x0e- \x0fGO \x0e(\x0fW\x0e)\x0fEST\r\n\x00'
4j: ret

इस छोटे से कोड स्निपेट से, मैं कई पहलुओं का पता लगाने में कामयाब रहा: "q0" निर्देश को कुछ सशर्त शाखाओं में बंटना चाहिए (क्योंकि इसका उपयोग फंक्शन 1v में अनावश्यक दिशा-निर्देशों को प्रिंट करने के लिए किया जाता है), और निर्देश "9c11", "921", "9c41", " 9c81 "को किसी प्रकार के निर्देश का संकेत देना चाहिए - वे यह देखने के लिए सेट बिट्स की जांच करते हैं कि क्या इन निर्देशों की अनुमति है (यह इन निर्देशों में" 1 "," 2 "," 4 "और" 8 "के उपयोग से स्पष्ट रूप से संकेत मिलता है)।

अगले दो घंटों में, Zachary Wade (@ zwad3) और मैंने विभिन्न निर्देशों को छांटा, जो वे कर रहे थे, उसके बारे में हमारी धारणाओं को बना और परिष्कृत किया। कई पठनीय प्रिंट स्टेटमेंट होने से हमारा काम काफी आसान हो गया। हमने फैसला किया कि हम में से प्रत्येक व्यक्ति व्यक्तिगत रूप से अपने स्वयं के डिस्सेम्बलर लिखेगा ताकि हम अपनी गति से निर्देशों की जांच कर सकें और अपने निष्कर्षों को साझा कर सकें।

कोड रिवर्स इंजीनियरिंग

कुछ घंटों के बाद, मैंने असहमति में बहुत प्रगति करना शुरू कर दिया। उपयोगकर्ता की इन्वेंट्री के साथ काम करने वाले कोड (अधिक विशेष रूप से, "ड्रिंक" फ़ंक्शन और इसके साथ जुड़े प्रत्येक हैंडलर) की जांच करने के बाद, हमने मेमोरी से बचत और लोड करने के निर्देश पाए (यह मत भूलिए कि सीपीयू में डेटा मेमोरी का 1 किबायटे है)। तब हमें पता चला कि कुछ अंकगणितीय / तार्किक (ALU) निर्देश मेमोरी ऑपरेंड्स लेते हैं (उदाहरण के लिए, "9c41" का अर्थ है "निष्पादन और मूल्य 4 के साथ डेटा पते 1 पर)। इससे, हम डेटा मेमोरी में वेरिएबल्स को फिर से बनाने में सक्षम थे, उदाहरण के लिए, [0] में NPC पहचानकर्ता को वर्तमान स्थान में संग्रहीत किया जाता है, और [6,7] में खिलाड़ी का वर्तमान स्वास्थ्य संग्रहीत किया जाता है ([6] में निचले 5 बिट्स, [7 में सबसे पुराने 5 बिट्स]। ])। इस स्तर पर, मैंने अपने असंतुष्ट कोड को एनोटेट करने के लिए रिवर्स इंजीनियरिंग निर्देशों से स्विच किया और स्वयं प्रोग्राम को रिवर्स इंजीनियरिंग किया। नीचे 5-बिट मानों के लिए मेरा मज़ेदार अंकन है:

_start:
call init

L4:
call check_moves
call print_menu
call handle_command
br 4

print_menu:
call print_itemname
print 83k # 'SELECT AN OPTION\x0e:\r\n\r\n\x0f\x00'
call print_moves
call print_npcmenu
call print_itemmenu
print 4ss # '\r\nYOUR CHOICE\x0e: \x0f\x00'
ret

print_moves:
and 0y1, [1]
brz 2k
print 6ds # '\x0e- \x0fGO \x0e(\x0fS\x0e)\x0fOUTH\r\n\x00'
2k: and 0y2, [1]
brz 39
print 6f5 # '\x0e- \x0fGO \x0e(\x0fN\x0e)\x0fORTH\r\n\x00'
39: and 0y4, [1]
brz 3u
print 6d8 # '\x0e- \x0fGO \x0e(\x0fE\x0e)\x0fAST\r\n\x00'
3u: and 0y8, [1]
brz 4j
print 6eh # '\x0e- \x0fGO \x0e(\x0fW\x0e)\x0fEST\r\n\x00'
4j: ret

print_npcmenu:
add 0y0, [0]
brz 6m
sub 0y2, [0]
br<c> 5p
print 7o1 # '\x0e- (\x0fT\x0e)\x0fALK TO \x00'
call print_npcname
call print_crlf
5p: sub 0y1, [0]
brz 6m
print 7n2 # '\x0e- (\x0fF\x0e)\x0fIGHT \x00'
call print_npcname
call print_crlf
6m: ret

print_itemmenu:
print 7nh # '\x0e- (\x0fD\x0e)\x0fRINK\r\n\x00'
print 765 # '\x0e- \x0fSHOW \x0e(\x0fI\x0e)\x0fNVENTORY\r\n\x00'
ret

उदाहरण के लिए, हमारे पास अभी भी कई अज्ञात opcodes हैं, हालांकि हमें पता चला है कि "qa" शून्य पर एक सशर्त शाखा है (शाखा-शून्य, brz), हम यह नहीं समझ पा रहे थे कि "qc" क्या है (ऊपर दर्शाया गया है) br <c>)। लेकिन यह कार्यक्रम के तर्क को समझने के लिए पर्याप्त था।

वास्तव में, खेल खिलाड़ी को 8 × 8 के नक्शे पर घूमने की अनुमति देता है, जिस पर NPCs (ड्रेगन, रेड बुल और मानव) को बेतरतीब ढंग से रखा जाता है। आप किसी भी NPC के साथ लड़ सकते हैं (यहां तक ​​कि Valis, इसी मेनू आइटम की कमी के बावजूद)। लड़ाई के दौरान, आप दुश्मन पर हमला कर सकते हैं, जिससे यादृच्छिक मात्रा में क्षति या चूक हो सकती है, जिसके बाद दुश्मन खिलाड़ी पर हमला करता है, जिससे यादृच्छिक मात्रा में क्षति या चूक भी हो सकती है। आप एक ढाल लॉक भी चुन सकते हैं, धन्यवाद जिसके कारण दुश्मन या तो चूक जाता है या क्षति के बिना ढाल को हिट करता है। अंत में, आप अपने स्वास्थ्य को 1000 तक बढ़ाकर धोखा दे सकते हैं, लेकिन इस मामले में, छिपे हुए चर ("धोखा", पता 10) 1 पर सेट है। यदि खिलाड़ी सफलतापूर्वक दुश्मन को मारता है, तो एक वस्तु उसके बाहर गिर जाती है, आमतौर पर कुछ शराब की एक बोतल (जाहिर है) यह खेल बच्चों के लिए नहीं है)।

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

यादृच्छिक संख्या पीढ़ी एक फ़ंक्शन द्वारा किया जाता है जो किसी प्रकार के PRNG (पता 37a) के समान होता है, लेकिन यह अद्वितीय निर्देशों का उपयोग करता है जो कहीं और उपयोग नहीं किए जाते हैं, इसलिए हम उन्हें इंजीनियर रिवर्स नहीं कर सकते। हालाँकि, हमने देखा कि यह अपने स्टेट वेक्टर को मेमोरी में तीन पतों ([11], [12] और [13]) से लोड करता है, यानी इसकी पूरी अवस्था में केवल 15 बिट्स लगते हैं। इसका मतलब है कि RNG की अवधि कम होनी चाहिए - लंबाई में 2 ^ 15 = 32768 से अधिक नहीं।

जबकि हमने (असफल रूप से) RNG कार्यान्वयन को उलटने की कोशिश की, जे बोसमिया (@ jay_f0xtr0t) और मैथ्यू सैवेज (@thebluepichu) ने एक कारनामे को लागू किया। केवल पंक्ति में "ढाल" कमांड को 100,000 बार भेजने से, हम RNG से बिट आउटपुट के अनुरूप दुश्मन "हिट" और "मिसेज" का एक क्रम प्राप्त करने में सक्षम थे। हमने सुनिश्चित किया कि यह क्रम 32767 की अवधि के साथ दोहराता है। इसके लिए धन्यवाद, हम अपने मुख्य कारनामे को इकट्ठा करने में सक्षम थे - जब हम मिले पहले दुश्मन से लड़ रहे थे, हमने हिट्स और मिसेस के अनुक्रम को फिर से बनाने के लिए 40 बार बंद किया, एक बड़े आवधिक अनुक्रम में इस अनुक्रम की तलाश की, और फिर पता चला। कब ढालें ​​और कब हमला करें ताकि दुश्मन हमेशा छूटे। फिर हम सिर्फ मर्डरहोबो मोड में पूरे नक्शे के आसपास चले गए, सभी को मार डाला और उनकी लूट को इकट्ठा किया। अंत में, हम वालिस के पास लौटे और विनम्रता से अपना झंडा माँगा, जो हमें मिला:

DrgnS{m4kin9-v4lis-happy-w1th-n4t1ve-b4ud0t-cpu}

ओह! दरअसल, एक असली रोमांच। मैं अभी भी पूरी तरह से विश्वास नहीं कर सकता कि हम एक बाइनरी स्ट्रिंग और दो से लगभग पूर्ण disassembler और एक साफ disassembled कोड में प्रोसेसर प्रलेखन की पूरी कमी के कारण 10 घंटे से भी कम समय में आए! GitHub पर सभी कोड उपलब्ध हैं: मेरे डिसबेंबलर , ज़ाचरी के डिस्सेम्बलर , मेरे रॉ डिसैम्बल्ड कोड , मेरे एनोटेट डिसैम्बल्ड कोड , मैट एक्सप्लॉइट क्लाइंट ।