如何解决转发WinAPI的循环依赖，获取实际DLL地址与入口点？

嘿，这个API集转发循环的问题我之前也碰到过——其实这不是真的循环，而是Windows API集（API Sets）的分层映射搞出来的表象。要像系统模块加载器那样正确找到实际的DLL和函数地址，有几个靠谱的方法：

方法一：直接用GetProcAddress省心解决 #

系统自带的GetProcAddress本身就会自动处理所有转发链，不管中间经过多少次API集或DLL转发，最终都会返回实际实现的函数地址。你完全可以跳过手动解析API集的步骤，直接这么做：

// 加载API集模块（不解析依赖，避免额外加载）
HMODULE hApiSet = LoadLibraryEx(L"API-MS-WIN-CORE-PROCESSTHREADS-L1-1-2.DLL", NULL, DONT_RESOLVE_DLL_REFERENCES);
if (hApiSet) {
    // 让系统自动解析转发链，拿到实际函数地址
    FARPROC pFunc = GetProcAddress(hApiSet, "DeleteProcThreadAttributeList");
    if (pFunc) {
        // 根据函数地址反查它所属的实际DLL
        HMODULE hRealDll = NULL;
        GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (LPCSTR)pFunc, &hRealDll);
        if (hRealDll) {
            WCHAR realDllPath[MAX_PATH];
            GetModuleFileName(hRealDll, realDllPath, MAX_PATH);
            // 这里就能拿到你要的实际DLL路径和函数内存地址了
            wprintf(L"实际DLL路径: %s\n函数内存地址: 0x%p\n", realDllPath, pFunc);
        }
    }
    FreeLibrary(hApiSet);
}

这个方法的核心就是相信系统的API，GetProcAddress已经帮你把所有转发逻辑都处理好了，不用自己折腾循环解析。

方法二：手动解析PE结构（想深究底层可以试试） #

如果你想搞清楚系统加载器到底是怎么处理的，可以手动解析DLL的导出表，递归处理转发函数：

1. 加载目标DLL，找到它的PE头
2. 定位导出表，遍历找到目标函数
3. 判断该函数是否是转发函数（看地址是否在导出表范围内）
4. 如果是转发，拆分转发字符串（格式一般是[DLL名].[函数名]），然后递归解析这个新的DLL

简化版的示例代码如下：

bool ResolveForwardedFunc(HMODULE hModule, LPCSTR targetFunc, HMODULE& outRealDll, FARPROC& outRealAddr) {
    // 获取PE头指针
    PIMAGE_DOS_HEADER pDosHdr = (PIMAGE_DOS_HEADER)hModule;
    PIMAGE_NT_HEADERS pNtHdr = (PIMAGE_NT_HEADERS)((BYTE*)hModule + pDosHdr->e_lfanew);
    auto pExportDir = (PIMAGE_EXPORT_DIRECTORY)((BYTE*)hModule + pNtHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);

    // 遍历导出函数名称表
    DWORD* pNameArray = (DWORD*)((BYTE*)hModule + pExportDir->AddressOfNames);
    WORD* pOrdinalArray = (WORD*)((BYTE*)hModule + pExportDir->AddressOfNameOrdinals);
    DWORD* pFuncArray = (DWORD*)((BYTE*)hModule + pExportDir->AddressOfFunctions);

    for (DWORD i = 0; i < pExportDir->NumberOfNames; i++) {
        LPCSTR currName = (LPCSTR)((BYTE*)hModule + pNameArray[i]);
        if (strcmp(currName, targetFunc) != 0) continue;

        DWORD funcRva = pFuncArray[pOrdinalArray[i]];
        // 判断是否为转发函数：地址落在导出表的范围内
        if (funcRva >= pExportDir->VirtualAddress && funcRva < pExportDir->VirtualAddress + pExportDir->Size) {
            LPCSTR forwardStr = (LPCSTR)((BYTE*)hModule + funcRva);
            // 拆分转发字符串，比如"api-ms-win-core-processthreads-l1-1-0.DeleteProcThreadAttributeList"
            LPCSTR dotPos = strchr(forwardStr, '.');
            if (!dotPos) return false;

            std::string forwardDll(forwardStr, dotPos - forwardStr);
            std::string forwardFunc(dotPos + 1);
            // 加载转发的DLL（记得加.dll后缀）
            std::wstring wDllName(forwardDll.begin(), forwardDll.end());
            wDllName += L".dll";
            HMODULE hForwardDll = LoadLibraryEx(wDllName.c_str(), NULL, DONT_RESOLVE_DLL_REFERENCES);
            if (!hForwardDll) return false;

            // 递归解析转发的函数
            bool result = ResolveForwardedFunc(hForwardDll, forwardFunc.c_str(), outRealDll, outRealAddr);
            FreeLibrary(hForwardDll);
            return result;
        } else {
            // 找到实际的函数实现了
            outRealDll = hModule;
            outRealAddr = (FARPROC)((BYTE*)hModule + funcRva);
            return true;
        }
    }
    return false;
}

调用这个函数时，传入你一开始的API集模块或者kernel32.dll，就能递归追到最终的实现。

方法三：用Native API模拟系统加载器 #

如果你想完全复刻系统加载器的行为，可以用NTDLL里的LdrGetProcedureAddress——这就是GetProcAddress底层调用的函数，能直接处理所有API集映射和转发：

// 定义Native API的函数指针类型
typedef NTSTATUS(WINAPI* LdrGetProcAddrFn)(
    HMODULE Module,
    LPCSTR ProcedureName,
    WORD ProcedureOrdinal,
    FARPROC* ProcedureAddress
);

int main() {
    // 加载ntdll.dll（系统默认已经加载了）
    HMODULE hNtdll = GetModuleHandle(L"ntdll.dll");
    if (!hNtdll) return 1;

    LdrGetProcAddrFn pLdrGetProcAddr = (LdrGetProcAddrFn)GetProcAddress(hNtdll, "LdrGetProcedureAddress");
    if (!pLdrGetProcAddr) return 1;

    HMODULE hApiSet = LoadLibraryEx(L"API-MS-WIN-CORE-PROCESSTHREADS-L1-1-2.DLL", NULL, DONT_RESOLVE_DLL_REFERENCES);
    if (hApiSet) {
        FARPROC pFunc = NULL;
        NTSTATUS status = pLdrGetProcAddr(hApiSet, "DeleteProcThreadAttributeList", 0, &pFunc);
        if (NT_SUCCESS(status) && pFunc) {
            // 同样反查实际DLL
            HMODULE hRealDll = NULL;
            GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (LPCSTR)pFunc, &hRealDll);
            if (hRealDll) {
                WCHAR realDllPath[MAX_PATH];
                GetModuleFileName(hRealDll, realDllPath, MAX_PATH);
                wprintf(L"实际DLL: %s\n函数地址: 0x%p\n", realDllPath, pFunc);
            }
        }
        FreeLibrary(hApiSet);
    }
    return 0;
}

补充说明 #

你之前碰到的"循环"其实是API集的版本分层导致的：新的API集（L1-1-2）映射到kernel32.dll，而kernel32.dll里的函数又转发到旧版本的API集（L1-1-0）——但系统加载器知道这些API集最终都会指向kernelbase.dll（在WoW64环境下就是syswow64\kernelbase.dll）里的实际实现，所以不会真的循环。

内容的提问来源于stack exchange，提问作者c00000fd