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

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

प्रस्तावना

यह ओपस विंडोज, विनएपीआई और सी ++ के कुछ ज्ञान को मानता है, इसलिए यदि मेरे लिए कुछ स्पष्ट बिंदुओं पर अधिक विस्तृत स्पष्टीकरण की आवश्यकता है, तो पूछें। मैं तुरंत स्पष्ट कर दूंगा कि इस पोस्ट में उल्लिखित सिद्धांतों के आधार पर वीडियो को इंटरसेप्ट करने के लिए कोई तैयार कार्यक्रम नहीं है (कम से कम मैंने ऐसा कुछ नहीं लिखा है)। कुछ खाली और सैद्धांतिक निर्माण हैं, जो मुख्य रूप से एनडीआईएस मिनिपोर्ट चालक और नीली स्क्रीन के साथ निर्णय के प्रतिपक्षी के रूप में प्रेरित हैं।
इसलिए, यदि हम काल्पनिक रूप से यह मान लेते हैं कि हमारे पास एक निश्चित मॉड्यूल है जो ब्राउज़र से HTTP या TCP / IP पैकेट्स को इंटरसेप्ट करने में सक्षम है, तो हम वास्तव में वीडियो को कैसे पकड़ेंगे? दो विकल्प हैं:

1. पतों को URL के रूप में संबोधित करते हैं।
   ऐसा करने के लिए, आपको HTTP GET वाले आउटगोइंग पैकेट्स को इंटरसेप्ट करना होगा, और यह देखना होगा कि यह GET कहां निर्देशित है। निर्णय बल्कि संदिग्ध है, क्योंकि इसमें किसी विशेष साइट के बारे में विशिष्ट ज्ञान की आवश्यकता होती है। दूसरी ओर, " www.youtube.com/watch?v=o78nFVB1tJA " जैसे टेम्पलेट के लिए उपयुक्त पते आपको स्ट्रीम प्राप्त करने के लिए सीधे वीडियो स्ट्रीमिंग के लिए अनुरोधों को फ़िल्टर करने की अनुमति देंगे।
2. सर्वर से प्रतिक्रियाओं की जाँच करें
   ऐसा करने के लिए, आपको आने वाले पैकेटों को रोकना होगा और कंटेंट-टाइप के लिए उनके HTTP हेडर को जांचना होगा। जाहिर है, वीडियो के लिए वे विशिष्ट प्रारूपों के लिए विशिष्ट होंगे। उदाहरण के लिए, YouTube से फ्लैश वीडियो के उपरोक्त लिंक के लिए, जहां मैं सैक्सोफोन बजाता हूं, सर्वर की प्रतिक्रिया में हेडर "सामग्री-प्रकार: वीडियो / x-flv" होगा, जो स्पष्ट रूप से हमें बताता है कि फ्लैश वीडियो शीर्षक का अनुसरण करेगा। MPEG4 के मामले में, हेडर में वीडियो / mp4 और इसी तरह होगा।

अंतिम समाधान को प्रभावी ढंग से काम करने के लिए संभवतः 1) और 2 के संयोजन की आवश्यकता होगी, लेकिन इस पोस्ट में हम पहले पैकेट कैप्चर पर ध्यान देंगे।

DLL जाल और कार्यान्वयन

इंटरसेप्टर लिखने के लिए पहली बात जो दिमाग में आती है वह है ब्राउज़र प्रक्रिया में एक DLL की शुरूआत। इस जगह में कुछ पढ़ना बंद कर देंगे, क्योंकि तब सब कुछ स्पष्ट है। जो कोई भी सब कुछ समझ सकता है वह यहां स्रोत और संकलित संस्करण डाउनलोड कर सकता है (हां, केवल 3 केबी)। यदि आप यह कोशिश करने का निर्णय लेते हैं कि यह कैसे काम करता है, तो मैं दृढ़ता से 32-बिट ब्राउज़र लेने और सभी सॉफ़्टवेयर को काटने की सलाह देता हूं, जो समान ट्रिक्स का उपयोग करता है, उदाहरण के लिए AdMuncher (हैलो मरे और शैनॉवे!), क्योंकि इस उदाहरण ने इस तरह के सॉफ़्टवेयर के साथ सही सहवास के बारे में परवाह नहीं की है (यह) सुधार-)। % TEMP% में .log फ़ाइलों के रूप में परिणामों के लिए देखें।

बाकी सभी के लिए, किसी को कुछ समझाना होगा, हालांकि सिस्टम ट्रैप और विंडोज प्रक्रियाओं में डीएलएल का परिचय एक सुंदर हैकिंग विषय है। ब्राउज़र प्रक्रिया में अपने DLL को एम्बेड करने का अंतिम परिणाम कुछ इस प्रकार होगा:



