BOOL WINAPI DllMain(
    HINSTANCE hinstDLL,  // DLL实例的句柄，即DLL被映射到的基地址
    DWORD fdwReason,     // 系统调用 DllMain 的原因
    LPVOID lpReserved    // 保留参数
)
{
    switch(fdwReason)
    {
        case DLL_PROCESS_ATTACH: 	// 进程加载 DLL —— 这是我们执行注入代码的时机！！！！！！！！
            // DLL 首次被加载到进程时调用，例如程序启动或调用 LoadLibrary() 时
            // 只会被调用一次，如果加载失败，返回 FALSE，系统会立即卸载 DLL
            // 常用于初始化全局变量、创建所需的资源（如文件、互斥锁、线程池等）、设置钩子、建立与主程序的通信通道
            break;

        case DLL_THREAD_ATTACH: 	// 创建新线程
            // 进程创建新线程时，系统会调用所有已加载DLL的这个分支
            // 常用于为新线程分配线程局部存储（TLS） 、初始化与该线程有关的对象
            break;

        case DLL_THREAD_DETACH: 	// 线程退出
            // 线程（如调用ExitThread）正常退出时调用
            // 常用于释放该线程的局部资源、关闭句柄、写入日志等
            break;

        case DLL_PROCESS_DETACH: 	// 卸载 DLL
            // DLL 从进程地址空间卸载时（如FreeLibrary）调用
            //  常用于清理全局资源，如关闭文件、释放内存、断开连接
            break;
    }
    return TRUE; // 必须返回TRUE表示成功
}

#ifdef _UNICODE
  typedef wchar_t TCHAR;
#else
  typedef char TCHAR;
#endif

// 1: 强制 ANSI（char*）
TCHAR *sz1 = "Error";  
// 如果 UNICODE 被定义，TCHAR 变成 wchar_t，但这里把 narrow string 赋给 wchar_t* —— 不安全/错误！

// 2: 强制 Unicode（wchar_t*）
TCHAR *sz2 = L"Error";
// 如果 UNICODE 未定义，TCHAR==char，此处把 wchar_t* 赋给 char* —— 不安全/错误！

// 3: 根据 UNICODE 宏自动适配（推荐用于兼容旧代码）
TCHAR *sz3 = _T("Error");
// 如果 UNICODE 未定义 -> TCHAR==char, _T("Error") -> "Error"  （OK）
// 如果 UNICODE 定义 -> TCHAR==wchar_t, _T("Error") -> L"Error" （OK）

char szA[100];
WCHAR szW[100];

// 将Unicode字符串 L"Unicode Str" 转化为 ANSI字符串
sprintf_s(szA, "%S", L"Unicode Str"); 

// 将ANSI字符串 "ANSI Str" 转化为 Unicode字符串
swprintf_s(szW, L"%S", "ANSI Str");

HANDLE WINAPI OpenProcess(
  _In_ DWORD dwDesiredAccess, // 访问权限
  _In_ BOOL  bInheritHandle,  // 句柄是否可被继承
  _In_ DWORD dwProcessId      // 目标进程ID
);

DWORD targetPID = 1234;
HANDLE hProcess = OpenProcess(
    PROCESS_ALL_ACCESS, // 请求所有权限
    FALSE,              // 不继承句柄
    targetPID           // 目标进程ID
);

if (hProcess == NULL) {
    // 打开失败，处理错误
    // 可以调用GetLastError()获取错误代码
}

HANDLE WINAPI CreateThread(
  _In_opt_  LPSECURITY_ATTRIBUTES  lpThreadAttributes, // 线程安全属性
  _In_      SIZE_T                 dwStackSize,        // 初始堆栈大小(0为默认)
  _In_      LPTHREAD_START_ROUTINE lpStartAddress,     // 线程函数地址
  _In_opt_  LPVOID                 lpParameter,        // 传递给线程的参数
  _In_      DWORD                  dwCreationFlags,    // 线程创建标志(0为立即运行)
  _Out_opt_ LPDWORD                lpThreadId          // 接收线程ID的指针
);

