1. целевая функция является статической – она сразу присутствует в памяти загруженного модуля;
   
2. адрес целевой функции легко определить (через таблицу экспорта модуля или функцию GetProcAddress).
   

1. Способ вызова методов в CLR

1. JIT-компиляция метода, идентифицируемого структурой MethodDesc;
2. установка указателя в структуре MethodDesc на сгенерированный native-код;
3. перезапись переходника таким образом, чтобы он осуществлял безусловный переход (jmp) на сгенерированный native-код;
   
4. выполнение сгенерированного native-кода.

2. Precode-переходники CLR

1. StubPrecode. В указанный переходник в момент его создания значение адреса структуры MethodDesc встраивается системой CLR напрямую (в качестве непосредственного значения в ассемблерной команде). Код переходника зависит только от аппаратной платформы и не зависит от версии CLR. Для различных аппаратных платформ он имеет следующий вид:
   

   x86:    
           mov eax, pMethodDesc 
           mov ebp, ebp         
           jmp ThePreStub       
   x64: 
           mov r10, pMethodDesc 
           jmp ThePreStub       
           

   
   Таким образом, адрес структуры MethodDesc передается функции ThePreStub в регистре eax (для x86) или r10 (для x64). В процессе выполнения при анализе памяти указанный адрес можно явно прочитать по смещению 1 (для x86) или 2 (для x64) переходника с учетом разрядности процессора. Адрес же функции ThePreStub можно вычислить путем сложения относительного смещения, встроенного в последнюю команду jmp, с адресом завершения указанной команды.
   
   После выполнения JIT-компиляции адрес перехода заменяется с адреса функции ThePreStub на адрес сгенерированного кода и содержимое переходника становится следующим:
   

   x86: 
           mov eax, pMethodDesc 
           mov ebp, ebp         
           jmp NativeCode       
   x64: 
           mov r10, pMethodDesc 
           jmp NativeCode       
           

   
   Способ определения адреса сгенерированного кода после выполнения JIT-компиляции совпадает со способом определения адреса функции ThePreStub до выполнения JIT-компиляции.
   
   
