Windows下DLL远程注入实战：如何安全卸载不影响宿主进程（附VC2008源码）

Windows平台DLL远程注入与安全卸载：从原理到实战的深度解析

如果你在Windows平台上做过一些底层开发，尤其是涉及进程间通信或功能扩展，大概率会碰到一个经典场景：需要将一个动态链接库（DLL）注入到另一个正在运行的进程中。这听起来像是高级黑客技术，但实际上，它在软件调试、热修复、功能插件化、安全监控等众多合法且实用的领域有着广泛的应用。然而，很多开发者，包括一些有经验的中高级工程师，在成功实现注入后，往往会遇到一个更棘手的问题——如何在不影响宿主进程稳定性的前提下，安全、干净地卸载这个DLL。一个不当的卸载操作，轻则导致目标进程功能异常，重则直接引发进程崩溃，让之前所有的努力付诸东流。

这篇文章，我们就来彻底拆解这个难题。我不会仅仅给你一段可以“复制粘贴”的代码，而是会带你深入Windows进程和内存管理的核心，理解远程注入与卸载背后的机制。我们将从最基础的API讲起，逐步构建一个健壮的注入/卸载框架，并重点剖析那些导致卸载失败的“坑”，以及如何优雅地跨过它们。无论你是想为自己的软件增加插件系统，还是需要对第三方进程进行合法监控，亦或是单纯对Windows底层机制充满好奇，这篇文章都将提供一套完整、可操作且注重安全性的解决方案。

1. 理解远程注入：不仅仅是“注入”那么简单

在深入代码之前，我们必须先建立正确的认知模型。远程DLL注入，本质上是在目标进程的地址空间中“强塞”并执行一段我们指定的代码。这个过程绕过了进程本身的安全边界，因此充满了风险与挑战。

1.1 核心原理与关键API

Windows操作系统为进程提供了严格的隔离机制，每个进程都拥有独立的虚拟地址空间。远程注入的核心，就是利用系统提供的几个关键API，突破这层隔离。

• OpenProcess: 这是第一步，获取目标进程的句柄。你需要足够的权限（如PROCESS_ALL_ACCESS或更细粒度的权限组合）才能进行操作。权限不足是注入失败的常见原因之一。
• VirtualAllocEx / WriteProcessMemory: 在目标进程的地址空间中分配内存，并将我们的DLL路径字符串写入这块内存。这就像在别人的房子里租了一个房间，并放进去一张写着地址的纸条。
• CreateRemoteThread: 这是最关键的步骤。它在目标进程中创建一个新的线程，并让这个线程的入口点指向系统函数LoadLibraryA或LoadLibraryW，同时将之前写入的DLL路径地址作为参数传递给它。于是，目标进程“自己”调用了LoadLibrary，加载了我们的DLL。

这个过程听起来清晰，但魔鬼藏在细节里。例如，32位进程无法注入64位进程，反之亦然，因为地址空间寻址方式不同。再比如，如果目标进程运行在更低或受保护完整性级别下，即使你有管理员权限，也可能无法成功打开进程。

1.2 注入方式的演进与选择

除了经典的CreateRemoteThread + LoadLibrary方法，还有其他几种注入技术，各有优劣：

对于大多数应用开发场景，CreateRemoteThread方法因其稳定性和可理解性，仍然是首选。我们后续的实战也将基于此方法展开。

注意：在进行任何形式的进程注入前，请务必确保你拥有合法的权限，并且操作符合软件许可协议和法律法规。对非自有进程的注入应仅限于调试、分析或获得明确授权的场景。

2. 构建稳健的注入器：权限、路径与错误处理

理解了原理，我们开始动手构建注入器。一个健壮的注入器不能只关注“成功注入”这一种情况，必须妥善处理权限提升、路径解析、进程选择以及各种可能的错误。

2.1 权限提升：以调试权限运行

许多系统进程（如svchost.exe, lsass.exe）或受保护进程，默认情况下普通管理员权限也无法完全访问。这时需要为当前进程启用SeDebugPrivilege（调试特权）。这个特权允许进程调试和修改其他进程，是注入操作的关键前提。

下面是一个启用特权的通用函数实现：

