HOOK 几种实现方式区别

最新推荐文章于 2024-04-03 09:37:29 发布
最新推荐文章于 2024-04-03 09:37:29 发布
阅读量662 收藏
点赞数

Hook简介

微软的MSDN中，对Hook的解释为：
A hook is a point in the system message-handling mechanism where an application can install a subroutine to monitor the message traffic in the system and process certain types of messages before they reach the target window procedure.

微软只是简单的将Hook解释为一种过滤（或叫挂钩）消息的技术。

我们这里讲解的Hook，简单解释为：挂钩，挂钩一切事物。包含微软的解释。

挂钩的事物通常指的是函数。

Hook 目的

过滤一些关键函数调用，在函数执行前，先执行自己的挂钩函数。达到监控函数调用，改变函数功能的目的。

Hook 分类

  • 系统消息Hook（微软官方提供的方法 Ring3）
    • SetWindowsHookEx
    • UnhookWindowsHookEx
    • CallNextHookEx

 

  • API Hook（非官方方法 Ring0/Ring3）
    • 使用汇编代码编替换函数开始的汇编代码，使其跳转到我们的Hook函数中，非官方叫法：Inline hook
    • 使用Hook函数地址替换调用函数地址（IAT hook/SSDT hook … …）

系统消息 Hook

类型：

WH_GETMESSAGE    当系统调用GetMessage和PeekMessage时，调用Hook函数

WH_KEYBOARD_LL     当系统发送键盘消息到线程输入队列前，先调用Hook函数

WH_MOUSE_LL         当系统发送鼠标消息到线程输入队列前，先调用Hook函数

… …

 

HHOOK WINAPI SetWindowsHookEx(

int idHook,            // 类型

HOOKPROC lpfn,        // 回调函数

HINSTANCE hMod,    // 回调函数所在的DLL的Handle（可能在调用进程也可能不在）

DWORD dwThreadId    // 针对哪儿个线程做Hook

);

 

此Hook可以以线程为单位进行筛选。每个GUI线程有一个消息队列，用来接受消息，既然是消息Hook，那就应该是针对某个线程的接收到的消息做Hook。

例如：实现的防键盘勾取，可以使用这种技术。安装了一个WH_KEYBOARD_LL钩子，在键盘按下，发往任意的线程消息队列前，会先调用我们的键盘钩子，钩子里面判断是不是我们的输入框的窗口消息，如果不是，忽略。如果是，做加密处理并保存，改变发送的字符（如改为"*"），发送至窗口过程中。如果第三方调用GetWindowText，由于文本框中的都是"*"，所以无法获取出真实字符。

但这种钩子谁也可以安装，Windows将所有程序安装的钩子组成了一个钩子链。如果第三方也安装了一个钩子，还是在我们安装完之后安装的，那么它将会截获到真实字符。所以，所以可以进一步加强处理，增加一个定时器，不停的安装卸载多个钩子。这样，即便第三方也在不停的安装钩子，想截取到完整的PIN，可能性变的很小。但如果这个恶意程序驻留在用户系统中很多天，通过每次的统计，可能能得到完整的PIN。

API Hook - Inline Hook

工作方式如下：

  1. 调用GetProcAddress对内存中要拦截的函数进行定位（如Kernel32.dll的ExitProcess），得到它的内存地址。
  2. 把这个函数起始的几个字节保存到我们的内存中。
  3. 用CPU的JUMP汇编指令来覆盖这个函数的起始几个字节，这条JUMP指令用来跳转到我们的替换函数的内存地址。我们替换的函数需要和原函数具有完全相同的声明：参数相同，返回值相同，调用约定相同。
  4. 当线程调用被拦截的函数时，跳转指令实际上会跳转到我们的替代函数，这是，我们可以执行相应的功能代码。
  5. 为了撤销对函数的拦截，我们必须把步骤2中保存的字节恢复回被拦截的函数中。
  6. 我们调用被拦截函数（现在已经不再拦截），让函数执行它的正常处理。
  7. 当原来函数返回时，我们再次执行第2，第3步，这样我们的替代函数将来还会被调用到。

注意事项：

  • JUMP指令对CPU（AMD，Intel）有依赖，在X86，X64下，更会有不同的表现。
  • 由于替换汇编代码的过程，不是原子操作的，很有可能在其它线程运行到此函数的入口的时候进行了替换，导致指令异常，程序崩溃。

