प्रस्तावना

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

अंत में, अनुसंधान के एक पूरे सप्ताह के बाद, मैंने इसे किया। आपके ध्यान के लिए एक सरल विधि प्रदान की गई है:

protected string CompareOneAndTwo() { int a = 1; int b = 2; if (a < b) { return "Number 1 is less than 2"; } else { return "Number 1 is greater than 2 (O_o)"; } } 

जैसा कि आप देख सकते हैं, यह "नंबर 1 2 से कम है"। आइए इस गलतफहमी को दूर करने का प्रयास करें और इस पद्धति को बदलने की कोशिश करें ताकि लौटा परिणाम "संख्या 1 2 (O_o)" से अधिक हो।
इस विधि के लिए MSIL कोड को देखकर, हम Bt_S opcode को Blt_S के साथ बदलकर अपना लक्ष्य प्राप्त कर सकते हैं।

और यदि आप डेमो एप्लिकेशन चलाते हैं, तो यह आपको गलत परिणाम दिखाएगा।

नीचे IL की जगह कोड दिया गया है। मेरा मानना ​​है कि कोड को समझने के लिए पर्याप्त टिप्पणियां हैं।

 //    Type type=this.GetType(); MethodInfo methodInfo=type.GetMethod("CompareOneAndTwo", BindingFlags.NonPublic|BindingFlags.Instance); // ,   ,  //     ,   ,  JIT //     ,       JIT-  :) RuntimeHelpers.PrepareMethod(methodInfo.MethodHandle); //  IL-   byte[] ilCodes=methodInfo.GetMethodBody().GetILAsByteArray(); //       //      for (int i=0; i<ilCodes.Length; i++) { if (ilCodes[i]==OpCodes.Bge_S.Value) { // Bge_S  Blt_S ilCodes[i]=(byte)OpCodes.Blt_S.Value; } } // IL- InjectionHelper.UpdateILCodes(methodInfo, ilCodes); 

आप अपने लिए एक डेमो डाउनलोड कर सकते हैं और कोशिश कर सकते हैं।

• .NET 2.0 से 4.0 का समर्थन करता है
• यह कई प्रकार के तरीकों का समर्थन करता है, जिसमें गतिशील और सामान्य तरीके शामिल हैं।
• .NET अनुप्रयोगों के रिलीज़ संस्करण का समर्थन करता है
• X86 और x64 का समर्थन करता है

कोड का उपयोग

InjectionHelper.cs की प्रतिलिपि बनाएँ, जिसमें आपके प्रोजेक्ट में आवश्यक विधियाँ समाहित हैं।

 public static class InjectionHelper { // Load the unmanaged injection.dll, the initlaization happens in a background thread // you can check if the initialization is completed by GetStatus() public static void Initialize() // Unload the unmanaged injection.dll public static void Uninitialize() // Update the IL Code of a Method. public static void UpdateILCodes(MethodInfo method, byte[] ilCodes) // The method returns until the initialization is completed public static Status WaitForIntializationCompletion() // Query the current status of the unmanaged dll, returns immediately. public static Status GetStatus() } 

Injectionhelper :: आरंभिक विधि में injection.dll लोड होता है, जिसमें असेंबली कोड होता है, उस डायरेक्टरी से जिसमें असेंबली स्थित होती है, इसलिए वे सभी फाइलें जिन्हें आप संशोधित करना चाहते हैं, होनी चाहिए। या आप स्रोत को ठीक कर सकते हैं, जैसा कि आप पसंद करते हैं :)
फ़ाइल सूची:

फ़ाइल का नाम	विवरण
Injection32.dll	अप्रबंधित dll हमारे कार्य (x86 संस्करण) का प्रदर्शन कर रहा है
Injection64.dll	अप्रबंधित dll हमारे कार्य का प्रदर्शन कर रहा है (x64 संस्करण)
EasyHook32.dll	x86 इज़ीहुक डीएलएल (http://easyhook.codeplex.com/) (इंजेक्शन32.dll का उपयोग करके)
EasyHook64.dll	X64 EasyHook DLL (http://easyhook.codeplex.com/) (Injection64.dll का उपयोग करके)
x86 / *	X86 के लिए विंडोज डिबग टूल
x64 / *	X64 के लिए विंडोज डिबग टूल
PDB_symbols / *	पीडीबी फाइलें। उन्हें हटाया जा सकता है, लेकिन यह आरंभ को धीमा कर देगा।

पर्दे के पीछे

आइए पहले देखें कि सीएलआर और जेआईटी कैसे काम करते हैं।

JIT का वर्णन करने वाली लाइब्रेरी (.NET 2.0 के लिए .NET 4.0 / mscorwks.dll के लिए clr.dll) + _stdcall getJit विधि प्रदान करती है, जो ICorJitCompiler इंटरफ़ेस लौटाती है।
CLR (.NET 4.0 / mscorwks.dll .NET 2.0 के लिए clr.dll) का वर्णन करने वाला एक पुस्तकालय ICJJitCompiler इंटरफ़ेस प्राप्त करने के लिए गेट विधि को कॉल करता है।

 CorJitResult compileMethod(ICorJitInfo * pJitInfo, CORINFO_METHOD_INFO * pMethodInfo, UINT nFlags, LPBYTE * pEntryAddress, ULONG * pSizeOfCode); 

यह हिस्सा आसान है, आपको बस संकलनमिथोड विधि का पता ढूंढना होगा और इसे EasyHook के साथ बदलना होगा।

 // ICorJitCompiler interface from JIT dll class ICorJitCompiler { public: typedef CorJitResult (__stdcall ICorJitCompiler::*PFN_compileMethod)(ICorJitInfo * pJitInfo, CORINFO_METHOD_INFO * pMethodInfo, UINT nFlags, LPBYTE * pEntryAddress, ULONG * pSizeOfCode); CorJitResult compileMethod(ICorJitInfo * pJitInfo, CORINFO_METHOD_INFO * pMethodInfo, UINT nFlags, LPBYTE * pEntryAddress, ULONG * pSizeOfCode) { return (this->*s_pfnComplieMethod)( pJitInfo, pMethodInfo, nFlags, pEntryAddress, pSizeOfCode); } private: static PFN_compileMethod s_pfnComplieMethod; }; //    LPVOID pAddr = tPdbHelper.GetJitCompileMethodAddress(); LPVOID* pDest = (LPVOID*)&ICorJitCompiler::s_pfnComplieMethod; *pDest = pAddr; //    compileMethod CorJitResult __stdcall CInjection::compileMethod(ICorJitInfo * pJitInfo , CORINFO_METHOD_INFO * pCorMethodInfo , UINT nFlags , LPBYTE * pEntryAddress , ULONG * pSizeOfCode ) { ICorJitCompiler * pCorJitCompiler = (ICorJitCompiler *)this; // TO DO:  IL-     CorJitResult result = pCorJitCompiler->compileMethod( pJitInfo, pCorMethodInfo, nFlags, pEntryAddress, pSizeOfCode); return result; } //    JIT-    NTSTATUS ntStatus = LhInstallHook( (PVOID&)ICorJitCompiler::s_pfnComplieMethod , &(PVOID&)CInjection::compileMethod , NULL , &s_hHookCompileMethod ); 

JIT संकलित विधियों के लिए IL कोड बदलना

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

हां, यह यह आरेख है जो पुराना है, लेकिन समग्र संरचना संरक्षित है। .NET में प्रत्येक वर्ग में मेमोरी में कम से कम एक MethodTable संरचना होती है। और प्रत्येक मेथडटेबल संरचना एक ईईसीलैस से जुड़ी है जो प्रतिबिंब और अन्य उद्देश्यों के लिए रनटाइम जानकारी संग्रहीत करती है।
प्रत्येक विधि के लिए, कम से कम एक MethodDesc संरचना होती है जिसमें झंडे, स्लॉट पते, इनपुट पता आदि के बारे में जानकारी होती है।
विधि JIT- संकलित होने से पहले, स्लॉट एक JMI कनवर्टर को इंगित करता है, जो JIT संकलन को स्विच करता है; जब आईएल-कोड संकलित किया जाता है, तो जेएमआई को एक सूचक स्लॉट में लिखा जाएगा, और कोड निष्पादन के दौरान सीधे संकलित कोड पर जाएगा।
जानकारी की संरचना को पुनर्स्थापित करने के लिए, आपको पहले झंडे को साफ करना होगा, फिर प्रवेश बिंदु के पते को एक अस्थायी एक आदि में संशोधित करना होगा। परीक्षण के दौरान, मैंने मेमोरी को सीधे बदलकर ऐसा किया। लेकिन यह गंदा है, कम से कम, क्योंकि डेटा संरचनाओं के पते पर निर्भरता है और विभिन्न .NET संस्करणों का कोड अलग है।
मैं सही तरीके की तलाश कर रहा था, और सौभाग्य से, मुझे SSCLI स्रोत कोड (vm / method.cpp) में MethodDesc :: रीसेट विधि मिली।

 void MethodDesc::Reset() { CONTRACTL { THROWS; GC_NOTRIGGER; } CONTRACTL_END //      ,      . //            _ASSERTE(IsEnCMethod() || //     IsDynamicMethod() || GetLoaderModule()->IsReflection()); //    ClearFlagsOnUpdate(); if (HasPrecode()) { GetPrecode()->Reset(); } else { //      Reflection- _ASSERTE(GetLoaderModule()->IsReflection()); InterlockedUpdateFlags2(enum_flag2_HasStableEntryPoint | enum_flag2_HasPrecode, FALSE); *GetAddrOfSlotUnchecked() = GetTemporaryEntryPoint(); } _ASSERTE(!HasNativeCode()); } 

जैसा कि आप देख सकते हैं, यह कोड सही काम करता है। इसलिए, मुझे सिर्फ JIT संकलन से पहले MethodDesc के लिए इसे कॉल करने की आवश्यकता है।
कड़ाई से कहे तो, मैं SSCLI से मेथडेसक का उपयोग नहीं कर सकता, क्योंकि मेथडस्क को माइक्रोसॉफ्ट द्वारा आंतरिक रूप से उपयोग किया जाता है, और कोई नहीं जानता कि इसके कारण क्या हो सकता है।
सौभाग्य से, इस आंतरिक विधि का पता Microsoft प्रतीक सर्वर के PDB c में मौजूद है, और यह मेरी समस्या को हल करता है। सीएलआर डीएलएल में रीसेट () विधि का पता बस पीडीबी पार्स करके पाया जा सकता है!
अब, एक महत्वपूर्ण पैरामीटर बना हुआ है - MethodDesc को यह पॉइंटर। इसे हासिल करना इतना मुश्किल नहीं है। सामान्य तौर पर, MethodBase.MethodHandle.Value == CORINFO_METHOD_HANDLE == MethodDesc पता == MethodDesc को यह पॉइंटर।

 class MethodDesc { typedef void (MethodDesc::*PFN_Reset)(void); typedef BOOL (MethodDesc::*PFN_IsGenericMethodDefinition)(void); typedef ULONG (MethodDesc::*PFN_GetNumGenericMethodArgs)(void); typedef MethodDesc * (MethodDesc::*PFN_StripMethodInstantiation)(void); typedef BOOL (MethodDesc::*PFN_HasClassOrMethodInstantiation)(void); typedef BOOL (MethodDesc::*PFN_ContainsGenericVariables)(void); typedef MethodDesc * (MethodDesc::*PFN_GetWrappedMethodDesc)(void); typedef AppDomain * (MethodDesc::*PFN_GetDomain)(void); typedef Module * (MethodDesc::*PFN_GetLoaderModule)(void); public: void Reset(void) { (this->*s_pfnReset)(); } BOOL IsGenericMethodDefinition(void) { return (this->*s_pfnIsGenericMethodDefinition)(); } ULONG GetNumGenericMethodArgs(void) { return (this->*s_pfnGetNumGenericMethodArgs)(); } MethodDesc * StripMethodInstantiation(void) { return (this->*s_pfnStripMethodInstantiation)(); } BOOL HasClassOrMethodInstantiation(void) { return (this->*s_pfnHasClassOrMethodInstantiation)(); } BOOL ContainsGenericVariables(void) { return (this->*s_pfnContainsGenericVariables)(); } MethodDesc * GetWrappedMethodDesc(void) { return (this->*s_pfnGetWrappedMethodDesc)(); } AppDomain * GetDomain(void) { return (this->*s_pfnGetDomain)(); } Module * GetLoaderModule(void) { return (this->*s_pfnGetLoaderModule)(); } private: static PFN_Reset s_pfnReset; static PFN_IsGenericMethodDefinition s_pfnIsGenericMethodDefinition; static PFN_GetNumGenericMethodArgs s_pfnGetNumGenericMethodArgs; static PFN_StripMethodInstantiation s_pfnStripMethodInstantiation; static PFN_HasClassOrMethodInstantiation s_pfnHasClassOrMethodInstantiation; static PFN_ContainsGenericVariables s_pfnContainsGenericVariables; static PFN_GetWrappedMethodDesc s_pfnGetWrappedMethodDesc; static PFN_GetDomain s_pfnGetDomain; static PFN_GetLoaderModule s_pfnGetLoaderModule; }; 

स्टेटिक वैरिएबल आंतरिक मेथडेस विधियों के पतों को संग्रहीत करते हैं और जब एक अप्रबंधित डीएलएल लोड किया जाता है, तो उन्हें प्रारंभ किया जाता है। और सार्वजनिक तरीके सिर्फ आंतरिक तरीकों को कहते हैं।
अब हम आसानी से Microsoft आंतरिक तरीकों को कॉल कर सकते हैं:

 MethodDesc * pMethodDesc = (MethodDesc*)pMethodHandle; pMethodDesc->Reset(); 

एक पीडीबी फ़ाइल में आंतरिक विधियों के पते ढूँढना

जब एक मानवरहित DLL लोड किया जाता है, तो यह CLR / JIT वातावरण के उस संस्करण की जाँच करता है जिसमें यह लोड किया गया है। और वह पीडीबी फ़ाइल से आंतरिक विधियों के पते प्राप्त करने की कोशिश कर रही है। यदि वे नहीं मिल सके, तो वह Microsoft डीबग सर्वर से संबंधित PDB फ़ाइलों को डाउनलोड करने के लिए Windows Debug Tools से symchk.exe चलाने का प्रयास करेगा। इस प्रक्रिया में कुछ सेकंड से लेकर कई मिनट तक काफी लंबा समय लगता है। शायद हम अपने हैश की गिनती करके सीएलआर / जेआईटी पुस्तकालयों के पते को कैशिंग करके इस प्रक्रिया को गति दे सकते हैं।

गैर-जेआईटी संकलित करने के लिए एक विधि बहाल करना

अब सब कुछ तैयार है। प्रबंधित कोड के लिए अप्रबंधित पुस्तकालय निर्यात विधियों, IL कोड और MethodBase.MethodHandle.Value प्रबंधित कोड से लेता है।

 // structure to store the IL code for replacement typedef struct _ILCodeBuffer { LPBYTE pBuffer; DWORD dwSize; } ILCodeBuffer, *LPILCodeBuffer; // method to be called by managed code BOOL CInjection::StartUpdateILCodes( MethodTable * pMethodTable , CORINFO_METHOD_HANDLE pMethodHandle , mdMethodDef md , LPBYTE pBuffer , DWORD dwSize ) { MethodDesc * pMethodDesc = (MethodDesc*)pMethodHandle; // reset this MethodDesc pMethodDesc->Reset(); ILCodeBuffer tILCodeBuffer; tILCodeBuffer.pBuffer = pBuffer; tILCodeBuffer.dwSize = dwSize; tILCodeBuffer.bIsGeneric = FALSE; // save the IL code for the method s_mpILBuffers.insert( std::pair< CORINFO_METHOD_HANDLE, ILCodeBuffer>( pMethodHandle, tILCodeBuffer) ); return TRUE; } 

यह कोड बस रीसेट करता है () और एक मानचित्र में IL कोड संग्रहीत करता है, जिसका उपयोग compileMethod द्वारा किया जाएगा जब विधि संकलित होती है।
और compileMethod में, बस IL कोड बदलें:

 CorJitResult __stdcall CInjection::compileMethod(ICorJitInfo * pJitInfo , CORINFO_METHOD_INFO * pCorMethodInfo , UINT nFlags , LPBYTE * pEntryAddress , ULONG * pSizeOfCode ) { ICorJitCompiler * pCorJitCompiler = (ICorJitCompiler *)this; LPBYTE pOriginalILCode = pCorMethodInfo->ILCode; unsigned int nOriginalSize = pCorMethodInfo->ILCodeSize; ILCodeBuffer tILCodeBuffer = {0}; MethodDesc * pMethodDesc = (MethodDesc*)pCorMethodInfo->ftn; // find the method to be replaced std::map< CORINFO_METHOD_HANDLE, ILCodeBuffer>::iterator iter = s_mpILBuffers.find((CORINFO_METHOD_HANDLE)pMethodDesc); if( iter != s_mpILBuffers.end() ) { tILCodeBuffer = iter->second; pCorMethodInfo->ILCode = tILCodeBuffer.pBuffer; pCorMethodInfo->ILCodeSize = tILCodeBuffer.dwSize; } CorJitResult result = pCorJitCompiler->compileMethod( pJitInfo, pCorMethodInfo, nFlags, pEntryAddress, pSizeOfCode); return result; } 

सामान्य विधि

जेनेरिक विधि MethodDesc में मेमोरी में प्रदर्शित होती है। लेकिन विभिन्न प्रकार के मापदंडों के साथ जेनेरिक पद्धति को कॉल करने से सीएलआर एक ही विधि के विभिन्न निकाय बना सकते हैं।
नीचे दी गई लाइन एक डेमो प्रोग्राम से एक साधारण जेनेरिक है।

 string GenericMethodToBeReplaced<T, K>(T t, K k) 

GenericMethodToBeReplaced <string, int> ("11", 2) को पहली बार कॉल करके, CLR एक प्रकार की वस्तु बनाता है InstantiatedMethodDesc (MethodDesc का बच्चा, और इसका ध्वज mcInstantied के रूप में चिह्नित है), जो InstMethodHashTash में विधि डेटा संरचना को संग्रहीत करता है।
और GenericMethodToBeReplaced <long, int> (1, 2) कॉल करके, CLR एक और InstantMatedMethodDesc ऑब्जेक्ट बनाता है।
इसलिए, हमें सभी InstantiatedMethodDesc जेनेरिक विधियों को खोजने और उन पर रीसेट करने की आवश्यकता है।
SSCLI स्रोत कोड (vm / proftoeeinterfaceimpl.cpp) में एक LoadedMethodDescIterator वर्ग है जिसका हम उपयोग कर सकते हैं। यह एक इनपुट के रूप में तीन पैरामीटर प्राप्त करता है और विधि पहचानकर्ता (MethodToken) द्वारा विधियों की खोज करता है।

 LoadedMethodDescIterator MDIter(ADIter.GetDomain(), pModule, methodId); while(MDIter.Next()) { MethodDesc * pMD = MDIter.Current(); if (pMD) { _ASSERTE(pMD->IsIL()); pMD->SetRVA(rva); } } 

ध्यान दें कि हम पीडीबी फ़ाइल से कंस्ट्रक्टर, नेक्स्ट, करंट तरीकों के पते प्राप्त कर सकते हैं।

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

 class LoadedMethodDescIterator { private: BYTE dummy[10240]; }; 

मैं इस तथ्य पर भी ध्यान आकर्षित करना चाहूंगा कि संस्करण 2.0 से 4.5 तक .NET के संक्रमण के दौरान नेक्स्ट () विधि में छोटे बदलाव थे।

 // .Net 2.0 & 4.0 LoadedMethodDescIterator(AppDomain * pAppDomain, Module *pModule, mdMethodDef md) BOOL LoadedMethodDescIterator::Next(void) // .Net 4.5 LoadedMethodDescIterator(AppDomain * pAppDomain, Module *pModule, mdMethodDef md,enum AssemblyIterationMode mode) BOOL LoadedMethodDescIterator::Next(CollectibleAssemblyHolder<DomainAssembly *> *) 

इसलिए, हमें सही तरीके से कॉल करने के लिए .NET फ्रेमवर्क के वर्तमान संस्करण को निर्धारित करने की आवश्यकता है।

 // detect the version of CLR BOOL DetermineDotNetVersion(void) { WCHAR wszPath[MAX_PATH] = {0}; ::GetModuleFileNameW( g_hClrModule, wszPath, MAX_PATH); CStringW strPath(wszPath); int nIndex = strPath.ReverseFind('\\'); if( nIndex <= 0 ) return FALSE; nIndex++; CStringW strFilename = strPath.Mid( nIndex, strPath.GetLength() - nIndex); if( strFilename.CompareNoCase(L"mscorwks.dll") == 0 ) { g_tDotNetVersion = DotNetVersion_20; return TRUE; } if( strFilename.CompareNoCase(L"clr.dll") == 0 ) { DWORD dwHandle = NULL; UINT nSize = 0; LPBYTE lpBuffer = NULL; BYTE szTempBuf[2048] = {0}; DWORD dwSize = GetFileVersionInfoSizeW( wszPath, &dwHandle); if (dwSize != NULL) { LPVOID pData = szTempBuf; if (GetFileVersionInfo( wszPath, dwHandle, dwSize, pData)) { if (VerQueryValueW( pData, L"\\",(VOID FAR* FAR*)&lpBuffer,&nSize)) { if (nSize) { VS_FIXEDFILEINFO * pVerInfo = (VS_FIXEDFILEINFO *)lpBuffer; if (pVerInfo->dwSignature == 0xfeef04bd) { int nMajor = HIWORD(pVerInfo->dwFileVersionMS); int nMinor = LOWORD(pVerInfo->dwFileVersionMS); int nBuildMajor = HIWORD(pVerInfo->dwFileVersionLS); int nBuildMinor = LOWORD(pVerInfo->dwFileVersionLS); if( nMajor == 4 && nMinor == 0 && nBuildMajor == 30319 ) { if( nBuildMinor < 10000 ) g_tDotNetVersion = DotNetVersion_40; else g_tDotNetVersion = DotNetVersion_45; return TRUE; } } } } } return FALSE; } } return FALSE; } 

अब हम अपने LoadMethodDescIterator की घोषणा कर सकते हैं, जो सीएलआर के साथ मिलकर काम करेगा।

 enum AssemblyIterationMode { AssemblyIterationMode_Default = 0 }; class LoadedMethodDescIterator { typedef void (LoadedMethodDescIterator::*PFN_LoadedMethodDescIteratorConstructor)(AppDomain * pAppDomain, Module *pModule, mdMethodDef md); typedef void (LoadedMethodDescIterator::*PFN_LoadedMethodDescIteratorConstructor_v45)(AppDomain * pAppDomain, Module *pModule, mdMethodDef md, AssemblyIterationMode mode); typedef void (LoadedMethodDescIterator::*PFN_Start)(AppDomain * pAppDomain, Module *pModule, mdMethodDef md); typedef BOOL (LoadedMethodDescIterator::*PFN_Next_v4)(LPVOID pParam); typedef BOOL (LoadedMethodDescIterator::*PFN_Next_v2)(void); typedef MethodDesc* (LoadedMethodDescIterator::*PFN_Current)(void); public: LoadedMethodDescIterator(AppDomain * pAppDomain, Module *pModule, mdMethodDef md) { memset( dummy, 0, sizeof(dummy)); memset( dummy2, 0, sizeof(dummy2)); if( s_pfnConstructor ) (this->*s_pfnConstructor)( pAppDomain, pModule, md); if( s_pfnConstructor_v45 ) (this->*s_pfnConstructor_v45)( pAppDomain, pModule, md, AssemblyIterationMode_Default); } void Start(AppDomain * pAppDomain, Module *pModule, mdMethodDef md) { (this->*s_pfnStart)( pAppDomain, pModule, md); } BOOL Next() { if( s_pfnNext_v4 ) return (this->*s_pfnNext_v4)(dummy2); if( s_pfnNext_v2 ) return (this->*s_pfnNext_v2)(); return FALSE; } MethodDesc* Current() { return (this->*s_pfnCurrent)(); } private: // we don't know the exact size of LoadedMethodDescIterator, so add enough memory here BYTE dummy[10240]; // class CollectibleAssemblyHolder<class DomainAssembly *> parameter for Next() in .Net4.0 and above BYTE dummy2[10240]; // constructor for .Net2.0 & .Net 4.0 static PFN_LoadedMethodDescIteratorConstructor s_pfnConstructor; // constructor for .Net4.5 static PFN_LoadedMethodDescIteratorConstructor_v45 s_pfnConstructor_v45; static PFN_Start s_pfnStart; static PFN_Next_v4 s_pfnNext_v4; static PFN_Next_v2 s_pfnNext_v2; static PFN_Current s_pfnCurrent; public: static void MatchAddress(PSYMBOL_INFOW pSymbolInfo) { LPVOID* pDest = NULL; if( wcscmp( L"LoadedMethodDescIterator::LoadedMethodDescIterator", pSymbolInfo->Name) == 0 ) { switch(g_tDotNetVersion) { case DotNetVersion_20: case DotNetVersion_40: pDest = (LPVOID*)&(LoadedMethodDescIterator::s_pfnConstructor); break; case DotNetVersion_45: pDest = (LPVOID*)&(LoadedMethodDescIterator::s_pfnConstructor_v45); break; default: ATLASSERT(FALSE); return; } } else if( wcscmp( L"LoadedMethodDescIterator::Next", pSymbolInfo->Name) == 0 ) { switch(g_tDotNetVersion) { case DotNetVersion_20: pDest = (LPVOID*)&(LoadedMethodDescIterator::s_pfnNext_v2); break; case DotNetVersion_40: case DotNetVersion_45: pDest = (LPVOID*)&(LoadedMethodDescIterator::s_pfnNext_v4); break; default: ATLASSERT(FALSE); return; } } else if( wcscmp( L"LoadedMethodDescIterator::Start", pSymbolInfo->Name) == 0 ) pDest = (LPVOID*)&(LoadedMethodDescIterator::s_pfnStart); else if( wcscmp( L"LoadedMethodDescIterator::Current", pSymbolInfo->Name) == 0 ) pDest = (LPVOID*)&(LoadedMethodDescIterator::s_pfnCurrent); if( pDest ) *pDest = (LPVOID)pSymbolInfo->Address; } }; 

अंत में, हम जेनेरिक विधियों के लिए रीसैट () को कॉल करने के लिए LoadedMethodDescIterator का उपयोग करते हैं।

 Module * pModule = pMethodDesc->GetLoaderModule(); AppDomain * pAppDomain = pMethodDesc->GetDomain(); if( pModule ) { LoadedMethodDescIterator * pLoadedMethodDescIter = new LoadedMethodDescIterator( pAppDomain, pModule, md); while(pLoadedMethodDescIter->Next()) { MethodDesc * pMD = pLoadedMethodDescIter->Current(); if( pMD ) pMD->Reset(); } delete pLoadedMethodDescIter; } 

संकलन और अनुकूलन

मैंने पाया कि यदि विधि बहुत छोटी है और इसका आकार केवल कुछ बाइट्स है, तो यह इनलाइन मोड को संकलित करेगा। इसलिए, MethodDesc :: Reset () मदद नहीं करेगा, क्योंकि रन टाइम पर, यहां तक ​​कि इस पद्धति का कॉल भी नहीं मिलेगा। कुछ और जानकारी CEEInfo :: canInline (vm। / / Jitinterface.cpp में SSCLC) से मिल सकती है।

गतिशील विधियाँ

IL कोड में डायनामिक तरीके जोड़ने पर, आपको बहुत सावधान रहना होगा। अन्य प्रकार के तरीकों के लिए गलत IL कोड जोड़ना केवल InvalidApplicationException को बढ़ाएगा, लेकिन डायनेमिक विधि में गलत IL कोड जोड़ने से CLR और हमारी प्रक्रिया की पूर्ण विफलता हो सकती है। डायनेमिक कोड IL बाकी से अलग है। सबसे अच्छा तरीका है एक और गतिशील विधि से आईएल कोड उत्पन्न करना, और फिर कॉपी और पेस्ट करना।

स्रोत फ़ाइलें

• बाइनरी फाइलें
• स्रोत फ़ाइलें