2. FixupPrecode. Указанный переходник был разработан с целью оптимизации использования памяти. Он на всех аппаратных платформах занимает 8 байт, что меньше, чем размер переходника StubPrecode (12 байт для x86 и 16 байт для x64). Код переходника для всех аппаратных платформ и версий CLR имеет следующий вид:
   
   

           call PrecodeFixupThunk  
           db 0x5E                
           db MethodDescChunkIndex 
           db PrecodeChunkIndex    
   или
           call PrecodeFixupThunk  
           db 0xСС                 
           db MethodDescChunkIndex 
           db PrecodeChunkIndex    
           

   
   При использовании FixupPrecode-переходников CLR соблюдает следующие два требования:
   
   
   1. предназначенные для переходников структуры MethodDesc объединяются в непрерывных блоках памяти MethodDescChunk:
      
      
   2. FixupPrecode-переходники также объединяются в непрерывный блок памяти, причем в указанном блоке после окончания переходников системой CLR встраивается базовый адрес pMethodDescChunkBase структур MethodDesc в блоке памяти MethodDescChunk:
      
      

      call PrecodeFixupThunk       
      db ?                         
      db MethodDescChunkIndex      
      db PrecodeChunkIndex         
      ...                          
      call PrecodeFixupThunk       
      db ?                         
      db MethodDescChunkIndex      
      db 2                         
                                   
      call PrecodeFixupThunk       
      db ?                         
      db MethodDescChunkIndex      
      db 1                         
                                   
      call PrecodeFixupThunk       
      db ?                         
      db MethodDescChunkIndex      
      db 0                         
      dd pMethodDescChunkBase (x86)
      dq pMethodDescChunkBase (x64)
                 

      
      
   
   При такой организации памяти адрес структуры MethodDesc для определенного переходника FixupPrecode задается по следующей формуле:
   
   aдрес MethodDesc = pMethodDescChunkBase + MethodDescChunkIndex * sizeof(void*),
   
   где базовое смещение (pMethodDescChunkBase) извлекается по следующему адресу:
   
   адрес pMethodDescChunkBase = адрес FixupPrecode + 8 + PrecodeChunkIndex * 8,
   
   а MethodDescChunkIndex и PrecodeChunkIndex — байтовые значения, встроенные в PrecodeFixupThunk.
   
   Значение адреса структуры MethodDesc средой CLR вычисляется внутри дополнительного переходника PrecodeFixupThunk, который существует в памяти в единственном числе и предназначен только для вычисления и передачи указанного адреса функции ThePreStub в регистре eax (для x86) или r10 (для x64). Приведем код переходника PrecodeFixupThunk для различных аппаратных платформ.
   

   x86: 
           pop    eax	                                            
           push   esi	                                            
           push   edi	                                            
           movzx  esi, byte ptr  [eax + 0x2]	                    
           movzx  edi, byte ptr  [eax + 0x1]	                    
           mov    eax, dword ptr [eax + esi * 8 + 0x3]             
           lea    eax, [eax + edi * 4] 			                
           pop    edi	                                            
           pop    esi	                                            
           jmp    dword ptr [g_dwPreStubAddr] (для CLR 2.0)        
           jmp    ThePreStub                  (для CLR 4.0 и выше)                  
   x64: 
           pop    rax	                                            
           movzx  r10, byte ptr  [rax + 0x2]	                    
           movzx  r11, byte ptr  [rax + 0x1]	                    
           mov    rax, qword ptr [rax + r10 * 8 + 0x3]	            
           lea    r10, [rax + r11 * 8] 			                
           jmp    ThePreStub                                       
           

   
   Адрес внутренней функции ThePreStub с использованием FixupPrecode-переходника можно вычислить в два этапа:
   
   
   1. вычислить адрес переходника PrecodeFixupThunk путем сложения относительного смещения, встроенного в первую команду call FixupPrecode-переходника, с адресом завершения указанной команды;
      
   2. для всех платформ, кроме CLR 2.0 x86, вычислить адрес ThePreStub путем сложения относительного смещения, встроенного в последнюю команду jmp переходника PrecodeFixupThunk, с адресом завершения указанной команды;
      
   3. для платформы CLR 2.0 x86, извлечь адрес ThePreStub по адресу, который встроен в последнюю команду jmp (косвенная адресация через внутреннюю переменную g_dwPreStubAddr).
      
   
   
   После выполнения JIT-компиляции в переходнике FixupPrecode первая команда call заменяется командой jmp с заменой адреса перехода с адреса переходника PrecodeFixupThunk на адрес сгенерированного кода. Кроме того, если за первой командой следует байт 0x5E, то он заменяется байтом 0x5F (указанные байты являются индикатором присутствия или отсутствия JIT-компиляции, байт 0xCC означает отсутствие информации). Таким образом, после замены содержимое переходника представляет собой следующее:
   
   

           jmp NativeCode         
           db 0x5E                
           db MethodDescChunkIndex
           db PrecodeChunkIndex   
   или
           jmp NativeCode          
           db 0xСС                 
           db MethodDescChunkIndex 
           db PrecodeChunkIndex    
           

   
   Адрес сгенерированного кода после выполнения JIT-компиляции вычисляется путем сложения относительного смещения, встроенного в первую команду jmp, с адресом завершения указанной команды.
   
   
3. RemotingPrecode. Указанный переходник используется при вызове методов объектов, которые могут существовать в другом домене приложений. Код переходника имеет следующий вид:
   

   x86: 
           mov eax, pMethodDesc        
           nop                         
           call PrecodeRemotingThunk   
           jmp ThePreStub              
   x64: 
           test rcx,rcx
           je Local
           mov rax, qword ptr [rcx]
           mov r10, ProxyAddress
           cmp rax, r10
           je Remote
   Local:  mov rax, ThePreStub
           jmp rax
   Remote: mov r10, pMethodDesc
           mov rax, RemotingCheck
           jmp rax
           

   
   Как и в случае с переходником StubPrecode, в RemotingPrecode в момент его создания значение адреса структуры MethodDesc встраивается системой CLR напрямую (в качестве непосредственного значения в ассемблерной команде). Указанное значение можно извлечь по смещению 1 (для x86) и 37 (для x64). Адрес же функции ThePreStub представляет собой результат сложения относительного смещения, встроенного в последнюю команду jmp, с адресом завершения указанной команды (для x86) или непосредственное значение по смещению 25 (для x64).
   
   Для объектов, не принадлежащих другим доменам, после выполнения JIT-компиляции адрес перехода заменяется с адреса функции ThePreStub на адрес сгенерированного кода, поэтому способ определения адреса сгенерированного кода после выполнения JIT-компиляции совпадает со способом определения адреса функции ThePreStub до выполнения JIT-компиляции. Для объектов, принадлежащих другим доменам, после выполнения JIT компиляции тело переходника RemotingPrecode не изменяется. Для упрощения далее не рассматриваем вариант использования RemotingPrecode для объектов, не принадлежащих домену приложения.
   

