Windows API Hook C++

Question

Я учусь писать хуки для Windows API и для упражнения пишу хуки для функции pDeleteFileA. Когда функция будет вызвана, перед удалением файла я хочу проверить, является ли имя файла 'testfile.txt', если да, то вместо того, чтобы удалить его, появится сообщение, и если его вызвали что-то еще, тогда продолжите удаление файла.

Я уже написал некоторый код, и код компилируется без каких-либо ошибок, но когда я пытаюсь удалить "testfile.txt", он просто удаляется. Может, кто-нибудь подскажет, что я делаю неправильно или что я не делаю?

Вот мой код до сих пор:

#include <Windows.h>

struct hook_t{// a datatype to store information about our hook
    bool isHooked = false;
    void* FunctionAddress = operator new(100);
    void* HookAddress = operator new(100);
    char Jmp[6] = { 0 };
    char OriginalBytes[6] = {0};
    void* OriginalFunction = operator new(100);
};

namespace hook {
    bool InitializeHook(hook_t* Hook, char* Module, char* Function, void* HookFunction) {
        HMODULE hModule;
        DWORD OrigFunc, FuncAddr;
        byte opcodes[] = {0x90, 0x90, 0x90, 0x90, 0x90, 0xe9, 0x00, 0x00, 0x00, 0x00};
        if (Hook->isHooked) {
            return false;
        }

        hModule = GetModuleHandleA(Module);
        if (hModule == INVALID_HANDLE_VALUE) {
            Hook->isHooked = false;
            return false;
        }

        Hook->Jmp[0] = 0xe9;
        *(PULONG)&Hook->Jmp[1] = (ULONG)HookFunction - (ULONG)Hook->FunctionAddress - 5;
        memcpy(Hook->OriginalBytes, Hook->FunctionAddress, 5);
        Hook->OriginalFunction = VirtualAlloc(0, 4096, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
        if (Hook->OriginalFunction == NULL) {
            return false;
        }
        memcpy(Hook->OriginalFunction, Hook->OriginalBytes, 5);
        OrigFunc = (ULONG)Hook->OriginalFunction + 5;
        FuncAddr = (ULONG)Hook->OriginalFunction + 5;
        *(LPBYTE)((LPBYTE)Hook->OriginalFunction + 5) = 0xe9;
        *(PULONG)((LPBYTE)Hook->OriginalFunction + 6) = (ULONG)FuncAddr;
        Hook->isHooked = true;
        return true;

    }//end InitializeHook

    bool InsertHook(hook_t* Hook) {
        DWORD op;
        if (!Hook->isHooked) {
            return false;
        }
        VirtualProtect(Hook->FunctionAddress, 5, PAGE_EXECUTE_READWRITE, &op);
        memcpy(Hook->FunctionAddress, Hook->Jmp, 5);
        VirtualProtect(Hook->FunctionAddress, 5, op, &op);
        return true;
    }

    bool Unhook(hook_t* Hook) {
        DWORD op;
        if (!Hook->isHooked) {
            return false;
        }
        VirtualProtect(Hook->FunctionAddress, 5, PAGE_EXECUTE_READWRITE, &op);
        memcpy(Hook->FunctionAddress, Hook->OriginalBytes, 5);
        VirtualProtect(Hook->FunctionAddress, 5, op, &op);
        Hook->isHooked = false;
        return true;
    }

    bool FreeHook(hook_t* Hook) {
        if (Hook->isHooked) {
            return false;
        }
        VirtualFree(Hook->OriginalFunction, 0, MEM_RELEASE);
        memset(Hook, 0, sizeof(hook_t*));
        return true;
    }

}//end namespase

==========================================================================

#define _CRT_SECURE_NO_WARNINGS

#include "apihook.h"
#include <stdlib.h>
#include <stdio.h>
#include <iostream>

using namespace hook;

//define the function to be hooked
typedef BOOL(WINAPI* pDeleteFileA)(LPCSTR lpFileName);//in this case this will be delete file a

pDeleteFileA pDeleteFile;//instance of it
hook_t* Hook = new hook_t();

//this function will replace the original API function in the process
BOOL WINAPI HookDeleteFileA(LPCSTR lpFileName) {
    //we can do here whatever we want before the original API function is called
    //for example disable deleting of a certain file
    if (strstr(lpFileName, "testfile")) {//checks if parameter contains a string
        //disable deleting of this file
        SetLastError(ERROR_ACCESS_DENIED);
        MessageBoxA(0, "You can't delete this file!", "error", 0);
        return false;
    }
    return pDeleteFile(lpFileName);//if parameter does not contain our string, call the original API function
}

void StartRoutine() {
    pDeleteFile = (pDeleteFileA)&Hook->OriginalFunction;
    //the pDeleteFileA is located in "kernel32.dll"
    InitializeHook(Hook, "kernel32.dll", "DeleteFileA", HookDeleteFileA);
    InsertHook(Hook);//spawn the hook to the current process
}

BOOL WINAPI DllMain(HMODULE hModule, DWORD dwReason, LPVOID lpReserved) {
    switch (dwReason) {
    case DLL_PROCESS_ATTACH:
        printf("API Hook Attached!");//notify
        StartRoutine();
        break;
    case DLL_PROCESS_DETACH:
        Unhook(Hook);//unhook the hook
        FreeHook(Hook);//remove the hook from memory
    }
}

int main() {

    HMODULE hModule = GetModuleHandleA("kernel32.dll");

    //The reason code that indicates why the DLL entry-point function is being called.
    //This parameter can be one of the following values:
    //DLL_PROCESS_ATTACH 1:
    //The DLL is being loaded into the virtual address space of the current process 
    //as a result of the process starting up or as a result of a call to LoadLibrary. 
    //DLL_PROCESS_DETACH 0:
    //The DLL is being unloaded from the virtual address space of the calling process 
    //because it was loaded unsuccessfully or the reference count has reached zero 
    //(the processes has either terminated or called FreeLibrary one time for each time it called LoadLibrary).
    DWORD dwReason = DLL_PROCESS_ATTACH;


    //If fdwReason is DLL_PROCESS_ATTACH, lpvReserved is NULL for dynamic loads and non-NULL for static loads
    //If fdwReason is DLL_PROCESS_DETACH, lpvReserved is NULL if FreeLibrary has been called or the DLL load 
    //failed and non-NULL if the process is terminating.
    LPVOID lpReserved = NULL;

    DllMain(hModule, dwReason, lpReserved);

    return 0;
}

Answer 1

Каждый процесс имеет свое собственное адресное пространство.

Каждый процесс загружает свои библиотеки DLL отдельно и имеет отдельную память. Поэтому, если вы пытаетесь перезаписать память - вы перезаписываете только копию DLL, которая загружена в ваш процесс. Это сделано из соображений стабильности и безопасности.

Чтобы перезаписать память и выполнить код в другом процессе - вам нужно использовать DLL-инъекцию, в вики есть хороший обзор сценариев и методов.

Поэтому вам нужно поместить свой код в DLL, а затем загрузить эту DLL в процесс цели. Тогда ваша DLL в своем DLLMain перезапишет функцию для этого процесса (код хука). Это также означает, что код подключения будет выполняться в контексте подключенного процесса, поэтому MessageBox или printf могут работать не так, как ожидалось.

Также я настоятельно рекомендую использовать второй ПК с удаленной отладкой или виртуальной машиной, потому что перехват системных процессов может вызвать нестабильность.

Редактировать: еще несколько заметок. Вы пытаетесь зацепить DeleteFileA, которая является версией ASCII и будет использовать более новое программное обеспечение DeleteFileW вместо.

Edit2: также вы не можете загрузить 32-битную DLL в 64-битный процесс и наоборот.