// 1. 定义我们的线程函数
DWORD WINAPI MyThreadFunction(LPVOID lpParam) {
    int* pValue = (int*)lpParam;
    printf("线程开始，接收到的参数值: %d\n", *pValue);
    // ... 执行线程任务 ...
    return 0; // 线程退出
}

// 2. 在主函数中创建线程
int myValue = 100;
DWORD threadId;
HANDLE hThread = CreateThread(
    NULL,           // 默认安全属性
    0,              // 默认堆栈大小
    MyThreadFunction, // 线程函数地址
    &myValue,       // 传递给线程的参数
    0,              // 立即运行
    &threadId       // 接收线程ID
);

if (hThread == NULL) {
    // 创建失败
}

HANDLE WINAPI CreateRemoteThread(
  _In_  HANDLE                 hProcess,             // 目标进程句柄
  _In_  LPSECURITY_ATTRIBUTES  lpThreadAttributes, // 线程安全属性
  _In_  SIZE_T                 dwStackSize,        // 初始堆栈大小(0为默认)
  _In_  LPTHREAD_START_ROUTINE lpStartAddress,     // 远程线程函数地址
  _In_  LPVOID                 lpParameter,        // 传递给远程线程的参数
  _In_  DWORD                  dwCreationFlags,    // 线程创建标志(0为立即运行)
  _Out_ LPDWORD                lpThreadId          // 接收线程ID的指针
);

// (这是一个概念性示例，假设hTargetProcess已通过OpenProcess获取)
// (并且pRemoteFunction和pRemoteParam已通过VirtualAllocEx和WriteProcessMemory写入)

// HANDLE hTargetProcess = ... 
// LPVOID pRemoteFunction = ... (例如LoadLibraryA的地址)
// LPVOID pRemoteParam = ... (例如DLL路径字符串在目标进程中的地址)

HANDLE hRemoteThread = CreateRemoteThread(
    hTargetProcess,  // 目标进程句柄
    NULL,            // 默认安全属性
    0,               // 默认堆栈大小
    (LPTHREAD_START_ROUTINE)pRemoteFunction, // 远程函数地址
    pRemoteParam,    // 远程参数地址
    0,               // 立即运行
    NULL             // 不关心线程ID
);

if (hRemoteThread == NULL) {
    // 远程线程创建失败
}

LPVOID WINAPI VirtualAllocEx(
  _In_     HANDLE hProcess,         // 目标进程句柄
  _In_opt_ LPVOID lpAddress,        // 期望的起始地址(NULL为自动选择)
  _In_     SIZE_T dwSize,           // 分配的内存大小(字节)
  _In_     DWORD  flAllocationType, // 内存分配类型(如MEM_COMMIT)
  _In_     DWORD  flProtect         // 内存保护属性(如PAGE_READWRITE)
);

// HANDLE hTargetProcess = ... (通过OpenProcess获取)
SIZE_T allocSize = 1024; // 1KB

LPVOID pRemoteBuffer = VirtualAllocEx(
    hTargetProcess,
    NULL,           // 系统自动选择地址
    allocSize,
    MEM_COMMIT | MEM_RESERVE, // 提交并保留内存
    PAGE_READWRITE  // 内存保护：可读可写
);

if (pRemoteBuffer == NULL) {
    // 分配失败
}

// 函数原型 (结构)
BOOL WINAPI WriteProcessMemory(
  _In_  HANDLE  hProcess,               // 目标进程句柄
  _In_  LPVOID  lpBaseAddress,          // 写入的目标内存基地址
  _In_  LPCVOID lpBuffer,               // 指向本地数据的指针
  _In_  SIZE_T  nSize,                  // 要写入的字节数
  _Out_ SIZE_T* lpNumberOfBytesWritten  // 接收实际写入字节数的指针
);

// HANDLE hTargetProcess = ...
// LPVOID pRemoteBuffer = ... (通过VirtualAllocEx获取)

const char* myData = "Hello, Remote Process!";
SIZE_T dataSize = strlen(myData) + 1; // +1为了null终止符
SIZE_T bytesWritten = 0;

BOOL bResult = WriteProcessMemory(
    hTargetProcess,
    pRemoteBuffer,      // 写入的目标地址
    myData,             // 本地数据源
    dataSize,           // 写入大小
    &bytesWritten       // 接收实际写入的字节数
);

