vc6 version win10

https://files.cnblogs.com/files/marklove/version.7z
https://blog.csdn.net/CosmopolitanMe/article/details/106761399
这个代码却 DisableThreadLibraryCalls(hModule); 路径用的绝对路径 是不行的 下面是修补版

#include "stdafx.h"
// 导出
#pragma comment(linker, "/EXPORT:GetFileVersionInfoA=_DG_GetFileVersionInfoA,@1")
#pragma comment(linker, "/EXPORT:GetFileVersionInfoByHandle=_DG_GetFileVersionInfoByHandle,@2")
#pragma comment(linker, "/EXPORT:GetFileVersionInfoExA=_DG_GetFileVersionInfoExA,@3")
#pragma comment(linker, "/EXPORT:GetFileVersionInfoExW=_DG_GetFileVersionInfoExW,@4")
#pragma comment(linker, "/EXPORT:GetFileVersionInfoSizeA=_DG_GetFileVersionInfoSizeA,@5")
#pragma comment(linker, "/EXPORT:GetFileVersionInfoSizeExA=_DG_GetFileVersionInfoSizeExA,@6")
#pragma comment(linker, "/EXPORT:GetFileVersionInfoSizeExW=_DG_GetFileVersionInfoSizeExW,@7")
#pragma comment(linker, "/EXPORT:GetFileVersionInfoSizeW=_DG_GetFileVersionInfoSizeW,@8")
#pragma comment(linker, "/EXPORT:GetFileVersionInfoW=_DG_GetFileVersionInfoW,@9")
#pragma comment(linker, "/EXPORT:VerFindFileA=_DG_VerFindFileA,@10")
#pragma comment(linker, "/EXPORT:VerFindFileW=_DG_VerFindFileW,@11")
#pragma comment(linker, "/EXPORT:VerInstallFileA=_DG_VerInstallFileA,@12")
#pragma comment(linker, "/EXPORT:VerInstallFileW=_DG_VerInstallFileW,@13")
#pragma comment(linker, "/EXPORT:VerLanguageNameA=_DG_VerLanguageNameA,@14")
#pragma comment(linker, "/EXPORT:VerLanguageNameW=_DG_VerLanguageNameW,@15")
#pragma comment(linker, "/EXPORT:VerQueryValueA=_DG_VerQueryValueA,@16")
#pragma comment(linker, "/EXPORT:VerQueryValueW=_DG_VerQueryValueW,@17")


// AheadLib 命名空间
namespace AheadLib
{
	HMODULE m_hModule = NULL;	// 原始模块句柄
	DWORD m_dwReturn[17] = {0};	// 原始函数返回地址


	// 加载原始模块
	inline BOOL WINAPI Load()
	{
		TCHAR tzPath[MAX_PATH];
		TCHAR tzTemp[MAX_PATH * 2];

		GetSystemDirectory(tzPath, MAX_PATH);
		lstrcat(tzPath, TEXT("\version"));
//		wsprintf(tzTemp, TEXT("无法加载 %s，程序无法正常运行。"), tzPath);
//		MessageBox(NULL, tzTemp, TEXT("hit"), MB_OK | MB_ICONWARNING);
		m_hModule = LoadLibrary(tzPath);
		if (m_hModule == NULL)
		{
			wsprintf(tzTemp, TEXT("无法加载 %s，程序无法正常运行。"), tzPath);
			MessageBox(NULL, tzTemp, TEXT("AheadLib"), MB_ICONSTOP);
		}

		return (m_hModule != NULL);	
	}
		
	// 释放原始模块
	inline VOID WINAPI Free()
	{
		if (m_hModule)
		{
			FreeLibrary(m_hModule);
		}
	}

