इंटरसेप्ट रैपिंग लाइब्रेरी

सभी को शुभ दिन!
हाल ही में, मैंने अपने इंटरसेप्टर ( यहां ) के कार्यान्वयन को निर्धारित किया।
यह निकला, ईमानदार, बोझिल और अनाड़ी काम करने वाला। टिप्पणियों में से 1 में, सम्मानित k_d ने सदस्यता समाप्त कर ली और mhook ( MHook बनाम Zuma ) पर अपने आवरण का उल्लेख किया।
बेशक, मुझे एक ऐसे विकल्प में दिलचस्पी थी जो न केवल __cdecl के साथ अवरोधन के साथ काम करता है, बल्कि इसके अलावा, यह अवरोधन को कोड में लगभग कहीं भी रखने की अनुमति देता है।
मुझे इसका समाधान पसंद आया और मैंने अपनी लाइब्रेरी को फिर से लिखने का फैसला किया, जिसका उपयोग मैं विभिन्न प्रकार के अवरोधन के लिए करता हूं, सफाई से, डी_डी से सामग्री का उपयोग करके। वर्तमान संस्करण सब कुछ अवरोध कर सकता है जो एक प्रोग्रामर के हड़ताली-प्रयोगात्मक हाथ पहुंचते हैं और स्टैक से तर्क को पार्स करते हैं (कम से कम, संभवतः, विचार यह कर सकता है। संभवतः।)
मैं आपके ध्यान को प्रस्तुत करता हूं कि क्या हुआ।


कामकाजी पुस्तकालय को संकलित करने के लिए, आपको MHook की जरूरत है, k_d से एक आवरण, मध्यम सीधे हाथ, मेज के नीचे से एक सिर और परामर्श के लिए एक बतख: बतख ।

तो चलिए!

मैं) कार्यशीलता:

1) लॉग आउटपुट फाइल करने के लिए:

void debug_msg(const char* func_name, const char* txt,...) { va_list args; FILE *file; char file_name[256]="\0"; strcpy(file_name,"C:\\VariadicDump\\"); strcat(file_name,func_name); strcat(file_name,".txt"); fopen_s(&file,file_name, "a"); va_start(args,txt); vfprintf(file,txt,args); va_end (args); fprintf(file, "\n"); fclose(file); } 

का उपयोग करें:

 debug_msg("Advanced", "--%s arg list started--", funcName); 

FuncName = "हैलो, दुनिया के साथ, आप इस संदेश को कई बार पढ़ते हैं" हमें निम्न सामग्री के साथ C: \ VariadicDump \ Advanced.txt फाइल मिलती है:

--Hello, world, you read this message so many times arg list started--


2) पार्स lua_State (इस फ़ंक्शन के लिए केवल इनिशियलाइज़ और निजी के लिए! उपयोगी, उदाहरण के लिए, चैट को इंटरसेप्ट करने के लिए MMO रून्स ऑफ़ मैजिक में, अन्य मामलों में मैंने इसका उपयोग नहीं किया है):

 void Parse_LuaState(lua_State *L, const char *func_name) { int n = lua_gettop(L); std::vector<const char*> names; for(int i = 0; i < n; i++) { size_t arg2Len = 0; names.push_back(luaL_checklstring(L, i, &arg2Len)); } string str = ""; for (unsigned int i=0; i<names.size(); i++) { str.append(names[i]); str.append("; "); } debug_named_msg(func_name, str.c_str()); } 

का उपयोग करें:

 void lua_hook(lua_State *L) { Parse_LuaState(L, "Lua"); } 

उदाहरण के लिए, * L के पास 2 तर्क थे - चैट और पाठ का प्रकार (1 और "हैलो, दुनिया, क्या आप इसे फिर से सुनने के लिए नफरत करते हैं?")। फ़ंक्शन "C: \ VariadicDump \ Lua.txt" के लिए निम्नलिखित लिखेगा:

1; hello, world, are you hate to hear it again?


3) स्टैक से पार्सिंग तर्क:

 void parseArgs(int *ptr, int size, char* funcName) { debug_msg("Advanced", "--%s arg list started--", funcName); for(int i=0; i*4<size; i++) { debug_msg("Advanced", " |---Element %d: %d", i, ptr[i]); } debug_msg("Advanced", "--arg list finished--\n"); } 

का उपयोग करें:

 void con_hook(Context *context) { int *ptr = (int*)(void*)(context->ESP+4); parseArgs(ptr, con_arg_amount, __FUNCTION__); } 

नतीजतन, तर्क की गणना एस्प + इंडेक्स * 4 नाम ## _ arg_amount / 4 बार से की जाएगी।
एक अच्छे तरीके से, वहाँ तर्कों की संख्या को पारित करना अधिक सही और अधिक सुंदर है, लेकिन यदि आवश्यक हो तो इसे स्वयं करना मुश्किल नहीं है।

4) इंटरसेप्टेड एप्लिकेशन के मुख्य मॉड्यूल का पता:

 int GetMainModuleAddress() { DWORD dwAddress = NULL; HANDLE hthSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, _getpid()); if (hthSnapshot) { MODULEENTRY32 me = { sizeof(me) }; if (Module32First(hthSnapshot, &me)) { CloseHandle(hthSnapshot); dwAddress = (DWORD)me.modBaseAddr; } } return dwAddress; } 