if (bResult == FALSE || bytesWritten != dataSize) {
    // 写入失败
}

// 函数原型 (结构)
HMODULE WINAPI GetModuleHandle(
  _In_opt_ LPCTSTR lpModuleName  // 模块名称(DLL或EXE)，NULL为获取主EXE句柄
);

// 1. 获取当前进程(EXE)的模块句柄
HMODULE hExe = GetModuleHandle(NULL);

// 2. 获取kernel32.dll的模块句柄(它一定已被加载)
HMODULE hKernel32 = GetModuleHandle(_T("kernel32.dll"));

if (hKernel32 == NULL) {
    // 获取失败(极不可能发生)
}

// 函数原型 (结构)
DWORD WINAPI GetModuleFileName(
  _In_opt_ HMODULE hModule,    // 模块句柄(NULL为获取当前EXE路径)
  _Out_    LPTSTR  lpFilename, // 接收路径的缓冲区
  _In_     DWORD   nSize     // 缓冲区大小(TCHARs)
);

TCHAR exePath[MAX_PATH]; // MAX_PATH是一个预定义常量
DWORD pathLen = GetModuleFileName(
    NULL,    // 传递NULL来获取当前EXE的路径
    exePath, // 接收路径的缓冲区
    MAX_PATH // 缓冲区大小
);

if (pathLen == 0) {
    // 获取失败
} else {
    // exePath现在包含"C:\Path\To\YourApp.exe"
}

// 函数原型 (结构)
FARPROC WINAPI GetProcAddress(
  _In_ HMODULE hModule,     // 模块句柄
  _In_ LPCSTR  lpProcName  // 导出函数名称(ANSI字符串)
);

// 1. 定义一个函数指针类型，使其与CreateFileA匹配
typedef HANDLE (WINAPI *PFN_CREATEFILEA)(
    LPCSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE
);

// 2. 获取模块句柄
HMODULE hKernel32 = GetModuleHandle(_T("kernel32.dll"));

// 3. 获取函数地址
FARPROC pFunc = GetProcAddress(
    hKernel32,
    "CreateFileA" // 注意：必须是ANSI字符串
);

if (pFunc == NULL) {
    // 获取地址失败
} else {
    // 4. 将通用的FARPROC转换为我们定义的类型
    PFN_CREATEFILEA MyCreateFile = (PFN_CREATEFILEA)pFunc;
    // 5. 现在可以像普通函数一样调用它
    // MyCreateFile("test.txt", ...);
}

// 函数原型 (结构)
DWORD WINAPI WaitForSingleObject(
  _In_ HANDLE hHandle,        // 要等待的对象句柄(如线程、进程)
  _In_ DWORD  dwMilliseconds  // 超时时间(毫秒)，INFINITE为无限等待
);

// HANDLE hThread = ... (通过CreateThread获取)

DWORD waitResult = WaitForSingleObject(
    hThread,
    INFINITE // 无限期等待，直到线程结束
);

if (waitResult == WAIT_OBJECT_0) {
    // 线程已成功结束
    printf("线程已退出。\n");
} else {
    // 等待失败或超时
}

// 函数原型 (结构)
BOOL WINAPI CloseHandle(
  _In_ HANDLE hObject  // 要关闭的有效对象句柄
);

// HANDLE hProcess = OpenProcess(...);
// HANDLE hThread = CreateThread(...);

// 使用完毕后...
if (hThread != NULL) {
    CloseHandle(hThread); // 关闭线程句柄
}
if (hProcess != NULL) {
    CloseHandle(hProcess); // 关闭进程句柄
}

HHOOK WINAPI SetWindowsHookEx(
  _In_ int       idHook,     // 钩子类型(如WH_KEYBOARD_LL)
  _In_ HOOKPROC  lpfn,       // 钩子过程(回调函数)的地址
  _In_ HINSTANCE hMod,       // 包含钩子过程的DLL句柄
  _In_ DWORD     dwThreadId  // 要钩取的线程ID(0为所有线程)
);

