开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > PlugIns编程 > 查看源码
NtApi.cpp
资源名称：MSNPlugin_src.zip　[点击查看]
上传用户：kittypts
上传日期：2018-02-11
资源大小：241k
文件大小：9k
源码类别：

PlugIns编程

开发平台：

Visual C++

NtApi.cpp：源码内容
  1. #include "ntapi.h"
  2. #include "NtUnDoc.h"
  3. #include <tchar.h>
  4. #include <stdio.h>
  5. #include <stdarg.h>
  6. #pragma warning(disable:4005)
  7. #include <ntstatus.h>
  8. #include <crtdbg.h>
  9. #include <malloc.h>
  11. ///
  12. /// Types:
  13. ///
  14. typedef ULONG_PTR KPRIORITY;
  15. typedef struct _THREAD_BASIC_INFORMATION {
  16. NTSTATUS                ExitStatus;
  17. PVOID                   TebBaseAddress;
  18. ClientId               ClientId;
  19. KAFFINITY               AffinityMask;
  20. KPRIORITY               Priority;
  21. KPRIORITY               BasePriority;
  22. } THREAD_BASIC_INFORMATION, *PTHREAD_BASIC_INFORMATION;
  24. ///
  25. /// Helpers:
  26. ///
  27. void SetUnicodeString(UNICODE_STRING& ustr, LPCWSTR txt);
  28. #define InitializeObjectAttributes( p, n, a, r, s ) { 
  29. (p)->Length = sizeof( OBJECT_ATTRIBUTES );          
  30. (p)->RootDirectory = r;                             
  31. (p)->Attributes = a;                                
  32. (p)->ObjectName = n;                                
  33. (p)->SecurityDescriptor = s;                        
  34. (p)->SecurityQualityOfService = NULL;               
  35. }
  36. #define ANSI_TO_WIDE(_ansi, _wide) 
  37. size_t l = strlen(_ansi); 
  38. size_t wl = MultiByteToWideChar(CP_ACP, 0, _ansi, (int)l, NULL,0); 
  39. _wide = static_cast<LPWSTR>(alloca(++wl*sizeof(WCHAR))); 
  40. if (::MultiByteToWideChar(CP_ACP, 0, _ansi, (int)l, _wide, (int)wl) == 0) 
  41. _wide = NULL;
  45. /**
  46. NtApiInitializer
  47. */
  48. class NktNtApiInitializer
  49. {
  50. public:
  51. NktNtApiInitializer()
  52. {
  53. NktNtApi::Initialize();
  54. }
  55. } NtApiInitializerInst;
  57. ///
  58. /// NtApi: Statics
  59. ///
  60. bool NktNtApi::initialized = false;
  61. NktNtApi::LdrGetProcedureAddress NktNtApi::getProcAddress = NULL;
  62. NktNtApi::NtSuspendThread NktNtApi::suspendThread = NULL;
  63. NktNtApi::DbgPrint NktNtApi::dbgPrint = NULL;
  64. NktNtApi::RtlInitAnsiString NktNtApi::initAnsiString = NULL;
  65. NktNtApi::RtlInitUnicodeString NktNtApi::initUnicodeString = NULL;
  66. NktNtApi::NtCurrentTeb NktNtApi::ntCurrentTeb = NULL;
  67. NktNtApi::NtSetEvent NktNtApi::ntSetEvent = NULL;
  68. NktNtApi::NtPulseEvent NktNtApi::ntPulseEvent = NULL;
  69. NktNtApi::NtResetEvent NktNtApi::ntResetEvent = NULL;
  70. NktNtApi::NtClose NktNtApi::ntClose = NULL;
  71. NktNtApi::NtCreateEvent NktNtApi::ntCreateEvent = NULL;
  72. NktNtApi::NtOpenEvent NktNtApi::ntOpenEvent = NULL;
  73. NktNtApi::NtQueryInformationThread NktNtApi::ntQueryInformationThread = NULL;
  74. NktNtApi::NtLdrGetDllHandle NktNtApi::ntLdrGetDllHandle = NULL;
  75. SYSTEM_INFO NktNtApi::systemInfo = { 0 };
  77. ///
  78. /// Helpers:
  79. ///
  80. void GetClientID(ClientId& cid)
  81. {
  82. PUndocTeb teb = NULL;
  83. // calculate the offset of the clientId (it should work in 64b
  84. SIZE_T offset = (INT_PTR) &teb->Cid - (INT_PTR) teb;
  85. INT_PTR cteb = (SIZE_T)NktNtApi::CurrentTEB();
  87. memcpy(&cid, (const void*)(cteb + offset), sizeof(ClientId));
  88. }
  90. ///
  91. /// Constructors / Destructor
  92. ///
  93. void NktNtApi::Initialize()
  94. {
  95. if (initialized)
  96. return;
  98. HMODULE hMod = ::GetModuleHandleW(L"ntdll.dll"); _ASSERT(hMod);
  99. initAnsiString = (RtlInitAnsiString) ::GetProcAddress(hMod, "RtlInitAnsiString");
  100. initUnicodeString = (RtlInitUnicodeString) ::GetProcAddress(hMod, "RtlInitUnicodeString");
  101. getProcAddress = (LdrGetProcedureAddress)::GetProcAddress(hMod, "LdrGetProcedureAddress");
  102. suspendThread = (NtSuspendThread)::GetProcAddress(hMod, "NtSuspendThread");
  103. dbgPrint = (DbgPrint)::GetProcAddress(hMod, "DbgPrint");
  104. ntCurrentTeb = (NtCurrentTeb)::GetProcAddress(hMod, "NtCurrentTeb");
  105. ntSetEvent = (NtSetEvent)::GetProcAddress(hMod, "NtSetEvent");
  106. ntResetEvent = (NtResetEvent)::GetProcAddress(hMod, "NtPulseEvent");
  107. ntPulseEvent = (NtPulseEvent)::GetProcAddress(hMod, "NtResetEvent");
  108. ntClose = (NtClose)::GetProcAddress(hMod, "NtClose");
  109. ntCreateEvent = (NtCreateEvent) ::GetProcAddress(hMod, "NtCreateEvent");
  110. ntOpenEvent = (NtOpenEvent) ::GetProcAddress(hMod, "NtOpenEvent");
  111. ntQueryInformationThread = (NtQueryInformationThread) ::GetProcAddress(hMod, "NtQueryInformationThread");
  112. ntLdrGetDllHandle = (NtLdrGetDllHandle) ::GetProcAddress(hMod, "LdrGetDllHandle");
  114. ZeroMemory(&systemInfo, sizeof(SYSTEM_INFO));
  115. ::GetSystemInfo(&systemInfo);
  117. initialized = true;
  118. }
  120. ///
  121. /// NktNtApi::CloseHandle
  122. ///
  123. BOOL NktNtApi::CloseHandle(HANDLE h)
  124. {
  125. NTSTATUS st = ntClose(h);
  126. return st == 0;
  127. }
  129. ///
  130. /// NktNtApi::SuspendThread
  131. ///
  132. void NktNtApi::SuspendThread(HANDLE hthread)
  133. {
  134. _ASSERT(initialized);
  135. suspendThread(hthread, NULL);
  136. }
  138. ///
  139. /// NktNtApi::GetCurrentThreadId
  140. ///
  141. DWORD NktNtApi::GetCurrentThreadId()
  142. {
  143. _ASSERT(initialized);
  144. ClientId cid;
  145. GetClientID(cid);
  146. return cid.UniqueThreadId;
  147. }
  149. ///
  150. /// NktNtApi::GetCurrentProcessId
  151. ///
  152. DWORD NktNtApi::GetCurrentProcessId()
  153. {
  154. _ASSERT(initialized);
  155. ClientId cid;
  156. GetClientID(cid);
  157. return cid.UniqueProcessId;
  158. }
  160. ///
  161. /// NktNtApi::GetProcAddress
  162. ///
  163. FARPROC NktNtApi::GetProcAddress(IN HMODULE hModule, IN LPCSTR lpProcName)
  164. {
  165. _ASSERT(initialized);
  166. FARPROC ret = NULL;
  167. char buffer[256];
  168. STRING ntString;
  169. ntString.Buffer = buffer;
  170. initAnsiString(&ntString, lpProcName);
  171. getProcAddress(hModule, &ntString, 0, (PVOID*)&ret);
  172. return ret;
  173. }
  175. ///
  176. /// NktNtApi::CurrentTEB
  177. ///
  178. PTEB NktNtApi::CurrentTEB()
  179. {
  180. _ASSERT(initialized);
  181. return ntCurrentTeb();
  182. }
  184. ///
  185. /// NktNtApi::GetThreadTEB
  186. ///
  187. PTEB NktNtApi::GetThreadTEB(DWORD tid)
  188. {
  189. THREAD_BASIC_INFORMATION tbInfo;
  190. PTEB teb = NULL;
  192. HANDLE hThread = OpenThread(THREAD_QUERY_INFORMATION, FALSE, tid);
  193. if (!hThread) return teb;
  195. NTSTATUS ret = ntQueryInformationThread(hThread, (THREADINFOCLASS)0, &tbInfo, sizeof(tbInfo), NULL);
  196. if (ret == STATUS_SUCCESS)
  197. teb = (PTEB)tbInfo.TebBaseAddress;
  199. CloseHandle(hThread);
  200. return teb;
  201. }
  203. ///
  204. /// NktNtApi::GetPageSize
  205. ///
  206. DWORD NktNtApi::GetPageSize()
  207. {
  208. _ASSERT(initialized);
  209. return systemInfo.dwPageSize;
  210. }
  212. ///
  213. /// NktNtApi::CreateEvent
  214. ///
  215. HANDLE NktNtApi::CreateEvent(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCWSTR lpName)
  216. {
  217. EVENT_TYPE type = (bManualReset)? NotificationEvent : SynchronizationEvent;
  218. HANDLE hEvent = 0;
  219. OBJECT_ATTRIBUTES obj;
  220. UNICODE_STRING uname, *puname = NULL;
  221. if (lpName)
  222. {
  223. SetUnicodeString(uname, lpName);
  224. puname = &uname;
  225. }
  226. InitializeObjectAttributes(&obj, &uname, 0, 0, 0);
  227. NTSTATUS ret = ntCreateEvent(&hEvent, EVENT_ALL_ACCESS, &obj, type, bInitialState);
  228. return hEvent;
  229. }
  230. HANDLE NktNtApi::CreateEvent(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCSTR lpName)
  231. {
  232. LPWSTR wname = NULL;
  233. if (lpName)
  234. {
  235. ANSI_TO_WIDE(lpName, wname);
  236. if (wname == NULL)
  237. {
  238. OutputDebugStringW(L"NtApi: CreateEvent: Can't create event with provided name.");
  239. return INVALID_HANDLE_VALUE;
  240. }
  241. }
  242. return CreateEvent(lpEventAttributes, bManualReset, bInitialState, wname);
  243. }
  245. ///
  246. /// NktNtApi::OpenEvent
  247. ///
  248. HANDLE NktNtApi::OpenEvent(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName)
  249. {
  250. _ASSERT(bInheritHandle == FALSE);
  251. HANDLE hEvent = 0;
  252. OBJECT_ATTRIBUTES obj;
  253. UNICODE_STRING uname, *puname = NULL;
  254. if (lpName)
  255. {
  256. SetUnicodeString(uname, lpName);
  257. puname = &uname;
  258. }
  259. InitializeObjectAttributes(&obj, puname, 0, 0, 0);
  260. NTSTATUS ret = ntOpenEvent(&hEvent, dwDesiredAccess, &obj); //_ASSERT(ret == STATUS_SUCCESS);
  261. return hEvent;
  262. }
  263. HANDLE NktNtApi::OpenEvent(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName)
  264. {
  265. LPWSTR wname = NULL;
  266. if (lpName)
  267. {
  268. ANSI_TO_WIDE(lpName, wname);
  269. }
  270. return OpenEvent(dwDesiredAccess, bInheritHandle, wname);
  271. }
  273. ///
  274. /// NktNtApi::SetEvent
  275. ///
  276. BOOL NktNtApi::SetEvent(IN HANDLE hEvent)
  277. {
  278. _ASSERT(initialized);
  279. NTSTATUS ret = ntSetEvent(hEvent, 0);
  280. return ret == STATUS_SUCCESS;
  281. }
  283. ///
  284. /// NktNtApi::SetEvent
  285. ///
  286. BOOL NktNtApi::PulseEvent(IN HANDLE hEvent)
  287. {
  288. _ASSERT(initialized);
  289. NTSTATUS ret = ntPulseEvent(hEvent, 0);
  290. return ret == STATUS_SUCCESS;
  291. }
  293. ///
  294. /// NktNtApi::SetEvent
  295. ///
  296. BOOL NktNtApi::ResetEvent(IN HANDLE hEvent)
  297. {
  298. _ASSERT(initialized);
  299. NTSTATUS ret = ntResetEvent(hEvent, 0);
  300. return ret == STATUS_SUCCESS;
  301. }
  304. ///
  305. /// NktNtApi::DebugPrint
  306. ///
  307. void __declspec(naked) NktNtApi::DebugPrint(IN LPCSTR msg, ...)
  308. {
  309. _ASSERT(initialized);
  310. _asm {
  311. jmp [NktNtApi::dbgPrint]
  312. }
  313. }
  315. ///
  316. /// NktNtApi::GetModuleHandle
  317. ///
  318. HMODULE NktNtApi::RawGetModuleHandle(IN LPCWSTR modName)
  319. {
  320. HANDLE handle;
  321. UNICODE_STRING ustr;
  322. SetUnicodeString(ustr, modName);
  323. NTSTATUS status = ntLdrGetDllHandle(0, 0, &ustr, &handle);
  324. return (status == STATUS_SUCCESS)? (HMODULE)handle : NULL;
  325. }
  326. HMODULE NktNtApi::RawGetModuleHandle(IN LPCSTR modName)
  327. {
  328. size_t l = strlen(modName);
  329. WCHAR* buffer = (WCHAR*)alloca((l+1)*sizeof(WCHAR));
  330. int conv = MultiByteToWideChar(CP_ACP, 0, modName, (int)l+1, buffer, (int)(l+1)*sizeof(WCHAR));
  331. return (conv != 0)? GetModuleHandle(buffer) : NULL;
  332. }
  334. /************************************************************************/
  335. /* Helpers                                                              */
  336. /************************************************************************/
  337. void SetUnicodeString(UNICODE_STRING& ustr, LPCWSTR txt)
  338. {
  339. ustr.Buffer = (PWSTR)txt;
  340. ustr.Length = static_cast<USHORT>(wcslen(ustr.Buffer) << 1);
  341. ustr.MaximumLength = ustr.Length + sizeof(WCHAR);
  342. }