	// 获取原始函数地址
	FARPROC WINAPI GetFunctionAddress(PCSTR pszProcName)
	{
		FARPROC fpAddress;
		CHAR szProcName[16];
		TCHAR tzTemp[MAX_PATH];

		if (m_hModule == NULL)
		{
			if (Load() == FALSE)
			{
				ExitProcess(-1);
			}
		}

		fpAddress = GetProcAddress(m_hModule, pszProcName);
//			wsprintf(tzTemp, TEXT("无法找到函数 %hs，程序无法正常运行。"), pszProcName);
//			MessageBox(NULL, tzTemp, TEXT("hit"), MB_OK | MB_ICONWARNING);
		if (fpAddress == NULL)
		{
			if (HIWORD(pszProcName) == 0)
			{
				wsprintf(szProcName, "%d", pszProcName);
				pszProcName = szProcName;
			}

			wsprintf(tzTemp, TEXT("无法找到函数 %hs，程序无法正常运行。"), pszProcName);
			MessageBox(NULL, tzTemp, TEXT("AheadLib"), MB_ICONSTOP);
			ExitProcess(-2);
		}

		return fpAddress;
	}
}
using namespace AheadLib;

BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
					 )
{
	switch (ul_reason_for_call)
	{
	case DLL_PROCESS_ATTACH:
	{
 
        //DisableThreadLibraryCalls(hModule);
		Load();
		::MessageBox(NULL, "调用函数方法", "From DLL Hijack", MB_OK | MB_ICONWARNING);
		break;
	}
	case DLL_THREAD_ATTACH:
	{
		break;
	}
	case DLL_THREAD_DETACH:
	{
 
	}
	case DLL_PROCESS_DETACH:
	{
		Free();
	}
		break;
	}
	return TRUE;
}

// 函数
extern "C" void __declspec(naked) DG_GetFileVersionInfoA()
{
		// 保存返回地址
	__asm POP m_dwReturn[0 * TYPE long];

	// 调用原始函数
	GetFunctionAddress("GetFileVersionInfoA")();

	// 转跳到返回地址
	__asm JMP m_dwReturn[0 * TYPE long];
 
}

extern "C" void __declspec(naked) DG_GetFileVersionInfoByHandle()
{
			// 保存返回地址
	__asm POP m_dwReturn[0 * TYPE long];
	GetFunctionAddress("GetFileVersionInfoByHandle")();
	// 转跳到返回地址
	__asm JMP m_dwReturn[0 * TYPE long];
}

extern "C" void __declspec(naked) DG_GetFileVersionInfoExA()
{
				// 保存返回地址
	__asm POP m_dwReturn[0 * TYPE long];
	GetFunctionAddress("GetFileVersionInfoExA")();
	// 转跳到返回地址
	__asm JMP m_dwReturn[0 * TYPE long];
}

extern "C" void __declspec(naked) DG_GetFileVersionInfoExW()
{
				// 保存返回地址
	__asm POP m_dwReturn[0 * TYPE long];
	GetFunctionAddress("GetFileVersionInfoExW")();
	// 转跳到返回地址
	__asm JMP m_dwReturn[0 * TYPE long];
}

extern "C" void __declspec(naked) DG_GetFileVersionInfoSizeA()
{
				// 保存返回地址
	__asm POP m_dwReturn[0 * TYPE long];
	GetFunctionAddress("GetFileVersionInfoSizeA")();
	// 转跳到返回地址
	__asm JMP m_dwReturn[0 * TYPE long];
}

extern "C" void __declspec(naked) DG_GetFileVersionInfoSizeExA()
{
				// 保存返回地址
	__asm POP m_dwReturn[0 * TYPE long];
	GetFunctionAddress("GetFileVersionInfoSizeExA")();
	// 转跳到返回地址
	__asm JMP m_dwReturn[0 * TYPE long];
}

extern "C" void __declspec(naked) DG_GetFileVersionInfoSizeExW()
{
				// 保存返回地址
	__asm POP m_dwReturn[0 * TYPE long];
	GetFunctionAddress("GetFileVersionInfoSizeExW")();
	// 转跳到返回地址
	__asm JMP m_dwReturn[0 * TYPE long];
}

extern "C" void __declspec(naked) DG_GetFileVersionInfoSizeW()
{
				// 保存返回地址
	__asm POP m_dwReturn[0 * TYPE long];
	GetFunctionAddress("GetFileVersionInfoSizeW")();
	// 转跳到返回地址
	__asm JMP m_dwReturn[0 * TYPE long];
}