// 1. 定义一个钩子过程
LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) {
    if (nCode == HC_ACTION) {
        // ... 处理键盘事件 ...
    }
    // 必须调用下一个钩子
    return CallNextHookEx(NULL, nCode, wParam, lParam);
}

// 2. 在主函数中安装钩子
HHOOK g_hHook = NULL;
g_hHook = SetWindowsHookEx(
    WH_KEYBOARD_LL,     // 钩子类型：低级键盘
    LowLevelKeyboardProc, // 钩子过程回调函数
    GetModuleHandle(NULL), // 包含回调函数的模块句柄
    0                      // 关联到所有线程
);

if (g_hHook == NULL) {
    // 安装钩子失败
}

// 函数原型 (结构)
LRESULT WINAPI CallNextHookEx(
  _In_opt_ HHOOK  hhk,    // 当前钩子的句柄(可忽略，传NULL)
  _In_     int    nCode,  // 钩子代码(从回调函数传入)
  _In_     WPARAM wParam, // 消息参数(从回调函数传入)
  _In_     LPARAM lParam  // 消息参数(从回调函数传入)
);

// (HHOOK g_hHook; 在SetWindowsHookEx中获取)
LRESULT CALLBACK MyHookProc(int nCode, WPARAM wParam, LPARAM lParam) {
    // ... 在这里可以监视或修改 wParam/lParam ...
    
    // 在钩子过程中调用此函数至关重要
    // 否则会“吞掉”消息，导致系统或其他程序功能异常
    return CallNextHookEx(g_hHook, nCode, wParam, lParam);
}

// 函数原型 (结构)
BOOL WINAPI UnhookWindowsHookEx(
  _In_ HHOOK hhk // 要移除的钩子句柄
);

// HHOOK g_hHook = ... (通过SetWindowsHookEx获取)

if (g_hHook != NULL) {
    BOOL bResult = UnhookWindowsHookEx(g_hHook);
    if (bResult) {
        // 卸载成功
        g_hHook = NULL;
    }
}

#include <windows.h>
#include <tchar.h> // 为了 TCHAR 和 _T()

BOOL WINAPI DllMain(
    HINSTANCE hinstDLL,  // DLL实例句柄
    DWORD fdwReason,     // 调用原因
    LPVOID lpReserved    // 保留
)
{
    // 我们只关心DLL何时被“附加”到进程上
    switch (fdwReason)
    {
        case DLL_PROCESS_ATTACH:
            // 当DLL被加载时，在目标进程中弹出一个消息框
            MessageBox(
                NULL,                             // 父窗口句柄 (NULL 亦可)
                _T("DLL 注入成功! (来自 TestDll_MsgBox)"), // 消息内容
                _T("注入测试"),                     // 标题
                MB_OK | MB_ICONINFORMATION        // 按钮 (OK) 和图标 (信息)
            );
            break;

        case DLL_THREAD_ATTACH:
            // 线程创建时不做任何事
            break;

        case DLL_THREAD_DETACH:
            // 线程退出时不做任何事
            break;

        case DLL_PROCESS_DETACH:
            // DLL被卸载时不做任何事
            break;
    }
    return TRUE; // 始终返回 TRUE
}

#include <windows.h>

BOOL WINAPI DllMain(
    HINSTANCE hinstDLL,
    DWORD fdwReason,
    LPVOID lpReserved
)
{
    switch (fdwReason)
    {
        case DLL_PROCESS_ATTACH:
            // 当DLL被加载时，播放一个“信息”提示音
            // MB_ICONINFORMATION 对应一个系统声音
            // 你也可以用 Beep(1000, 500); 来发声 (1000Hz, 500毫秒)
            MessageBeep(MB_ICONINFORMATION);
            break;
    }
    return TRUE;
}

#include <windows.h>
#include <stdio.h>    // 为了 printf 和 FILE*
#include <io.h>       // 为了 _open_osfhandle
#include <fcntl.h>    // 为了 _O_TEXT