bool EnableDebugPrivilege(BOOL bEnable) {
    HANDLE hToken = nullptr;
    TOKEN_PRIVILEGES tp = {0};
    LUID luid;

    // 1. 打开当前进程的访问令牌
    if (!OpenProcessToken(GetCurrentProcess(),
                         TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
                         &hToken)) {
        return false;
    }

    // 2. 查找“SeDebugPrivilege”特权的本地唯一标识符(LUID)
    if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &luid)) {
        CloseHandle(hToken);
        return false;
    }

    // 3. 调整令牌权限
    tp.PrivilegeCount = 1;
    tp.Privileges[0].Luid = luid;
    tp.Privileges[0].Attributes = bEnable ? SE_PRIVILEGE_ENABLED : 0;

    BOOL bResult = AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(TOKEN_PRIVILEGES), NULL, NULL);
    DWORD dwError = GetLastError();
    CloseHandle(hToken);

    // 即使AdjustTokenPrivileges返回成功，也应检查GetLastError
    return (bResult && dwError == ERROR_SUCCESS);
}

在注入函数开始处调用EnableDebugPrivilege(TRUE)，并在所有操作结束后调用EnableDebugPrivilege(FALSE)来还原，是一个良好的安全实践。

2.2 进程枚举与选择

一个友好的注入工具应该允许用户选择目标进程。我们可以使用CreateToolhelp32Snapshot、Process32First和Process32Next这一系列函数来获取系统进程快照。

void PopulateProcessList(CComboBox& comboBox) {
    comboBox.ResetContent();
    PROCESSENTRY32 pe32 = {0};
    pe32.dwSize = sizeof(PROCESSENTRY32);

    // 创建进程快照
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnapshot == INVALID_HANDLE_VALUE) return;

    if (Process32First(hSnapshot, &pe32)) {
        do {
            // 构造显示字符串，例如: "[1234] notepad.exe"
            CString strItem;
            strItem.Format(_T("[%d] %s"), pe32.th32ProcessID, pe32.szExeFile);
            // 将进程ID作为项数据存储，方便后续使用
            int index = comboBox.AddString(strItem);
            comboBox.SetItemData(index, pe32.th32ProcessID);
        } while (Process32Next(hSnapshot, &pe32));
    }
    CloseHandle(hSnapshot);
}

在UI线程中（例如组合框的下拉事件中）调用此函数，就能动态填充进程列表。用户选择后，通过GetItemData获取对应的进程ID（PID）。

2.3 核心注入函数实现

结合权限和路径处理，下面是注入函数的核心逻辑。我增加了更详细的错误检查和资源清理。