3. Функция ThePreStub

1. JIT-компиляция метода, идентифицируемого структурой MethodDesc;
2. установка указателя в структуре MethodDesc на сгенерированный native-код;
3. перезапись переходника таким образом, чтобы он осуществлял безусловный переход (jmp) на сгенерированный native-код;
4. выполнение сгенерированного native-кода.

CLR 4.6 и выше:
        push        r15  
        push        r14  
        push        r13  
        push        r12  
        push        rbp  
        push        rbx  
        push        rsi  
        push        rdi  
        sub         rsp,68h  
        mov         qword ptr   [rsp+0B0h],rcx  
        mov         qword ptr   [rsp+0B8h],rdx  
        mov         qword ptr   [rsp+0C0h],r8  
        mov         qword ptr   [rsp+0C8h],r9  
        movdqa      xmmword ptr [rsp+ 20h],xmm0  
        movdqa      xmmword ptr [rsp+ 30h],xmm1  
        movdqa      xmmword ptr [rsp+ 40h],xmm2  
        movdqa      xmmword ptr [rsp+ 50h],xmm3  
        lea         rcx,[rsp+68h]  
        mov         rdx,r10  
        call        PreStubWorker  
        movdqa      xmm0,xmmword ptr [rsp+20h]  
        movdqa      xmm1,xmmword ptr [rsp+ 30h]  
        movdqa      xmm2,xmmword ptr [rsp+ 40h]  
        movdqa      xmm3,xmmword ptr [rsp+ 50h]  
        mov         rcx,qword ptr    [rsp+0B0h]  
        mov         rdx,qword ptr    [rsp+0B8h]  
        mov         r8,qword ptr     [rsp+0C0h]  
        mov         r9,qword ptr     [rsp+0C8h]  
        add         rsp,68h  
        pop         rdi  
        pop         rsi  
        pop         rbx  
        pop         rbp  
        pop         r12  
        pop         r13  
        pop         r14  
        pop         r15  
        jmp         rax  

CLR 4.0:
        lea     rax, [rsp + 0x08]
        push    r10
        push    r15
        push    r14
        push    r13
        push    r12
        push    rbp
        push    rbx
        push    rsi
        push    rdi
        push    rax
        sub     rsp, 0x78
        mov     qword ptr   [rsp + 0xD0], rcx
        mov     qword ptr   [rsp + 0xD8], rdx
        mov     qword ptr   [rsp + 0xE0], r8
        mov     qword ptr   [rsp + 0xE8], r9
        movdqa  xmmword ptr [rsp + 0x20], xmm0
        movdqa  xmmword ptr [rsp + 0x30], xmm1
        movdqa  xmmword ptr [rsp + 0x40], xmm2
        movdqa  xmmword ptr [rsp + 0x50], xmm3
        lea     rcx, qword ptr [rsp + 0x68]
        call    PreStubWorker
        movdqa  xmm0, xmmword ptr [rsp + 0x20]
        movdqa  xmm1, xmmword ptr [rsp + 0x30]
        movdqa  xmm2, xmmword ptr [rsp + 0x40]
        movdqa  xmm3, xmmword ptr [rsp + 0x50]
        mov     rcx, qword ptr    [rsp + 0xD0]
        mov     rdx, qword ptr    [rsp + 0xD8]
        mov     r8 , qword ptr    [rsp + 0xE0]
        mov     r9 , qword ptr    [rsp + 0xE8]
        nop     
        add     rsp, 0x80
        pop     rdi
        pop     rsi
        pop     rbx
        pop     rbp
        pop     r12
        pop     r13
        pop     r14
        pop     r15
        pop     r10
        jmp     rax