यही है, प्रत्येक ब्राउज़र प्रक्रिया के अंदर, हमारा जेनेरिक डीएलएल बैठेगा, जो आवश्यक पैकेजों को रोक देगा। अभी दो सवाल उठते हैं।

1. DLL कैसे लागू करें?
2. पैकेट कैसे पकड़े?

आइए नीचे उनका जवाब देने की कोशिश करते हैं ...

किसी और की प्रक्रिया में एक DLL इंजेक्षन

पहले चरण में, यह स्पष्ट है कि हमें दो मॉड्यूल लिखने की आवश्यकता है - मुख्य अनुप्रयोग और डीएलएल। मुख्य एप्लिकेशन को तैनात करेगा, और तदनुसार DLL तैनात किया जाएगा। आगे की हलचल के बिना, हम Vistual Studio लॉन्च करेंगे और तुरंत मुख्य एप्लिकेशन (Injector.cpp) लिखेंगे:

#pragma comment(linker, "/entry:WinMain /nodefaultlib") void APIENTRY winMain() { HMODULE interceptor = LoadLibrary(TEXT("Interceptor.dll")); if (interceptor != NULL) { HOOKPROC cbtHook = (HOOKPROC) GetProcAddress(interceptor, (LPCSTR) 1); HHOOK hHook = (HHOOK) SetWindowsHookEx(WH_CBT, cbtHook, interceptor, 0); if (hHook != NULL) { MessageBox(NULL, TEXT("Press OK to terminate."), TEXT("Interceptor is working."), MB_OK); UnhookWindowsHookEx(hHook); } FreeLibrary(interceptor); } } 

उपरोक्त कोड क्या करता है? पहली पंक्ति में, कोड की कॉम्पैक्टनेस के कारणों के लिए, हम सीधे WinMain () में एप्लिकेशन को प्रवेश बिंदु डालते हैं, बिना रीप्ले के। स्रोत में, मैं आमतौर पर अनावश्यक रूप से MSVCRT काट देता हूं।
इसके बाद, हम अपने इंटरसेप्टर को लोड करते हैं, इसमें एक्सपोर्ट फंक्शन नंबर 1 (ऑर्डिनल द्वारा इम्पोर्ट) पाते हैं, और बनाए गए मापदंडों का उपयोग करके सीबीटी टाइप का एक ग्लोबल ट्रैप सेट करते हैं। तब हम केवल एक मोडल संदेश प्रदर्शित करते हैं, "ओके" बटन को पूरा करने और सूक्ष्म विमान पर जाने के लिए दबाएँ। वह सब है। यह उन सभी प्रक्रियाओं में DLL को लागू करने के लिए पर्याप्त है जो किसी भी तरह विंडोज के साथ काम करने के लिए User32 WinAPI का उपयोग करती हैं।
सीबीटी, कंप्यूटर-आधारित प्रशिक्षण के लिए छोटा। WH_CBT ट्रैप आम तौर पर अच्छा है क्योंकि "... सिस्टम विंडो को सक्रिय करने, बनाने, नष्ट करने, कम करने, अधिकतम करने, स्थानांतरित करने या आकार बदलने से पहले इस जाल को कहता है। और सिस्टम कमांड के पूरा होने से पहले, संदेश कतार से कीबोर्ड या माउस इवेंट को हटाने से पहले, इनपुट फ़ोकस सेट करने से पहले और सिस्टम संदेश कतार के साथ सिंक्रनाइज़ करने से पहले ... ”MSDN का ऐसा मुफ्त अनुवाद। वास्तव में, इसका मतलब है कि यह उन 99% अनुप्रयोगों के लिए काम करेगा जो मानक खिड़की वास्तुकला के अनुसार लिखे गए हैं।
इस पद्धति की सुंदरता यह है कि हमें वास्तव में विंडोज ट्रैप सिस्टम से परेशान नहीं होना चाहिए।

हम DLL लिखना शुरू करते हैं

चूंकि हम एक इंटरसेप्टर लिख रहे हैं, और कुछ और नहीं, यह उसके लिए पर्याप्त होगा:

1. आवेदन प्रक्रिया में लोड होने पर DLL को इनिशियलाइज़ करेगा
2. DLL प्रक्रिया पूरी होने तक पता स्थान पर रहेगा
3. पूरा होने पर या किसी बाहरी घटना के बाद, एप्लिकेशन अनलोड करने से पहले DLL को अनइंस्टॉल कर देता है