bool InjectDll(DWORD dwProcessId, const CString& strDllFullPath) {
    HANDLE hProcess = nullptr;
    LPVOID pRemoteMemory = nullptr;
    HANDLE hRemoteThread = nullptr;
    BOOL bSuccess = FALSE;

    // 0. 启用调试特权
    if (!EnableDebugPrivilege(TRUE)) {
        TRACE(_T("[Inject] Failed to enable debug privilege.\n"));
        // 不一定立即失败，某些进程可能不需要此特权
    }

    // 1. 打开目标进程
    hProcess = OpenProcess(PROCESS_CREATE_THREAD | PROCESS_QUERY_INFORMATION |
                           PROCESS_VM_OPERATION | PROCESS_VM_WRITE | PROCESS_VM_READ,
                           FALSE, dwProcessId);
    if (hProcess == nullptr) {
        TRACE(_T("[Inject] OpenProcess failed for PID %d. Error: %d\n"), dwProcessId, GetLastError());
        EnableDebugPrivilege(FALSE);
        return false;
    }

    // 2. 在目标进程中分配内存，用于存放DLL路径
    size_t pathSize = (strDllFullPath.GetLength() + 1) * sizeof(TCHAR);
    pRemoteMemory = VirtualAllocEx(hProcess, nullptr, pathSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    if (pRemoteMemory == nullptr) {
        TRACE(_T("[Inject] VirtualAllocEx failed. Error: %d\n"), GetLastError());
        CloseHandle(hProcess);
        EnableDebugPrivilege(FALSE);
        return false;
    }

    // 3. 将DLL路径写入目标进程内存
    SIZE_T bytesWritten = 0;
    if (!WriteProcessMemory(hProcess, pRemoteMemory, (LPVOID)strDllFullPath.GetString(), pathSize, &bytesWritten) ||
        bytesWritten != pathSize) {
        TRACE(_T("[Inject] WriteProcessMemory failed. Error: %d\n"), GetLastError());
        VirtualFreeEx(hProcess, pRemoteMemory, 0, MEM_RELEASE);
        CloseHandle(hProcess);
        EnableDebugPrivilege(FALSE);
        return false;
    }

    // 4. 获取LoadLibrary函数地址（在目标进程中，kernel32.dll的加载地址通常相同）
    LPTHREAD_START_ROUTINE pLoadLibrary = (LPTHREAD_START_ROUTINE)GetProcAddress(
        GetModuleHandle(_T("kernel32.dll")),
#ifdef _UNICODE
        "LoadLibraryW"
#else
        "LoadLibraryA"
#endif
    );
    if (pLoadLibrary == nullptr) {
        TRACE(_T("[Inject] GetProcAddress for LoadLibrary failed.\n"));
        VirtualFreeEx(hProcess, pRemoteMemory, 0, MEM_RELEASE);
        CloseHandle(hProcess);
        EnableDebugPrivilege(FALSE);
        return false;
    }

    // 5. 在目标进程中创建远程线程，执行LoadLibrary
    hRemoteThread = CreateRemoteThread(hProcess, nullptr, 0, pLoadLibrary, pRemoteMemory, 0, nullptr);
    if (hRemoteThread == nullptr) {
        TRACE(_T("[Inject] CreateRemoteThread failed. Error: %d\n"), GetLastError());
        VirtualFreeEx(hProcess, pRemoteMemory, 0, MEM_RELEASE);
        CloseHandle(hProcess);
        EnableDebugPrivilege(FALSE);
        return false;
    }

    // 6. 等待远程线程结束（即LoadLibrary执行完毕）
    WaitForSingleObject(hRemoteThread, INFINITE);

    // 7. 可选：获取DLL模块句柄（通过线程退出码）
    DWORD hRemoteModule = 0;
    GetExitCodeThread(hRemoteThread, &hRemoteModule);
    // 如果hRemoteModule为NULL，可能加载失败，但线程已成功执行

    // 8. 清理资源
    CloseHandle(hRemoteThread);
    // 注意：分配的内存(pRemoteMemory)在DLL被加载后通常不再需要，可以释放。
    // 但更安全的做法是在确认DLL成功加载并可能需要卸载信息后再释放，或交由DLL自身管理。
    // 此处我们先不释放，为后续卸载做准备。一个更完善的框架会记录这个地址。
    // VirtualFreeEx(hProcess, pRemoteMemory, 0, MEM_RELEASE);

    CloseHandle(hProcess);
    EnableDebugPrivilege(FALSE);

    TRACE(_T("[Inject] Injection into PID %d appears successful. Remote module handle: 0x%p\n"), dwProcessId, (HMODULE)hRemoteModule);
    return (hRemoteModule != NULL); // 返回是否成功获取到模块句柄
}

至此，一个相对健壮的注入器核心就完成了。但注入只是开始，真正的挑战在于如何让这个“外来客”在完成任务后，安静地离开，不留下任何烂摊子。

3. 安全卸载的陷阱与核心挑战

为什么卸载DLL比注入更难？因为注入时，我们是在一个“干净”的环境中启动线程执行LoadLibrary。而卸载时，DLL可能已经深入参与了进程的运行。

3.1 导致进程崩溃的常见原因

1. 活动线程或钩子：如果DLL创建的线程仍在运行，或者设置了尚未移除的Windows钩子（SetWindowsHookEx），直接调用FreeLibrary会导致这些资源在DLL卸载后访问无效内存，引发崩溃。
2. 未释放的资源：DLL中分配的内存（new/malloc）、打开的文件句柄、GDI对象、内核对象等如果没有被正确释放，会造成资源泄漏。虽然不一定会立即崩溃，但会损害进程健康。
3. 静态/全局对象析构：C++的全局或静态对象会在DLL卸载时（DLL_PROCESS_DETACH）析构。如果析构函数中访问了其他可能已失效的模块状态或资源，也会导致问题。
4. 消息循环依赖：如果DLL创建了窗口并进入了消息循环，直接卸载会导致消息派发目标失效。
5. 其他模块的依赖：如果进程中的其他代码（包括系统代码）仍然持有该DLL导出函数的指针，卸载后调用这些指针会导致访问违规。

3.2 安全卸载的设计哲学

安全卸载的核心思想是：让DLL自己做好“撤离”准备。注入器不应该粗暴地远程调用FreeLibrary，而应该向DLL发送一个“请准备卸载”的指令，等待DLL完成所有清理工作（停止线程、移除钩子、释放资源、关闭窗口等）后，再通知注入器或自行卸载。

这就需要建立一种从注入器到已注入DLL的进程内通信（IPC）机制。由于DLL和注入器在不同的进程，但DLL与目标进程共享地址空间，我们可以使用一些轻量级的IPC方法：

• 共享内存（Memory Mapped File）：在DLL中创建，注入器读写。
• 命名事件/互斥体：用于同步和发送信号。
• 窗口消息（PostThreadMessage / SendMessage）：如果DLL有消息循环，这是最方便的方式。
• 管道（Pipe）或套接字（Socket）：功能强大但稍重。

在本文的实战场景中，我们将采用一种简单有效的组合：共享内存用于传递命令和状态，命名事件用于同步通知。

4. 实现可安全卸载的DLL框架

要让DLL能被安全卸载，我们必须改造它，使其从一个被动的库，变成一个能接收命令、管理自身生命周期的主动组件。

4.1 DLL的初始化与通信设施建立

首先，在DLL的入口点（DllMain）或一个导出的初始化函数中，我们需要建立通信设施。通常不建议在DLL_PROCESS_ATTACH中做太多复杂操作，因此我们可以创建一个专门的初始化线程。

// 在DLL中定义共享的数据结构和命令
#define SHARED_MEM_NAME L"Global\\MyInjector_SharedMem_PID_1234" // 名称包含PID避免冲突
#define EVENT_NAME L"Global\\MyInjector_Event_PID_1234"

struct SharedData {
    volatile LONG shutdownRequested; // 1 表示请求关闭
    volatile LONG cleanupCompleted;  // 1 表示清理完成
    DWORD mainThreadId; // DLL主线程ID，用于发送消息
};

// 全局变量
HANDLE g_hMapFile = NULL;
SharedData* g_pSharedData = NULL;
HANDLE g_hEvent = NULL;
DWORD g_dwMainThreadId = 0;

// 一个导出的初始化函数，由注入器或DLL自身调用
extern "C" __declspec(dllexport) bool InitializeCommunication(DWORD dwHostProcessId) {
    // 1. 创建或打开共享内存
    CString strMemName;
    strMemName.Format(SHARED_MEM_NAME, dwHostProcessId); // 替换PID
    g_hMapFile = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, sizeof(SharedData), strMemName);
    if (g_hMapFile == NULL) return false;

    g_pSharedData = (SharedData*)MapViewOfFile(g_hMapFile, FILE_MAP_ALL_ACCESS, 0, 0, sizeof(SharedData));
    if (g_pSharedData == NULL) {
        CloseHandle(g_hMapFile);
        return false;
    }

    // 如果是创建者，初始化数据
    if (GetLastError() != ERROR_ALREADY_EXISTS) {
        g_pSharedData->shutdownRequested = 0;
        g_pSharedData->cleanupCompleted = 0;
        g_pSharedData->mainThreadId = GetCurrentThreadId(); // 假设在主线程调用
    } else {
        // 已经存在，直接使用
        g_dwMainThreadId = g_pSharedData->mainThreadId;
    }

    // 2. 创建或打开命名事件
    CString strEventName;
    strEventName.Format(EVENT_NAME, dwHostProcessId);
    g_hEvent = CreateEvent(NULL, FALSE, FALSE, strEventName); // 自动重置事件
    if (g_hEvent == NULL) {
        UnmapViewOfFile(g_pSharedData);
        CloseHandle(g_hMapFile);
        return false;
    }

    return true;
}

