已经拦截了CreateProcess函数，如何取得名字和命令行等信息？

[cnbugs]

已经成功拦截了函数，但想取得lpApplicationName，lpCommandLine等信息，想不明白。
请大家讲解下，能有代码示范更好，感谢！

[Enter空格]

都在栈里呢。
知道调用约定后,自己去栈里取值。

[Enter空格]

楼主是HOOK的 SSDT？

[cnbugs]

只是向目标进程注入DLL进行拦截。
怎么去栈里取？

[Enter空格]

那你是怎么拦截的？大概讲一下
我目前还不知道怎么在应用层,用DLL拦截本进程API调用的。
你DLL是怎么实现的,可以知道API被调用了。

[Roy_Smiling]

浮云~

[cnbugs]

源代码就是“Windows程序设计”王艳平书中的例子。
想在HookProc()函数里加个函数，取得数据。

apihook.cpp
---------------------------------

//////////////////////////////////////////////////////////////
// APIHook.cpp文件

#include "APIHook.h"
#include "Tlhelp32.h"

#include <ImageHlp.h>	// 为了调用ImageDirectoryEntryToData函数
#pragma comment(lib, "ImageHlp")


// CAPIHook对象链表的头指针
CAPIHook* CAPIHook::sm_pHeader = NULL;

CAPIHook::CAPIHook(LPSTR pszModName, LPSTR pszFuncName, PROC pfnHook, BOOL bExcludeAPIHookMod)
{
	// 保存这个Hook函数的信息
	m_bExcludeAPIHookMod = bExcludeAPIHookMod;
	m_pszModName = pszModName;
	m_pszFuncName = pszFuncName;
	m_pfnHook = pfnHook;
	m_pfnOrig = ::GetProcAddress(::GetModuleHandle(pszModName), pszFuncName);

	// 将此对象添加到链表中
	m_pNext = sm_pHeader;
	sm_pHeader = this;
	
	// 在所有当前已加载的模块中HOOK这个函数
	ReplaceIATEntryInAllMods(m_pszModName, m_pfnOrig, m_pfnHook, bExcludeAPIHookMod); 
}

CAPIHook::~CAPIHook()
{
	// 取消对所有模块中函数的HOOK
	ReplaceIATEntryInAllMods(m_pszModName, m_pfnHook, m_pfnOrig, m_bExcludeAPIHookMod);

	CAPIHook *p = sm_pHeader;

	// 从链表中移除此对象
	if(p == this)
	{
		sm_pHeader = p->m_pNext;
	}
	else
	{
		while(p != NULL)
		{
			if(p->m_pNext == this)
			{
				p->m_pNext = this->m_pNext;
				break;
			}
			p = p->m_pNext;
		}
	}

}

void CAPIHook::ReplaceIATEntryInOneMod(LPSTR pszExportMod, 
				   PROC pfnCurrent, PROC pfnNew, HMODULE hModCaller)
{
	// 取得模块的导入表（import descriptor）首地址。ImageDirectoryEntryToData函数可以直接返回导入表地址
	ULONG ulSize;
	PIMAGE_IMPORT_DESCRIPTOR pImportDesc = (PIMAGE_IMPORT_DESCRIPTOR)
				::ImageDirectoryEntryToData(hModCaller, TRUE, 
					IMAGE_DIRECTORY_ENTRY_IMPORT, &ulSize);
	if(pImportDesc == NULL)	// 这个模块没有导入节表
	{
		return;
	}

	// 查找包含pszExportMod模块中函数导入信息的导入表项
	while(pImportDesc->Name != 0)
	{
		LPSTR pszMod = (LPSTR)((DWORD)hModCaller + pImportDesc->Name);
		if(lstrcmpiA(pszMod, pszExportMod) == 0) // 找到
			break;

		pImportDesc++;
	}
	if(pImportDesc->Name == 0) // hModCaller模块没有从pszExportMod模块导入任何函数
	{
		return;
	}

	// 取得调用者的导入地址表（import address table, IAT）
	PIMAGE_THUNK_DATA pThunk = (PIMAGE_THUNK_DATA)(pImportDesc->FirstThunk + (DWORD)hModCaller);

	// 查找我们要HOOK的函数，将它的地址用新函数的地址替换掉
	while(pThunk->u1.Function)
	{
		// lpAddr指向的内存保存了函数的地址
		PDWORD lpAddr = (PDWORD)&(pThunk->u1.Function);
		if(*lpAddr == (DWORD)pfnCurrent)
		{
			// 修改页的保护属性
			DWORD dwOldProtect;
			MEMORY_BASIC_INFORMATION mbi;
			::VirtualQuery(lpAddr, &mbi, sizeof(mbi));
			::VirtualProtect(lpAddr, sizeof(DWORD), PAGE_READWRITE, &dwOldProtect);

			// 修改内存地址  相当于“*lpAddr = (DWORD)pfnNew;”
			::WriteProcessMemory(::GetCurrentProcess(), 
						lpAddr, &pfnNew, sizeof(DWORD), NULL);

			::VirtualProtect(lpAddr, sizeof(DWORD), dwOldProtect, 0);
			break;
		}
		pThunk++;
	}
}