CLR 2.0:
        lea    rax, [rsp + 0x08]	          
        push   r10	
        push   r15	
        push   r14	
        push   r13	
        push   r12	
        push   rbp	
        push   rbx	
        push   rsi	
        push   rdi	
        push   rax	
        sub    rsp, 0x78	
        mov    qword ptr   [rsp + 0xD0], rcx		  
        mov    qword ptr   [rsp + 0xD8], rdx	  
        mov    qword ptr   [rsp + 0xE0], r8	  
        mov    qword ptr   [rsp + 0xE8], r9	  
        movdqa xmmword ptr [rsp + 0x20], xmm0
        movdqa xmmword ptr [rsp + 0x30], xmm1
        movdqa xmmword ptr [rsp + 0x40], xmm2
        movdqa xmmword ptr [rsp + 0x50], xmm3
        call   PrestubMethodFrame::GetMethodFrameVPtr
        mov    qword ptr [rsp + 0x68], rax	
        mov    rax, qword ptr [s_gsCookie]
        mov    qword ptr [rsp + 0x60], rax	
        call   GetThread
        mov    r12, rax	
        mov    rdx, qword ptr [r12 + 0x10]	
        mov    qword ptr [rsp + 0x70], rdx	
        lea    rcx, [rsp + 0x68]	
        mov    qword ptr [r12 + 0x10], rcx	
        call   PreStubWorker
        mov    rcx, qword ptr [r12 + 0x10]	
        mov    rdx, qword ptr [rcx + 0x08]	
        mov    qword ptr [r12 + 0x10], rdx
        movdqa xmm0, xmmword ptr [rsp + 0x20]
        movdqa xmm1, xmmword ptr [rsp + 0x30]
        movdqa xmm2, xmmword ptr [rsp + 0x40]
        movdqa xmm3, xmmword ptr [rsp + 0x50]
        mov    rcx, qword ptr    [rsp + 0xD0]	  
        mov    rdx, qword ptr    [rsp + 0xD8]	  
        mov    r8 , qword ptr    [rsp + 0xE0]	  
        mov    r9 , qword ptr    [rsp + 0xE8]	  
        nop	
        add    rsp, 0x80	  
        pop    rdi	
        pop    rsi	
        pop    rbx	
        pop    rbp	
        pop    r12
        pop    r13	
        pop    r14	
        pop    r15	
        pop    r10	
        jmp    rax
    

CLR 4.6 и выше:
        push    ebp  
        mov     ebp,esp  
        push    ebx  
        push    esi  
        push    edi  
        push    ecx  
        push    edx  
        mov     esi,esp  
        push    eax  
        push    esi  
        call   PreStubWorker
        pop     edx  
        pop     ecx  
        pop     edi  
        pop     esi  
        pop     ebx  
        pop     ebp  
        jmp     eax  

CLR 4.0:
        push   ebp	
        mov    ebp, esp	
        push   ebx	
        push   esi	
        push   edi	
        push   ecx	
        push   edx	
        push   eax	
        sub    esp, 0x0C	
        lea    esi, [esp + 0x04]	
        push   esi	
        call   PreStubWorker
        add    esp, 0x10	
        pop    edx	
        pop    ecx	
        pop    edi	
        pop    esi	
        pop    ebx	
        pop    ebp	
        jmp    eax	

CLR 2.0:
        push   eax
        push   edx
        push   PrestubMethodFrame::'vftable'
        push   ebp	
        push   ebx	
        push   esi	
        push   edi	
        lea    esi, [esp + 0x10]
        push   dword ptr [esi + 0x0C]
        push   ebp	
        mov    ebp, esp	
        push   ecx	
        push   edx	
        mov    ebx, dword ptr fs:0x0E34
        mov    edi, dworp ptr [ebx + 0x0C]
        mov    dword ptr [esi + 0x04], edi
        mov    dword ptr [ebx + 0x0C], esi
        push   cookie
        push   esi
        call   PreStubWorker
        mov    dword ptr [ebx + 0x0C], edi
        mov    ecx, dword ptr [esi + 0x08]
        mov    dword ptr [esi + 0x08], eax
        mov    eax, ecx
        add    esp, 0x04	
        pop    edx	
        pop    ecx	
        mov    esp, ebp	
        pop    ebp	
        add    esp, 0x04	
        pop    edi	
        pop    esi	
        pop    ebx	
        pop    ebp	
        add    esp, 0x08	
        ret    
    