解决多线程的办法（分析来自Mhook库）：

  • 替换的过程首先上互斥锁（如EnterCriticalSection），这把锁只对替换的过程互斥，并无法避免其它线程正在调用要替换的函数。
  • 第二步做的就是挂起除本线程外的其它线程，并同时确保其它线程的执行点（IP）不在我们将以替换的区域中。（参加Mhook的： SuspendOtherThreads函数）

下面是摘自Mhook的一段代码，它会挂起除了Hook线程以外的其它线程，并且确保其他线程的执行点（IP）不在要Hook的区域内。

//=========================================================================
// Internal function:
//
// Suspend all threads in this process while trying to make sure that their 
// instruction pointer is not in the given range.
//=========================================================================
static BOOL SuspendOtherThreads(PBYTE pbCode, DWORD cbBytes) {
    BOOL bRet = FALSE;
    // make sure we're the most important thread in the process
    INT nOriginalPriority = GetThreadPriority(GetCurrentThread());
    SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
    // get a view of the threads in the system
    HANDLE hSnap = fnCreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, GetCurrentProcessId());
    if (GOOD_HANDLE(hSnap)) {
        THREADENTRY32 te;
        te.dwSize = sizeof(te);
        // count threads in this process (except for ourselves)
        DWORD nThreadsInProcess = 0;
        if (fnThread32First(hSnap, &te)) {
            do {
                if (te.th32OwnerProcessID == GetCurrentProcessId()) {
                    if (te.th32ThreadID != GetCurrentThreadId()) {
                        nThreadsInProcess++;
                    }
                }
                te.dwSize = sizeof(te);
            } while(fnThread32Next(hSnap, &te));
        }
        ODPRINTF((L"mhooks: SuspendOtherThreads: counted %d other threads", nThreadsInProcess));
        if (nThreadsInProcess) {
            // alloc buffer for the handles we really suspended
            g_hThreadHandles = (HANDLE*)malloc(nThreadsInProcess*sizeof(HANDLE));
            if (g_hThreadHandles) {
                ZeroMemory(g_hThreadHandles, nThreadsInProcess*sizeof(HANDLE));
                DWORD nCurrentThread = 0;
                BOOL bFailed = FALSE;
                te.dwSize = sizeof(te);
                // go through every thread
                if (fnThread32First(hSnap, &te)) {
                    do {
                        if (te.th32OwnerProcessID == GetCurrentProcessId()) {
                            if (te.th32ThreadID != GetCurrentThreadId()) {
                                // attempt to suspend it
                                g_hThreadHandles[nCurrentThread] = SuspendOneThread(te.th32ThreadID, pbCode, cbBytes);
                                if (GOOD_HANDLE(g_hThreadHandles[nCurrentThread])) {
                                    ODPRINTF((L"mhooks: SuspendOtherThreads: successfully suspended %d", te.th32ThreadID));
                                    nCurrentThread++;
                                } else {
                                    ODPRINTF((L"mhooks: SuspendOtherThreads: error while suspending thread %d: %d", te.th32ThreadID, gle()));
                                    // TODO: this might not be the wisest choice
                                    // but we can choose to ignore failures on
                                    // thread suspension. It's pretty unlikely that
                                    // we'll fail - and even if we do, the chances
                                    // of a thread's IP being in the wrong place
                                    // is pretty small.
                                    // bFailed = TRUE;
                                }
                            }
                        }
                        te.dwSize = sizeof(te);
                    } while(fnThread32Next(hSnap, &te) && !bFailed);
                }
                g_nThreadHandles = nCurrentThread;
                bRet = !bFailed;
            }
        }
        CloseHandle(hSnap);
        //TODO: we might want to have another pass to make sure all threads
        // in the current process (including those that might have been
        // created since we took the original snapshot) have been 
        // suspended.
    } else {
        ODPRINTF((L"mhooks: SuspendOtherThreads: can't CreateToolhelp32Snapshot: %d", gle()));
    }
    SetThreadPriority(GetCurrentThread(), nOriginalPriority);
    if (!bRet) {
        ODPRINTF((L"mhooks: SuspendOtherThreads: Had a problem (or not running multithreaded), resuming all threads."));
        ResumeOtherThreads();
    }
    return bRet;
}
 