extern "C" void __declspec(naked) DG_GetFileVersionInfoW()
{
				// 保存返回地址
	__asm POP m_dwReturn[0 * TYPE long];
	GetFunctionAddress("GetFileVersionInfoW")();
	// 转跳到返回地址
	__asm JMP m_dwReturn[0 * TYPE long];
}

extern "C" void __declspec(naked) DG_VerFindFileA()
{
				// 保存返回地址
	__asm POP m_dwReturn[0 * TYPE long];
	GetFunctionAddress("VerFindFileA")();
	// 转跳到返回地址
	__asm JMP m_dwReturn[0 * TYPE long];
}

extern "C" void __declspec(naked) DG_VerFindFileW()
{
				// 保存返回地址
	__asm POP m_dwReturn[0 * TYPE long];
	GetFunctionAddress("VerFindFileW")();
	// 转跳到返回地址
	__asm JMP m_dwReturn[0 * TYPE long];
}

extern "C" void __declspec(naked) DG_VerInstallFileA()
{
				// 保存返回地址
	__asm POP m_dwReturn[0 * TYPE long];
	GetFunctionAddress("VerInstallFileA")();
	// 转跳到返回地址
	__asm JMP m_dwReturn[0 * TYPE long];
}

extern "C" void __declspec(naked) DG_VerInstallFileW()
{
				// 保存返回地址
	__asm POP m_dwReturn[0 * TYPE long];
	GetFunctionAddress("VerInstallFileW")();
	// 转跳到返回地址
	__asm JMP m_dwReturn[0 * TYPE long];
}

extern "C" void __declspec(naked) DG_VerLanguageNameA()
{
				// 保存返回地址
	__asm POP m_dwReturn[0 * TYPE long];
	GetFunctionAddress("VerLanguageNameA")();
	// 转跳到返回地址
	__asm JMP m_dwReturn[0 * TYPE long];
}

extern "C" void __declspec(naked) DG_VerLanguageNameW()
{
				// 保存返回地址
	__asm POP m_dwReturn[0 * TYPE long];
	GetFunctionAddress("VerLanguageNameW")();
	// 转跳到返回地址
	__asm JMP m_dwReturn[0 * TYPE long];
}

extern "C" void __declspec(naked) DG_VerQueryValueA()
{
				// 保存返回地址
	__asm POP m_dwReturn[0 * TYPE long];
	GetFunctionAddress("VerQueryValueA")();
	// 转跳到返回地址
	__asm JMP m_dwReturn[0 * TYPE long];
}

extern "C" void __declspec(naked) DG_VerQueryValueW()
{
				// 保存返回地址
	__asm POP m_dwReturn[0 * TYPE long];
	GetFunctionAddress("VerQueryValueW")();
	// 转跳到返回地址
	__asm JMP m_dwReturn[0 * TYPE long];
}

https://www.cnblogs.com/x-poior/p/5113237.html

// Win32Project2.cpp : 定义 DLL 应用程序的导出函数。
//
///////////////////////////////////////////////////////////////////////////////////////////////////////
/*

                                   DLL名称劫持注入法

当游戏运行加载一个重要的的DLL模块时,我们让他来加载我们需要注入的DLL和原来那个必须加载的游戏DLL模块。

比如说一些游戏加载游戏本身DLL“client.dll”。
游戏DLL“client.dll”重命名为“client- original.dll”。
把我们需要注入的DLL重命名成“client.dll”，并把2个DLL放在一起。
把下面源码的client.exe更换成你需要注入的游戏的进程名。

原理：
游戏运行时先加载我们伪造的DLL“client.dll”，但由于关键函数还在原来的client.dll中。
所以先将自身复制为临时文件“client - temp.dll”
加载后然后卸载本身。替换原来的“client.dll”并加载。
然后，它运行一个bat脚本，将等待游戏退出，一旦游戏退出。
bat脚本将复制临时文件“client - temp.dll”到“client.dll”，
这样它就会在下次游戏启动时继续加载。


*/
#include "stdafx.h"
#include "fstream"
using namespace std;


