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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 钩子与API截获 > 查看源码
mydll.cpp
资源名称：HookAPI　[点击查看]
上传用户：nbcables
上传日期：2007-01-11
资源大小：1243k
文件大小：17k
源码类别：

钩子与API截获

开发平台：

Visual C++

mydll.cpp：源码内容
  1. // ------------------------------------- //
  2. // 您如果要使用本文件，请不要删除本说明  //
  3. // ------------------------------------- //
  4. //             HOOKAPI 开发例子          //
  5. //   Copyright 2002 编程沙龙 Paladin     //
  6. //       www.ProgramSalon.com            //
  7. // ------------------------------------- //
  9. #include "stdafx.h"
  10. #include <stdio.h>
  12. #include "mydll.h"
  13. #include "util.h"
  14. #include "psapi.h"
  15. #include "tlhelp32.h"
  16. #include "ps.h"
  17. #include "filter.h"
  19. HINSTANCE g_hInstance =NULL;
  20. CFileFilter g_Filter;
  22. BOOL APIENTRY DllMain( HANDLE hModule, 
  23.                        DWORD  ul_reason_for_call, 
  24.                        LPVOID lpReserved
  25.  )
  26. {
  27. g_hInstance =(HINSTANCE)hModule;
  28.     return TRUE;
  29. }
  31. HANDLE WINAPI myCreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
  32. {          
  33. char temp[200];
  34. GetModuleFileName(NULL, temp, sizeof(temp));
  35. //WriteLog("myCreateFileA:filename=%s", lpFileName);
  37. if(g_Filter.FilterCreateFile((char *)lpFileName))
  38. {
  39. SetLastError(ERROR_NOT_AUTHENTICATED);
  40. return NULL;
  41. }
  42. return CreateFileA(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes,
  43. dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
  44. }
  46. HANDLE WINAPI myCreateFileW(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
  47. {
  48. char temp[200];
  49. GetModuleFileName(NULL, temp, sizeof(temp));
  50. char fname[128];
  51. int len =WideCharToMultiByte( CP_ACP, 0, lpFileName, -1, fname, 128,NULL,NULL); 
  52. fname[len] =0;
  54. WriteLog("myCreateFileW:filename=%s", fname);
  56. if(strstr(fname, "NOTEPAD") || strstr(fname, "notepad") || strstr(fname, "Notepad") || strstr(fname, "NotePad"))
  57. {
  58. WriteLog("found notepad");
  59. return NULL;
  60. }
  61. if(g_Filter.FilterCreateFile(fname))
  62. {
  63. SetLastError(ERROR_NOT_AUTHENTICATED);
  64. return NULL;
  65. }
  67. HANDLE hFile =CreateFileW(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes,
  68. dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
  69. int err =GetLastError();
  70. //WriteLog("CreateFileW:handle=%x", hFile);
  71. SetLastError(err);
  73. return hFile;
  74. }
  76. BOOL WINAPI myDeleteFileA(LPCSTR lpFileName)
  77. {
  78. char temp[200];
  79. GetModuleFileName(NULL, temp, sizeof(temp));
  80. WriteLog("myDeleteFileA:filename=%s", lpFileName);
  82. if(g_Filter.FilterDeleteFile((char *)lpFileName))
  83. {
  84. SetLastError(ERROR_NOT_AUTHENTICATED);
  85. return NULL;
  86. }
  88. return DeleteFileA(lpFileName);
  89. }
  91. BOOL WINAPI myDeleteFileW(LPCWSTR lpFileName)
  92. {
  93. char temp[200];
  94. GetModuleFileName(NULL, temp, sizeof(temp));
  95. char fname[128];
  96. int len =WideCharToMultiByte( CP_ACP, 0, lpFileName, -1, fname, 128,NULL,NULL); 
  97. fname[len] =0;
  98. WriteLog("myDeleteFileW:filename=%s", fname);
  100. if(g_Filter.FilterDeleteFile(fname))
  101. {
  102. SetLastError(ERROR_NOT_AUTHENTICATED);
  103. return NULL;
  104. }
  106. return DeleteFileW(lpFileName);
  107. }
  109. BOOL WINAPI myCopyFileW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, BOOL bFailIfExists)
  110. {
  111. char fname1[128];
  112. int len =WideCharToMultiByte( CP_ACP, 0, lpExistingFileName, -1, fname1, 128,NULL,NULL); 
  113. fname1[len] =0;
  114. char fname2[128];
  115. len =WideCharToMultiByte( CP_ACP, 0, lpNewFileName, -1, fname2, 128,NULL,NULL); 
  116. fname2[len] =0;
  118. WriteLog("CopyfileW:%s to %s", fname1, fname2);
  120. if(g_Filter.FilterCopyFile(fname1, fname2))
  121. {
  122. SetLastError(ERROR_NOT_AUTHENTICATED);
  123. return NULL;
  124. }
  126. return CopyFileW(lpExistingFileName, lpNewFileName, bFailIfExists);
  127. }
  129. BOOL WINAPI myCopyFileA(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, BOOL bFailIfExists)
  130. {
  131. WriteLog("CopyfileA:%s to %s", lpExistingFileName, lpNewFileName);
  133. if(g_Filter.FilterCopyFile((char *)lpExistingFileName, (char *)lpNewFileName))
  134. {
  135. SetLastError(ERROR_NOT_AUTHENTICATED);
  136. return NULL;
  137. }
  139. return CopyFileA(lpExistingFileName, lpNewFileName, bFailIfExists);
  140. }
  142. BOOL WINAPI myCreateDirectoryW(LPCWSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes)
  143. {
  144. char pname[128];
  145. int len =WideCharToMultiByte( CP_ACP, 0, lpPathName, -1, pname, 128,NULL,NULL); 
  146. pname[len] =0;
  147. WriteLog("CreateDirectoryW:path=%s", pname);
  149. if(g_Filter.FilterCreateDir(pname))
  150. {
  151. SetLastError(ERROR_NOT_AUTHENTICATED);
  152. return NULL;
  153. }
  155. return CreateDirectoryW(lpPathName, lpSecurityAttributes);
  156. }
  158. BOOL WINAPI myCreateDirectoryA(LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes)
  159. {
  160. WriteLog("CreateDirectoryA:path=%s", lpPathName);
  161. if(g_Filter.FilterCreateDir((char *)lpPathName))
  162. {
  163. SetLastError(ERROR_NOT_AUTHENTICATED);
  164. return NULL;
  165. }
  166. return CreateDirectoryA(lpPathName, lpSecurityAttributes);
  167. }
  169. BOOL WINAPI myCreateDirectoryExW(LPCWSTR lpTemplateDirectory, LPCWSTR lpNewDirectory,
  170. LPSECURITY_ATTRIBUTES lpSecurityAttributes)
  171. {
  172. char pname1[128], pname2[128];
  173. int len =WideCharToMultiByte( CP_ACP, 0, lpTemplateDirectory, -1, pname1, 128,NULL,NULL); 
  174. pname1[len] =0;
  175. len =WideCharToMultiByte( CP_ACP, 0, lpNewDirectory, -1, pname2, 128,NULL,NULL); 
  176. pname2[len] =0;
  178. WriteLog("CreateDirectoryExW:pathtemp=%s, path=%s", pname1, pname2);
  180. if(g_Filter.FilterCreateDir(pname1))
  181. {
  182. SetLastError(ERROR_NOT_AUTHENTICATED);
  183. return NULL;
  184. }
  186. if(g_Filter.FilterCreateDir(pname2))
  187. {
  188. SetLastError(ERROR_NOT_AUTHENTICATED);
  189. return NULL;
  190. }
  192. return CreateDirectoryExW(lpTemplateDirectory, lpNewDirectory, lpSecurityAttributes);
  193. }
  195. BOOL WINAPI myCreateDirectoryExA(LPCSTR lpTemplateDirectory, LPCSTR lpNewDirectory,
  196. LPSECURITY_ATTRIBUTES lpSecurityAttributes)
  197. {
  198. WriteLog("CreateDirectoryExA:pathtemp=%s, path=%s", lpTemplateDirectory, lpNewDirectory);
  200. if(g_Filter.FilterCreateDir((char *)lpTemplateDirectory))
  201. {
  202. SetLastError(ERROR_NOT_AUTHENTICATED);
  203. return NULL;
  204. }
  206. if(g_Filter.FilterCreateDir((char *)lpNewDirectory))
  207. {
  208. SetLastError(ERROR_NOT_AUTHENTICATED);
  209. return NULL;
  210. }
  212. return CreateDirectoryExA(lpTemplateDirectory, lpNewDirectory, lpSecurityAttributes);
  213. }
  215. HANDLE WINAPI myFindFirstFileW(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileData)
  216. {
  217. HANDLE h =FindFirstFileW(lpFileName, lpFindFileData);
  218. if(h)
  219. {
  220. char fname[128];
  221. int len =WideCharToMultiByte( CP_ACP, 0, lpFindFileData->cFileName, -1, fname, 128,NULL,NULL); 
  222. fname[len] =0;
  224. WriteLog("FindFirstFileW:%s", fname);
  226. if(strstr(fname, "Debug"))//g_Filter.FilterOpenFile(fname))
  227. {
  228. WriteLog("okkkkkkkkkkkkkkkkkkkkkk");
  229. //SetLastError(ERROR_NOT_AUTHENTICATED);
  230. //return NULL;
  231. memset(lpFindFileData, 0, sizeof(*lpFindFileData));
  232. if(!FindNextFileW(h, lpFindFileData))
  233. {
  234. FindClose(h);
  235. SetLastError(ERROR_NOT_AUTHENTICATED);
  236. return h;
  237. }
  238. }
  239. }
  240. return h; 
  241. }
  243. HANDLE WINAPI myFindFirstFileA(LPCSTR lpFileName, LPWIN32_FIND_DATA lpFindFileData)
  244. {
  245. WriteLog("FindFirstFileA:%s", lpFileName);
  246. /*if(g_Filter.FilterFindFile(lpFileName))
  247. {
  248. SetLastError(ERROR_NOT_AUTHENTICATED);
  249. return NULL;
  250. }*/
  251. return FindFirstFileA(lpFileName, lpFindFileData);
  252. }
  253. //隐藏文件或目录
  254. HANDLE WINAPI myFindFirstFileExW(LPCWSTR lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, LPWIN32_FIND_DATAW lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, DWORD dwAdditionalFlags)
  255. {
  256. HANDLE h=FindFirstFileExW(lpFileName, fInfoLevelId, lpFindFileData, fSearchOp, lpSearchFilter, dwAdditionalFlags);
  257. if(h)
  258. {
  259. char fname[128];
  260. int len =WideCharToMultiByte( CP_ACP, 0, lpFindFileData->cFileName, -1, fname, 128,NULL,NULL); 
  261. fname[len] =0;
  263. WriteLog("FindFirstFileW:%s", fname);
  265. if(g_Filter.FilterOpenFile(fname))
  266. {
  267. //WriteLog("okkkkkkkkkkkkkkkkkkkkkk");
  268. //SetLastError(ERROR_NOT_AUTHENTICATED);
  269. //return NULL;
  270. memset(lpFindFileData, 0, sizeof(*lpFindFileData));
  271. if(!FindNextFileW(h, lpFindFileData))
  272. {
  273. FindClose(h);
  274. SetLastError(ERROR_NOT_AUTHENTICATED);
  275. return h;
  276. }
  277. }
  278. }
  279. return h; 
  280. }
  281. //隐藏文件或目录
  282. BOOL WINAPI myFindNextFileW(HANDLE h, LPWIN32_FIND_DATAW lpFindFileData)
  283. {
  284. //WriteLog("FindNextFileW");
  285. BOOL f =FindNextFileW(h, lpFindFileData);
  286. if(f)
  287. {
  288. char fname[128];
  289. int len =WideCharToMultiByte( CP_ACP, 0, lpFindFileData->cFileName, -1, fname, 128,NULL,NULL); 
  290. fname[len] =0;
  292. WriteLog("FindNextFileW:%s", fname);
  294. if(g_Filter.FilterOpenFile(fname))  // 如果发现了此文件或目录，就跳过返回下一个查找结果
  295. {
  296. //WriteLog("ok2 kkkkkkkkkkkkkkkkkkkkk");
  297. //SetLastError(ERROR_NOT_AUTHENTICATED);
  298. //return NULL;
  299. return FindNextFileW(h, lpFindFileData);
  300. }
  301. }
  302. return f; 
  303. }
  305. BOOL WINAPI myFindNextFileA(HANDLE h, LPWIN32_FIND_DATAA lpFindFileData)
  306. {
  307. BOOL f =FindNextFileA(h, lpFindFileData);
  308. if(f)
  309. {
  310. WriteLog("FindNextFileA:%s", lpFindFileData->cFileName);
  312. if(g_Filter.FilterOpenFile(lpFindFileData->cFileName))
  313. {
  314. //WriteLog("ok2 kkkkkkkkkkkkkkkkkkkkk");
  315. //SetLastError(ERROR_NOT_AUTHENTICATED);
  316. //return NULL;
  317. return FindNextFileA(h, lpFindFileData);
  318. }
  319. }
  320. return f; 
  321. }
  323. BOOL WINAPI myMoveFileW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName)
  324. {
  325. char fname[128];
  326. int len =WideCharToMultiByte( CP_ACP, 0, lpExistingFileName, -1, fname, 128,NULL,NULL); 
  327. fname[len] =0;
  328. char fname1[128];
  329. len =WideCharToMultiByte( CP_ACP, 0, lpNewFileName, -1, fname1, 128,NULL,NULL); 
  330. fname1[len] =0;
  332. WriteLog("MoveFileW:%s,%s", fname, fname1);
  334. if(g_Filter.FilterMoveFile(fname, fname1))
  335. {
  336. SetLastError(ERROR_NOT_AUTHENTICATED);
  337. return NULL;
  338. }
  340. return MoveFileW(lpExistingFileName, lpNewFileName);
  341. }
  343. BOOL WINAPI myMoveFileA(LPCSTR lpExistingFileName, LPCSTR lpNewFileName)
  344. {
  345. WriteLog("MoveFileA:%s,%s", lpExistingFileName, lpNewFileName);
  347. if(g_Filter.FilterMoveFile((char *)lpExistingFileName, (char *)lpNewFileName))
  348. {
  349. SetLastError(ERROR_NOT_AUTHENTICATED);
  350. return NULL;
  351. }
  353. return MoveFileA(lpExistingFileName, lpNewFileName);
  354. }
  356. BOOL WINAPI myMoveFileExW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, DWORD dwFlags)
  357. {
  358. char fname[128];
  359. int len =WideCharToMultiByte( CP_ACP, 0, lpExistingFileName, -1, fname, 128,NULL,NULL); 
  360. fname[len] =0;
  361. char fname1[128];
  362. len =WideCharToMultiByte( CP_ACP, 0, lpNewFileName, -1, fname1, 128,NULL,NULL); 
  363. fname1[len] =0;
  365. WriteLog("MoveFileExW:%s,%s", fname, fname1);
  367. if(g_Filter.FilterMoveFile(fname, fname1))
  368. {
  369. SetLastError(ERROR_NOT_AUTHENTICATED);
  370. return NULL;
  371. }
  373. return MoveFileExW(lpExistingFileName, lpNewFileName, dwFlags);
  374. }
  376. BOOL WINAPI myMoveFileExA(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, DWORD dwFlags)
  377. {
  378. WriteLog("MoveFileExA:%s,%s", lpExistingFileName, lpNewFileName);
  380. if(g_Filter.FilterMoveFile((char *)lpExistingFileName, (char *)lpNewFileName))
  381. {
  382. SetLastError(ERROR_NOT_AUTHENTICATED);
  383. return NULL;
  384. }
  386. return MoveFileExA(lpExistingFileName, lpNewFileName, dwFlags);
  387. }
  389. BOOL WINAPI myReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead,
  390. LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped)
  391. {
  392. //WriteLog("ReadFile:handle=%x", hFile);
  394. char fname[200];
  395. GetFileNameByHandle(hFile, fname);
  396. if(g_Filter.FilterReadFile(fname))
  397. {
  398. SetLastError(ERROR_NOT_AUTHENTICATED);
  399. return NULL;
  400. }
  402. return ReadFile(hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead, lpOverlapped);
  403. }
  405. BOOL WINAPI myReadFileEx(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead,
  406. LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
  407. {
  408. WriteLog("ReadFileEx");
  409. char fname[200];
  410. GetFileNameByHandle(hFile, fname);
  411. if(g_Filter.FilterReadFile(fname))
  412. {
  413. SetLastError(ERROR_NOT_AUTHENTICATED);
  414. return false;
  415. }
  416. return ReadFileEx(hFile, lpBuffer, nNumberOfBytesToRead,
  417. lpOverlapped, lpCompletionRoutine);
  418. }
  420. BOOL WINAPI mySetCurrentDirectoryW(LPCWSTR lpPathName)
  421. {
  422. char pname[128];
  423. int len =WideCharToMultiByte( CP_ACP, 0, lpPathName, -1, pname, 128,NULL,NULL); 
  424. pname[len] =0;
  426. WriteLog("SetCurrentDirectoryW:%s", pname);
  428. if(strstr(pname, "Debug"))
  429. {
  430. SetLastError(ERROR_NOT_AUTHENTICATED);
  431. return false;
  432. }
  434. if(g_Filter.FilterChDir(pname))
  435. {
  436. SetLastError(ERROR_NOT_AUTHENTICATED);
  437. return false;
  438. }
  440. return SetCurrentDirectoryW(lpPathName);
  441. }
  443. BOOL WINAPI mySetCurrentDirectoryA(LPCSTR lpPathName)
  444. {
  445. WriteLog("SetCurrentDirectoryA:%s", lpPathName);
  447. if(g_Filter.FilterChDir((char *)lpPathName))
  448. {
  449. SetLastError(ERROR_NOT_AUTHENTICATED);
  450. return false;
  451. }
  453. return SetCurrentDirectoryA(lpPathName);
  454. }
  456. BOOL WINAPI myWriteFile(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite,
  457. LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped)
  458. {
  459. //WriteLog("WriteFile");
  461. char fname[200];
  462. GetFileNameByHandle(hFile, fname);
  463. if(g_Filter.FilterWriteFile(fname))
  464. {
  465. SetLastError(ERROR_NOT_AUTHENTICATED);
  466. return false;
  467. }
  469. return WriteFile(hFile, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten,
  470. lpOverlapped);
  471. }
  473. BOOL WINAPI myWriteFileEx(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite,
  474. LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
  475. {
  476. WriteLog("WriteFileEx");
  478. char fname[200];
  479. GetFileNameByHandle(hFile, fname);
  480. if(g_Filter.FilterWriteFile(fname))
  481. {
  482. SetLastError(ERROR_NOT_AUTHENTICATED);
  483. return false;
  484. }
  486. return WriteFileEx(hFile, lpBuffer, nNumberOfBytesToWrite, lpOverlapped, lpCompletionRoutine);
  487. }
  489. // 过滤执行文件
  490. DWORD WINAPI myCreateProcessW(
  491. LPCWSTR lpApplicationName,
  492. LPWSTR lpCommandLine, 
  493. LPSECURITY_ATTRIBUTES lpProcessAttributes,
  494. LPSECURITY_ATTRIBUTES lpThreadAttributes,
  495. BOOL bInheritHandles,
  496. DWORD dwCreationFlags,
  497. LPVOID lpEnvironment,
  498. LPCWSTR lpCurrentDirectory,
  499. LPSTARTUPINFOW lpStartupInfo,
  500. LPPROCESS_INFORMATION lpProcessInformation
  501. )
  502. {
  503. char cmd[600];
  504. int len =WideCharToMultiByte( CP_ACP, 0, lpCommandLine, -1, cmd, sizeof(cmd),NULL,NULL); 
  505. cmd[len] =0;
  507. //WriteLog("CreateProcessW :cmd=%s", cmd);
  509. if(g_Filter.FilterExecute(cmd))
  510. {
  511. SetLastError(ERROR_NOT_AUTHENTICATED);
  512. return false;
  513. }
  515. BOOL ifsuccess = CreateProcessW(lpApplicationName,
  516. lpCommandLine, lpProcessAttributes,
  517. lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment,
  518. lpCurrentDirectory, lpStartupInfo, lpProcessInformation);
  519. DWORD err =GetLastError();
  520. SetLastError(err);
  521. return (DWORD)ifsuccess;
  522. }
  524. DWORD WINAPI myCreateProcessA(
  525. LPCSTR lpApplicationName,
  526. LPSTR lpCommandLine, 
  527. LPSECURITY_ATTRIBUTES lpProcessAttributes,
  528. LPSECURITY_ATTRIBUTES lpThreadAttributes,
  529. BOOL bInheritHandles,
  530. DWORD dwCreationFlags,
  531. LPVOID lpEnvironment,
  532. LPCSTR lpCurrentDirectory,
  533. LPSTARTUPINFO lpStartupInfo,
  534. LPPROCESS_INFORMATION lpProcessInformation
  535. )
  536. {
  537. if(g_Filter.FilterExecute(lpCommandLine))
  538. {
  539. SetLastError(ERROR_NOT_AUTHENTICATED);
  540. return false;
  541. }
  543. BOOL ifsuccess = CreateProcessA(lpApplicationName,
  544. lpCommandLine, lpProcessAttributes,
  545. lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment,
  546. lpCurrentDirectory, lpStartupInfo, lpProcessInformation);
  547. DWORD err =GetLastError();
  548. WriteLog("CreateProcessA %s", lpCommandLine);
  549. SetLastError(err);
  550. return (DWORD)ifsuccess;
  551. }
  553. DWORD WINAPI myGetFileAttributesW(LPCWSTR pfile)
  554. {
  555. char fname[128];
  556. int len=WideCharToMultiByte(CP_ACP, 0, pfile, -1, fname, sizeof(fname), NULL, NULL);
  557. fname[len] =0;
  558. WriteLog("myGetFileAttributesW:%s",fname);
  560. return GetFileAttributesW(pfile);
  561. }
  563. DWORD WINAPI myGetFileAttributesA(LPCSTR pfile)
  564. {
  565. WriteLog("myGetFileAttributesA:%s",pfile);
  567. return GetFileAttributesA(pfile);
  568. }
  570. MYAPIINFO myapi_info[] =
  571. {
  572. {"KERNEL32.DLL", "CreateFileA", 7, "myCreateFileA"},
  573. {"KERNEL32.DLL", "CreateFileW", 7, "myCreateFileW"},
  574. {"KERNEL32.DLL", "ReadFile", 5, "myReadFile"},
  575. {"KERNEL32.DLL", "ReadFileEx", 6, "myReadFileEx"},
  576. {"KERNEL32.DLL", "WriteFile", 5, "myWriteFile"},
  577. {"KERNEL32.DLL", "WriteFileEx", 5, "myWriteFileEx"},
  578. {"KERNEL32.DLL", "MoveFileA", 2, "myMoveFileA"},
  579. {"KERNEL32.DLL", "MoveFileW", 2, "myMoveFileW"},
  580. {"KERNEL32.DLL", "MoveFileExA", 3, "myMoveFileExA"},
  581. {"KERNEL32.DLL", "MoveFileExW", 3, "myMoveFileExW"},
  582. {"KERNEL32.DLL", "DeleteFileA", 1, "myDeleteFileA"},
  583. {"KERNEL32.DLL", "DeleteFileW", 1, "myDeleteFileW"},
  584. {"KERNEL32.DLL", "CopyFileA", 3, "myCopyFileA"},
  585. {"KERNEL32.DLL", "CopyFileW", 3, "myCopyFileW"},
  586. {"KERNEL32.DLL", "FindFirstFileA", 2, "myFindFirstFileA"},
  587. {"KERNEL32.DLL", "FindFirstFileW", 2, "myFindFirstFileW"},
  588. {"KERNEL32.DLL", "FindNextFileW", 2, "myFindNextFileW"},
  589. {"KERNEL32.DLL", "CreateDirectoryExA", 3, "myCreateDirectoryExA"},
  590. {"KERNEL32.DLL", "CreateDirectoryExW", 3, "myCreateDirectoryExW"},
  591. {"KERNEL32.DLL", "CreateDirectoryA", 2, "myCreateDirectoryA"},
  592. {"KERNEL32.DLL", "CreateDirectoryW", 2, "myCreateDirectoryW"},
  593. {"KERNEL32.DLL", "SetCurrentDirectoryA", 1, "mySetCurrentDirectoryA"},
  594. {"KERNEL32.DLL", "SetCurrentDirectoryW", 1, "mySetCurrentDirectoryW"},
  595. {"KERNEL32.DLL", "CreateProcessW", 10, "myCreateProcessW"},
  596. {"KERNEL32.DLL", "CreateProcessA", 10, "myCreateProcessA"},
  597. {"KERNEL32.DLL", "GetFileAttributesW", 1, "myGetFileAttributesW"},
  598. {"KERNEL32.DLL", "GetFileAttributesA", 1, "myGetFileAttributesA"},
  599. {"KERNEL32.DLL", "FindFirstFileExW", 6, "myFindFirstFileExW"},
  601. {NULL,NULL,NULL}
  602. };
  604. MYAPIINFO *GetMyAPIInfo()
  605. {
  606. return &myapi_info[0];
  607. }