//=========================================================================
// Internal function:
//
// Suspend a given thread and try to make sure that its instruction
// pointer is not in the given range.
//=========================================================================
static HANDLE SuspendOneThread(DWORD dwThreadId, PBYTE pbCode, DWORD cbBytes) {
    // open the thread
    HANDLE hThread = OpenThread(THREAD_ALL_ACCESS, FALSE, dwThreadId);
    if (GOOD_HANDLE(hThread)) {
        // attempt suspension
        DWORD dwSuspendCount = SuspendThread(hThread);
        if (dwSuspendCount != -1) {
            // see where the IP is
            CONTEXT ctx;
            ctx.ContextFlags = CONTEXT_CONTROL;
            int nTries = 0;
            while (GetThreadContext(hThread, &ctx)) {
#ifdef _M_IX86
                PBYTE pIp = (PBYTE)(DWORD_PTR)ctx.Eip;
#elif defined _M_X64
                PBYTE pIp = (PBYTE)(DWORD_PTR)ctx.Rip;
#endif
                if (pIp >= pbCode && pIp < (pbCode + cbBytes)) {
                    if (nTries < 3) {
                        // oops - we should try to get the instruction pointer out of here.
                        ODPRINTF((L"mhooks: SuspendOneThread: suspended thread %d - IP is at %p - IS COLLIDING WITH CODE", dwThreadId, pIp));
                        ResumeThread(hThread);
                        Sleep(100);
                        SuspendThread(hThread);
                        nTries++;
                    } else {
                        // we gave it all we could. (this will probably never 
                        // happen - unless the thread has already been suspended 
                        // to begin with)
                        ODPRINTF((L"mhooks: SuspendOneThread: suspended thread %d - IP is at %p - IS COLLIDING WITH CODE - CAN'T FIX", dwThreadId, pIp));
                        ResumeThread(hThread);
                        CloseHandle(hThread);
                        hThread = NULL;
                        break;
                    }
                } else {
                    // success, the IP is not conflicting
                    ODPRINTF((L"mhooks: SuspendOneThread: Successfully suspended thread %d - IP is at %p", dwThreadId, pIp));
                    break;
                }
            }
        } else {
            // couldn't suspend
            CloseHandle(hThread);
            hThread = NULL;
        }
    }
    return hThread;
}

Inline Hook技术复杂，对CPU有依赖，需要编写汇编代码，在抢占式，多线程系统中，很容易出现问题。但目前有比较稳定的Hook库可以使用，也是不错的选择之一。

API Hook – SEH Hook

这里简单介绍一下，SEH是windows的结构化异常处理，通过安装一个结构化异常处理函数，当在保护的执行区域内发生异常时，会跳转到此异常函数。SEH Hook属于比较另类的Hook方式，它在函数开头插入异常代码，如（INT 3），当执行到此函数时，由于触发异常，则会跳到我们的处理函数中。

API Hook - IAT Hook

IAT - Import Address Table （输入地址表）

简单的说，此表格由一连串的函数地址组成，这些函数地址从其它模块中导入的函数地址。当Windows加载器加载一个PE可执行文件时，会将真正需要的函数的虚拟地址填入此表格。

 

输入函数是如何被调用的

通常，我们编写一个程序（调用者），调用一个输入函数时，此函数并不在当前程序中。我们只需要包含相应的头文件，然后链接正确的lib库（静态lib 和 动态DLL对应的lib），这些函数的实际代码存在于外部的一个DLL中。调用者只保留函数的相关信息（函数名，DLL文件名等）。由于一个PE文件没有被加载到内存中，编译完成的PE文件是无法确定输入函数的具体地址的。

 

下面通过一个例子来说明输入函数的地址是如何确定的。

现在，我调用一个Windows API函数：Sleep，原型如下：

extern "C" __declspec(dllimport) void __stdcall Sleep(

     unsigned long dwMilliseconds

);

 

代码中调用如下：

Sleep(200);

 

VC编译器会将此函数汇编如下：

push     0C8h

call dword ptr [00407000]

 