यह कहने योग्य है कि इस तकनीक को थोड़ा गहराई में मिलान मॉड्यूल की आवश्यकता है। इसका मतलब है कि 64-बिट ब्राउज़र को 64-बिट DLL इंटरसेप्टर की आवश्यकता होगी, वही 32-बिट अनुप्रयोगों के लिए जाता है। आपको यह उम्मीद नहीं करनी चाहिए कि 32-बिट इंटरसेप्टर को 64-बिट एप्लिकेशन और विशेष रूप से इसके विपरीत में लोड किया जाएगा।
तो, आइए भविष्य के इंटरसेप्टर (Interceptor.cpp) के कंकाल लिखें:

 HINSTANCE g_hDllInstance; //  ,     LRESULT CALLBACK CBT_Hook(int nCode, WPARAM wParam, LPARAM lParam) { return 0; } //        BOOL onLoad() { return TRUE; } //        BOOL onUnload() { return TRUE; } BOOL WINAPI DllMain(HINSTANCE hDllInstance, DWORD dwReason, LPVOID lpRsrv) { switch(dwReason) { case DLL_PROCESS_ATTACH: DisableThreadLibraryCalls(hDllInstance); g_hDllInstance = hDllInstance; return onDllLoad(); break; case DLL_PROCESS_DETACH: return onDllUnload(); break; default: break; } return TRUE; } 

इसके अलावा, हमें निर्यात को नंबर 1 के साथ निर्दिष्ट करने की आवश्यकता है। इसके लिए, हम मानक DEF फ़ाइल (Interceptor.def) लिखते हैं और इसे / DEF पैरामीटर के माध्यम से लिंकर को खिलाने के लिए मत भूलना:

 LIBRARY Intercept EXPORTS CBT_Hook @1 

