function MyLoadLibraryA(
 pszModuleName: pChar
 ): HMODULE; stdcall;
begin
 sm_pInstance.funcEvent.ResetEvent;
  // debug
 sm_pInstance.funcEvent.CurFuncName := 'MyLoadLibraryA';
 //

 try
  Result := LoadLibraryA(pszModuleName);
   TModuleScope(sm_pModuleScope).LogMessage(pChar('Подгружена библиотека :' + pszModuleName));
  TApiHookMgr.HackModuleOnLoad(Result, 0);
 finally
   sm_pInstance.funcEvent.setEvent;
 end
end;

class procedure TApiHookMgr.HackModuleOnLoad(hmod: HMODULE; dwFlags: Cardinal);
var
 lockMgr : TLockMgr;
 i       : Integer;
 Hook    : THookedFunction;
begin
// Если был загружен новый модуль то тоже вставим перехватчик
if ((hmod <> 0) and ((dwFlags and LOAD_LIBRARY_AS_DATAFILE) = 0)) then
begin
 lockMgr := TLockMgr.Create(sm_CritSec, TRUE);
   try
   for i := 0 to sm_pHookedFunctions.Count - 1 do
     begin
       Hook := sm_pHookedFunctions[i];
    Hook.ReplaceInOneModule(
     Hook.CalleeModName,
     Hook.pfnOrig,
     Hook.pfnHook,
     hmod
     );
   end; // for
   finally
     lockMgr.Free;
   end;
end // if
end;

function MyGetProcAddress(hModule: HMODULE; lpProcName: LPCSTR): FARPROC; stdcall;
var
 lockMgr  : TLockMgr;
 pfn      : pointer;
 FuncHook : THookedFunction;
begin
  sm_pInstance.funcEvent.ResetEvent;
  // debug
 sm_pInstance.funcEvent.CurFuncName := 'MyGetProcAddress';
 //

 try

   lockMgr := TLockMgr.Create(sm_CritSec, TRUE);
   try
     // получение оргинального адресса функции
     pfn := Pointer(TApiHookMgr.GetProcAddressWindows(hModule, lpProcName));
     //  попытка найти если функция была сломана
     FuncHook :=
       sm_pHookedFunctions.GetHookedFunction(
         hModule,
         lpProcName
         );

     if (nil <> FuncHook) then
       // возаращаем адрес перехваченной функции
       pfn := FuncHook.pfnHook;
     Result := pfn;
   finally
     lockMgr.Free;
   end;
 finally
   sm_pInstance.funcEvent.setEvent;
 end;

 TModuleScope(sm_pModuleScope).LogMessage(pChar('В библиотеке :' + GetModuleName(hModule) +
                                                ' запрошена функция :'+ lpProcName));

end;

function CallBack(nCode: Integer; wprm: WParam;
 lprm: LParam): LResult;
begin
 result := CallNextHookEx(Modulescope.sm_pInstance.HookHandle, nCode, wprm, lprm);
end;

procedure DLLEntryPoint(Reason: DWORD);
 begin
   case Reason of
     DLL_PROCESS_ATTACH:
     begin
       InitSharedFile;
       sg_hwndServer := @sm_lpSharedRec^.m_phwndServer;
       sg_bHookInstalled := @sm_lpSharedRec^.m_pbHookInstalled;
       sg_hwndTarget := @sm_lpSharedRec^.m_phwndTarget;
       sg_bSendMsg := @sm_lpSharedRec^.m_SendResults;
       sg_hHookHandle := @sm_lpSharedRec^.m_HookHandle;
         // Отключаем События потока
      // Чтоб потоки не звали ни на что больше не риагировал
    DisableThreadLibraryCalls(HINSTANCE);

    g_pModuleScope := TModuleScope.GetInstance(
      sg_hwndServer,
     sg_bHookInstalled,
         sg_hwndTarget,
         sg_bSendMsg,
         sg_hHookHandle
     );
    g_pModuleScope.ManageModuleEnlistment();
     end;
     DLL_THREAD_ATTACH:
     begin

     end;
     DLL_THREAD_DETACH:
     begin

     end;
     DLL_PROCESS_DETACH:
     begin
     //  DLL Выходит из адресного пространства процесса .
       g_pModuleScope.HookAll := true;
    g_pModuleScope.ManageModuleDetachment();
       ReleaseShredFile;
     end;
  end;