1. Определим произвольный статический метод CLR (можно даже его сделать пустым), запретив inline-встраивание и предварительную компиляцию:
   
   

   public delegate void EmptyDelegate();
   [MethodImplAttribute(
    MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
   public static void Empty() {}
       

   
   
2. Создадим и заблокируем в памяти делегат метода и определим адрес, возвращаемый функцией RuntimeMethodHandle.GetFunctionPointer:
   
   

   EmptyDelegate function = Empty; 
   GCHandle gc = GCHandle.Alloc(function);
   IntPtr methodPtr = function.Method.MethodHandle.GetFunctionPointer();
       

   
   
3. Если команды по адресу methodPtr совпадают с образцом переходника StubPrecode, то следует воспользоваться способом вычисления адреса функции ThePreStub из пункта 1 раздела 2. Если же команды по полученному адресу совпадают с образцом переходника FixupPrecode, то следует воспользоваться способом вычисления адреса функции ThePreStub из пункта 2 раздела 2.
   
   
4. Отменить блокировку памяти делегата метода:
   
   

   gc.Free();
       

   
   

4. Функция PreStubWorker

1. JIT-компиляция метода, идентифицируемого структурой MethodDesc;
2. установка указателя в структуре MethodDesc на сгенерированный native-код;
3. перезапись переходника таким образом, чтобы он осуществлял безусловный переход (jmp) на сгенерированный native-код;
4. возврат функции ThePreStub адреса измененного переходника.

для CLR 4.6 и выше: void* __stdcall PreStubWorker(TransitionBlock* pTransitionBlock, MethodDesc* pMD);
для CLR ниже 4.6:   void* __stdcall PreStubWorker(PrestubMethodFrame *pPFrame);
    

1. для CLR 4.6 (и выше) указанное значение извлекается из второго переданного функции параметра;
   
2. для CLR ниже 4.6 платформы x86 значение находится по смещению 8 структуры, адресуемой параметром pPFrame;
   
3. для CLR ниже 4.6 платформы x64 значение находится адресу, на 16 байтов меньше значения адреса, расположенного по смещению 16 структуры, адресуемой параметром pPFrame.
   

1. для платформы x86 и x64 (кроме CLR 2.0) указанным адресом будет результат сложения относительного смещения, встроенного в единственную в функции ThePreStub команду call, с адресом завершения указанной команды;
   
2. для CLR 2.0 платформы x64 указанным адресом будет результат сложения относительного смещения, встроенного в команду call, которой предшествует команда lea, с адресом завершения команды call.
   

5. Алгоритм перехвата

1. получить адрес замещающего метода с использованием вызова RuntimeMethodHandle.GetFunctionPointer;
   
2. если заменяемый метод уже JIT-скомпилирован, то найти адрес в памяти сгенерированного native-кода и перехватить указанный адрес для выполнения замещающего метода;
   
3. если заменяемый метод еще не JIT-скомпилирован, то
   
   1. вычислить адрес его структуры MethodDesc;
      
   2. вычислить адрес и выполнить перехват функции PreStubWorker таким образом, чтобы в заменяющем PreStubWorker методе вызывалась исходная реализация;
      
   3. добавить в заменяющую PreStubWorker функцию дополнительную логику для случая использования функцией адреса MethodDesc, совпадающего с требуемым адресом. В этом случае после вызова исходной реализации получить адрес сгенерированного native-метода и выполнить перехват полученного адреса для выполнения замещающего метода.
      
   
   

1. Получить адрес .NET-метода через вызов RuntimeMethodHandle.GetFunctionPointer.
   
2. Если команды по полученному адресу совпадают с образцом переходника StubPrecode или RemotingPrecode, то извлечь адрес скомпилированного кода, как описано в п.1 и п.3 раздела 2. Если указанный адрес совпадает с адресом функции ThePreStub, то JIT-компиляция метода не проводилась и следует вернуть NULL. В противном случае вернуть адрес скомпилированного кода.
   
3. До тех пор пока текущий адрес не совпадает с адресом функции ThePreStub выполнять следующее:
   
   1. если текущий адрес указывает на команду jmp, то перейти на адрес назначения для команды jmp;
      
   2. иначе, если текущий адрес указывает на команду call, то проверить адрес назначения команды call. Если он равен переходнику PrecodeFixupThunk (случай FixupPrecode-переходника до проведения JIT компиляции), то вернуть NULL. В противном случае вернуть адрес, по которому расположена команда call (или адрес назначения для команды call);
      
   3. иначе, вернуть текущий адрес.
      
   
   
4. Вернуть NULL, поскольку достигнут адрес функции ThePreStub.
   

1. Получить адрес .NET-метода через вызов RuntimeMethodHandle.GetFunctionPointer.
   
2. Если команды по полученному адресу совпадают с образцом переходника StubPrecode или RemotingPrecode, то вычислить адрес структуры MethodDesc, как описано в п.1 и п.3 раздела 2.
   
3. До тех пор пока текущий адрес не совпадает с адресом функции ThePreStub выполнять следующее:
   
   1. если текущий адрес указывает на команду jmp, то то проверить байт сразу после команды jmp. Если он равен 0x5F (случай FixupPrecode после проведения JIT-компиляции), то вычислить адрес структуры MethodDesc, как описано в п.2 раздела 2. В противном случае перейти на адрес для команды jmp;
      
   2. иначе, если текущий адрес указывает на команду call, то проверить адрес назначения команды call. Если он равен переходнику PrecodeFixupThunk (случай FixupPrecode-переходника до проведения JIT компиляции), то вычислить адрес структуры MethodDesc, как описано в п.2 раздела 2. В противном случае вернуть NULL;
      
   3. иначе, вернуть NULL.
      
   
   
4. Вернуть NULL (указанный пункт должен быть недостижимым).
   

6. Заключение

public static class HookedConnection
{
    public static RTX.NET.HookHandle OpenHandle;

    [MethodImplAttribute(MethodImplOptions.NoInlining)]
    public static void Open(SqlConnection connection)
    {
        // вывести строку соединения
        Console.WriteLine(connection.ConnectionString); 
        // вызвать базовую функцию
        OpenHandle.Call(connection); 
    } 
} 
    

using (ConnectionEntry entry = new ConnectionEntry()) 
{ 
    Test(); 
}
    

public class ConnectionEntry : RTX.NET.HookDispatcher, RTX.NET.IHookLoadHandler
{
    // обрабатываемые типы
    public virtual string[] GetTypes() 
    { 
        // указать класс для перехватываемых методов
        return new string[] { "System.Data.SqlClient.SqlConnection"}; 
    }
    // обработчик загрузки типов
    public virtual void OnLoad(RTX.NET.HookDispatcher dispatcher, Type type)
    {
        // перехватить методы
        HookedConnection.OpenHandle = HookOpen(dispatcher, type); 
    }
    private RTX.NET.HookHandle HookOpen(
        RTX.NET.HookDispatcher dispatcher, Type targetType)
    {
        // указать имя и тип параметров метода
        string name = "Open"; Type[] types = Type.EmptyTypes; 

        // указать атрибуты метода
        BindingFlags flags = BindingFlags.Public | 
        BindingFlags.Instance | BindingFlags.InvokeMethod; 

        // выполнить перехват
        return dispatcher.Install(targetType, name, 
            typeof(HookedConnection), name, flags, types
        ); 
    }
}
    

public static void Test()
{
    SqlConnection connection = new SqlConnection(); 
    connection.ConnectionString = @"Server=(localdb)\v11.0;" + 
        @"AttachDbFileName=C:\MyFolder\MyData.mdf;Integrated Security=true;"; 
    connection.Open (); 
    connection.Close(); 
}
    

Server=(localdb)\v11.0;AttachDbFileName=C:\MyFolder\MyData.mdf;Integrated Security=true;