void CAPIHook::ReplaceIATEntryInAllMods(LPSTR pszExportMod, 
					PROC pfnCurrent, PROC pfnNew, BOOL bExcludeAPIHookMod)
{
	// 取得当前模块的句柄
	HMODULE hModThis = NULL;
	if(bExcludeAPIHookMod)
	{
		MEMORY_BASIC_INFORMATION mbi;
		if(::VirtualQuery(ReplaceIATEntryInAllMods, &mbi, sizeof(mbi)) != 0)
			hModThis = (HMODULE)mbi.AllocationBase;
	}

	// 取得本进程的模块列表
	HANDLE hSnap = ::CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, ::GetCurrentProcessId());

	// 遍历所有模块，分别对它们调用ReplaceIATEntryInOneMod函数，修改导入地址表
	MODULEENTRY32 me = { sizeof(MODULEENTRY32) };
	BOOL bOK = ::Module32First(hSnap, &me);
	while(bOK)
	{
		// 注意：我们不HOOK当前模块的函数
		if(me.hModule != hModThis)
			ReplaceIATEntryInOneMod(pszExportMod, pfnCurrent, pfnNew, me.hModule);

		bOK = ::Module32Next(hSnap, &me);
	}
	::CloseHandle(hSnap);
}


// 挂钩LoadLibrary和GetProcAddress函数，以便在这些函数被调用以后，挂钩的函数也能够被正确的处理

CAPIHook CAPIHook::sm_LoadLibraryA("Kernel32.dll", "LoadLibraryA",   
					(PROC)CAPIHook::LoadLibraryA, TRUE);

CAPIHook CAPIHook::sm_LoadLibraryW("Kernel32.dll", "LoadLibraryW",   
					(PROC)CAPIHook::LoadLibraryW, TRUE);

CAPIHook CAPIHook::sm_LoadLibraryExA("Kernel32.dll", "LoadLibraryExA", 
					(PROC)CAPIHook::LoadLibraryExA, TRUE);

CAPIHook CAPIHook::sm_LoadLibraryExW("Kernel32.dll", "LoadLibraryExW", 
					(PROC)CAPIHook::LoadLibraryExW, TRUE);

CAPIHook CAPIHook::sm_GetProcAddress("Kernel32.dll", "GetProcAddress", 
					(PROC)CAPIHook::GetProcAddress, TRUE);



void WINAPI CAPIHook::HookNewlyLoadedModule(HMODULE hModule, DWORD dwFlags)
{
	// 如果一个新的模块被加载，挂钩各CAPIHook对象要求的API函数
	if((hModule != NULL) && ((dwFlags&LOAD_LIBRARY_AS_DATAFILE) == 0))
	{
		CAPIHook *p = sm_pHeader;
		while(p != NULL)
		{
			ReplaceIATEntryInOneMod(p->m_pszModName, p->m_pfnOrig, p->m_pfnHook, hModule);
			p = p->m_pNext;
		}
	}
}


HMODULE WINAPI CAPIHook::LoadLibraryA(PCSTR pszModulePath) 
{
	HMODULE hModule = ::LoadLibraryA(pszModulePath);
	HookNewlyLoadedModule(hModule, 0);
	return(hModule);
}

HMODULE WINAPI CAPIHook::LoadLibraryW(PCWSTR pszModulePath) 
{
	HMODULE hModule = ::LoadLibraryW(pszModulePath);
	HookNewlyLoadedModule(hModule, 0);
	return(hModule);
}