procedure TModuleScope.ManageModuleDetachment;
begin
//
// Проверка сообщения что оно из перехваченого приложения
//
if (not m_bIsThisServerProcess) then
begin
  // Извлекаем перехватчики
 FinalizeHookManagement();
 // Сервер исчо работает?
 if (0 <> m_phwndServer^) then
    // Посылаем сообщение серверу об отключении
  PostMessage(
   m_phwndServer^,
   UWM_HOOKTOOL_DLL_UNLOADED,
   0,
   GetCurrentProcessId()
   );
end else
begin
 m_pInjector.EjectModuleFromAllProcesses(m_pWhenZero.GetZeroHandle);
 LogMessage( '-------  Сервер становлен и все ловушки выгружены ------');
end;
end;

IsMultiThread := True;

// На вход передаем dwProcessId - идентификатор процесса,
// в который требуется внедрить dll с именем lpModName
function InjectLibByRemoteThread(dwProcessId: DWORD; lpModName: PChar): Boolean;
var
 l_hProcess: THandle;
 l_hThread: THandle;
 l_ThreadFunc: TFNThreadStartRoutine;
 l_ThreadId: DWORD;
 l_iLength: Cardinal;
 l_pBuffer: PChar;
 l_NumberOfBytesWritten: DWORD;
begin
 Result := False;
 l_hProcess := OpenProcess(PROCESS_CREATE_THREAD or PROCESS_VM_OPERATION or
   PROCESS_VM_WRITE, False, dwProcessId);
 if l_hProcess = 0 then Exit;
 try
   l_ThreadFunc := GetProcAddress(GetModuleHandle(kernel32), 'LoadLibraryA');
   if not Assigned(l_ThreadFunc) then Exit;
   l_iLength := Length(lpModName);
   l_pBuffer := VirtualAllocEx(l_hProcess, nil, l_iLength + 1,
     MEM_COMMIT, PAGE_READWRITE);
   if not Assigned(l_pBuffer) then Exit;
   try
     if not WriteProcessMemory(l_hProcess, l_pBuffer, lpModName, l_iLength,
       l_NumberOfBytesWritten)
     then Exit;
     l_hThread := CreateRemoteThread(l_hProcess, nil, 0, l_ThreadFunc,
       l_pBuffer, 0, l_ThreadId);
     Result := l_hThread <> 0;
     if Result then begin
       WaitForSingleObject(l_hThread, INFINITE);
       CloseHandle(l_hThread);
     end;
   finally
     VirtualFreeEx(l_hProcess, l_pBuffer, 0, MEM_RELEASE);
   end;
 finally
   CloseHandle(l_hProcess);
 end;
end;

// На вход передаем dwProcessId - идентификатор процесса,
// из которого требуется выгрузить dll с именем lpModName
function WithdrawLibByRemoteThread(dwProcessId: DWORD; lpModName: PChar): Boolean;
var
 l_hProcess: THandle;
 l_hThread: THandle;
 l_ThreadFunc: TFNThreadStartRoutine;
 l_ToolHelp: TToolHelp;
 l_me: TModuleEntry32;
 l_ThreadId: DWORD;
begin
 Result := False;
 l_hProcess := OpenProcess(PROCESS_CREATE_THREAD or PROCESS_VM_OPERATION or
   PROCESS_VM_WRITE, False, dwProcessId);
 if l_hProcess = 0 then Exit;
 try
   l_ThreadFunc := GetProcAddress(GetModuleHandle(kernel32), 'FreeLibrary');
   if not Assigned(l_ThreadFunc) then Exit;
   // Найдем внедренную библиотеку в целевом процессе
   l_ToolHelp := TToolHelp.Create(TH32CS_SNAPMODULE, dwProcessId);
   try
     l_me.dwSize := SizeOf(TModuleEntry32);
     if not l_ToolHelp.ModuleByNameFind(lpModName, l_me) then Exit;
     l_hThread := CreateRemoteThread(l_hProcess, nil, 0, l_ThreadFunc,
       Pointer(l_me.hModule), 0, l_ThreadId);
     Result := l_hThread <> 0;
     if Result then begin
       WaitForSingleObject(l_hThread, INFINITE);
       CloseHandle(l_hThread);
     end;
   finally
     l_ToolHelp.Free;
   end;
 finally
   CloseHandle(l_hProcess);
 end;
end;

WaitForSingleObject(l_hThread, INFINITE);

цикл:
push ebx

условие 1:
call ebx // перехваченная функция

... прочие условия

условие N:
call FreeLibrary

pop ebx
cmp ...
jmp nz, цикл