घुटने पर विंडोज के लिए एक ब्राउज़र या टीसीपी स्निफर में वीडियो कैप्चर (भाग दो)

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


कट के तहत सूत्र, विवरण और स्पष्टीकरण ...

इसलिए, तथाकथित के कार्यान्वयन को पूरा करने के लिए मैंने समय लिया स्थायी "ट्रैप्स जिन्हें मूल फ़ंक्शन को कॉल करते समय रीराइटिंग कोड की आवश्यकता नहीं होती है। स्रोत कोड यहां है , और संकलित संस्करण यहां है ।

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

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

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

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

प्रोसेसर निर्देशों के अलग-अलग आकार हैं, जो 1 से 15 बाइट्स तक भिन्न हो सकते हैं। इस प्रकार, एक प्राथमिकता यह ज्ञात नहीं है कि पांच बाइट्स के पैच विधि द्वारा जाल को स्थापित करने के बाद हम क्या और कैसे ठीक से तोड़ देंगे। सिद्धांत रूप में, प्रवेश बिंदु पर कुछ भी हो सकता है, इसलिए दो विकल्प हैं - या तो सामान्य विधि से किसी एक विशेष पर स्विच करें या तर्क को जटिल करें।

"सामान्य से विशेष तक" का अर्थ है कि हम अपने जाल को विशिष्ट कार्यों के लिए निर्धारित करेंगे, उन सभी का अध्ययन करने के बाद और एक व्यक्ति के लिए व्यक्तिगत रूप से सबसे अच्छा तरीका पाया। यह बहुत सुविधाजनक नहीं है, क्योंकि उदाहरण के लिए, एक ही WinSock के लिए, इसके कई संस्करण हैं जैसे XP, XPSP1, XPSP2, XPSP3, Vista, VistaSP1, Vista PU, विंडोज 7, आदि। और सभी प्रकार के सुरक्षा अद्यतन हैं जो सिस्टम लाइब्रेरी के अपने संस्करण भी स्थापित कर सकते हैं। इसलिए, एक निजी विधि द्वारा जाल के सही संचालन के लिए, आपको एक ही पुस्तकालय के सभी संभावित संस्करणों को देखना होगा। सौभाग्य से, अधिकांश भाग के लिए, पुस्तकालयों के विभिन्न संस्करण प्रविष्टि बिंदु पर एक दूसरे से इतने भिन्न नहीं होते हैं।

"जटिल तर्क" का मतलब है कि एक निर्देश पार्सर लिखना
क) हमेशा "पूरे" निर्देश पर नियंत्रण स्थानांतरित करने के लिए प्रोसेसर ऑपकोड के आकार की गणना करने में सक्षम होगा, और कहीं बीच में नहीं।
b) समस्या क्षेत्रों का पता लगाने और उन्हें सही ढंग से संभालने में सक्षम होगा

एक समस्या जगह का सबसे स्पष्ट उदाहरण "विदेशी" जाल है। मान लीजिए कि हम इस प्रक्रिया में घुसपैठ करने और फ़ंक्शन को बाधित करने वाले पहले व्यक्ति नहीं हैं। इस मामले में, हम ज्यादातर मामलों में पहला निर्देश देखेंगे JMP XX XX XX XX XX, कुछ मामलों में PUSH XX XX XX XX RETN, और सिद्धांत रूप में, कुछ भी। इसलिए, JMP के मामले में, हम कॉपी किए गए कोड को दूसरी जगह से सही तरीके से निष्पादित नहीं कर पाएंगे, क्योंकि संक्रमण सापेक्ष है और इसके निष्पादन के पते के सापेक्ष माना जाता है। इसलिए, इस संक्रमण को गिना जाना होगा। लेकिन PUSH-RETN के मामले में, पते की जरूरत नहीं है। और "कुछ भी" के मामले में, समस्या स्थान का ऐसा उदाहरण हो सकता है:

00004EE1: 3C01 cmp al,1 00004EE3: 7404 je 000004EE9 00004EE5: E916010000 jmp 000005000 

इस मामले में, हमें एक जटिल रक्तस्रावी मामला मिलता है:

• एक रिश्तेदार सशर्त शाखा है जिसे हमारे 5 बाइट्स द्वारा अधिलेखित किया जाएगा और जिसे हम इसकी सापेक्षता के कारण अपने हैंडलर में सही ढंग से निष्पादित नहीं कर पाएंगे। दो तरीके हैं: या तो मूल पते पर संक्रमण को फिर से लिखें और इसके परिणामस्वरूप, अनुदेश की लंबाई को दो से छह बाइट्स में बदलने की संभावना है, क्योंकि दो-बाइट संक्रमण छोटा है और प्लस / मिंट 128 बाइट पर काम करता है; या अपने आप को भी उस कोड पर कॉपी करें जिसमें सशर्त कूद संभवत: कूद जाएगा। पहले मामले में, चूंकि हम अनुदेश के आकार को बदल देंगे, इसलिए हमें बाद के सभी कोड को नए पते पर फिर से लिखना होगा। दूसरे मामले में, यह स्पष्ट है कि हमें उस स्थिति का अनुकरण करना होगा जब संक्रमण होता है और जब ऐसा नहीं होता है और नियंत्रण प्राप्त करने की गारंटी देने वाले स्थान पर वापसी को निचोड़ते हैं। फिर से, अगर हम यह मानते हैं कि जिस कोड में सशर्त संक्रमण की स्थिति हो सकती है, वह भी सशर्त और बिना शर्त कूदता है, तो हमें एक बहुत ही दिलचस्प समस्या का सामना करना पड़ता है
• बिना शर्त कूद का हिस्सा, या स्वयं जेएमपी निर्देश, हमारे पांच बाइट्स द्वारा भी मिटा दिए जाएंगे। यदि हम अगले अप्रयुक्त निर्देश पर वापस जाते हैं, तो यह स्पष्ट है कि मूल कोड सही ढंग से काम नहीं करेगा, क्योंकि हम बिना शर्त कूद को छोड़ देते हैं। एक अन्य मामले में, यदि हम पूरे निर्देश को कॉपी करते हैं, तो बिना शर्त संक्रमण हाइपरस्पेस के लिए कहीं न कहीं बना दिया जाएगा, क्योंकि यह सापेक्ष है। इसलिए, नई जगह से सही पते की गणना करना आवश्यक होगा, जो पिछले पैराग्राफ के साथ मिलकर हमें उबाऊ जीवन का वादा करता है।

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

उपरोक्त कारणों से, इस उदाहरण में, मैंने WS2_32 के लिए एक विशेष समाधान पर ध्यान केंद्रित किया। इसलिए, सभी कार्य जो हम अवरोधन करते हैं, मानक के रूप में शुरू होते हैं:

 8BFF mov edi,edi 55 push ebp 8BEC mov ebp,esp 83ECXX sub esp,0000000XX 

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