4.2 实现DLL的主循环与消息处理

假设我们的DLL需要创建一个窗口并运行。我们需要让这个窗口循环能够响应外部的卸载请求。

// DLL内的主窗口线程函数
DWORD WINAPI MainDllThread(LPVOID lpParam) {
    g_dwMainThreadId = GetCurrentThreadId();
    if (g_pSharedData) {
        g_pSharedData->mainThreadId = g_dwMainThreadId; // 更新共享内存中的线程ID
    }

    // 创建窗口等初始化工作...
    CWnd* pMainWnd = ...;

    MSG msg;
    // 主消息循环
    while (GetMessage(&msg, nullptr, 0, 0)) {
        // 检查是否收到卸载请求（通过共享内存标志）
        if (g_pSharedData && g_pSharedData->shutdownRequested) {
            TRACE(_T("[DLL] Shutdown requested via shared memory.\n"));
            PostQuitMessage(0); // 优雅退出消息循环
            // 也可以发送一个自定义的WM_CLOSE消息给主窗口
            if (pMainWnd && ::IsWindow(pMainWnd->m_hWnd)) {
                ::PostMessage(pMainWnd->m_hWnd, WM_CLOSE, 0, 0);
            }
            // 设置清理完成标志
            if (g_pSharedData) {
                g_pSharedData->cleanupCompleted = 1;
                SetEvent(g_hEvent); // 通知注入器
            }
        }

        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    // 执行最终的资源清理
    CleanupResources();
    return 0;
}

// 资源清理函数
void CleanupResources() {
    // 1. 停止所有工作线程
    // 2. 卸载所有钩子 (UnhookWindowsHookEx)
    // 3. 释放所有分配的内存、句柄等
    // 4. 销毁窗口
    TRACE(_T("[DLL] All resources cleaned up.\n"));

    // 最后，通知共享内存清理完成（如果之前没设置）
    if (g_pSharedData) {
        g_pSharedData->cleanupCompleted = 1;
    }
    if (g_hEvent) {
        SetEvent(g_hEvent);
    }
}

4.3 注入器端的协同卸载逻辑

现在，注入器不再是简单地远程调用FreeLibrary，而是通过以下步骤进行协同卸载：

1. 查找DLL模块句柄：通过CreateToolhelp32Snapshot枚举目标进程的模块列表，找到我们DLL的基地址（hModule）。
2. 发送卸载请求：打开与DLL约定好的共享内存，将shutdownRequested标志置为1。
3. 等待DLL清理完成：等待命名事件（g_hEvent）被触发，或者轮询检查cleanupCompleted标志。可以设置一个超时时间。
4. 远程调用FreeLibrary：确认DLL已完成清理后，再创建远程线程执行FreeLibrary。
5. 清理注入器端资源：关闭共享内存和事件的句柄。

bool UnloadDllSafely(DWORD dwProcessId, const CString& strDllName) {
    // 1. 获取目标进程中DLL的模块句柄 (HMODULE)
    HMODULE hRemoteModule = GetRemoteModuleHandle(dwProcessId, strDllName);
    if (hRemoteModule == NULL) {
        TRACE(_T("[Unload] DLL not found in target process.\n"));
        return false;
    }

    // 2. 打开共享内存和事件，发送关闭信号
    CString strMemName, strEventName;
    strMemName.Format(SHARED_MEM_NAME, dwProcessId);
    strEventName.Format(EVENT_NAME, dwProcessId);

    HANDLE hMapFile = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, strMemName);
    if (hMapFile) {
        SharedData* pData = (SharedData*)MapViewOfFile(hMapFile, FILE_MAP_ALL_ACCESS, 0, 0, sizeof(SharedData));
        if (pData) {
            pData->shutdownRequested = 1; // 发送请求
            // 可以尝试向DLL主线程发送一个自定义消息，作为另一种通知方式
            if (pData->mainThreadId != 0) {
                PostThreadMessage(pData->mainThreadId, WM_APP + 100, 0, 0); // 自定义消息
            }
            UnmapViewOfFile(pData);
        }
        CloseHandle(hMapFile);
    }

    HANDLE hEvent = OpenEvent(EVENT_MODIFY_STATE | SYNCHRONIZE, FALSE, strEventName);
    if (hEvent) {
        // 3. 等待DLL清理完成（带超时）
        DWORD dwWait = WaitForSingleObject(hEvent, 5000); // 等待5秒
        if (dwWait == WAIT_OBJECT_0) {
            TRACE(_T("[Unload] DLL cleanup confirmed.\n"));
        } else {
            TRACE(_T("[Unload] Timeout waiting for cleanup. Proceed with caution.\n"));
            // 超时后，可以根据策略决定是否强制卸载或放弃
        }
        CloseHandle(hEvent);
    } else {
        TRACE(_T("[Unload] Could not open event. DLL may not support safe unload.\n"));
    }

    // 4. 执行远程FreeLibrary
    EnableDebugPrivilege(TRUE);
    HANDLE hProcess = OpenProcess(PROCESS_CREATE_THREAD | PROCESS_VM_OPERATION | PROCESS_VM_WRITE, FALSE, dwProcessId);
    if (hProcess) {
        LPTHREAD_START_ROUTINE pFreeLibrary = (LPTHREAD_START_ROUTINE)GetProcAddress(
            GetModuleHandle(_T("kernel32.dll")), "FreeLibrary");
        if (pFreeLibrary) {
            HANDLE hThread = CreateRemoteThread(hProcess, nullptr, 0, pFreeLibrary, (LPVOID)hRemoteModule, 0, nullptr);
            if (hThread) {
                WaitForSingleObject(hThread, INFINITE);
                DWORD exitCode;
                GetExitCodeThread(hThread, &exitCode);
                TRACE(_T("[Unload] FreeLibrary called. Exit code: %d\n"), exitCode);
                CloseHandle(hThread);
                EnableDebugPrivilege(FALSE);
                CloseHandle(hProcess);
                return (exitCode != 0); // FreeLibrary成功返回非0
            }
        }
        CloseHandle(hProcess);
    }
    EnableDebugPrivilege(FALSE);
    return false;
}