由于在编译阶段，编译器是无法确定Sleep在真正运行时候的地址的。所以，编译器在PE文件中分配一块导入地址表，call 的只是导入地址的地址，而不是真正的地址。此示例中， 00407000是地址，它指向导入地址表的某个区域，指向的内容在PE被Windows加载器加载的时候，根据DLL实际加载的地址，找到真正的Sleep地址，将其替换为Sleep的真实地址。此方法类似于C++的多态。(父类的指针在运行时可以指向不同类型的子类）。这样，call dword ptr [00407000]，从00407000取出来的地址就是Sleep的地址。如下图所示。

IAT Hook就是去替换取出来的这个Sleep地址，将00407000地址指向的内存替换为我们的MySleep。当再次执行到call dword ptr [00407000]，此00407000指向的内存保存的已经是MySleep地址了。

IAT Hook的优点在于不依赖CPU，容易实现。很难出现程序崩溃的问题。

 

如何找到IAT并定位正确的地址？

需要掌握PE文件的结构。（可以参考看雪论坛出版的加密与解密（第三版））

下面的代码片段，引自《Windows核心编程（第5版）》 示例代码 22-LastMsgBoxInfo ：

 

void CAPIHook::ReplaceIATEntryInOneMod(PCSTR pszCalleeModName,
PROC pfnCurrent, PROC pfnNew, HMODULE hmodCaller) {
 
// Get the address of the module's import section
ULONG ulSize;
 
// An exception was triggered by Explorer (when browsing the content of 
// a folder) into imagehlp.dll. It looks like one module was unloaded...
// Maybe some threading problem: the list of modules from Toolhelp might 
// not be accurate if FreeLibrary is called during the enumeration.
PIMAGE_IMPORT_DESCRIPTOR pImportDesc = NULL;
__try {
pImportDesc = (PIMAGE_IMPORT_DESCRIPTOR) ImageDirectoryEntryToData(
hmodCaller, TRUE, IMAGE_DIRECTORY_ENTRY_IMPORT, &ulSize);
} 
__except (InvalidReadExceptionFilter(GetExceptionInformation())) {
// Nothing to do in here, thread continues to run normally
// with NULL for pImportDesc 
}
 
if (pImportDesc == NULL)
return; // This module has no import section or is no longer loaded
 
 
// Find the import descriptor containing references to callee's functions
for (; pImportDesc->Name; pImportDesc++) {
PSTR pszModName = (PSTR) ((PBYTE) hmodCaller + pImportDesc->Name);
if (lstrcmpiA(pszModName, pszCalleeModName) == 0) {
 
// Get caller's import address table (IAT) for the callee's functions
PIMAGE_THUNK_DATA pThunk = (PIMAGE_THUNK_DATA) 
((PBYTE) hmodCaller + pImportDesc->FirstThunk);
 
// Replace current function address with new function address
for (; pThunk->u1.Function; pThunk++) {
 
// Get the address of the function address
PROC* ppfn = (PROC*) &pThunk->u1.Function;
 
// Is this the function we're looking for?
BOOL bFound = (*ppfn == pfnCurrent);
if (bFound) {
if (!WriteProcessMemory(GetCurrentProcess(), ppfn, &pfnNew, 
sizeof(pfnNew), NULL) && (ERROR_NOACCESS == GetLastError())) {
DWORD dwOldProtect;
if (VirtualProtect(ppfn, sizeof(pfnNew), PAGE_WRITECOPY, 
&dwOldProtect)) {
 
WriteProcessMemory(GetCurrentProcess(), ppfn, &pfnNew, 
sizeof(pfnNew), NULL);
VirtualProtect(ppfn, sizeof(pfnNew), dwOldProtect, 
&dwOldProtect);
}
}
return; // We did it, get out
}
}
} // Each import section is parsed until the right entry is found and patched
}
}

API Hook - SSDT Hook (Ring0)

SSDT （System Service Dispatch Table) 系统服务调度表

此表保存了系统中所有的系统服务函数地址，通过改变此表中的地址，达到Hook某个系统函数的目的

为何替换SSDT表中的地址，首先需要了解，Windows内核是如何为应用程序服务的？

为了保证每个进程的安全， Windows为不同的进程分配了独立的进程空间，即虚拟内存空间。一个进程的虚拟地址是无法指到另一个进程中的数据的。对应32位x86系统，每个进程的空间是4G，0x00000000-0xFFFFFFFF。为了高效的调用系统服务，Windows把操作系统的代码和数据映射到所有进程的空间中，因此4G划分为低2G的用户层和高2G的内核层空间。如图所示：