// 我们的控制台线程
// 注意：在DllMain中执行复杂操作（比如创建控制台）是不被推荐的
// 因为 DllMain 运行在加载器锁 (Loader Lock) 内部，容易造成死锁。
// 最安全的方法是像这样，创建一个新线程来执行实际工作。
DWORD WINAPI ConsoleThread(LPVOID lpParam)
{
    // 1. 为当前进程分配一个新的控制台窗口
    if (AllocConsole())
    {
        FILE* pFile = NULL;
        
        // 2. 将标准输出 (stdout) 重定向到新的控制台
        // freopen_s 是一个安全的方式来重新打开一个文件流
        freopen_s(&pFile, "CONOUT$", "w", stdout); // "CONOUT$" 是控制台输出的设备名

        // 3. 设置标题
        SetConsoleTitle(_T("Injected Console - (TestDll_Console)"));

        // 4. 打印我们的消息
        printf("--- DLL 注入成功! ---\n");
        printf("这个控制台窗口现在属于目标进程。\n");
        printf("按回车键关闭此控制台...\n");

        // 5. 等待用户输入，以便观察
        getchar();

        // 6. 清理并释放控制台
        if (pFile)
        {
            fclose(pFile);
        }
        FreeConsole();
    }
    
    return 0;
}

BOOL WINAPI DllMain(
    HINSTANCE hinstDLL,
    DWORD fdwReason,
    LPVOID lpReserved
)
{
    switch (fdwReason)
    {
        case DLL_PROCESS_ATTACH:
            // 创建一个新线程来执行我们的控制台逻辑
            // 我们不希望在 DllMain 中直接做这些
            HANDLE hThread = CreateThread(NULL, 0, ConsoleThread, NULL, 0, NULL);
            if (hThread)
            {
                CloseHandle(hThread); // 关闭句柄，线程会继续执行
            }
            break;
    }
    return TRUE;
}

HANDLE WINAPI CreateRemoteThread(
  _In_  HANDLE                                       hProcess,                   // 目标进程句柄
  _In_  LPSECURITY_ATTRIBUTES            lpThreadAttributes,   // 线程安全属性
  _In_  SIZE_T                                           dwStackSize,             // 初始堆栈大小(0为默认)
  _In_  LPTHREAD_START_ROUTINE        lpStartAddress,         // 远程线程函数地址，重要！
  _In_  LPVOID                                         lpParameter,              // 传递给远程线程的参数，重要！
  _In_  DWORD                                        dwCreationFlags,      // 线程创建标志(0为立即运行)
  _Out_ LPDWORD                                   lpThreadId                // 接收线程ID的指针
);

GetProcAddress(GetModuleHandle(L"kernel32.dll"), "LoadLibraryW")

LoadLibrary("C:\\path\\to\\myhack.dll")

#include <windows.h>
#include <tchar.h>

BOOL InjectDll(DWORD dwPID, LPCTSTR szDllPath) {
    HANDLE hProcess = NULL, hThread = NULL;
    HMODULE hMod = NULL;
    LPVOID pRemoteBuf = NULL;
    
    // 1. 计算DLL路径字符串所需的字节大小 (包括结尾的 \0)
    DWORD dwBufSize = (DWORD)(_tcslen(szDllPath) + 1) * sizeof(TCHAR);
    LPTHREAD_START_ROUTINE pThreadProc;

    // 2. 获取目标进程句柄 (dwPID)，需要所有权限
    if (!(hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID)))
        return FALSE;

    // 3. 在目标进程中分配内存，用于存放DLL路径
    pRemoteBuf = VirtualAllocEx(hProcess, NULL, dwBufSize, MEM_COMMIT, PAGE_READWRITE);
    if (pRemoteBuf == NULL) {
        CloseHandle(hProcess);
        return FALSE;
    }

    // 4. 将DLL路径字符串写入刚刚分配的远程内存中
    if (!WriteProcessMemory(hProcess, pRemoteBuf, (LPVOID)szDllPath, dwBufSize, NULL)) {
        CloseHandle(hProcess);
        return FALSE;
    }

    // 5. 获取 Kernel32.dll 模块的句柄（在当前进程中）
    hMod = GetModuleHandle(_T("kernel32.dll"));
    
    // 6. 获取 LoadLibraryW 函数的地址
    // (这里使用 LoadLibraryW 是因为我们使用了 TCHAR，并且很可能定义了 UNICODE)
    pThreadProc = (LPTHREAD_START_ROUTINE)GetProcAddress(hMod, "LoadLibraryW");

    // 7. 在目标进程中创建远程线程
    // 线程函数 = LoadLibraryW 的地址
    // 线程参数 = 远程内存中DLL路径的地址
    hThread = CreateRemoteThread(hProcess, NULL, 0, pThreadProc, pRemoteBuf, 0, NULL);
    if (hThread == NULL) {
        CloseHandle(hProcess);
        return FALSE;
    }

    WaitForSingleObject(hThread, INFINITE); // 等待线程执行完毕

    // 8. 清理
    // VirtualFreeEx(hProcess, pRemoteBuf, 0, MEM_RELEASE); // 理论上应该释放内存
    CloseHandle(hThread);
    CloseHandle(hProcess);
    return TRUE;
}