5. 实战进阶：异常处理、兼容性与调试技巧

即使有了上述框架，在实际环境中仍会遇到各种边界情况。这里分享几个我踩过坑后总结的经验。

5.1 处理权限与会话隔离

在Windows Vista及更高版本中，服务进程（Session 0）与用户界面进程（Session 1,2...）是隔离的。从用户程序注入服务进程，或跨会话注入，需要额外的权限或使用CreateRemoteThreadEx等特定API。同时，注意管理员权限和UAC的影响。如果你的注入器需要高权限，最好在清单文件中声明requireAdministrator。

5.2 应对防病毒/安全软件的干扰

现代安全软件会监控CreateRemoteThread、WriteProcessMemory等敏感API的调用。你的注入行为可能会被拦截。为了增加成功率：

• 使用合法的进程名和签名：确保你的注入器程序有数字签名，名称不要可疑。
• 考虑替代API：例如NtCreateThreadEx（需通过GetProcAddress从ntdll.dll动态获取），但同样可能被监控。
• 白名单：在测试时，将你的工具添加到安全软件的白名单中。
• 最重要的是：确保你的工具用途合法合规，并准备好向用户解释其行为。

5.3 调试注入的DLL

调试被注入到其他进程的DLL是一项关键技能。

1. 使用Visual Studio附加进程：这是最直接的方法。运行目标进程和你的DLL，在VS中选择“调试”->“附加到进程”，选择目标进程，确保勾选“本机代码”。在DLL代码中设置断点。
2. 输出调试信息：使用OutputDebugString函数输出日志，然后用DebugView（Sysinternals工具）查看所有进程的调试输出。
3. 日志文件：在DLL中写入日志文件到特定位置。注意路径权限问题。
4. 进程崩溃转储：如果卸载导致崩溃，配置Windows在应用程序错误时生成转储文件（.dmp），然后用WinDbg或Visual Studio分析。

5.4 64位与32位互操作性问题

这是一个非常常见的坑。你不能将32位DLL注入到64位进程，也不能将64位DLL注入到32位进程。你的注入器必须与目标进程的架构匹配。如何判断？

• 在注入前，使用IsWow64Process函数判断目标进程是否是32位运行在64位系统上（WOW64）。
• 你的注入器最好能编译为32位和64位两个版本，或者做成一个AnyCPU的.NET程序（通过P/Invoke调用本地API），再根据目标进程架构决定调用哪个原生辅助模块。

我在一个需要同时管理32位和64位进程的项目中，最终维护了两套独立的C++注入库，由一个C#写的管理器前端来调度，虽然麻烦，但彻底解决了架构问题。

通过以上五个章节的梳理，我们从概念到原理，从基础实现到安全卸载框架，再到实战中的疑难杂症，已经构建了一套完整的Windows DLL远程注入与卸载的知识体系。记住，技术本身是双刃剑，深入理解这些底层机制，能让你在开发系统级软件、调试复杂问题、构建插件架构时游刃有余。始终将稳定性和安全性放在首位，你的代码才能真正强大而可靠。