void 替换(char* szBuffer, size_t bufferSize, char* from, char* to)
{
        char* szpTemp,
                *szpTempBuffer,
                *szpCurrentBuffer;


        szpCurrentBuffer = szBuffer;
        szpTempBuffer = new char[bufferSize];

        while (true)
        {
                szpTemp = strstr(szpCurrentBuffer, from);

                if (szpTemp != NULL)
                {
                        if (strlen(szBuffer) - strlen(from) + strlen(to) < bufferSize)
                        {
                                strcpy(szpTempBuffer, szpTemp + strlen(from));

                                *szpTemp = '';
                                strcat(szpTemp, to);
                                szpCurrentBuffer = szpTemp + strlen(to);
                                strcat(szpTemp, szpTempBuffer);
                        }
                        else
                                break;
                }
                else
                        break;
        }

        delete[] szpTempBuffer;
}

DWORD WINAPI ThreadMain(LPVOID lpvParam)
{
        MessageBox(0, "劫持注入成功", "hello", 0);

        return 0;
}

BOOL WINAPI DllMain(HMODULE hModule, DWORD dwReason, LPVOID lpvReserved)
{
        BYTE* pCave;

        ifstream in;

        ofstream out;

        BOOL bLoad;

        FARPROC targetFunction;

        HMODULE hTargetModule;

        char* szpName;

        char szFileName[MAX_PATH],
                szBuffer[MAX_PATH],
                szTempBuffer[MAX_PATH];

        char* szpTargetModule;

        STARTUPINFO si = { sizeof(STARTUPINFO) };

        PROCESS_INFORMATION pi;

        char szCmdLine[MAX_PATH];


        bLoad = FALSE;


        if (dwReason == DLL_PROCESS_ATTACH)
        {
                GetModuleFileName(hModule, szFileName, sizeof(szFileName));
                strcpy(szBuffer, szFileName);

                // 判断自身是否为临时文件,如果不是临时文件将创建并加载
                if (strstr(szFileName, " - temp.dll") == NULL)
                {
                        替换(szBuffer, sizeof(szBuffer), ".dll", " - temp.dll");

                        if (CopyFile(szFileName, szBuffer, FALSE) != NULL)
                        {
                                szpTargetModule = (char*)VirtualAlloc(NULL, 1024, MEM_COMMIT, PAGE_EXECUTE_READWRITE);

                                strcpy(szpTargetModule, szBuffer);

                                hTargetModule = GetModuleHandle("Kernel32.dll");
                                targetFunction = GetProcAddress(hTargetModule, "LoadLibraryA");

                                pCave = (BYTE*)VirtualAlloc(NULL, 0x10, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
                                *pCave++ = 0x68;
                                *(DWORD*)pCave = (DWORD)szpTargetModule;
                                pCave += 4;
                                *pCave++ = 0xe8;
                                *(DWORD*)pCave = (DWORD)((DWORD)targetFunction - (DWORD)pCave - 4);
                                pCave += 4;
                                *pCave++ = 0xc2;
                                *pCave++ = 0x04;
                                *pCave++ = 0x00;
                                pCave -= 13;

                                CreateThread(0, 0, (LPTHREAD_START_ROUTINE)pCave, 0, 0, 0);
                        }
                }
                else
                {
                        // 如果是临时的DLL
                        替换(szBuffer, sizeof(szBuffer), " - temp.dll", ".dll");

                        // 等待遊戲主進程是否佔用此DLL  等待寫入權限
                        do
                        {
                                in.open(szBuffer, ios::out);

                                if (in.is_open() == true)
                                {
                                        in.close();
                                        break;
                                }

                                Sleep(1000);
                        } while (true);



                        // 写一个bat脚本,一旦游戏退出,恢复自身文件名,下次可以继续加载
                        ////  把下面的client.exe改成你需要注入的游戏进程名
                        out.open("bat.bat", ios::out);

                        if (out.is_open() == true)
                        {
                                out << ":WAITLOOP" << endl;
                                out << "tasklist /FI "IMAGENAME eq Client.exe" 2>NUL | find /I /N "Client.exe">NUL" << endl;
                                out << "if "%ERRORLEVEL%"=="0" goto RUNNING" << endl;
                                out << "goto NOTRUNNING" << endl;

                                out << ":RUNNING" << endl;
                                out << "timeout /t 2" << endl;
                                out << "goto WAITLOOP" << endl;

                                out << ":NOTRUNNING" << endl;
                                out << "copy "" << szFileName << "" "" << szBuffer << """ << endl;
                                out.close();

                                strcpy(szTempBuffer, szFileName);
                                *strrchr(szTempBuffer, '\') = '';

                                sprintf(szCmdLine, "cmd.exe /C "%s\bat.bat"", szTempBuffer);

                                CreateProcess(NULL, szCmdLine, 0, 0, FALSE, CREATE_UNICODE_ENVIRONMENT, NULL, 0, &si, &pi);
                        }

                        替换(szFileName, sizeof(szFileName), " - temp.dll", " - original.dll");
                        CopyFile(szFileName, szBuffer, FALSE);

                        LoadLibrary(szBuffer);

                        CreateThread(0, 0, ThreadMain, 0, 0, 0);
                        bLoad = TRUE;
                }
        }

        return bLoad;
}

带hook

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 头文件
#include <Windows.h>
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
PVOID pfnGetFileVersionInfoA;
PVOID pfnGetFileVersionInfoByHandle;
PVOID pfnGetFileVersionInfoExA;
PVOID pfnGetFileVersionInfoExW;
PVOID pfnGetFileVersionInfoSizeA;
PVOID pfnGetFileVersionInfoSizeExA;
PVOID pfnGetFileVersionInfoSizeExW;
PVOID pfnGetFileVersionInfoSizeW;
PVOID pfnGetFileVersionInfoW;
PVOID pfnVerFindFileA;
PVOID pfnVerFindFileW;
PVOID pfnVerInstallFileA;
PVOID pfnVerInstallFileW;
PVOID pfnVerLanguageNameA;
PVOID pfnVerLanguageNameW;
PVOID pfnVerQueryValueA;
PVOID pfnVerQueryValueW;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	// 获取原始函数地址
	FARPROC WINAPI GetAddress(PCSTR pszProcName)
{
pfnGetFileVersionInfoA=GetAddress("GetFileVersionInfoA");
pfnGetFileVersionInfoByHandle=GetAddress("GetFileVersionInfoByHandle");
pfnGetFileVersionInfoExA=GetAddress("GetFileVersionInfoExA");
pfnGetFileVersionInfoExW=GetAddress("GetFileVersionInfoExW");
pfnGetFileVersionInfoSizeA=GetAddress("GetFileVersionInfoSizeA");
pfnGetFileVersionInfoSizeExA=GetAddress("GetFileVersionInfoSizeExA");
pfnGetFileVersionInfoSizeExW=GetAddress("GetFileVersionInfoSizeExW");
pfnGetFileVersionInfoSizeW=GetAddress("GetFileVersionInfoSizeW");
pfnGetFileVersionInfoW=GetAddress("GetFileVersionInfoW");
pfnVerFindFileA=GetAddress("VerFindFileA");
pfnVerFindFileW=GetAddress("VerFindFileW");
pfnVerInstallFileA=GetAddress("VerInstallFileA");
pfnVerInstallFileW=GetAddress("VerInstallFileW");
pfnVerLanguageNameA=GetAddress("VerLanguageNameA");
pfnVerLanguageNameW=GetAddress("VerLanguageNameW");
pfnVerQueryValueA=GetAddress("VerQueryValueA");
pfnVerQueryValueW=GetAddress("VerQueryValueW");
	}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 宏定义
#define EXTERNC extern "C"
#define NAKED __declspec(naked)
#define EXPORT __declspec(dllexport)

#define ALCPP EXPORT NAKED
#define ALSTD EXTERNC EXPORT NAKED void __stdcall
#define ALCFAST EXTERNC EXPORT NAKED void __fastcall
#define ALCDECL EXTERNC NAKED void __cdecl
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Hook 命名空间
namespace Hook
{
	HHOOK m_hHook;
			// HOOK 句柄


	// HOOK 函数
	LRESULT CALLBACK HookProc(INT iCode, WPARAM wParam, LPARAM lParam)
	{
		if (iCode > 0)
		{
			;
		}

		return CallNextHookEx(m_hHook, iCode, wParam, lParam);
	}

	// Hook
	inline BOOL WINAPI Hook(INT iHookId = WH_CALLWNDPROC)
	{
		m_hHook = SetWindowsHookEx(iHookId, HookProc, NULL, GetCurrentThreadId());
		return (m_hHook != NULL);
	}

	// Unhook
	inline VOID WINAPI Unhook()
	{
		if (m_hHook)
		{
			UnhookWindowsHookEx(m_hHook);
		}
	}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// AheadLib 命名空间
namespace AheadLib
{
	HMODULE m_hModule = NULL;	// 原始模块句柄
	DWORD m_dwReturn[17] = {0};	// 原始函数返回地址


	// 加载原始模块
	inline BOOL WINAPI Load()
	{
		TCHAR tzPath[MAX_PATH];
		TCHAR tzTemp[MAX_PATH * 2];

		GetSystemDirectory(tzPath, MAX_PATH);
		lstrcat(tzPath, TEXT("\version"));
		m_hModule = LoadLibrary(tzPath);
		if (m_hModule == NULL)
		{
			wsprintf(tzTemp, TEXT("无法加载 %s，程序无法正常运行。"), tzPath);
			MessageBox(NULL, tzTemp, TEXT("AheadLib"), MB_ICONSTOP);
		}

		return (m_hModule != NULL);	
	}
		
	// 释放原始模块
	inline VOID WINAPI Free()
	{
		if (m_hModule)
		{
			FreeLibrary(m_hModule);
		}
	}

	// 获取原始函数地址
	FARPROC WINAPI GetAddress(PCSTR pszProcName)
	{
		FARPROC fpAddress;
		CHAR szProcName[16];
		TCHAR tzTemp[MAX_PATH];

		fpAddress = GetProcAddress(m_hModule, pszProcName);
		if (fpAddress == NULL)
		{
			if (HIWORD(pszProcName) == 0)
			{
				wsprintf(szProcName, "%d", pszProcName);
				pszProcName = szProcName;
			}

			wsprintf(tzTemp, TEXT("无法找到函数 %hs，程序无法正常运行。"), pszProcName);
			MessageBox(NULL, tzTemp, TEXT("AheadLib"), MB_ICONSTOP);
			ExitProcess(-2);
		}

		return fpAddress;
	}
}
using namespace AheadLib;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 入口函数
BOOL WINAPI DllMain(HMODULE hModule, DWORD dwReason, PVOID pvReserved)
{
	if (dwReason == DLL_PROCESS_ATTACH)
	{
		DisableThreadLibraryCalls(hModule);

		Hook::Hook();

		return Load();
	}
	else if (dwReason == DLL_PROCESS_DETACH)
	{
		Free();
		Hook::Unhook();

	}

	return TRUE;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_GetFileVersionInfoA(void)
{
	// 保存返回地址
	__asm POP m_dwReturn[0 * TYPE long];

	// 调用原始函数
	GetAddress("GetFileVersionInfoA")();

	// 转跳到返回地址
	__asm JMP m_dwReturn[0 * TYPE long];
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_GetFileVersionInfoByHandle(void)
{
	// 保存返回地址
	__asm POP m_dwReturn[1 * TYPE long];

	// 调用原始函数
	GetAddress("GetFileVersionInfoByHandle")();

	// 转跳到返回地址
	__asm JMP m_dwReturn[1 * TYPE long];
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_GetFileVersionInfoExA(void)
{
	// 保存返回地址
	__asm POP m_dwReturn[2 * TYPE long];

	// 调用原始函数
	GetAddress("GetFileVersionInfoExA")();

	// 转跳到返回地址
	__asm JMP m_dwReturn[2 * TYPE long];
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_GetFileVersionInfoExW(void)
{
	// 保存返回地址
	__asm POP m_dwReturn[3 * TYPE long];

	// 调用原始函数
	GetAddress("GetFileVersionInfoExW")();

	// 转跳到返回地址
	__asm JMP m_dwReturn[3 * TYPE long];
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_GetFileVersionInfoSizeA(void)
{
	// 保存返回地址
	__asm POP m_dwReturn[4 * TYPE long];

	// 调用原始函数
	GetAddress("GetFileVersionInfoSizeA")();

	// 转跳到返回地址
	__asm JMP m_dwReturn[4 * TYPE long];
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_GetFileVersionInfoSizeExA(void)
{
	// 保存返回地址
	__asm POP m_dwReturn[5 * TYPE long];

	// 调用原始函数
	GetAddress("GetFileVersionInfoSizeExA")();

	// 转跳到返回地址
	__asm JMP m_dwReturn[5 * TYPE long];
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_GetFileVersionInfoSizeExW(void)
{
	// 保存返回地址
	__asm POP m_dwReturn[6 * TYPE long];

	// 调用原始函数
	GetAddress("GetFileVersionInfoSizeExW")();

	// 转跳到返回地址
	__asm JMP m_dwReturn[6 * TYPE long];
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_GetFileVersionInfoSizeW(void)
{
	// 保存返回地址
	__asm POP m_dwReturn[7 * TYPE long];

	// 调用原始函数
	GetAddress("GetFileVersionInfoSizeW")();

	// 转跳到返回地址
	__asm JMP m_dwReturn[7 * TYPE long];
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_GetFileVersionInfoW(void)
{
	// 保存返回地址
	__asm POP m_dwReturn[8 * TYPE long];

	// 调用原始函数
	GetAddress("GetFileVersionInfoW")();

	// 转跳到返回地址
	__asm JMP m_dwReturn[8 * TYPE long];
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_VerFindFileA(void)
{
	// 保存返回地址
	__asm POP m_dwReturn[9 * TYPE long];

	// 调用原始函数
	GetAddress("VerFindFileA")();

	// 转跳到返回地址
	__asm JMP m_dwReturn[9 * TYPE long];
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_VerFindFileW(void)
{
	// 保存返回地址
	__asm POP m_dwReturn[10 * TYPE long];

	// 调用原始函数
	GetAddress("VerFindFileW")();

	// 转跳到返回地址
	__asm JMP m_dwReturn[10 * TYPE long];
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_VerInstallFileA(void)
{
	// 保存返回地址
	__asm POP m_dwReturn[11 * TYPE long];

	// 调用原始函数
	GetAddress("VerInstallFileA")();

	// 转跳到返回地址
	__asm JMP m_dwReturn[11 * TYPE long];
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_VerInstallFileW(void)
{
	// 保存返回地址
	__asm POP m_dwReturn[12 * TYPE long];

	// 调用原始函数
	GetAddress("VerInstallFileW")();

	// 转跳到返回地址
	__asm JMP m_dwReturn[12 * TYPE long];
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_VerLanguageNameA(void)
{
	// 保存返回地址
	__asm POP m_dwReturn[13 * TYPE long];

	// 调用原始函数
	GetAddress("VerLanguageNameA")();

	// 转跳到返回地址
	__asm JMP m_dwReturn[13 * TYPE long];
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_VerLanguageNameW(void)
{
	// 保存返回地址
	__asm POP m_dwReturn[14 * TYPE long];

	// 调用原始函数
	GetAddress("VerLanguageNameW")();

	// 转跳到返回地址
	__asm JMP m_dwReturn[14 * TYPE long];
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_VerQueryValueA(void)
{
	// 保存返回地址
	__asm POP m_dwReturn[15 * TYPE long];

	// 调用原始函数
	GetAddress("VerQueryValueA")();

	// 转跳到返回地址
	__asm JMP m_dwReturn[15 * TYPE long];
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_VerQueryValueW(void)
{
	// 保存返回地址
	__asm POP m_dwReturn[16 * TYPE long];

	// 调用原始函数
	GetAddress("VerQueryValueW")();

	// 转跳到返回地址
	__asm JMP m_dwReturn[16 * TYPE long];
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////