int _tmain(int argc, TCHAR* argv[]) {
    // 用法: InjectDll.exe <PID> <DLL路径>
    // 示例: InjectDll.exe 4232 F:\1\MyDll.dll
    if (argc != 3) {
        _tprintf(_T("Usage: InjectDll.exe <PID> <Full Dll Path>\n"));
        return 1;
    }
    
    if (InjectDll(_ttoi(argv[1]), argv[2])) {
        _tprintf(_T("InjectDll(\"%s\") success!!!\n"), argv[2]);
    }
    
    return 0;
}

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows

HHOOK WINAPI SetWindowsHookEx(
  _In_ int                      idHook,          // 钩子类型(如WH_KEYBOARD_LL)
  _In_ HOOKPROC       lpfn,                // 钩子过程(回调函数)的地址
  _In_ HINSTANCE        hMod,            // 包含钩子过程的DLL句柄
  _In_ DWORD             dwThreadId    // 要钩取的线程ID(0为所有线程)
);

#include <windows.h>
#include <tchar.h>

// 必须使用共享变量，以便在不同进程中共享句柄
#pragma data_seg("Shared")
HINSTANCE g_hInstance = NULL; // DLL实例句柄
HHOOK g_hHook = NULL;         // 钩子句柄
#pragma data_seg()
#pragma comment(linker, "/SECTION:Shared,RWS") // 设置段属性为读、写、共享

BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD dwReason, LPVOID lpvReserved) {
    if (dwReason == DLL_PROCESS_ATTACH) {
        g_hInstance = hinstDLL; // 保存DLL实例句柄
    }
    return TRUE;
}

// 钩子过程（回调函数）
LRESULT CALLBACK KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) {
    // lParam的第31位：0表示按键，1表示释放键
    if (nCode >= 0 && !(lParam & 0x80000000)) {
        TCHAR szPath[MAX_PATH] = {0};
        GetModuleFileName(NULL, szPath, MAX_PATH);
        TCHAR *p = _tcsrchr(szPath, _T('\\'));

        // 检查当前进程是否为 notepad.exe
        if (p && !lstrcmpi(p + 1, _T("notepad.exe"))) {
            return 1; // 是Notepad，返回1，拦截该消息（按键失效）
        }
    }
    
    // 不是Notepad，或不是按键消息，将消息传递给下一个钩子
    return CallNextHookEx(g_hHook, nCode, wParam, lParam);
}

// 导出函数：开始钩取
extern "C" __declspec(dllexport) void HkStart() {
    g_hHook = SetWindowsHookEx(
        WH_KEYBOARD,    // 钩子类型：键盘
        KeyboardProc,   // 钩子过程地址
        g_hInstance,    // DLL实例句柄
        0               // 全局钩子（所有线程）
    );
}

// 导出函数：停止钩取
extern "C" __declspec(dllexport) void HkStop() {
    if (g_hHook) {
        UnhookWindowsHookEx(g_hHook);
        g_hHook = NULL;
    }
}

#include <windows.h>
#include <tchar.h>

// 定义导出函数的指针类型
typedef void (*PFN_HOOKSTART)();
typedef void (*PFN_HOOKSTOP)();