HMODULE WINAPI CAPIHook::LoadLibraryExA(PCSTR pszModulePath, HANDLE hFile, DWORD dwFlags) 
{
	HMODULE hModule = ::LoadLibraryExA(pszModulePath, hFile, dwFlags);
	HookNewlyLoadedModule(hModule, dwFlags);
	return(hModule);
}

HMODULE WINAPI CAPIHook::LoadLibraryExW(PCWSTR pszModulePath, HANDLE hFile, DWORD dwFlags) 
{
	HMODULE hModule = ::LoadLibraryExW(pszModulePath, hFile, dwFlags);
	HookNewlyLoadedModule(hModule, dwFlags);
	return(hModule);
}

FARPROC WINAPI CAPIHook::GetProcAddress(HMODULE hModule, PCSTR pszProcName)
{
	// 得到这个函数的真实地址
	FARPROC pfn = ::GetProcAddress(hModule, pszProcName);

	// 看它是不是我们要hook的函数
	CAPIHook *p = sm_pHeader;
	while(p != NULL)
	{
		if(p->m_pfnOrig == pfn)
		{
			pfn = p->m_pfnHook;
			break;
		}

		p = p->m_pNext;
	}

	return pfn;
}

apispylib.cpp
---------------------------

/////////////////////////////////////////////
// APISpyLib.cpp文件

#include <windows.h>
#include <stdio.h>
#include "APIHook.h"
#include "APISpyLib.h"

void HookProc();

// 共享内存数据，以便初始化下面的CAPIHook对象
CMyShareMem g_shareData(FALSE);

// HOOK主程序指定的API函数
CAPIHook g_orgFun(g_shareData.GetData()->szModName, 
		       g_shareData.GetData()->szFuncName, (PROC)HookProc);

void NotifyCaller()
{
	CMyShareMem mem(FALSE);
	::SendMessage(mem.GetData()->hWndCaller, HM_SPYACALL, 0, 0);
}

// 使用这个函数替代要HOOK的API
__declspec(naked)void HookProc()
{
	// 通知主程序
	NotifyCaller();

	// 跳转到原来的函数
	DWORD dwOrgAddr;
	dwOrgAddr = (DWORD)PROC(g_orgFun);
	__asm
	{
		mov eax, dwOrgAddr;
		jmp eax;
	}
	// 永远运行不到这里
}

[Enter空格]

大概看了下。
这个HOOK应该是修改本模块导入表实现挂钩API的。
所以你的程序中只要声明一个调用约定和形参原型都和原API相同的函数,
并把这个函数的地址写进导入表就可以得到传入此地址的实参了。
这些参数都在当前的栈上保存着呢。

另外,直接修改导入表是可以实现静态加载的DLL中那些API的HOOK,但是如果是
动态加载的DLL应该就不好使了。

[cnbugs]

[Quote=引用 7 楼 mymixing 的回复:]
大概看了下。
这个HOOK应该是修改本模块导入表实现挂钩API的。
所以你的程序中只要声明一个调用约定和形参原型都和原API相同的函数,
并把这个函数的地址写进导入表就可以得到传入此地址的实参了。
这些参数都在当前的栈上保存着呢。

另外,直接修改导入表是可以实现静态加载的DLL中那些API的HOOK,但是如果是
动态加载的DLL应该就不好使了。
[/Quote]
1.动态加载的DLL用什么办法可以挂钩API ?
2.并把这个函数的地址写进导入表就可以得到传入此地址的实参,这个要怎么写，有代码参考吗?

[Enter空格]

1.动态加载的DLL用什么办法可以挂钩API ?
2.并把这个函数的地址写进导入表就可以得到传入此地址的实参,这个要怎么写，有代码参考吗?

关于1,我不确定下面这个函数是否可以取得本进程动态加载的模块句柄,
如果可以的话,那修改本进程内那个动态加载进来的DLL的导入表中的地址内容是可行的。

// 取得本进程的模块列表
HANDLE hSnap = ::CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, ::GetCurrentProcessId());

关于2,以下这段话中pfnNew就是你用来替换原函数的挂钩函数。
// 修改内存地址 相当于“*lpAddr = (DWORD)pfnNew;”
::WriteProcessMemory(::GetCurrentProcess(),
lpAddr, &pfnNew, sizeof(DWORD), NULL);
pfnNew的实现部分会有与原函数相同的调用约定与形参格式。
所以被挂钩的原函数参数,你直接到这个pfnNew实现找就可以了。