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

एक गेंडा इंजन क्या है?

डेवलपर्स खुद के बारे में लिखते हैं गेंडा इंजन इस तरह से गेंडा इंजन:

यूनिकॉर्न एक हल्का, मल्टी-प्लेटफॉर्म और मल्टी-आर्किटेक्चर प्रोसेसर एमुलेटर है।

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

तो यह कैसे उपयोगी है?

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

आपको क्या चाहिए?

• पायथन बंधन के साथ स्थापित गेंडा इंजन।
• Disassembler।

उदाहरण

एक उदाहरण के रूप में, फाइबोनैचि नाम के तहत hxp CTF 2017 के साथ एक कार्य लें। बाइनरी को यहां डाउनलोड किया जा सकता है ।

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

The flag is: hxp{F 

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

आईडीए प्रो का उपयोग करना ( मैंने व्यक्तिगत रूप से रडार 2 + कटर का उपयोग किया ) हमने कोड को सी- लाइक स्यूडोकोड में अपघटित किया । इस तथ्य के बावजूद कि कोड ठीक से विघटित नहीं हुआ था, हम अभी भी इसके बारे में जानकारी प्राप्त कर सकते हैं कि अंदर क्या हो रहा है।

 __int64 __fastcall main(__int64 a1, char **a2, char **a3) { void *v3; // rbp@1 int v4; // ebx@1 signed __int64 v5; // r8@2 char v6; // r9@3 __int64 v7; // r8@3 char v8; // cl@3 __int64 v9; // r9@5 int a2a; // [sp+Ch] [bp-1Ch]@3 v3 = &encrypted_flag; v4 = 0; setbuf(stdout, 0LL); printf("The flag is: ", 0LL); while ( 1 ) { LODWORD(v5) = 0; do { a2a = 0; fibonacci(v4 + v5, &a2a); v8 = v7; v5 = v7 + 1; } while ( v5 != 8 ); v4 += 8; if ( (unsigned __int8)(a2a << v8) == v6 ) break; v3 = (char *)v3 + 1; _IO_putc((char)(v6 ^ ((_BYTE)a2a << v8)), stdout); v9 = *((char *)v3 - 1); } _IO_putc(10, stdout); return 0LL; } 

 unsigned int __fastcall fibonacci(int i, _DWORD *a2) { _DWORD *v2; // rbp@1 unsigned int v3; // er12@3 unsigned int result; // eax@3 unsigned int v5; // edx@3 unsigned int v6; // esi@3 unsigned int v7; // edx@4 v2 = a2; if ( i ) { if ( i == 1 ) { result = fibonacci(0, a2); v5 = result - ((result >> 1) & 0x55555555); v6 = ((result - ((result >> 1) & 0x55555555)) >> 2) & 0x33333333; } else { v3 = fibonacci(i - 2, a2); result = v3 + fibonacci(i - 1, a2); v5 = result - ((result >> 1) & 0x55555555); v6 = ((result - ((result >> 1) & 0x55555555)) >> 2) & 0x33333333; } v7 = v6 + (v5 & 0x33333333) + ((v6 + (v5 & 0x33333333)) >> 4); *v2 ^= ((BYTE1(v7) & 0xF) + (v7 & 0xF) + (unsigned __int8)((((v7 >> 8) & 0xF0F0F) + (v7 & 0xF0F0F0F)) >> 16)) & 1; } else { *a2 ^= 1u; result = 1; } return result; } 

यहाँ मुख्य और फ़ंक्शंस के कोडांतरक कोड हैं:

 .text:0x4004E0 main proc near ; DATA XREF: start+1Do .text:0x4004E0 .text:0x4004E0 var_1C = dword ptr -1Ch .text:0x4004E0 .text:0x4004E0 push rbp .text:0x4004E1 push rbx .text:0x4004E2 xor esi, esi ; buf .text:0x4004E4 mov ebp, offset unk_4007E1 .text:0x4004E9 xor ebx, ebx .text:0x4004EB sub rsp, 18h .text:0x4004EF mov rdi, cs:stdout ; stream .text:0x4004F6 call _setbuf .text:0x4004FB mov edi, offset format ; "The flag is: " .text:0x400500 xor eax, eax .text:0x400502 call _printf .text:0x400507 mov r9d, 49h .text:0x40050D nop dword ptr [rax] .text:0x400510 .text:0x400510 loc_400510: ; CODE XREF: main+8Aj .text:0x400510 xor r8d, r8d .text:0x400513 jmp short loc_40051B .text:0x400513 ; --------------------------------------------------------------------------- .text:0x400515 align 8 .text:0x400518 .text:0x400518 loc_400518: ; CODE XREF: main+67j .text:0x400518 mov r9d, edi .text:0x40051B .text:0x40051B loc_40051B: ; CODE XREF: main+33j .text:0x40051B lea edi, [rbx+r8] .text:0x40051F lea rsi, [rsp+28h+var_1C] .text:0x400524 mov [rsp+28h+var_1C], 0 .text:0x40052C call fibonacci .text:0x400531 mov edi, [rsp+28h+var_1C] .text:0x400535 mov ecx, r8d .text:0x400538 add r8, 1 .text:0x40053C shl edi, cl .text:0x40053E mov eax, edi .text:0x400540 xor edi, r9d .text:0x400543 cmp r8, 8 .text:0x400547 jnz short loc_400518 .text:0x400549 add ebx, 8 .text:0x40054C cmp al, r9b .text:0x40054F mov rsi, cs:stdout ; fp .text:0x400556 jz short loc_400570 .text:0x400558 movsx edi, dil ; c .text:0x40055C add rbp, 1 .text:0x400560 call __IO_putc .text:0x400565 movzx r9d, byte ptr [rbp-1] .text:0x40056A jmp short loc_400510 .text:0x40056A ; --------------------------------------------------------------------------- .text:0x40056C align 10h .text:0x400570 .text:0x400570 loc_400570: ; CODE XREF: main+76j .text:0x400570 mov edi, 0Ah ; c .text:0x400575 call __IO_putc .text:0x40057A add rsp, 18h .text:0x40057E xor eax, eax .text:0x400580 pop rbx .text:0x400581 pop rbp .text:0x400582 retn .text:0x400582 main endp 

 .text:0x400670 fibonacci proc near ; CODE XREF: main+4Cp .text:0x400670 ; fibonacci+19p ... .text:0x400670 test edi, edi .text:0x400672 push r12 .text:0x400674 push rbp .text:0x400675 mov rbp, rsi .text:0x400678 push rbx .text:0x400679 jz short loc_4006F8 .text:0x40067B cmp edi, 1 .text:0x40067E mov ebx, edi .text:0x400680 jz loc_400710 .text:0x400686 lea edi, [rdi-2] .text:0x400689 call fibonacci .text:0x40068E lea edi, [rbx-1] .text:0x400691 mov r12d, eax .text:0x400694 mov rsi, rbp .text:0x400697 call fibonacci .text:0x40069C add eax, r12d .text:0x40069F mov edx, eax .text:0x4006A1 mov ebx, eax .text:0x4006A3 shr edx, 1 .text:0x4006A5 and edx, 55555555h .text:0x4006AB sub ebx, edx .text:0x4006AD mov ecx, ebx .text:0x4006AF mov edx, ebx .text:0x4006B1 shr ecx, 2 .text:0x4006B4 and ecx, 33333333h .text:0x4006BA mov esi, ecx .text:0x4006BC .text:0x4006BC loc_4006BC: ; CODE XREF: fibonacci+C2j .text:0x4006BC and edx, 33333333h .text:0x4006C2 lea ecx, [rsi+rdx] .text:0x4006C5 mov edx, ecx .text:0x4006C7 shr edx, 4 .text:0x4006CA add edx, ecx .text:0x4006CC mov esi, edx .text:0x4006CE and edx, 0F0F0F0Fh .text:0x4006D4 shr esi, 8 .text:0x4006D7 and esi, 0F0F0Fh .text:0x4006DD lea ecx, [rsi+rdx] .text:0x4006E0 mov edx, ecx .text:0x4006E2 shr edx, 10h .text:0x4006E5 add edx, ecx .text:0x4006E7 and edx, 1 .text:0x4006EA xor [rbp+0], edx .text:0x4006ED pop rbx .text:0x4006EE pop rbp .text:0x4006EF pop r12 .text:0x4006F1 retn .text:0x4006F1 ; --------------------------------------------------------------------------- .text:0x4006F2 align 8 .text:0x4006F8 .text:0x4006F8 loc_4006F8: ; CODE XREF: fibonacci+9j .text:0x4006F8 mov edx, 1 .text:0x4006FD xor [rbp+0], edx .text:0x400700 mov eax, 1 .text:0x400705 pop rbx .text:0x400706 pop rbp .text:0x400707 pop r12 .text:0x400709 retn .text:0x400709 ; --------------------------------------------------------------------------- .text:0x40070A align 10h .text:0x400710 .text:0x400710 loc_400710: ; CODE XREF: fibonacci+10j .text:0x400710 xor edi, edi .text:0x400712 call fibonacci .text:0x400717 mov edx, eax .text:0x400719 mov edi, eax .text:0x40071B shr edx, 1 .text:0x40071D and edx, 55555555h .text:0x400723 sub edi, edx .text:0x400725 mov esi, edi .text:0x400727 mov edx, edi .text:0x400729 shr esi, 2 .text:0x40072C and esi, 33333333h .text:0x400732 jmp short loc_4006BC .text:0x400732 fibonacci endp 

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

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

चरण 1: वर्चुअलाइजेशन आने दो

आइए रिट्रेसफ्री फाइल बनाते हैं और बाइनरी के बगल में सेव करते हैं।

आइए आवश्यक पुस्तकालयों को आयात करके शुरू करें:

 from unicorn import * from unicorn.x86_const import * import struct 

पहली पंक्ति मुख्य बाइनरी और बेसिक यूनिकॉर्न स्थिरांक को लोड करती है। दूसरी पंक्ति दो x86 और x86_64 आर्किटेक्चर के लिए स्थिरांक को लोड करती है।

अगला, कुछ आवश्यक कार्य जोड़ें:

 def read(name): with open(name) as f: return f.read() def u32(data): return struct.unpack("I", data)[0] def p32(num): return struct.pack("I", num) 

यहां हमने उन कार्यों की घोषणा की है जिनकी हमें बाद में आवश्यकता होगी:

• पढ़ें बस फ़ाइल की सामग्री देता है,
• u32 ले एन्कोडिंग में एक 4-बाइट स्ट्रिंग लेता है और इंट में कनवर्ट करता है,
• p32 इसके विपरीत करता है - यह एक संख्या लेता है और ले एन्कोडिंग में इसे 4-बाइट स्ट्रिंग में बदल देता है।

नोट: यदि आपने pwntools स्थापित किए हैं , तो आपको इन कार्यों को बनाने की आवश्यकता नहीं है, आपको बस उन्हें आयात करने की आवश्यकता है:

 from pwn import * 

और इसलिए, आखिरकार, x86_64 आर्किटेक्चर के लिए हमारे यूनिकॉर्न इंजन क्लास को शुरू करना शुरू करें:

 mu = Uc (UC_ARCH_X86, UC_MODE_64) 

यहां हम Uc फ़ंक्शन को निम्नलिखित मापदंडों के साथ कहते हैं:

• पहला पैरामीटर मुख्य वास्तुकला है। लगातार UC_ARCH_ के साथ शुरू होता है;
• दूसरा पैरामीटर वास्तुकला की विशिष्टता है। Constants UC_MODE_ से शुरू होते हैं ।

आप सभी स्थिरांक को धोखा दे सकते हैं ।

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

बाइनरी का आधार पता (बेस एड्र) 0x400000 से शुरू होता है। आइए हमारे स्टैक को 0x0 पर रखें और इसके लिए 1024 * 1024 मेमोरी आवंटित करें। सबसे अधिक संभावना है, हमें इतनी जगह की आवश्यकता नहीं है, लेकिन यह अभी भी चोट नहीं पहुंचाता है।

हम mem_map विधि को कॉल करके मेमोरी को चिह्नित कर सकते हैं।

इन पंक्तियों को जोड़ें:

 BASE = 0x400000 STACK_ADDR = 0x0 STACK_SIZE = 1024*1024 mu.mem_map(BASE, 1024*1024) mu.mem_map(STACK_ADDR, STACK_SIZE) 

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

 mu.mem_write(BASE, read("./fibonacci")) mu.reg_write(UC_X86_REG_RSP, STACK_ADDR + STACK_SIZE - 1) 

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

मुख्य () से पहले कमांड का पता लें, हम 0x004004e0 से अनुकरण शुरू कर सकते हैं। संपूर्ण ध्वज को प्रदर्शित करने के बाद अंत को putc ("\ n") पर कॉल माना जाएगा, जो 0x00400575 पर स्थित है।

 .text:0x400570 mov edi, 0Ah ; c .text:0x400575 call __IO_putc 

हम अनुकरण शुरू कर सकते हैं:

 mu.emu_start(0x004004e0,0x00400575) 

अब स्क्रिप्ट चलाएँ:

 a@x:~/Desktop/unicorn_engine_lessons$ python solve.py Traceback (most recent call last): File "solve.py", line 32, in <module> mu.emu_start(0x00000000004004E0, 0x0000000000400575) File "/usr/local/lib/python2.7/dist-packages/unicorn/unicorn.py", line 288, in emu_start raise UcError(status) unicorn.unicorn.UcError: Invalid memory read (UC_ERR_READ_UNMAPPED) 

उफ़, कुछ गड़बड़ हो गई, लेकिन हम यह भी नहीं जानते कि क्या। Mu.emu_start को कॉल करने से पहले , हम इसे जोड़ सकते हैं:

 def hook_code(mu, address, size, user_data): print('>>> Tracing instruction at 0x%x, instruction size = 0x%x' %(address, size)) mu.hook_add(UC_HOOK_CODE, hook_code) 

यह कोड एक हुक जोड़ता है। हम अपने स्वयं के हुक_कोड फ़ंक्शन की घोषणा करते हैं, जिसे प्रत्येक कमांड से पहले एमुलेटर द्वारा कहा जाता है। यह निम्नलिखित पैरामीटर लेता है:

• Uc की हमारी प्रति,
• निर्देश का पता
• आकार निर्देश
• उपयोगकर्ता डेटा (हम इस मान को एक वैकल्पिक तर्क के साथ hook_add () ) में दे सकते हैं।
  अब, यदि हम स्क्रिप्ट चलाते हैं, तो हमें निम्न आउटपुट देखना चाहिए:
  

   a@x:~/Desktop/unicorn_engine_lessons$ python solve.py >>> Tracing instruction at 0x4004e0, instruction size = 0x1 >>> Tracing instruction at 0x4004e1, instruction size = 0x1 >>> Tracing instruction at 0x4004e2, instruction size = 0x2 >>> Tracing instruction at 0x4004e4, instruction size = 0x5 >>> Tracing instruction at 0x4004e9, instruction size = 0x2 >>> Tracing instruction at 0x4004eb, instruction size = 0x4 >>> Tracing instruction at 0x4004ef, instruction size = 0x7 Traceback (most recent call last): File "solve.py", line 41, in <module> mu.emu_start(0x00000000004004E0, 0x0000000000400575) File "/usr/local/lib/python2.7/dist-packages/unicorn/unicorn.py", line 288, in emu_start raise UcError(status) unicorn.unicorn.UcError: Invalid memory read (UC_ERR_READ_UNMAPPED) 

  
  

  पते पर जहां त्रुटि हुई, हम समझ सकते हैं कि हमारी स्क्रिप्ट इस आदेश को संसाधित नहीं कर सकती है:
  

   .text:0x4004EF mov rdi, cs:stdout ; stream 

  
  

  यह निर्देश 0x601038 पते के डेटा को पढ़ता है (आप इसे आईडीए प्रो में देख सकते हैं)। यह .bss खंड है जिसे हमने चिह्नित नहीं किया है। मेरा समाधान बस सभी समस्याग्रस्त निर्देशों को छोड़ना होगा यदि यह प्रोग्राम लॉजिक को प्रभावित नहीं करता है।
  नीचे एक और समस्यात्मक निर्देश है:
  

   .text:0x4004F6 call _setbuf 

  
  

  हम glibc के साथ किसी भी फ़ंक्शन को कॉल नहीं कर सकते, क्योंकि हमारे पास glibc मेमोरी में लोड नहीं है। किसी भी मामले में, हमें इस आदेश की आवश्यकता नहीं है, इसलिए हम इसे छोड़ भी सकते हैं।
  यहाँ स्किप करने के लिए कमांड की पूरी सूची है:
  

   .text:0x4004EF mov rdi, cs:stdout ; stream .text:0x4004F6 call _setbuf .text:0x400502 call _printf .text:0x40054F mov rsi, cs:stdout ; fp 

  
  

  आदेशों को छोड़ने के लिए, हमें निम्नलिखित निर्देश के साथ RIP को फिर से लिखना होगा:
  

   mu.reg_write(UC_X86_REG_RIP, address+size) 

  
  

  अब हुक_कोड कुछ इस तरह दिखना चाहिए:

  
  
  
  

   instructions_skip_list = [0x004004ef,0x004004f6,0x00400502,0x0040054f] def hook_code(mu, address, size, user_data): print('>>> Tracing instruction at 0x%x, instruction size = 0x%x' %(address, size)) if address in instructions_skip_list: mu.reg_write(UC_X86_REG_RIP, address+size) 

  
  

  हमें उन निर्देशों के साथ भी कुछ करना होगा जो बाइट-बाइट कंसोल में ध्वज को प्रदर्शित करते हैं।

  
  

   .text:0x400558 movsx edi, dil ; c .text:0x40055C add rbp, 1 .text:0x400560 call __IO_putc 

  
  

  प्रथम तर्क के रूप में __IO_putc आउटपुट के लिए बाइट्स लेता है (यह RDI रजिस्टर है)।

  
  

  हम डेटा को रजिस्टर से सीधे पढ़ सकते हैं, कंसोल को आउटपुट डेटा और निर्देशों के इस सेट को छोड़ सकते हैं। अद्यतन किया गया हुक_कोड नीचे प्रस्तुत किया गया है:

  
  

   instructions_skip_list = [0x004004ef,0x004004f6,0x00400502,0x0040054f] def hook_code(mu, address, size, user_data): #print('>>> Tracing instruction at 0x%x, instruction size = 0x%x' %(address, size)) if address in instructions_skip_list: mu.reg_write(UC_X86_REG_RIP, address+size) elif address == 0x400560: # c = mu.reg_read(UC_X86_REG_RDI) print(chr(c),end="") mu.reg_write(UC_X86_REG_RIP, address+size) 

  
  

  हम दौड़ सकते हैं और यह सब काम करेगा, लेकिन फिर भी धीरे-धीरे।

  
  

  चरण 2: गति बढ़ाएं!

  
  

  आइए काम की गति बढ़ाने के बारे में सोचें। यह कार्यक्रम इतना धीमा क्यों है?

  
  

  यदि हम विघटित कोड को देखते हैं, तो हम देखेंगे कि मुख्य () कॉल रिट्रेस () कई बार और रिट्रेस () एक पुनरावृत्ति फ़ंक्शन है। आइए इस फ़ंक्शन पर करीब से नज़र डालें, यह दो तर्कों को लेता है और वापस करता है। पहला रिटर्न मान RAX रजिस्टर के माध्यम से पारित किया जाता है, दूसरे को उस लिंक के माध्यम से लौटाया जाता है जिसे फ़ंक्शन के दूसरे तर्क से पारित किया गया था। यदि हम मुख्य () और फ़ोटोग्राफ़ी () के बीच संबंधों पर अधिक गहराई से देखते हैं, तो हम देखेंगे कि दूसरा तर्क केवल दो संभावित मान लेता है: 0 या 1. यदि आप अभी भी इसे नहीं देखते हैं, तो gdb चलाएं और फ़ंक्शन की शुरुआत में एक विराम बिंदु डालें रिट्रेसमेंट () ।

  
  

  एल्गोरिथ्म के संचालन का अनुकूलन करने के लिए, हम आने वाले मापदंडों के लिए वापसी मूल्य को याद रखने के लिए गतिशील प्रोग्रामिंग का उपयोग कर सकते हैं। अपने लिए सोचें, दूसरा तर्क केवल दो संभावित मूल्यों को ले सकता है, इसलिए हमें केवल इतना करना है कि हम याद रखें$$ $ इनलाइन $ 2 * MAX \ _OF \ _FIRST \ _ARGUMENT $ इनलाइन $ जोड़े।

  
  
  उन लोगों के लिए जो समझ में नहीं आते हैं

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

  
  

  एक उदाहरण:
  गहराई मान लें = 6, फिर: 1 1 2 3 5 8 ।
  और अब गहराई = 8, फिर: 1 1 2 3 5 8 13 21।

  
  

  हम केवल यह याद रख सकते हैं कि पहले 6 सदस्य 1 1 2 3 5 8 हैं , और जब वे हमें याद किए गए से अधिक गिनने के लिए कहते हैं, तो हम वही लेते हैं जो हम याद करते हैं और केवल वही याद करते हैं जो गायब है।

  
  

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

  
  

  मूल्यों की एक जोड़ी कैसे संसाधित करें?

  
  
  • फ़ंक्शन की शुरुआत में, हम जांच सकते हैं कि यह जोड़ी उन परिणामों में है जो हम पहले से जानते हैं:
    
    • अगर वहाँ है, तो हम इस जोड़ी को वापस कर सकते हैं। हमें केवल RAX में और लिंक के पते पर रिटर्न मान लिखने की आवश्यकता है, जो दूसरे तर्क में है। हम फ़ंक्शन से बाहर निकलने के लिए एक RIP पता भी प्रदान करते हैं। हम रिटेट को रिट्रेसमेंट () में उपयोग नहीं कर सकते हैं, क्योंकि ये कॉल हुक किए जाते हैं, इसलिए हम मुख्य से कुछ आरईटी लेंगे () ;
    • यदि ये मूल्य नहीं हैं, तो हम उन्हें केवल स्टैक में जोड़ते हैं।
  • फ़ंक्शन से बाहर निकलने से पहले, हम लौटे हुए जोड़े को बचा सकते हैं। हम इनपुट तर्कों को जानते हैं, क्योंकि हम उन्हें अपने स्टैक से पढ़ सकते हैं।
  
  
  यह कोड यहाँ प्रस्तुत किया गया है।

   FIBONACCI_ENTRY = 0x00400670 FIBONACCI_END = [ 0x004006f1, 0x00400709] instructions_skip_list = [0x004004ef,0x004004f6,0x00400502,0x0040054f] #     stack = [] # ,       d = {} def hook_code(mu, address, size, user_data): if address in instructions_skip_list: mu.reg_write(UC_X86_REG_RIP, address+size) #      elif address == 0x400560: c = mu.reg_read(UC_X86_REG_RDI) print(chr(c),end="") mu.reg_write(UC_X86_REG_RIP, address+size) #     ? elif address == FIBONACCI_ENTRY: #     RDI arg0 = mu.reg_read(UC_X86_REG_RDI) #    () r_rsi = mu.reg_read(UC_X86_REG_RSI) #   ,    arg1 = u32(mu.mem_read(r_rsi, 4)) # ,    ? if (arg0,arg1) in d: (ret_rax, ret_ref) = d[(arg0,arg1)] #     RAX mu.reg_write(UC_X86_REG_RAX, ret_rax) #     mu.mem_write(r_rsi, p32(ret_ref)) #  RIP  RET ,       fibonacci mu.reg_write(UC_X86_REG_RIP, 0x400582) else: #      ,      stack.append((arg0,arg1,r_rsi)) elif address in FIBONACCI_END: #     (arg0, arg1, r_rsi) = stack.pop() #     RAX ret_rax = mu.reg_read(UC_X86_REG_RAX) #  ,      ret_ref = u32(mu.mem_read(r_rsi,4)) #      d[(arg0, arg1)]=(ret_rax, ret_ref) 

  
  
  यहाँ पूरी स्क्रिप्ट है

   #!/usr/bin/env python # -*- coding: utf-8 -*- from __future__ import print_function from unicorn import * from unicorn.x86_const import * import struct def read(name): with open(name) as f: return f.read() def u32(data): return struct.unpack("I", data)[0] def p32(num): return struct.pack("I", num) FIBONACCI_ENTRY = 0x00400670 FIBONACCI_END = [ 0x004006f1, 0x00400709] instructions_skip_list = [0x004004ef,0x004004f6,0x00400502,0x0040054f] #     stack = [] # ,       d = {} def hook_code(mu, address, size, user_data): if address in instructions_skip_list: mu.reg_write(UC_X86_REG_RIP, address+size) #      elif address == 0x400560: c = mu.reg_read(UC_X86_REG_RDI) print(chr(c),end="") mu.reg_write(UC_X86_REG_RIP, address+size) #     ? elif address == FIBONACCI_ENTRY: #     RDI arg0 = mu.reg_read(UC_X86_REG_RDI) #    () r_rsi = mu.reg_read(UC_X86_REG_RSI) #   ,    arg1 = u32(mu.mem_read(r_rsi, 4)) # ,    ? if (arg0,arg1) in d: (ret_rax, ret_ref) = d[(arg0,arg1)] #     RAX mu.reg_write(UC_X86_REG_RAX, ret_rax) #     mu.mem_write(r_rsi, p32(ret_ref)) #  RIP  RET .     fibonacci mu.reg_write(UC_X86_REG_RIP, 0x400582) else: #      ,      stack.append((arg0,arg1,r_rsi)) elif address in FIBONACCI_END: #     (arg0, arg1, r_rsi) = stack.pop() #     RAX ret_rax = mu.reg_read(UC_X86_REG_RAX) #  ,      ret_ref = u32(mu.mem_read(r_rsi,4)) #      d[(arg0, arg1)]=(ret_rax, ret_ref) mu = Uc (UC_ARCH_X86, UC_MODE_64) BASE = 0x400000 STACK_ADDR = 0x0 STACK_SIZE = 1024*1024 mu.mem_map(BASE, 1024*1024) mu.mem_map(STACK_ADDR, STACK_SIZE) mu.mem_write(BASE, read("./fibonacci")) mu.reg_write(UC_X86_REG_RSP, STACK_ADDR + STACK_SIZE - 1) mu.hook_add(UC_HOOK_CODE, hook_code) mu.emu_start(0x004004e0, 0x00400575) print() 

  
  

  हुर्रे, हम अंततः यूनिकॉर्न इंजन का उपयोग करके एप्लिकेशन को अनुकूलित करने में सक्षम थे। अच्छा काम!

  
  

  एक नोट

  
  

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

  
  

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