Windows定义了两种访问模式（access mode）

  • 用户模式（user mode）    （ring3）
  • 内核模式（kernel mode）（ring0）

    应用程序运行在用户模式下，操作系统运行在内核模式下。内核模式对应CPU的高权限级别，内核模式下可以访问系统的所有资源，拥有执行所有指令的权限，用户模式对应CPU较低的权限，只可以访问系统允许的其访问的内存空间和资源，并且没有权限运行一些特殊指令。

    用户模式下的代码不可以直接访问内核模式下的代码和数据，不能直接通过call指令调用内核模式下的任何函数。如果尝试，系统会产生保护性错误，程序直接终止。

    间接访问：用户程序通过调用系统服务来间接访问系统空间的数据或间接的来调用系统空间中的代码。

下面介绍用户程序调用API：ReadFile，如何到达内核层：

对应的汇编代码如下：

eax中保存的就是SSDT的索引。

在KiSystemServcie中，通过eax，索引SSDT中保存的地址，并调用之。

所以，如果我们知道SSDT中的每个地址对应的服务函数，并且知道此服务函数对应到用户层的API。那么我们可以编写一个驱动，加载到内核空间中，将驱动中的我们自己的函数地址替换到SSDT中，应用层调用API后，最后会拐到我们自己的函数中，达到Hook的目的。

系统有两张SSDT表，一个是导出的KeServiceDescriptorTable(ntoskrnl.exe)，一个是未导出的KeServiceDescriptorTableShadow(ntoskrnl.exe,win32k.sys)

由于内核已经导出KeServiceDescriptorTable全局变量，所以编写程序的时候，不需要定位KeServiceDescriptorTable。KeServiceDescriptorTableShadow未导出，所以需要使用一些非公开的方法来定位此地址，通常都是采用硬性编码的，没有系统适应性。

这两张表见图：

在我在做的反截屏驱动中，就是查找到 KeServiceDescriptorTableShadow地址，替换NtGdiBitBlt（对应的Win32 API为 BitBlt）等内核函数地址，进行功能过滤。

SSDT的缺点在于在64位的系统下，基本无法工作，除非你能跨过微软的安全防护。目前来看，还没有人破解win8.1. 

Hook其他进程

下面的例子是否有问题：

  • 示例1：A进程中有个MySleep函数，A进程通过IAT Hook的方式，将A进程中的IAT中对应的Sleep地址进行了替换，替换为MySleep函数地址， Hook是否能够成功？
  • 示例2：A进程中有个MySleep函数，A进程通过IAT Hook的方式，将B进程中的IAT中对应的Sleep地址进行了替换，替换为MySleep函数地址，Hook是否能够成功？

我们知道，Windows下各个进程的空间是相互隔离的。A进程虽然能够替换B进程中的IAT地址（通过VirtualProtect，WriteProcessMemory可以实现），但是替换的MySleep的地址存在于A进程中，并不在B进程中，B进程直接调用，基本的可能就是崩溃了，如果这个地址正好是B进程的一个有效函数地址，还调用成功了，你会更加摸不着头脑。

 

自己Hook自己通常来说，没有太大意义，那么如何Hook其它进程？

  • 如果使用的是SSDT hook，由于是在内核层，对所有的进程都是有效的。
  • 如果是在应用层，如何Hook其它进程？我们可以将我们的函数放置到一个DLL中，将此DLL注入到其他进程中，这样其他进程调用DLL中的函数，将不会访问失败。

 

Windows提供了一种DLL注入的技术，注入的方式有：

  • 使用注册表来注入
  • 使用window 系统消息挂钩来注入（参见 Windows核心编程 22-DIPS示例）
  • 使用远程线程来注入（参见 Windows核心编程 22-InjLib示例）…
  • …

这几种注入技术都在《 Windows核心编程 》详细讲解到。

使用注册表来注入

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows\ 中：

有一个键：AppInit_DLLs，可以包含一组DLL（逗号或空格分隔），将我们的DLL路径写入此键值中。

创建一个名为LoadAppInit_DLLs，将其值设置为1.

当user32.dll被映射到一个新的进程时，会收到DLL_PROCESS_ATTACH通知。当user32.dll对它进行处理时，会取得上述注册表键值，并调用LoadLibrary载入这个键值存储的所有DLL。

 