int _tmain(int argc, TCHAR* argv[]) {
    HMODULE hDll = NULL;
    
    // 1. 加载DLL
    if (!(hDll = LoadLibraryA("HookDll.dll"))) // 使用A版本
        return 1;

    // 2. 获取导出函数地址
    PFN_HOOKSTART HookStart = (PFN_HOOKSTART)GetProcAddress(hDll, "HkStart");
    PFN_HOOKSTOP HookStop = (PFN_HOOKSTOP)GetProcAddress(hDll, "HkStop");

    if (!HookStart || !HookStop) {
        FreeLibrary(hDll);
        return 1;
    }

    // 3. 调用导出函数，安装全局钩子
    HookStart();

    _tprintf(_T("Hook installed. Press 'q' to quit!\n"));
    
    // 4. 阻塞，等待用户退出
    while (getchar() != 'q');

    // 5. 卸载钩子
    HookStop();
    
    // 6. 释放DLL
    FreeLibrary(hDll);
    return 0;
}

#include <windows.h>
#include <tchar.h>
#include <urlmon.h>
#pragma comment(lib, "urlmon.lib")

// 必须提供至少一个导出函数
extern "C" __declspec(dllexport) void dummy() {
    return;    //什么也不做
}

新RVA = 新RAW - 节RAW + 节RVA

typedef struct _IMAGE_IMPORT_DESCRIPTOR {
    union {
        DWORD Characteristics; 
        DWORD OriginalFirstThunk;  //导入名称表 INT 的 RVA
    };
    DWORD TimeDateStamp;           // 通常为 0
    DWORD ForwarderChain;          // 通常为 -1 或 0
    DWORD Name;                    // DLL 名称的 RVA
    DWORD FirstThunk;              // 导入地址表 IAT 的 RVA 
} IMAGE_IMPORT_DESCRIPTOR;

0x60000020+0x80000000=0xE0000020

typedef struct _THREAD_PARAM {
    // 我们需要目标进程调用 LoadLibraryA 和 GetProcAddress
    // 所以我们提前查好这两个API的地址传进去
    FARPROC pLoadLibrary;      
    FARPROC pGetProcAddress;   
    
    // 我们需要的数据（字符串）
    char moduleName[128];     // "user32.dll"
    char procName[128];       // "MessageBoxA"
} THREAD_PARAM, *PTHREAD_PARAM;

// 定义函数指针类型，以便在代码中调用
typedef HMODULE (WINAPI *PFLOADLIBRARYA)(LPCSTR);
typedef FARPROC (WINAPI *PFGETPROCADDRESS)(HMODULE, LPCSTR);
typedef int (WINAPI *PFMESSAGEBOXA)(HWND, LPCSTR, LPCSTR, UINT);

// 这就是我们的“有效载荷”
// 它将在目标进程的内存中执行
BOOL WINAPI ThreadProc(LPVOID lParam) {
    PTHREAD_PARAM param = (PTHREAD_PARAM)lParam;
    HMODULE hMod = NULL;
    FARPROC pFunc = NULL;

    // 1. 使用传入的 pLoadLibrary 地址，加载 "user32.dll"
    hMod = ((PFLOADLIBRARYA)param->pLoadLibrary)(param->moduleName);
    if (!hMod) return FALSE;

    // 2. 使用传入的 pGetProcAddress 地址，获取 "MessageBoxA" 地址
    pFunc = ((PFGETPROCADDRESS)param->pGetProcAddress)(hMod, param->procName);
    if (!pFunc) return FALSE;

    // 3. 调用 MessageBoxA
    ((PFMESSAGEBOXA)pFunc)(NULL, param->moduleName, param->procName, MB_OK);
    return TRUE;
}