वह सब है। अब DLL प्रक्रियाओं से चिपका हुआ है और पूरा होने तक उनमें बैठता है। हमारे लिए अनावश्यक प्रक्रियाओं में घुसपैठ न करने और मुख्य एप्लिकेशन के अंदर सही तरीके से व्यवहार करने के लिए (हां, क्योंकि यह डीएलएल को लोड और आरंभ करता है), हम एक अतिरिक्त जांच करेंगे:

 const char *appsToIntercept[] = { "chrome.exe", "iexplore.exe", "opera.exe", "firefox.exe", "safari.exe", 0}; char thisProcessPath[MAX_PATH], *thisProcessName; char thisDllPath[MAX_PATH], *thisDllName; BOOL onLoad() { BOOL rv = FALSE; //       thisProcessPath     thisProcessName GetModuleFileName(NULL, thisProcessPath, sizeof(thisProcessPath) - 1); GetFullPathName(thisProcessPath, sizeof(thisProcessPath), thisProcessPath, &thisProcessName); *(TCHAR*) ((TCHAR*) (thisProcessName - sizeof(TCHAR))) = 0; //     DLL  thisDllPath   DLL  thisDllName GetModuleFileName(g_hDllInstance, thisDllPath, sizeof(thisDllPath) - 1); GetFullPathName(thisDllPath, sizeof(thisDllPath), thisDllPath, &thisDllName); *(TCHAR*) ((TCHAR*) (thisDllName - sizeof(TCHAR))) = 0; //      ,       if (!lstrcmpi(thisProcessPath, thisDllPath)) return TRUE; //        for (int i = 0; appsToIntercept[i] != 0; i++) { if (!lstrcmpi(thisProcessName, appsToIntercept[i])) { rv = TRUE; break; } } //          ,   if (!rv) return FALSE; //     WinSock2 return installHooks(); } 

इस प्रकार, यदि आवेदन हमारे लिए अज्ञात है, तो हम इसमें लोड नहीं करेंगे। अब हम सीधे WinSock फ़ंक्शन के अवरोधन से निपटेंगे।

समारोह अवरोधन तंत्र

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

यह समझना महत्वपूर्ण है:



सभी DLL, जिनमें सिस्टम लाइब्रेरी और आयात के रूप में PE हेडर में निर्दिष्ट हैं, सीधे उन एप्लिकेशन के एड्रेस स्पेस में लोड किए जाते हैं जो उनका उपयोग करते हैं। तार्किक दृष्टिकोण से, प्रत्येक चल रहे एप्लिकेशन में सिस्टम और अन्य DLL की प्रतियों का अपना अलग सेट होता है।
इस प्रकार, पैकेट को किसी ब्राउज़र में इंटरसेप्ट करने का सबसे आसान तरीका है सिस्टम लाइब्रेरी में कुछ कार्यों के लिए कॉल को इंटरसेप्ट करना जो पैकेट भेजने और प्राप्त करने के लिए जिम्मेदार हैं। इस बिंदु पर, कुछ फिर से पढ़ना बंद कर देंगे, क्योंकि सब कुछ फिर से स्पष्ट है और कुछ भी नया नहीं है, जिसके साथ मैं पूरी तरह से सहमत हूं। लेकिन बाकी सभी के लिए मैं जारी रखूंगा।
अवरोधन विभिन्न स्तरों पर किया जा सकता है: WinHTTP, WinINet, WinSock। मेरे लिए, सबसे सार्वभौमिक WS2_32.DLL लाइब्रेरी से WinSock फ़ंक्शन का अवरोधन प्रतीत होता है। इसकी कमियां हैं, खासकर एचटीटीपीएस के साथ काम करते समय, जहां पैकेट एन्क्रिप्ट किए जाते हैं। HTTPS के लिए, मेरे दृष्टिकोण से, सबसे अच्छा समाधान WinHTTP फ़ंक्शन और / या ओपनएसएसएल लाइब्रेरीज़ को हुक करना होगा। लेकिन एक सरल के साथ शुरू करते हैं।

तो, हम मुख्य बिंदुओं पर प्रकाश डालते हैं जो हमें करने की आवश्यकता है:

1. इंटरसेप्ट होने के लिए फ़ंक्शन का पता निर्धारित करें
2. प्रवेश बिंदु पर एक फ़ंक्शन कॉल को फिर से लिखें, ताकि अपने स्वयं के हैंडलर को बुलाया जाए
3. अपने स्वयं के हैंडलर में, मूल फ़ंक्शन को कॉल करने से पहले कुछ क्रियाएं करें
4. प्रारंभिक फ़ंक्शन को कॉल करें
5. परिणाम सहेजें
6. अपने स्वयं के हैंडलर में, मूल फ़ंक्शन को कॉल करने के बाद कुछ क्रियाएं करें
7. कॉल प्रक्रिया पर परिणाम लौटाएं

विंडोज में पिछड़े संगतता की प्राचीन परंपराओं के अनुसार, विभिन्न कार्यों को कॉल करके एक ही काम करने के कई तरीके हैं, इसलिए हम उन सभी को पकड़ने की कोशिश करेंगे। हमारे कार्य के लिए, WS2_32 से निम्नलिखित को रोकना पर्याप्त होना चाहिए:

• भेजें ()
• WSASend ()
• पुनरावृत्ति ()
• WSARecv ()
• WSAGetOverlappedResult ()
• कनेक्ट ()
• WSAConnect ()
• बंद करने वाला ()

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

 //      typedef struct _APIHOOK { BOOL isInstalled; //    ? const TCHAR *moduleName; //   () const TCHAR *functionName; //    LPVOID newAddr; //    LPVOID oldAddr; //    DWORD oldCodeSize; //      char newCode[HOOK_CODE_SIZE]; //   char oldCode[HOOK_CODE_SIZE]; //   } APIHOOK, *PAPIHOOK; 

HOOK_CODE_SIZE क्या है और इस पर क्या निर्भर करता है, इसके बारे में पढ़ें।

थोड़ा सा असेंबलर

प्रवेश बिंदु पर फ़ंक्शन कॉल को इंटरसेप्ट करने के लिए, हमें कोड को पैच करना होगा। तो, सबसे सरल एल्गोरिथ्म यह होगा:

1. अपने हैंडलर को परिभाषित करें।
   इस स्थिति में, कॉल का प्रकार cdecl या stdcall, साथ ही सभी इनपुट पैरामीटर, मूल फ़ंक्शन में बिल्कुल समान होना चाहिए, अन्यथा हम स्टैक को दूषित करेंगे।
2. हमारे लिए रुचि के कार्य में प्रवेश बिंदु निर्धारित करें
   इसके साथ, सब कुछ सरल है, आपको कर्नेल 32.dll से GetProcAddress () को कॉल करने की आवश्यकता है।
3. फंक्शन एंट्री पॉइंट से कोड सेव करें
   यहाँ भी, सब कुछ सरल है - एकांत स्थान पर बाइट द्वारा प्रतिलिपि
4. पैच एंट्री पॉइंट
   मोटे तौर पर, यह सब प्रवेश बिंदु पर कोड को फिर से लिखने के लिए नीचे आता है ताकि जब आप इसे कॉल करते हैं, तो हमारे पहलवान को संक्रमण हो

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

 MyFuncHandler: <blablablablabla> OriginalFunction: JMP MyFunHandler 

यह अत्यंत सरल है और एक 32-बिट अभिव्यक्ति में 5 बाइट्स की आवश्यकता होती है, एक JMP बिना शर्त कूद अनुदेश कोड और चार रिश्तेदार पते के लिए। रिश्तेदार क्यों, बाद में। दूसरे मामले में, अवधारणा थोड़ी अलग है:

 MyFuncHandler: <blablablablabla> OriginalFunction: PUSH MyFuncHandler RETN 

इसके लिए 6 बाइट्स की आवश्यकता होती है - निर्देश कोड PUSH <32-बिट DWORD> और RETN के लिए दो बाइट्स और एक निरपेक्ष पते के लिए चार। हाँ, हाँ। पहले मामले में, पता निष्पादन योग्य कोड के वर्तमान पते के सापेक्ष माना जाता है। दूसरे में, यह स्थिर है और पते की जगह की शुरुआत के सापेक्ष माना जाता है। मैं पहली विधि जाऊंगा।
हम इंटरसेप्टर इंस्टॉलर लिखते हैं:

 //    #define HOOK_CODE_SIZE 5 // JMP XX XX XX XX //    BOOL hookInstall(PAPIHOOK thisHook) { UCHAR asmJMP = 0xE9; if (!thisHook || thisHook->isInstalled == TRUE) { SetLastError(ERROR_ALREADY_EXISTS); return FALSE; //   ,      } //      if (thisHook->moduleName && thisHook->functionName && !(thisHook->oldAddr = GetProcAddress( GetModuleHandle(thisHook->moduleName), thisHook->functionName) ) ) { SetLastError(ERROR_NOT_FOUND); return FALSE; //   ,      } //      if (IsBadReadPtr(thisHook->oldAddr, HOOK_CODE_SIZE)) { SetLastError(ERROR_INVALID_ADDRESS); return FALSE; //   } //            if ( *(DWORD*)((PBYTE) thisHook->oldAddr + 1) == ((DWORD) thisHook->newAddr - (DWORD) thisHook->oldAddr - HOOK_CODE_SIZE) && *(BYTE*) thisHook->oldAddr == asmJMP) { return TRUE; //       ,     } //           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; //     } //       memcpy(thisHook->oldCode, thisHook->oldAddr, HOOK_CODE_SIZE); //  JMP thisHook->newCode[0] = asmJMP; //    *(DWORD *) &thisHook->newCode[1] = ((DWORD) thisHook->newAddr - HOOK_CODE_SIZE - (DWORD) thisHook->oldAddr); //     thisHook->isInstalled = TRUE; //      #define hookEnable(p) memcpy(p->oldAddr, p->newCode, HOOK_CODE_SIZE); //      #define hookDisable(p) memcpy(p->oldAddr, p->oldCode, HOOK_CODE_SIZE); //   hookEnable(thisHook); return TRUE; } 

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

 //     BOOL hookRemove(PAPIHOOK thisHook) { //   ,     if (!thisHook->isInstalled) return FALSE; //    hookDisable(thisHook); //      thisHook->isInstalled = FALSE; //        thisHook->newAddr = (LPVOID) NULL; thisHook->oldAddr = (LPVOID) NULL; return TRUE; } 

अब जब हम जानते हैं कि प्रक्रिया में घुसपैठ कैसे करें, सेट करें, निकालें, चालू करें और जाल बंद करें, यह हमारे अपने हैंडलर करने का समय है।

विनसॉक नेटिव फंक्शन हैंडलर

तो, शुरुआत के लिए, आइए इंटरसेप्टेड फ़ंक्शंस के प्रोटोटाइप की एक सरणी को परिभाषित करें। जैसा कि ऊपर बताया गया है, हम केवल सबसे आवश्यक कार्यों को रोकने की कोशिश करेंगे:

 //      #define DECLARE_HOOK(module, name) {0, module, #name, my_##name} //       APIHOOK hookList[] = { DECLARE_HOOK(winSockDll, send), DECLARE_HOOK(winSockDll, WSASend), DECLARE_HOOK(winSockDll, recv), DECLARE_HOOK(winSockDll, WSARecv), DECLARE_HOOK(winSockDll, WSAGetOverlappedResult), DECLARE_HOOK(winSockDll, closesocket), 0}; 

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

 int WSAAPI my_send(SOCKET s, char *buf, int len, int flags) { PAPIHOOK thisHook = hookFind(my_send); if (NULL == thisHook) return (int) 0; hookDisable(thisHook); int rv; rv = send(s, buf, len, flags); hookEnable(thisHook); return rv; } 

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

 //        #define DEFINE_HOOK(RTYPE, CTYPE, NAME, ARGS)\ RTYPE CTYPE my_##NAME ##ARGS \ { \ PAPIHOOK thisHook = hookFind(my_##NAME); \ if (NULL == thisHook) \ return (RTYPE) 0; \ hookDisable(thisHook); \ RTYPE rv; 

और समारोह से बाहर निकलने के लिए भी:

 //        #define LEAVE_HOOK() } \ hookEnable(thisHook); \ return rv; 

अगला, हम सरणी से शेष जाल को निर्धारित करने के लिए इन मैक्रो का उपयोग करते हैं।

जाल की स्थापना

हमारे ओनलॉड में अंतिम पंक्ति () एक निश्चित मैजिक फंक्शन इंस्टॉलहूक () कहती है। चूंकि हमारे पास समाधान के सभी घटक हैं, हम सभी परिभाषित जाल की एक बैच स्थापना लिखेंगे:

 //      BOOL installHooks() { BOOL rv = FALSE; for (int i = 0; hookList[i].moduleName; i++) { if (hookInstall(&hookList[i])) rv = TRUE; } return rv; } 

तो संक्षेप में। और बैच ट्रैप हटाने कोई कम संक्षिप्त नहीं है:

 //      BOOL removeHooks() { BOOL rv = FALSE; for (int i = 0; hookList[i].moduleName; i++) { if (hookRemove(&hookList[i])) rv = TRUE; } return rv; } 

HTTP पैकेट कैप्चर

खैर, हम आसानी से सबसे दिलचस्प हो गए। तो, हमारे पास दो प्रकार के पैकेट हैं - HTTP अनुरोध और HTTP प्रतिक्रियाएं। तदनुसार, पूर्व को प्रकार भेजने के कार्यों द्वारा भेजा जाता है (), बाद के प्रकार के कार्यों द्वारा स्वीकार किए जाते हैं ()। भेजें कार्यों को मूल कोड कहते हुए पहले से ही इंटरसेप्ट किया जाना चाहिए, जबकि भेजें बफर अभी भी प्राचीन है। रिसेप्शन फ़ंक्शंस, क्रमशः इंटरसेप्ट किए जाने चाहिए, क्योंकि प्रारंभिक कोड निष्पादित किया जाता है, अन्यथा हम यह नहीं देखते हैं कि वास्तव में क्या स्वीकार किया जाता है।
अतुल्यकालिक कार्य भी हैं। विचार सरल है। WSASend () या WSARecv () कॉल करते समय, WSAOVERLAPPED संरचना निर्दिष्ट की जाती है जिसमें ईवेंट पंजीकृत है। एसिंक्रोनस फ़ंक्शंस तुरन्त समाप्त हो जाते हैं, और पूरा होने पर SOCKET_ERROR को GetLastError () के साथ WSA_IO_PENDING पर सेट करें। अगला, मुख्य एप्लिकेशन किसी भी तरह से किसी ईवेंट का इंतजार करता है, उदाहरण के लिए WaitForSingleObject (), और जैसे ही ईवेंट की स्थिति सेट होती है, एप्लिकेशन WSAGetOverlappedResult () के माध्यम से बफर पढ़ता है।
यदि आप सिंक्रोनस फ़ंक्शंस से डेटा निकालते हैं, तो यह मुश्किल नहीं है, लेकिन एसिंक्रोनस के साथ आपको थोड़ी छेड़छाड़ करनी होगी। पोस्ट की शुरुआत में, मैंने उल्लेख किया कि आप पूरी तरह से संदर्भों से छुटकारा पाने में सक्षम नहीं होंगे, और अतुल्यकालिक संचालन क्यों हैं। अधिक विस्तार से। WSAGetOverlappedResult () कॉल भेजने या प्राप्त करने वाले बफर के बारे में कोई जानकारी नहीं लेती है। इसलिए, यह स्पष्ट है कि आपको एक संदर्भ बनाने और वहां एक बफर को पॉइंटर स्टोर करने की आवश्यकता है।
संदर्भ की आवश्यकता है एक और कारण है। चूंकि हमारे कार्य, स्ट्रीमिंग वीडियो के अवरोधन के लिए HTTP अनुरोधों और प्रतिक्रियाओं की आवश्यकता होती है, इसलिए सबसे तर्कसंगत समाधान जोड़े में भेजने (), recv () के लिए अलग-अलग कॉल एकत्र करना है। तो, आइए संदर्भ के लिए एक संरचना बनाएं, जो HTTP अनुरोधों और प्रतिक्रियाओं के जोड़े को इकट्ठा करने और साथ काम करने के लिए उपयुक्त होगी
अतुल्यकालिक कार्य:

 struct REQUEST { SOCKET socket; char *request; LPWSABUF wsaBuf; PREQUEST next; } 

हमें उपरोक्त सभी की आवश्यकता क्यों है? सॉकेट नंबर द्वारा, हम अनुरोध और प्रतिक्रिया के पत्राचार का निर्धारण करेंगे। यही है, मुख्य आवेदन उसी टीसीपी सॉकेट पर एक अनुरोध भेजता है और प्राप्त करता है, अन्यथा यह नहीं हो सकता। अनुरोध सूचक HTTP अनुरोध को संदर्भित करेगा। LPWSABUF पॉइंटर का उपयोग अतुल्यकालिक कार्यों के लिए किया जाएगा। यही है, जब WSASend () / WSARecv () कहा जाता है, तो हम सूचक को बफर में सहेजेंगे, और WSAGetOverlappedResult () के पूरा होने पर, हम इसे वहां से हटा देंगे। फिर से, सॉकेट नंबर के माध्यम से मिलान निर्धारित किया जाता है।
आगे देखते हुए, मैं कहता हूं कि WSASend () के लिए, अतुल्यकालिक कॉल का उपयोग उन किसी भी ब्राउज़र में नहीं किया जाता है जिसे मैं इस पोस्ट के लेखन और इंटरसेप्टर रिक्त के दौरान परीक्षण करने में कामयाब रहा हूं।
आगे क्या है? एक जुड़े लिंक सूची को व्यवस्थित करने के लिए। यह तर्कसंगत है कि अनुरोध-प्रतिक्रिया जोड़े के संदर्भों को कहीं रखा जाना चाहिए ताकि वे खो न जाएं। कार्यक्रम के आकार को बढ़ाने और एसटीएल टेम्प्लेट जैसी किसी चीज़ का उपयोग न करने के लिए, मेरे लिए स्कूल ओलंपियाड के लिए समस्या को हल करना और बस कनेक्टेड सूची के कार्यान्वयन को लिखना आसान था। यह आपके लिए बेहतर होगा, अपने लिए देखें।
विस्तार में जाने के बिना, हम अनुरोध-प्रतिक्रिया संदर्भों की लिंक की गई सूची के साथ काम करने के लिए कार्यों का वर्णन करते हैं (विवरण के लिए स्रोत देखें):

 //      PREQUEST findRequest(SOCKET s); //    -     PREQUEST addRequest(SOCKET s, char *request); //     void delRequest(SOCKET s); 

अगला, हम सभी भेजने () कार्यों के लिए एक सामान्य हैंडलर लिखते हैं:

 //      BOOL commonSendHandler(PAPIHOOK thisHook, SOCKET s, char *buf, int len, BOOL isWsa) { //      'GET '    if … //  HTTP  char *request = getHttpHeaders((const char *) buf, len); if (request != NULL) addRequest(s, request); return TRUE; } 

और सभी रिकव के लिए एक सामान्य हैंडलर ():

 //           BOOL commonRecvHandler(PAPIHOOK thisHook, SOCKET s, char *buf, int len, BOOL isWsa) { //      'HTTP'    if … //  ,    PREQUEST req = findRequest(s); if (NULL == req) return FALSE; //  HTTP  char *response = getHttpHeaders((const char *) buf, len); if (response != NULL) { //       ... delRequest(s); } return TRUE; } 

टेलीमार्केटिंग। मैं उन लोगों के लिए समझाऊंगा जो अभी भी पकड़ रहे हैं। पैकेट भेजते समय, शुरुआत में 'GET' की उपस्थिति के लिए उनकी सामग्री की जाँच की जाती है। HTTP GET HTTP . 'HTTP' , GET . . %TEMP%\< .exe>-< >.log
. , WSARecv():

 // WSARecv() DEFINE_HOOK(int, WSAAPI, WSARecv, (SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesRecvd, LPDWORD lpFlags, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)) { rv = WSARecv(s, lpBuffers, dwBufferCount, lpNumberOfBytesRecvd, lpFlags, lpOverlapped, lpCompletionRoutine); //   if (!rv && NULL != lpNumberOfBytesRecvd) { commonRecvHandler(thisHook, s, lpBuffers->buf, *lpNumberOfBytesRecvd, TRUE); } else //   if (rv == SOCKET_ERROR && WSAGetLastError() == WSA_IO_PENDING) { //  WSARecv ,   WSA ,     PREQUEST req = findRequest(s); if (req != NULL) req->wsaBuf = lpBuffers; } LEAVE_HOOK(); } 

, . read():

 // WSAGetOverlappedResult() DEFINE_HOOK(BOOL, WSAAPI, WSAGetOverlappedResult, (SOCKET s, LPWSAOVERLAPPED lpOverlapped, LPDWORD lpcbTransfer, BOOL fWait, LPDWORD lpdwFlags)) { rv = WSAGetOverlappedResult(s, lpOverlapped, lpcbTransfer, fWait, lpdwFlags); if (rv && NULL != lpcbTransfer && *lpcbTransfer > MIN_HTTP_HEADER_SIZE) { // ,    ? PREQUEST req = findRequest(s); if (req != NULL && req->wsaBuf != NULL) commonRecvHandler(thisHook, s, req->wsaBuf->buf, *lpcbTransfer, TRUE); } LEAVE_HOOK(); } 

closesocket() , . , , , , YouTube…

Google Chrome www.youtube.com/watch?v=o78nFVB1tJA ( ):

 [22:28:48] [SOCKET = 0EB0, REQUEST = 1327 bytes, RESPONSE = 329 bytes] ->GET /videoplayback?algorithm=throttle-factor&burst=40&cp=U0hTS1RRU19OTUNOM19MS1dBOlR1eGNSd1JHRkdy&expire=1346465093&factor=1.25&fexp=926900%2C910103%2C922401%2C920704%2C912806%2C924412%2C913558%2C912706&gcr=fi&id=a3bf27155075b490&ip=91.155.190.10&ipbits=8&itag=34&keepalive=yes&key=yt1&ms=au&mt=1346441292&mv=m&range=13-1781759&signature=7415093589702691B2E46681B2EF24EC370C2F1F.D6D55168E2211687994A3F47D8919AC5470C567D&source=youtube&sparams=algorithm%2Cburst%2Ccp%2Cfactor%2Cgcr%2Cid%2Cip%2Cipbits%2Citag%2Csource%2Cupn%2Cexpire&sver=3&upn=GlJDbjcQ-2w HTTP/1.1 Host: oo---preferred---elia-hel1---v11---lscache1.c.youtube.com Connection: keep-alive User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.4 (KHTML, like Gecko) Chrome/22.0.1229.26 Safari/537.4 Accept: */* Referer: http://www.youtube.com/watch?v=o78nFVB1tJA Accept-Encoding: gzip,deflate,sdch Accept-Language: en-US,en;q=0.8 Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3 Cookie: VISITOR_INFO1_LIVE=UxycPwPFJBs; __utma=27069237.1349026492.1343302158.1343302158.1343302158.1; __utmz=27069237.1343302158.1.1.utmcsr=(direct)|utmccn=(direct)|utmcmd=(none); use_hitbox=d5c5516c3379125f43aa0d495d100d6ddAEAAAAw; recently_watched_video_id_list=697d12b6b10771c1d93bb1bb4cf53148WwEAAABzCwAAAG83OG5GVkIxdEpB; PREF=fv=11.3.31; ACTIVITY=1346441327664 <-HTTP/1.1 200 OK Last-Modified: Wed, 09 May 2012 00:20:14 GMT Content-Type: video/x-flv Date: Fri, 31 Aug 2012 19:28:48 GMT Expires: Fri, 31 Aug 2012 19:28:48 GMT Cache-Control: private, max-age=23465 Accept-Ranges: bytes Content-Length: 1781747 Connection: keep-alive X-Content-Type-Options: nosniff Server: gvs 1.0 

HTTP .

- , ? , .

निष्कर्ष

. IPC -. :

1. URL .
2. . IPC, , .
3. .

. YouTube / Flash Video. . 90% ”Content-type”.
:

• .
  , . , . - , .
• एचटीटीपीएस को बाधित करने की असंभवता
  वास्तव में, मुझे एनडीआईएस मिनिपोर्ट ड्राइवर के मामले में एचटीटीपीएस को बाधित करने की संभावना भी नहीं दिखती है। फिर भी, यह तकनीक आपको किसी अन्य लाइब्रेरी जैसे WinHTTP या OpenSSL के स्तर पर ऐसा करने की अनुमति देती है।

और क्या? दो पहलू:

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

आशा है कि यह पोस्ट किसी के लिए दिलचस्प होगी।

UPD: दूसरे भाग में लगातार लिखे गए कोड के बिना ट्रैप के बारे में लिखा जाता है ।

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