缺点：

基于CUI的应用程序没有用到user32.dll，因此无法加载DLL。

我可能只想注入某些应用中，映射的越多，崩溃的可能性越大。

使用window 系统消息挂钩来注入

为了能让系统消息挂钩正常运行，Microsoft被迫设计出一种机制，让我们可以将DLL注入到另一进程空间中（想象一下：调用SetWindowsHookEx安装一个WH_GETMESSAGE钩子，如果让其他进程运行SetWindowsHookEx设置的函数？）

SetWindowsHookEx（WH_GETMESSAGE，GetMsgProc，hInstDll，0）；

GetMsgProc在调用此函数的进程空间中，假设为A进程。第三个参数为hInstDll，为当前进程空间中的一个DLL的句柄，此DLL包含了GetMsgProc函数，最后一个参数表示要给哪儿个线程安装，0表示给系统中所有的GUI线程安装挂钩。

接下来会发生什么：

  1. B进程的一个线程准备向一个窗口发送一条消息。
  2. 系统检测到已经安装了一个WH_GETMESSAGE钩子。
  3. 系统检测GetMsgProc所在的DLL是否已经被映射到进程B地址空间中。
  4. 如果尚未映射，系统会强制调用LoadLibrary强制将DLL映射到B进程地址空间中，DLL引用计数加一。
  5. DLL映射到B中的地址可能和A相同，也可能不同。如果不同，需要调整GetMsgProc的地址。
  6. GetMsgProc = hInstDll B + （GetMsgProcA – hInstDll A）
  7. 系统在进程B中地址该DLL的引用计数。
  8. 在B空间调用GetMsgProc，在此函数里，可以做API Hook处理，还可以创建一些消息机制，通过A进程进行功能控制。

使用远程线程来注入

在另一个进程中创建远程线程：

HANDLE WINAPI CreateRemoteThread(
_In_ HANDLE hProcess,
_In_ LPSECURITY_ATTRIBUTES lpThreadAttributes,
_In_ SIZE_T dwStackSize,
_In_ LPTHREAD_START_ROUTINE lpStartAddress,
_In_ LPVOID lpParameter,
_In_ DWORD dwCreationFlags,
_Out_ LPDWORD lpThreadId
);


只要使用这个远程线程调用LoadLibrary，来加载我们的DLL，就能达到DLL注入的目的。例如：

CreateRemoteThread（hProcessRemote，NULL， 0， LoadLibraryW，L"C:\\MyLib.dll", 0, NULL);

当远程线程在远程进程执行时，会立即调用LoadLibraryW，并传入DLL路径。

 

但并没有这么简单

CreateRemoteThread（hProcessRemote，NULL， 0， LoadLibraryW，L"C:\\MyLib.dll", 0, NULL);

但存在两个问题：

  1. 第一个问题是：

上面我们已经讲过LoadLibraryW是个导入函数，使用地址引用IAT的方式来调用，显然这个地址在不同的PE文件里是不同的。在其他进程中，这个地址是不一样的。

对CreateRemoteThread调用，假定本进程和远程进程中，Kernel32.dll被映射到地址空间是同一内存。（虽然是假定，到目前为止，都是同一地址，重启会变，但启动后不变）。

可以改变为：

PTHREAD_START_ROUNTINE pfnThreadRtn = (PTHREAD_START_ROUNTINE)GetProcAddress(GetModuleHandle(_T("Kernel32")), "LoadLibraryW");

CreateRemoteThread（hProcessRemote，NULL， 0， pfnThreadRtn，L"C:\\MyLib.dll", 0, NULL);

  1. 第二个问题：

L"C:\\MyLib.dll"字符串在调用进程中，目标进程并没有这个字符串，如果在目标程序执行，此地址则是执行一个未知地址，可能会崩溃。

解决这个问题的办法，需要把本地字符串放到远程进程去。调用VirtualAllocEx可以让一个进程在另一个进程中分配一块空间。WriteProcessMemory可以将字符串从本进程复制到远程进程中。

Hook 开发库

EasyHook（inline）

同时支持内核和用户层Hook，在使用中发现内核层有不少Bug，据说用户层很稳定。看其代码对多线程没有处理，可能会有问题。

Mhook（inline）