BOOL InjectCode(DWORD dwPID) {
    HANDLE hProcess = NULL, hThread = NULL;
    LPVOID pRemoteBuf[2] = {0}; // pRemoteBuf[0] = 参数, pRemoteBuf[1] = 代码
    THREAD_PARAM param = {0};
    DWORD dwSize = 0;

    // 1. 填充参数结构体 (在注入器进程中)
    HMODULE hMod = GetModuleHandle(_T("kernel32.dll"));
    param.pLoadLibrary = GetProcAddress(hMod, "LoadLibraryA");
    param.pGetProcAddress = GetProcAddress(hMod, "GetProcAddress");
    strcpy_s(param.moduleName, "user32.dll");
    strcpy_s(param.procName, "MessageBoxA");
    
    // ... (OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID) 获取 hProcess) ...
    if (!hProcess) return FALSE;

    // 2. 注入参数 (pRemoteBuf[0])
    dwSize = sizeof(THREAD_PARAM);
    pRemoteBuf[0] = VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT, PAGE_READWRITE);
    if (!pRemoteBuf[0]) return FALSE;
    if (!WriteProcessMemory(hProcess, pRemoteBuf[0], (LPVOID)&param, dwSize, NULL))
        return FALSE;

    // 3. 注入代码 (pRemoteBuf[1])
    //    (InjectCode 和 ThreadProc 必须在同一个文件里)
    dwSize = (DWORD)InjectCode - (DWORD)ThreadProc;
    if (dwSize <= 0) return FALSE; // 确保大小正确
    
    pRemoteBuf[1] = VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    if (!pRemoteBuf[1]) return FALSE;
    if (!WriteProcessMemory(hProcess, pRemoteBuf[1], (LPVOID)ThreadProc, dwSize, NULL))
        return FALSE;

    // 4. 创建远程线程，执行代码
    hThread = CreateRemoteThread(hProcess, NULL, 0,
        (LPTHREAD_START_ROUTINE)pRemoteBuf[1], // lpStartAddress = 代码地址
        pRemoteBuf[0],                         // lpParameter = 参数地址
        0, NULL);
    if (!hThread) return FALSE;

    // ... (清理句柄) ...
    return TRUE;
}

dwSize = (DWORD)InjectCode - (DWORD)ThreadProc;

BOOL WINAPI FreeLibrary(HMODULE hLibModule);

#include <windows.h>
#include <tchar.h>
#include <tlhelp32.h> // 用于CreateToolhelp32Snapshot

// (这里需要一个FindProcessID函数，PDF中省略了，我们假设它已实现)
DWORD FindProcessID(LPCTSTR szProcessName); 

BOOL EjectDll(DWORD dwPID, LPCTSTR szDllName) {
    HANDLE hSnapshot = NULL, hProcess = NULL, hThread = NULL;
    MODULEENTRY32 me = {sizeof(me)}; // 必须初始化dwSize

    // 1. 创建工具快照，获取指定PID进程加载的所有模块（DLL）
    hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwPID);
    if (hSnapshot == INVALID_HANDLE_VALUE) return FALSE;

    // 2. 遍历模块列表
    BOOL bFound = FALSE;
    BOOL bMore = Module32First(hSnapshot, &me);
    for (; bMore; bMore = Module32Next(hSnapshot, &me)) {
        // 比较模块名或路径，找到我们要卸载的DLL
        if (!lstrcmpi(me.szModule, szDllName) || !lstrcmpi(me.szExePath, szDllName)) {
            bFound = TRUE;
            break; // 找到了
        }
    }
    CloseHandle(hSnapshot); // 关闭快照句柄
    if (!bFound) return FALSE; // 没找到

    // 3. 获取目标进程句柄
    if (!(hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID)))
        return FALSE;

    // 4. 获取 FreeLibrary 的地址（它也在 kernel32.dll 中）
    HMODULE hModule = GetModuleHandle(_T("kernel32.dll"));
    LPTHREAD_START_ROUTINE pThreadProc = (LPTHREAD_START_ROUTINE)GetProcAddress(hModule, "FreeLibrary");

    // 5. 创建远程线程
    // 线程函数 = FreeLibrary
    // 线程参数 = 要卸载的DLL的基地址 (me.modBaseAddr)
    hThread = CreateRemoteThread(hProcess, NULL, 0, pThreadProc, me.modBaseAddr, 0, NULL);
    if (hThread == NULL) {
        CloseHandle(hProcess);
        return FALSE;
    }

    WaitForSingleObject(hThread, INFINITE);
    CloseHandle(hThread);
    CloseHandle(hProcess);
    return TRUE;
}

int _tmain(int argc, TCHAR* argv[]) {
    DWORD dwPID = FindProcessID(_T("notepad.exe"));
    if (dwPID) {
        EjectDll(dwPID, _T("MyDll.dll"));
    }
    return 0;
}