कुछ विशेष, आवश्यक, उदाहरण के लिए, दरार में - आभासी पते की गणना निम्नानुसार की जाती है:

 #define RECALC(name)\ name##_Detour = (t##name)((int)name##_Detour-0x400000+rift); 

जहां ## _ डेटौर नाम दिया गया है।

5) संलग्न / अलग कार्य:

स्प्रिंगबोर्ड स्थापित / हटाने के लिए सरल आवरण। हमें DllMain की खोज में कोड पर चढ़ने के लिए विशुद्ध रूप से आवश्यकता है :)

सूची में अंतिम, लेकिन हमारे दिलों में अंतिम नहीं है और कार्यक्षमता में उपयोगिता - unhook'er:

 BOOL UnHookFunction(DWORD addr, unsigned char *lpBackup) { DWORD dwAddr = addr; if (WriteProcessMemory(GetCurrentProcess(), (LPVOID)dwAddr, lpBackup, 6, 0)) return TRUE; return FALSE; } 

यह बस और स्वादपूर्वक उस कोड को पुनर्स्थापित करता है जिसमें स्प्रिंगबोर्ड खड़ा था।

II) मैक्रों

मैक्रोज़ इस परियोजना की मुख्य विशेषता है, जो वास्तव में, छोटे हिस्से को अश्लील रूप से काम करने की अनुमति देता है।

1) RECALC:

 #define RECALC(name)\ name##_Detour = (t##name)((int)name##_Detour-0x400000+rift); 

पता अनुवाद के लिए आवश्यक है, ऊपर उल्लेखित है।

2)

 #define DETACH(name1)\ UnHookFunction((DWORD)name1##_Detour,name1##_var);\ 

पलटाव पर एक आवरण ... स्प्रिंगबोर्ड से कोड जारी करना।

3) एटीआर / एटीआर_आर:

 #define ATR(name)\ name##_var = RegHook((long)name##_Detour, (long)(void*)name##_hook) #define ATR_R(name)\ RECALC(name)\ name##_var = RegHook((long)name##_Detour, (long)(void*)name##_hook) 

स्प्रिंगबोर्ड की स्थापना के लिए दो जुड़वां भाई। RegHook - Mhook पर एक आवरण समारोह, विवरण स्रोत में या में पढ़ा जा सकता है। एक ही लेख में कहा गया है कि कॉन्टेक्स्ट है और क्या खाना है, इसलिए सैर के दौरान नग्न नहीं दौड़ना चाहिए और कोहरे से बाहर हेजहोग को नहीं बुलाना है (बस मजाक कर रहे हैं, कोई भी आपको यह नहीं बताएगा)।

संलग्न () फ़ंक्शन में उपयोग किया जाता है;

4) डीटीआर:

 #define DTR(name)\ DETACH(name) 

लपेटें पर लपेटें।
विवादास्पद आवश्यकता, लेकिन यह एटीआर ^ ^ के बगल में और अधिक खूबसूरती से पढ़ता है (डीटैच युग का एक अवशेष है, इसे हटाने के लिए एक दया है)।

टुकड़ी () फ़ंक्शन में उपयोग किया जाता है;

5) RF_O_UP_FUNC_CONTEXT:

 #define RF_O_UP_FUNC_CONTEXT(name1, adres, args)\ typedef void (__cdecl * t##name1 ) ();\ t##name1 name1##_Detour = ( t##name1 ) ( adres );\ /* */ void name1##_hook(Context *context);\ /*     ;   - */ BYTE *name1##_var;\ /*    */ int name1##_arg_amount = args;\ /*  ,   (. )*/ 

इस गांव में सबसे चालाक मैक्रो है। असल में, वह इंटरसेप्टर और एक इंटरसेप्टेड फ़ंक्शन को घोषित करने में लगा हुआ है, स्प्रिंगबोर्ड आदि से सोर्स कोड को बचाने के लिए एक वैरिएबल की घोषणा कर रहा है।

एक उदाहरण:

 RF_O_UP_FUNC_CONTEXT(con, 0x60D710, 0x8); 

हम 2 फ़ंक्शन घोषित करते हैं - con_Detour और con_hook, इंटरसेप्टेड फ़ंक्शन को 0x60D710 पते पर बाँधते हैं और इंगित करते हैं कि अगर हमें तर्कों का विश्लेषण करने की आवश्यकता है, तो हमें आउटपुट में 2 टुकड़े मिलेंगे।

III) केस स्टडी

 RF_O_UP_FUNC_CONTEXT(con, 0x60D710, 0x8); void lua_hook(Context *context) { int *ptr = (int*)(void*)(context->ESP+4); //  1      ptr parseArgs(ptr, con_arg_amount, __FUNCTION__); //    , 2  -     ! debug_msg("LuaDump", "%s", ptr[0]); // 1   -   .. } 

काम करने के लिए dll के लिए, आपको lua से कुछ की आवश्यकता हो सकती है, साथ ही khd से mhook + एक आवरण भी मिल सकता है।

यहां आप लाइब्रेरी सोर्स डाउनलोड कर सकते हैं।

उत्कृष्ट काम और विचार के लिए भी k_d को फिर से धन्यवाद!

आप सभी को धन्यवाद, ऑल द बेस्ट! और हाँ बतख जीत जाएगा! नीम हकीम!