只支持用户层Hook，代码轻量，清晰。

BruceEditCode
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
内核级HOOK的几种实现与应用
11-24
实现内核级 HOOK 对于拦截、分析、跟踪系统内核起着致关重要的作用。实现的方法不同意味着应用侧重点的不同。如想要拦截 NATIVE API 那么可能常用的就是 HOOK SERVICE TABLE 的方法。如果要分析一些系统调用，那么可能想到用 HOOK INT 2E 中断来实现。如果想要拦截或跟踪其他内核 DRIVER 的调用，那么就要用到HOOK PE 的方法来实现。
Hook技术
jinking01的专栏
09-06 3012
linux上基于C和C++的hook尝试
探索SysHttpHookSleep：一款高效实用的HTTP请求延时处理工具
最新发布
gitblog_00063的博客
04-03 299
探索SysHttpHookSleep：一款高效实用的HTTP请求延时处理工具 项目地址:https://gitcode.com/wangfly-me/SysHttpHookSleep 项目简介 在日常的软件开发中，我们常常需要对HTTP请求进行特定的处理，比如模拟延迟响应以测试系统的负载能力或者实现某些特定的业务逻辑。 SysHttpHookSleep（仓库链接）正是这样一款工具，它允许开发者轻松...
Windows HOOK学习（一）：简单的IAT HOOK
weixin_42777366的博客
03-27 929
（若文章有误的请放过，请在留言区告诉我修改一下） 1. 前言 由于毕设项目的需要，从一个毫无基础的小白（只会C语言基础，windows核心编程，汇编都一窍不通，学的很艰难啊），开始慢慢写Hook，记录一下学习过程和成果。 顺便梳理一下学到的知识。 2.准备工作 要学习Hook，当然首先要准备了解一下基础知识和准备编译器啦。 DLL:全名是Dynamic Link Library（动态链接库）。作用...
C#user32.dll内嵌方法使用详解
一只没有感情的AI机械猿
07-14 1588
Console.WriteLine("子窗口句柄: " + childWindowHandle);Console.WriteLine("窗口标题文本长度: " + titleLength);Console.WriteLine("窗口句柄: " + windowHandle);Console.WriteLine("未找到窗口句柄");// 调用 EnumChildWindows 函数来获取指定窗口的所有子窗口句柄。// 调用 EnumChildWindows 函数来枚举指定父窗口的所有子窗口。
Window Hook 技术详解
cx1990820的专栏
08-20 8115
Hook简介 微软的MSDN中，对Hook的解释为： A hook is a point in the system message-handling mechanism where an application can install a subroutine to monitor the message traffic in the system and process certain
Vue-router钩子函数和执行顺序
dachuichaobang的博客
04-29 1956
VUE生命周期中的钩子函数及父子组件的执行顺序 先附一张官网上的vue实例的生命周期图，每个Vue实例在被创建的时候都需要经过一系列的初始化过程，例如需要设置数据监听，编译模板，将实例挂载到DOM并在数据变化时更新DOM等。同时在这个过程中也会运行一些叫做生命周期钩子的函数(回调函数)，这给了用户在不同阶段添加自己代码的机会。 在vue实例的整个生命周期的各个阶段，会提供不同的钩子函数以供我们进行不同的操作。先列出vue官网上对各个钩子函数的详细解析。 创建前/后： beforeCreate：在实例初始
【Inline Hook基础篇】挂钩系统API
Fzuim的博客
07-31 1422
对于怎么挂钩系统API的实现，网上对此的解释有很多也很详细。这边暂不进行长篇大论，就简单的说明下原理：修改系统API的前几个字节，并写入 JMP 0x15a123 汇编指令，实现调用系统API自动跳转到我们的API的过程。 对于API HOOK的实现，现成的有MHOOK、DETOUR等类似的框架实现。既然我们要清晰的认识具体怎么实现，那么我们就自己编写实现方式，不采用第三方库。其实也很简单，没啥...
黑客爱用的 HOOK 技术
dzqxwzoe的博客
03-05 907
上面几种 HOOK，修改的都是应用层的函数指针，而操作系统内核中还有一些非常重要的表格，它们的表项中记录了一些更加关键的函数，HOOK 这些表格中的函数是非常高危的操作，操作不当将导致操作系统崩溃。从时代发展的角度看，网络安全的知识是学不完的，而且以后要学的会更多，同学们要摆正心态，既然选择入门网络安全，就不能仅仅只是入门程度而已，能力越强机会才越多。执行系统调用的时候，CPU 将从用户模式切换到内核模式，进入内核后，将会根据系统调用的 API 编号，去找到对应的系统服务函数，实现对应 API 的功能。
8种HOOK技术
liuhaidon1992的博客
01-07 5274
1.IAT_HOOK IAT是程序中存储导入函数地址的数据结构，如果HOOK了导入函数地址。就可以在函数调用的时候，将函数流程HOOK到我们指定的流程。但是我个人觉得这种方式最好要结合DLL注入的方式，如果单纯的使用HOOK，那么就需要将需要执行的操作的shellcode写入目标进程，如果操作复杂，可能需要的shellcode量特别大，所以我们需要借助DLL注入，这样就将我们需要执行的代码写入...
很不错的VB热键HOOK控件及源程序
05-07
内容索引:VB源码,系统相关,热键,HOOK　很不错的VB热键控件及源程序，可以用代码将多个限制类型用 OR 连接，这样就可以实现,只可用指定的几种组合。形式就不单一了，代码核心不够稳定，可能导致 IDE 异常或崩溃，提高...
autohooks：用于管理git hook的库
02-03
模式当前支持使用自动挂钩的三种模式： pythonpath pipenv poetry 这些模式处理在git hook执行期间如何加载自动钩子，插件及其依赖项。 如果在未指定任何模式，并且在过程中未设置任何模式，则默认情况下，自动钩子...
API HOOK 模块
10-11
分享几种 API HOOK 技术的实现方法，源码，方便开发人员在自己的程序中轻松实现 API HOOK。
React实现全局组件的Toast轻提示效果
12-03
Toast 需要提供几种不同的消息类型以适应不同的使用场景。 Toast 的方法必须足够简洁，以避免不必要的代码冗余。 如何使用 首先引入 import Toast from './components/toast' JSX中事件调用： <button ...
WINAPI调用约定函数的inlineHOOK模板类(class)
09-17
使用class封装的inlineHOOK模板类(class)，可劫持大部分WINAPI函数，此种函数的特征为前5字节为 8B FF 55 8B EC；和使用此模板类的几个示例。 如果劫持关键DLL中的函数，请注意DEP的状态：AlwaysOff或者自己实现过...
浅谈64位进程远程hook技术及64模块导出表的一些变化，附源码-易语言
06-11
本人使用易语言 也有10几年时间，至今留下来的也只是一些...一般远程HOOK数据传递使用消息或者远线程，因为这两种方式汇编改写量小一点，相对容易实现，在这我们不讨论远线程，我们来看看消息传递，一般是两个函数的选
modular-git-hooks:用于将 git hooks 组织到模块化文件目录中的工具
05-31
实现此目的的一种脆弱方法是将来自各种预提交钩子的所有代码复制并粘贴到 git 需要的单个钩子中，名为hooks/pre-commit 。 如果这些钩子中的一些是用不同的语言实现的，这当然是不可能的。 一个稍微不那么可怕但...
闲鱼爬虫,闲鱼采集,闲鱼分析.闲鱼hook,闲鱼签名.闲鱼滑块,闲鱼风控,闲鱼抢拍,闲鱼强聊,闲鱼秒拍,闲鱼商品监控.zip
03-25
爬虫（Web Crawler）是一种自动化程序，用于从互联网上收集信息。其主要功能是访问网页、提取数据并存储，以便后续分析或展示。爬虫通常由搜索引擎、数据挖掘工具、监测系统等应用于网络数据抓取的场景。 爬虫的...
基于SPI 的应用层个人防火墙设计与实现
05-07
本文简要介绍了在Windows 环境下个人防火墙的几种设计技术，对比分析 了各种方法的利弊。作者最终选用SPI 技术实现防火墙的封包截获模块和SSDT HOOK 技术实现防火墙的自我保护模块，实现了一款在Windows 环境下基于 ...
React hook子组件事件代码中调用父组件函数的几种方法
12-02
在React Hook中，子组件调用父组件函数的几种方法如下： 1. 通过props传递函数，子组件调用该函数实现调用父组件函数。 父组件代码： ```javascript import React from 'react'; import Child from './Child'; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值