इसके लिए, हम Interceptor.cpp कोड को संशोधित करने के लिए आगे बढ़ते हैं ... सबसे पहले, हम एक निर्देश पेश करेंगे जो नए तरीके से पुरानी विधि के चक से अनाज को अलग करेगा और स्थापना कोड जोड़ देगा:

 /************************************************************************/ /*     */ /************************************************************************/ BOOL hookInstall(PAPIHOOK thisHook) { ... #ifdef PERSISTENT_HOOKS //     thisHook->oldCodeSize = 0; //   5         //         .    //        (5  ) for (; thisHook->oldCodeSize < HOOK_CODE_SIZE; ) { //     int opSize = getX86InstructionLength((PBYTE) thisHook->oldAddr + thisHook->oldCodeSize); //   thisHook->oldCodeSize += opSize; } //       +   thisHook->oldCode = (UCHAR *) xmalloc(thisHook->oldCodeSize + HOOK_CODE_SIZE); if (NULL == thisHook->oldCode) { SetLastError(ERROR_NOT_ENOUGH_MEMORY); return FALSE; } DWORD fl; //  EXECUTE     DEP VirtualProtect(thisHook->oldCode, thisHook->oldCodeSize + HOOK_CODE_SIZE, PAGE_EXECUTE_READWRITE, &fl); //          memcpy(thisHook->oldCode, thisHook->oldAddr, thisHook->oldCodeSize); //         ... thisHook->oldCode[thisHook->oldCodeSize] = asmJMP; // ...      , //    JMP DWORD *d = (DWORD*) ((PBYTE) (thisHook->oldCode + thisHook->oldCodeSize + 1)); *d = (DWORD) ((PBYTE) thisHook->oldAddr + thisHook->oldCodeSize) - (DWORD) d - sizeof(DWORD); #else //     //       thisHook->oldCodeSize = HOOK_CODE_SIZE; memcpy(thisHook->oldCode, thisHook->oldAddr, HOOK_CODE_SIZE); #endif //     thisHook->isInstalled = TRUE; //   hookEnable(thisHook); #ifdef PERSISTENT_HOOKS //      VirtualProtect(thisHook->oldAddr, HOOK_CODE_SIZE, oldFlags, &oldFlags); #endif return TRUE; } 

जादू फ़ंक्शन getX86InstructionLength () के लिए कॉल को छोड़कर यहां सब कुछ स्पष्ट होना चाहिए। सवालों का सामना न करने के लिए, मैं जवाब दूंगा। प्रारंभ में, यह फ़ंक्शन हमेशा 5 पर लौटा। चूंकि हम एक विशेष मामले को लागू करने के लिए सहमत हुए हैं, इसलिए बहुत अधिक मांग नहीं है - 5 बाइट्स प्रवेश बिंदु पर पहले तीन निर्देशों की लंबाई है। लेकिन मैं थोड़ा आगे बढ़ गया और स्रोत में आपको वास्तविक x86 निर्देश लंबाई विश्लेषक मिलेगा। यह किसी के भविष्य के स्मार्ट इंटरसेप्टर के लिए मेरा योगदान है, इसलिए बोलने के लिए ... इस पोस्ट में, मैं इस मुद्दे की विशालता के कारण उस दिशा में विचलन नहीं करना चाहूंगा।

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

 /************************************************************************/ /*     */ /************************************************************************/ BOOL hookRemove(PAPIHOOK thisHook) { //   ,     if (!thisHook->isInstalled) return FALSE; #ifdef PERSISTENT_HOOKS DWORD oldFlags; if (!VirtualProtect(thisHook->oldAddr, HOOK_CODE_SIZE, PAGE_EXECUTE_READWRITE, &oldFlags) || IsBadWritePtr(thisHook->oldAddr, HOOK_CODE_SIZE)) { SetLastError(ERROR_WRITE_PROTECT); return FALSE; //     } #endif //    hookDisable(thisHook); #ifdef PERSISTENT_HOOKS VirtualProtect(thisHook->oldAddr, HOOK_CODE_SIZE, oldFlags, &oldFlags); if (thisHook->oldCode != NULL) xfree(thisHook->oldCode); #endif //      thisHook->isInstalled = FALSE; //        thisHook->newAddr = (LPVOID) NULL; thisHook->oldAddr = (LPVOID) NULL; return TRUE; } 

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

 #ifdef PERSISTENT_HOOKS /************************************************************************/ /*        */ /*   : typedef int (WSAAPI *PF_send) (SOCKET s, char *buf, int len, int flags); int WSAAPI my_send(SOCKET s, char *buf, int len, int flags) { PAPIHOOK thisHook = hookFind(my_send); PF_send p_send = (PF_send) thisHook->oldProc; if (NULL == thisHook || NULL == p_send) return (int) 0; int rv; ... /************************************************************************/ #define DEFINE_HOOK(RTYPE, CTYPE, NAME, ARGS)\ typedef RTYPE(CTYPE *PF_##NAME) ##ARGS; \ RTYPE CTYPE my_##NAME ##ARGS \ { \ PAPIHOOK thisHook = hookFind(my_##NAME); \ PF_##NAME p_##NAME = (PF_##NAME) thisHook->oldProc; \ if (NULL == thisHook || NULL == p_##NAME) \ return (RTYPE) 0; \ RTYPE rv; #define LEAVE_HOOK() } \ return rv; 

जैसा कि आप कोड से देख सकते हैं, मूल आयातित फ़ंक्शन के बजाय, अब हम इस पर अपना प्रोटोटाइप कहते हैं-> oldProc। यह ठीक वही जगह है जहाँ हमने मूल पाँच बाइट्स को बचाया और उन्हें वापस संक्रमण के साथ पूरक किया।

द्वारा और बड़े, यह सब है। सूत्रों में, PERSISTENT_HOOKS निर्देश पुराने और नए अवरोधन विधियों को बदलने के लिए ज़िम्मेदार है, और डिफ़ॉल्ट रूप से नई विधि का उपयोग ओवरराइटिंग के बिना किया जाता है।

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

यह मत भूलो कि मैं मूल होने का ढोंग नहीं करता और इस क्षेत्र में अग्रणी नहीं हूं। इसलिए ऐसे लोग हैं जो इस दिशा में मेरे प्रयासों की तुलना में अपने शस्त्रागार में अधिक सुरुचिपूर्ण समाधान रखते हैं।

निष्ठा से,
// स्ट