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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 系统编程 > 查看源码
BehaviorMon.c
资源名称：BehaviorProMon.rar　[点击查看]
上传用户：xuemeng126
上传日期：2022-07-05
资源大小：454k
文件大小：84k
源码类别：

系统编程

开发平台：

Visual C++

BehaviorMon.c：源码内容
  1. //////////////////////////////////////////////////////////////////////////
  2. //头文件
  3. #include "ntddk.h"
  4. #include "stdio.h" 
  5. #include "ntifs.h"
  6. #include "BehaviorMon.h"
  7. //from regmon
  8. #include "stdarg.h" 
  9. #include "IoctlCmd.h" 
  10. #include "ksecdd.h"
  11. #include "ntsec.h"
  12. #include "regsys.h"
  13. #include "reglib.h" 
  16. #pragma comment(lib,"regmlib.lib")
  17. #pragma comment(lib,"ksecdd.lib")
  19. //宏定义
  20. #define SYSNAME "System"
  21. #define NT_PROCNAMELEN 16 
  22. #define ObjectNameInformation (1)
  23. #define STATUS_INFO_LEN_MISMATCH       0xC0000004
  24. #define DELAYTIME -10
  25. //类型定义
  26. typedef unsigned long DWORD;
  27. //typedef void* PVOID;
  28. //结构体定义
  29. struct SYS_SERVICE_TABLE { 
  30. void **ServiceTable; 
  31. unsigned long CounterTable; 
  32. unsigned long ServiceLimit; 
  33. void **ArgumentsTable; 
  34. }; 
  35. //保存被hook的nativeAPI函数信息
  36. typedef struct {
  37. const char * nativeAPIname;//函数名称
  38. ULONG Index;//在描述符表中的代号
  39. ULONG RealCallee;//真正的地址
  40. ULONG proxyfunadd;//代理函数地址
  41. BOOL  hooked;
  42. }HOOKED_API_INFO;
  43. HOOKED_API_INFO hook_API_info[100];
  44. int hook_num=0;
  45. //交互缓冲区，驱动往里写，前台往出读，做显示
  46. typedef struct{
  47. char IsRead;
  48. char ProcessName[32];
  49. char NativeAPIName[32];
  50. char ProcessFullName[512];
  51. char Behavior[1024];
  52. char Result[64];
  53. char Time[16];
  54. }LOG_BEHAVIOR,* PLOG_BEHAVIOR;
  55. int curr_write_pointer=0;
  56. BOOL can_use_curr_write_pointer=TRUE;
  57. DWORD LOG_BEHAVIOR_NUM=10;
  58. PLOG_BEHAVIOR plog_behavior;
  59. //////////////////////////////////////////////////////////////////////////
  60. //常量
  61. const WCHAR devicename[]=L"\Device\BehaviorMon";
  62. const WCHAR devicelink[]=L"\DosDevices\BEHAVIORMON"; 
  63. // Is registry hooked? 
  64. BOOLEAN Hooked = FALSE;
  65. //ProcessName在EPROCESS结构体中的偏移量，不同操作系统不同
  66. //xp：0x174 2k：0x1fc
  67. ULONG ProcessNameOffset;
  68. //事件
  69. KEVENT event; 
  70. //真正NativeAPI函数的地址
  71. ULONG Index,RealCallee;
  72. //与前台的交换缓冲区
  73. //char*plog_behavior;
  74. char*tmp;
  75. int i=0;
  76. int goornot=0;
  77. //windows系统服务描述符表
  78. extern struct SYS_SERVICE_TABLE *KeServiceDescriptorTable; 
  79. PVOID                   *KeServiceTablePointers;
  80. SERVICE_HOOK_DESCRIPTOR *HookDescriptors;
  81. //要监控的程序全路径
  82. char processname_G[1024];
  83. //
  84. // Full path name lookaside 
  85. //
  86. //非分页内存
  87. PAGED_LOOKASIDE_LIST  FullPathLookaside;
  88. //
  89. // Lenghs of rootkeys (filled in at init). This table allows us to translate 
  90. // path names into better-known forms. Current user is treated specially since
  91. // its not a full match.
  92. //
  93. ROOTKEY CurrentUser[2] = {
  94. { "\\REGISTRY\USER\S", "HKCU", 0 },
  95. { "HKU\S", "HKCU", 0 }
  96. };
  98. ROOTKEY RootKey[NUMROOTKEYS] = {
  99. { "\\REGISTRY\USER", "HKU", 0 },
  100. { "\\REGISTRY\MACHINE\SYSTEM\CURRENTCONTROLSET\HARDWARE PROFILES\CURRENT", 
  101. "HKCC", 0 },
  102. { "\\REGISTRY\MACHINE\SOFTWARE\CLASSES", "HKCR", 0 },
  103. { "\\REGISTRY\MACHINE", "HKLM", 0 }
  104. };
  106. //
  107. // This is a hash table for keeping names around for quick lookup.
  108. //
  109. PHASH_ENTRY             HashTable[NUMHASH];
  111. //
  112. // Mutex for hash table accesses
  113. //
  114. KMUTEX                  HashMutex;
  115. //
  116. // Data structure for storing messages we generate
  117. //
  118. PLOG_BUF                Log           = NULL;
  119. ULONG                   Sequence      = 0;
  120. LARGE_INTEGER           StartTime;
  121. KMUTEX                  LogMutex;
  123. //
  124. // Maximum amount of data we will grab for buffered unread data
  125. //
  126. ULONG                   NumLog        = 0;
  127. ULONG                   MaxLog        = MAXMEM/LOGBUFSIZE;
  128. //
  129. // Global error string
  130. //
  131. CHAR                    errstring[256];
  132. //
  133. // A unicode string constant for the "default" value
  134. //
  135. #define DEFAULTNAMELEN  (9*sizeof(WCHAR))
  136. WCHAR                   DefaultValueString[] = L"(Default)";
  137. UNICODE_STRING          DefaultValue = {
  138.     DEFAULTNAMELEN,
  139. DEFAULTNAMELEN,
  140. DefaultValueString
  141. };
  142. //======================================================================
  143. //                   B U F F E R  R O U T I N E S 
  144. //======================================================================
  145. //----------------------------------------------------------------------
  146. //
  147. // ApplyNameFilter
  148. //
  149. // If the name matches the exclusion mask, we do not log it. Else if
  150. // it doesn't match the inclusion mask we do not log it. 
  151. //
  152. //----------------------------------------------------------------------
  153. BOOLEAN
  154. ApplyFilters( 
  155.  PCHAR fullname 
  156.  )
  157. {
  158. return TRUE;
  159. }
  160. //----------------------------------------------------------------------
  161. //
  162. // RegmonFreeLog
  163. //
  164. // Frees all the data output buffers that we have currently allocated.
  165. //
  166. //----------------------------------------------------------------------
  167. VOID 
  168. RegmonFreeLog(
  169.   VOID
  170.   )
  171. {
  172. PLOG_BUF      next;
  174. //
  175. // Just traverse the list of allocated output buffers
  176. //
  177. while( Log ) {
  178. next = Log->Next;
  179. ExFreePool( Log );
  180. Log = next;
  181. }
  182. }       
  183. //----------------------------------------------------------------------
  184. //
  185. // RegmonNewLog
  186. //
  187. // Called when the current buffer has filled up. This moves us to the
  188. // pre-allocated buffer and then allocates another buffer.
  189. //
  190. //----------------------------------------------------------------------
  191. VOID 
  192. RegmonNewLog( 
  193.  VOID 
  194.  )
  195. {
  196. PLOG_BUF prev = Log, newLog; 
  198. //
  199. // If we have maxed out or haven't accessed the current Log
  200. // just return
  201. //
  202. if( MaxLog == NumLog ) {
  204. Log->Len = 0;
  205. return; 
  206. }
  208. //
  209. // See if we can re-use a Log
  210. //
  211. if( !Log->Len ) {
  213. return;
  214. }
  216. //
  217. // Move to the next buffer and allocate another one
  218. //
  219. newLog = ExAllocatePool( PagedPool, sizeof(*Log) );
  220. if( newLog ) { 
  222. //
  223. // Allocation was successful so add the buffer to the list
  224. // of allocated buffers and increment the buffer count.
  225. //
  226. Log   = newLog;
  227. Log->Len  = 0;
  228. Log->Next = prev;
  229. NumLog++;
  231. } else {
  233. //
  234. // The allocation failed - just reuse the current buffer
  235. //
  236. Log->Len = 0;
  237. }
  238. }
  241. //----------------------------------------------------------------------
  242. //
  243. // RegmonOldestLog
  244. //
  245. // Goes through the linked list of storage buffers and returns the 
  246. // oldest one.
  247. //
  248. //----------------------------------------------------------------------
  249. PLOG_BUF 
  250. RegmonOldestLog( 
  251. VOID 
  252. )
  253. {
  254. PLOG_BUF  ptr = Log, prev = NULL;
  256. //
  257. // Traverse the list
  258. //
  259. while( ptr->Next ) {
  261. ptr = (prev = ptr)->Next;
  262. }
  264. //
  265. // Remove the buffer from the list
  266. //
  267. if( prev ) {
  269. prev->Next = NULL;    
  270. NumLog--;
  271. }
  272. return ptr;
  273. }
  276. //----------------------------------------------------------------------
  277. //
  278. // RegmonResetLog
  279. //
  280. // When a GUI is no longer communicating with us, but we can't unload,
  281. // we reset the storage buffers.
  282. //
  283. //----------------------------------------------------------------------
  284. VOID
  285. RegmonResetLog(
  286.    VOID
  287.    )
  288. {
  289. PLOG_BUF  current, next;
  291. MUTEX_ACQUIRE( LogMutex );
  293. //
  294. // Traverse the list of output buffers
  295. //
  296. current = Log->Next;
  297. while( current ) {
  299. //
  300. // Free the buffer
  301. //
  302. next = current->Next;
  303. ExFreePool( current );
  304. current = next;
  305. }
  307. // 
  308. // Move the output pointer in the buffer that's being kept
  309. // the start of the buffer.
  310. // 
  311. NumLog = 1;
  312. Log->Len = 0;
  313. Log->Next = NULL;
  315. MUTEX_RELEASE( LogMutex );
  316. }
  318. //----------------------------------------------------------------------
  319. //
  320. // LogRecord
  321. //
  322. // Add a new string to Log, if it fits. 
  323. //
  324. //----------------------------------------------------------------------
  325. VOID 
  326. LogRecord( 
  327.   const char * format, 
  328.   ... 
  329.   )
  330. { 
  331. PENTRY          Entry;
  332. ULONG           len;
  333. va_list         arg_ptr;
  334. static CHAR     text[MAXPATHLEN + MAXDATALEN + MAXPROCNAMELEN + MAXERRORLEN];
  336. #define A (&format)
  337. //KdPrint(( (char *)format, A[1], A[2], A[3], A[4], A[5], A[6] ));
  338. //KdPrint(( "n" ));
  339. #undef A
  341. //
  342. // only do this if a GUI is active
  343. //
  344. //if( !GUIActive ) return;
  346. //
  347. // Lock the buffer pool
  348. //
  349. MUTEX_ACQUIRE( LogMutex );
  351. //
  352. // Sprint the string to get the length
  353. //
  354. va_start( arg_ptr, format );
  355. len = vsprintf( text, format, arg_ptr );
  356. va_end( arg_ptr );    
  358. //
  359. // Only log it if it passes the filters
  360. //
  361. if( ApplyFilters( text )) {
  363. //
  364. // Get a sequence numnber
  365. //
  366. InterlockedIncrement( &Sequence );
  368. //
  369. // ULONG align for Alpha
  370. //
  371. len += 4; len &=  0xFFFFFFFC; // +1 to include null terminator and +3 to allign on longword
  373. //
  374. // See if its time to switch to extra buffer
  375. //
  376. if( Log->Len + len + sizeof(*Entry) + 1 >= LOGBUFSIZE ) {
  378. RegmonNewLog();
  379. }
  381. //
  382. // Log the sequence number so that 
  383. // a call's result can be paired with its
  384. // initial data collected when it was made.
  385. //
  386. Entry = (void *)(Log->Data+Log->Len);
  387. Entry->seq = Sequence;
  388. KeQuerySystemTime( &Entry->time );
  389. Entry->perftime = KeQueryPerformanceCounter( NULL );
  390. Entry->perftime.QuadPart -= StartTime.QuadPart;
  392. memcpy( Entry->text, text, len );
  394. //
  395. // Log the length of the string, plus 1 for the terminating
  396. // NULL  
  397. //   
  398. Log->Len += ((ULONG) (Entry->text - (PCHAR) Entry )) + len;
  399. }
  401. //
  402. // Release the buffer pool
  403. //
  404. MUTEX_RELEASE( LogMutex );
  405. }
  406. VOID 
  407. RegmonHashCleanup(
  408.   VOID
  409.   )
  410. {
  411. PHASH_ENTRY             hashEntry, nextEntry;
  412. ULONG                   i;
  414. MUTEX_ACQUIRE( HashMutex );    
  416. //
  417. // First free the hash table entries
  418. //       
  419. for( i = 0; i < NUMHASH; i++ ) {
  421. hashEntry = HashTable[i];
  422. while( hashEntry ) {
  423. nextEntry = hashEntry->Next;
  424. ExFreePool( hashEntry->FullPathName );
  425. ExFreePool( hashEntry );
  426. hashEntry = nextEntry;
  427. }
  428. HashTable[i] = NULL;
  429. }
  430. MUTEX_RELEASE( HashMutex );
  431. }
  432. //----------------------------------------------------------------------
  433. // 
  434. // Minimum
  435. //
  436. // Returns min of two numbers
  437. //
  438. //----------------------------------------------------------------------
  439. ULONG
  440. Minimum( 
  441. ULONG Value1, 
  442. ULONG Value2
  443. )
  444. {       
  445. return Value1 < Value2 ? Value1 : Value2;
  446. }
  447. //////////////////////////////////////////////////////////////////////////
  448. //功能函数
  449. //----------------------------------------------------------------------
  450. //
  451. // ErrorString
  452. //
  453. // Returns the string form of an error code.
  454. //
  455. //----------------------------------------------------------------------
  456. PCHAR 
  457. ErrorString( 
  458. NTSTATUS retval 
  459. )
  460. { 
  461. //
  462. // Passed filter, so log it
  463. //
  464. switch( retval ) {
  465. case STATUS_BUFFER_TOO_SMALL:
  466. return "BUFTOOSMALL";
  467. case STATUS_SUCCESS:
  468. return "SUCCESS";
  469. case STATUS_KEY_DELETED:
  470. return "KEYDELETED";
  471. case STATUS_REGISTRY_IO_FAILED:
  472. return "IOFAILED";
  473. case STATUS_REGISTRY_CORRUPT:
  474. return "CORRUPT";
  475. case STATUS_NO_MEMORY:
  476. return "OUTOFMEM";
  477. case STATUS_ACCESS_DENIED:
  478. return "ACCDENIED";
  479. case STATUS_NO_MORE_ENTRIES:
  480. return "NOMORE";
  481. case STATUS_OBJECT_NAME_NOT_FOUND:
  482. return "NOTFOUND";
  483. case STATUS_BUFFER_OVERFLOW:
  484. return "BUFOVRFLOW";
  485. case STATUS_OBJECT_PATH_SYNTAX_BAD:
  486. return "SYNTAXERR";
  487. case STATUS_OBJECT_NAME_COLLISION:
  488. return "NAMECOLLISION";
  489. case STATUS_REPARSE:
  490. return "REPARSE";
  491. case STATUS_BAD_IMPERSONATION_LEVEL:
  492. return "BADIMPERSONATION";
  493. default:
  494. sprintf(errstring, "%x", retval );
  495. return errstring;
  496. }
  497. }
  498. //----------------------------------------------------------------------
  499. //
  500. // ConverToUpper
  501. //
  502. // Obvious.
  503. //
  504. //----------------------------------------------------------------------
  505. VOID 
  506. ConvertToUpper( 
  507.    PCHAR Dest, 
  508.    PCHAR Source, 
  509.    ULONG Len 
  510.    )
  511. {
  512. ULONG   i;
  514. for( i = 0; i < Len; i++ ) {
  516. if( Source[i] >= 'a' && Source[i] <= 'z' ) {
  518. Dest[i] = Source[i] - 'a' + 'A';
  520. } else {
  522. Dest[i] = Source[i];
  523. }
  524. if( Source[i] == 0 ) return;
  525. }
  526. }
  528. //----------------------------------------------------------------------
  529. //
  530. // GetPointer
  531. //
  532. // Translates a handle to an object pointer. In a build for .NET
  533. // server we simply return the passed object pointer so as to 
  534. // avoid having to modify the code further.
  535. //
  536. //----------------------------------------------------------------------
  537. POBJECT 
  538. GetPointer( 
  539.    HANDLE KeyOrHandle 
  540.    )
  541. {
  542. POBJECT         pKey = NULL;
  543. //POBJECT_HANDLE_INFORMATION info=0;
  545. //
  546. // Ignore null handles.
  547. //
  548. if( !KeyOrHandle ) return NULL;
  550. //
  551. // Get the pointer the handle refers to.
  552. //
  553. #ifdef WNET
  554. pKey = KeyOrHandle;
  555. #else
  556. //
  557. // Make sure that we're not going to access
  558. // the kernel handle table from a non-system process
  559. //
  560. if( (LONG)(ULONG_PTR) KeyOrHandle < 0 &&
  561. ExGetPreviousMode() != KernelMode ) {
  563. return NULL;
  564. }
  565. //  ObReferenceObjectByHandle( KeyOrHandle, KEY_READ, NULL, KernelMode, &pKey, NULL );
  566. //  if( !pKey ) return NULL;
  568.     if( !NT_SUCCESS( ObReferenceObjectByHandle( KeyOrHandle, 0, NULL, KernelMode, &pKey, NULL ))) {
  570.         //KdPrint(("Error %x getting key pointern"));
  571.         pKey = NULL;
  572.     } 
  573. #endif
  574. return pKey;
  575. }
  576. //----------------------------------------------------------------------
  577. //
  578. // ReleasePointer
  579. //
  580. // Dereferences the object.
  581. //
  582. //----------------------------------------------------------------------
  583. VOID 
  584. ReleasePointer( 
  585.    POBJECT object 
  586.    )
  587. {
  588. #ifndef WNET
  589. if( object ) ObDereferenceObject( object );
  590. #endif
  591. }
  592. //----------------------------------------------------------------------
  593. //
  594. // GetProcessNameOffset
  595. //
  596. // In an effort to remain version-independent, rather than using a
  597. // hard-coded into the KPEB (Kernel Process Environment Block), we
  598. // scan the KPEB looking for the name, which should match that
  599. // of the GUI process
  600. //
  601. //----------------------------------------------------------------------
  602. //这个函数不知道为什么，我在xp上没成功，但在2k上成功了
  603. ULONG 
  604. GetProcessNameOffset(
  605.  VOID
  606.  )
  607. {
  608. PEPROCESS       curproc;
  609. int             i;
  611. curproc = PsGetCurrentProcess();
  613. //
  614. // Scan for 12KB, hopping the KPEB never grows that big!
  615. //
  616. for( i = 0; i < 3*PAGE_SIZE; i++ ) {
  618. if( !strncmp( SYSNAME, (char *) curproc + i, strlen(SYSNAME) )) {
  620. return i;
  621. }
  622. }
  624. //
  625. // Name not found - oh, well
  626. //
  627. return 0;
  628. }
  630. //----------------------------------------------------------------------
  631. //
  632. // GetProcess
  633. //
  634. // Uses undocumented data structure offsets to obtain the name of the
  635. // currently executing process.
  636. // 获取当前进程的程序名和pid
  637. //----------------------------------------------------------------------
  638. char *
  639. GetProcess( 
  640.    char * Name 
  641.    )
  642. {
  643. PEPROCESS       curproc;
  644. char            *nameptr;
  645. ULONG           i;
  647. //
  648. // We only try and get the name if we located the name offset
  649. // 
  650. //ProcessNameOffset=0x1fc; //2k
  651. if( ProcessNameOffset ) {
  653. //
  654. // Get a pointer to the current process block
  655. //
  656. curproc = PsGetCurrentProcess();
  658. //
  659. // Dig into it to extract the name. Make sure to leave enough room
  660. // in the buffer for the appended process ID.
  661. //
  662. nameptr   = (char *) curproc + ProcessNameOffset;
  663. strncpy( Name, nameptr, NT_PROCNAMELEN-1 );
  664. Name[NT_PROCNAMELEN-1] = 0; 
  665. sprintf( Name + strlen(Name), ":%d", (ULONG) PsGetCurrentProcessId()); 
  667. } else {
  669. strcpy( Name, "???");
  670. }
  671. return Name;
  672. }
  673. //----------------------------------------------------------------------
  674. //
  675. // GetProcess
  676. //
  677. // Uses undocumented data structure offsets to obtain the name of the
  678. // currently executing process.
  679. // 获取当前进程的程序名
  680. //----------------------------------------------------------------------
  681. char *
  682. GetProcess_noid( 
  683. char * Name 
  684. )
  685. {
  686. PEPROCESS       curproc;
  687. char            *nameptr;
  688. ULONG           i;
  690. //
  691. // We only try and get the name if we located the name offset
  692. // 
  693. //ProcessNameOffset=0x1fc; //2k
  694. if( ProcessNameOffset ) {
  696. //
  697. // Get a pointer to the current process block
  698. //
  699. curproc = PsGetCurrentProcess();
  701. //
  702. // Dig into it to extract the name. Make sure to leave enough room
  703. // in the buffer for the appended process ID.
  704. //
  705. nameptr   = (char *) curproc + ProcessNameOffset;
  706. strncpy( Name, nameptr, NT_PROCNAMELEN-1 );
  707. Name[NT_PROCNAMELEN-1] = 0; 
  708. //sprintf( Name + strlen(Name), ":%d", (ULONG) PsGetCurrentProcessId()); 
  710. } else {
  712. strcpy( Name, "???");
  713. }
  714. return Name;
  715. }
  716. //----------------------------------------------------------------------
  717. //
  718. // GetCurrentProcessFileName
  719. //
  720. // 获得当前进程对应PE文件的完整路径 
  721. // 返回PCWSTR类型
  722. //----------------------------------------------------------------------
  723. PCWSTR GetCurrentProcessFileName()
  724. {
  725. DWORD dwAddress = (DWORD)PsGetCurrentProcess();
  726. DWORD dwAddress1 ;
  728. if(KeGetCurrentIrql() != PASSIVE_LEVEL)
  729. return NULL;
  731. if(dwAddress == 0 || dwAddress == 0xFFFFFFFF)
  732. return NULL;
  733. dwAddress += 0x1B0;
  734. if((dwAddress = *(DWORD*)dwAddress) == 0) return 0;
  735. dwAddress += 0x10;
  736. if((dwAddress = *(DWORD*)dwAddress) == 0) return 0;
  737. dwAddress1=dwAddress;//20000
  738. dwAddress += 0x3C;
  739. if((dwAddress = *(DWORD*)dwAddress) == 0) return 0;
  740. if(dwAddress<dwAddress1)
  741. dwAddress=dwAddress+dwAddress1;
  742. //KdPrint(("Current Process Full Path Name: %wsn",  (PCWSTR)dwAddress)); 
  743. return (PCWSTR)dwAddress;
  744. }  
  745. //----------------------------------------------------------------------
  746. //
  747. // GetCurrentProcessFileName
  748. //
  749. // 获得当前进程的PE文件的全名
  750. // 返回到processfullname_c中
  751. //----------------------------------------------------------------------
  752. void GetCurrentProcessFileFullName(char * processfullname_c)
  753. {
  754. PCWSTR processfullname_pcwstr;
  755. PUNICODE_STRING processfullname_u;
  756. ANSI_STRING processfullname_a;
  758. processfullname_pcwstr=GetCurrentProcessFileName();
  759. if(processfullname_pcwstr)
  760. {
  761. processfullname_u = ExAllocatePool( PagedPool, MAXPATHLEN*sizeof(WCHAR)+2*sizeof(ULONG));
  762. if( !processfullname_u ) { 
  763. //
  764. // Out of memory
  765. //  
  766. return;
  767. } 
  768. processfullname_u->MaximumLength = MAXPATHLEN*sizeof(WCHAR);
  770. RtlInitUnicodeString(processfullname_u,processfullname_pcwstr);
  772. processfullname_a.Length=0;
  774. if(processfullname_u->Length!=0)
  775. RtlUnicodeStringToAnsiString(&processfullname_a,processfullname_u,1);
  777. if(processfullname_a.Length!=0)
  778. {
  779. strncpy(processfullname_c,processfullname_a.Buffer,processfullname_a.Length);
  780. processfullname_c[processfullname_a.Length]='';
  781. }
  782. ExFreePool( processfullname_u );
  783. if(&processfullname_a)
  784. RtlFreeAnsiString(&processfullname_a); 
  785. }
  786. }
  787. //----------------------------------------------------------------------
  788. //
  789. // GetKeyFullName
  790. //
  791. // Returns the full pathname of a key, if we can obtain one, else
  792. // returns a handle.
  793. //
  794. //----------------------------------------------------------------------
  795. VOID 
  796. GetKeyFullName( 
  797.    HANDLE hKey, 
  798.    PUNICODE_STRING lpszSubKeyVal, 
  799.    PCHAR fullname //输出的fullname
  800.    )
  801. {
  802. PHASH_ENTRY             hashEntry;
  803. POBJECT                 pKey = NULL;
  804. CHAR                    tmpkey[16];
  805. ANSI_STRING             keyname;
  806. PCHAR                   tmpname;
  807. PCHAR                   cmpname;
  808. PCHAR                   nameptr;
  809. PUNICODE_STRING         fullUniName;
  810. ULONG                   actualLen;
  811. int                     i;
  812. POBJECT_NAME_INFORMATION      keyNameInformation=0;
  814. //
  815. // If the fullname buffer is NULL, bail now
  816. //
  817. if( !fullname ) return;
  819. //
  820. // Allocate a temporary buffer
  821. //
  822. cmpname = ExAllocatePool( PagedPool, MAXROOTLEN );
  823. tmpname = ExAllocateFromPagedLookasideList( &FullPathLookaside );
  824. if( !tmpname || !cmpname ) {
  826. //
  827. // Not enough memory for a buffer
  828. //
  829. if( cmpname ) ExFreePool( cmpname );
  830. if( tmpname ) ExFreeToPagedLookasideList( &FullPathLookaside, tmpname );
  831. strcpy( fullname, "<INSUFFICIENT MEMORY>");
  832. return;
  833. }
  835. //
  836. // Translate the hkey into a pointer
  837. //
  838. fullname[0] = 0;
  839. tmpname[0] = 0;
  841. //
  842. // Is it a valid handle?
  843. //
  844. if( pKey = GetPointer( hKey )) {
  846. //
  847. // See if we find the key in the hash table
  848. //
  849. ReleasePointer( pKey );
  850. MUTEX_ACQUIRE( HashMutex );
  851. hashEntry = HashTable[ HASHOBJECT( pKey ) ];
  852. while( hashEntry && hashEntry->Object != pKey ) {
  854. hashEntry = hashEntry->Next;
  855. }
  856. if( hashEntry ) {
  858. strcpy( tmpname, hashEntry->FullPathName );
  859. MUTEX_RELEASE( HashMutex );
  861. } else {
  863. //
  864. // We will only get here if key was created before we loaded - ask the Configuration
  865. // Manager what the name of the key is.
  866. //
  867. MUTEX_RELEASE( HashMutex );
  868. if( pKey ) {
  870. fullUniName = ExAllocatePool( PagedPool, MAXPATHLEN*sizeof(WCHAR)+2*sizeof(ULONG));
  871. if( !fullUniName ) {
  873. //
  874. // Out of memory
  875. //
  876. strcpy( fullname, "<INSUFFICIENT MEMORY>" );
  877. ExFreePool( cmpname );
  878. ExFreeToPagedLookasideList( &FullPathLookaside, tmpname );
  879. return;
  880. }
  881. // NTKERNELAPI
  882. // NTSTATUS
  883. // ObQueryNameString (
  884. //     IN PVOID                        Object,
  885. //     OUT POBJECT_NAME_INFORMATION    ObjectNameInfo,
  886. //     IN ULONG                        Length,
  887. //     OUT PULONG                      ReturnLength
  888. // );
  889. fullUniName->MaximumLength = MAXPATHLEN*sizeof(WCHAR);
  890. //&keyNameInformation->Name=fullUniName;
  892. if( NT_SUCCESS(ObQueryNameString( pKey, fullUniName, MAXPATHLEN, &actualLen ) )) {
  894. //fullUniName=&keyNameInformation->Name;
  896. if( NT_SUCCESS( RtlUnicodeStringToAnsiString( &keyname, fullUniName, TRUE ))) { 
  898. if( keyname.Buffer[0] ) {
  900. strcpy( tmpname, "\" );
  901. strncat( tmpname, keyname.Buffer, Minimum( keyname.Length, MAXPATHLEN -2 ));
  902. }
  903. RtlFreeAnsiString( &keyname );
  904. }
  905. }
  906. ExFreePool( fullUniName );
  907. }
  908. }
  909. }
  911. //
  912. // Append subkey and value, if they are there
  913. //
  914. try {
  916. if( lpszSubKeyVal ) {
  917. keyname.Buffer = NULL;
  918. if( NT_SUCCESS( RtlUnicodeStringToAnsiString( &keyname, lpszSubKeyVal, TRUE ))) {
  920. if( keyname.Buffer[0] ) {
  922. //
  923. // See if this is an absolute rather than relative path, which 
  924. // can be the case on Open/Create when the Registry callback API
  925. // is used (.NET Server and higher)
  926. //
  927. ConvertToUpper( cmpname, keyname.Buffer, strlen("\REGISTRY")+1);
  928. if( !strncmp( cmpname, "\REGISTRY", strlen("\REGISTRY"))) {
  930. strcpy( tmpname, "\" );
  932. } else {
  934. strcat( tmpname, "\" );
  935. }
  936. strncat( tmpname, keyname.Buffer, Minimum( keyname.Length, MAXPATHLEN - 1 - strlen(tmpname) ));
  937. }
  938. RtlFreeAnsiString( &keyname );
  939. }
  940. }
  941. } except( EXCEPTION_EXECUTE_HANDLER ) {
  943. if( keyname.Buffer ) RtlFreeAnsiString( &keyname );
  944. strcat( tmpname, "*** Invalid Name ****" );
  945. }
  947. //
  948. // See if it matches current user
  949. //
  950. for( i = 0; i < 2; i++ ) {
  952. ConvertToUpper( cmpname, tmpname, CurrentUser[i].RootNameLen );
  953. if( !strncmp( cmpname, CurrentUser[i].RootName,
  954. CurrentUser[i].RootNameLen )) {
  956. //  KdPrint(( " CurrentUser(%d) %s ==> %sn", i, 
  957. //  tmpname, CurrentUser[i].RootName ));
  959. //
  960. // Its current user. Process to next slash
  961. //
  962. nameptr = tmpname + CurrentUser[i].RootNameLen;
  963. while( *nameptr && *nameptr != '\' ) nameptr++;
  964. strcpy( fullname, CurrentUser[i].RootShort );
  965. #if 0
  966. cmpname = nameptr - sizeof(USER_CLASSES);
  967. ConvertToUpper (cmpname, cmpname, sizeof(USER_CLASSES));
  968. if (!strncmp( cmpname, USER_CLASSES, sizeof(USER_CLASSES))) {
  970. strcat (fullname, "\Software\Classes");
  971. }
  972. #endif
  973. strcat( fullname, nameptr );
  974. ExFreePool( cmpname );
  975. ExFreeToPagedLookasideList( &FullPathLookaside, tmpname );
  976. return;
  977. }
  978. }     
  980. //
  981. // Now, see if we can translate a root key name
  982. //
  983. for( i = 0; i < NUMROOTKEYS; i++ ) {
  984. ConvertToUpper( cmpname, tmpname, RootKey[i].RootNameLen );
  985. if( !strncmp( cmpname, RootKey[i].RootName, 
  986. RootKey[i].RootNameLen )) {
  987. nameptr = tmpname + RootKey[i].RootNameLen;
  988. strcpy( fullname, RootKey[i].RootShort );
  989. strcat( fullname, nameptr );
  990. ExFreePool( cmpname );
  991. ExFreeToPagedLookasideList( &FullPathLookaside, tmpname );
  992. return;
  993. }
  994. }
  996. //
  997. // No translation
  998. //
  999. strcpy( fullname, tmpname );
  1000. ExFreeToPagedLookasideList( &FullPathLookaside, tmpname );
  1001. ExFreePool( cmpname );
  1002. }
  1003. //----------------------------------------------------------------------
  1004. //
  1005. // GetFileFullName
  1006. //
  1007. // Returns the full pathname of a file, if we can obtain one, else
  1008. // returns a handle.
  1009. // 获取一个注册项的全名
  1010. //----------------------------------------------------------------------
  1011. VOID 
  1012. GetFileFullName( 
  1013. POBJECT_ATTRIBUTES ObjectAttributes,
  1014. PCHAR fullname //输出的fullname
  1015. )
  1016. {
  1017. ANSI_STRING             filefullname_a;
  1019. filefullname_a.Length=0;
  1020. RtlUnicodeStringToAnsiString(&filefullname_a,ObjectAttributes->ObjectName,1);
  1021. if(filefullname_a.Length==0)
  1022. {
  1023. return;
  1024. }
  1025. strncpy(fullname,filefullname_a.Buffer,Minimum(filefullname_a.Length,1023)); 
  1026. fullname[Minimum(filefullname_a.Length,1023)]=''; 
  1028. if(&filefullname_a)
  1029. RtlFreeAnsiString(&filefullname_a); 
  1030. }
  1031. //----------------------------------------------------------------------
  1032. //
  1033. // GetFileFullName
  1034. //
  1035. // Returns the full pathname of a file, if we can obtain one, else
  1036. // returns a handle.
  1037. // 获取一个注册项的全名
  1038. //----------------------------------------------------------------------
  1039. VOID 
  1040. GetFileFullNamebyFileHandle_forSection( 
  1041. HANDLE FileHandle,
  1042. char   *filefullname_c
  1043. )
  1044. {
  1045. //文件相关的变量 
  1046. PFILE_OBJECT file=0; 
  1047. ANSI_STRING filefullname_a; 
  1048. POBJECT_NAME_INFORMATION      fileNameInformation; 
  1049. POBJECT_HANDLE_INFORMATION info=0;
  1050. ULONG retSize;  
  1052. ObReferenceObjectByHandle(FileHandle,0,0,KernelMode,&file,info);
  1053. if(!file)return;
  1055. filefullname_a.Length=0;
  1056. RtlUnicodeStringToAnsiString(&filefullname_a,&file->FileName,1);
  1057. if(filefullname_a.Length==0)
  1058. {
  1059. return;
  1060. }
  1061. strncpy(filefullname_c,filefullname_a.Buffer,Minimum(filefullname_a.Length,1023)); 
  1062. filefullname_c[Minimum(filefullname_a.Length,1023)]=''; 
  1064. if(&filefullname_a)
  1065. RtlFreeAnsiString(&filefullname_a); 
  1066. }
  1067. //----------------------------------------------------------------------
  1068. //
  1069. // GetFileFullNamebyFileHandle
  1070. //
  1071. // Returns the full pathname of a file, if we can obtain one, else
  1072. // returns a handle.
  1073. // 获取一个注册项的全名
  1074. //----------------------------------------------------------------------
  1075. VOID 
  1076. GetFileFullNamebyFileHandle_QueryNameString( 
  1077. HANDLE filehandle,
  1078. char   *filefullname_c
  1079. )
  1080. {
  1081. //文件相关的变量 
  1082. PFILE_OBJECT file=0; 
  1083. ANSI_STRING filefullname_a; 
  1084. POBJECT_NAME_INFORMATION      fileNameInformation; 
  1085. POBJECT_HANDLE_INFORMATION info=0;
  1086. ULONG retSize;
  1087. PUNICODE_STRING filefullname_u;
  1089. //经由文件句柄得到文件名 
  1090. ObReferenceObjectByHandle(filehandle,0,0,KernelMode,&file,info);
  1091. if(!file)return; 
  1093. // 得到的文件路径是 DeviceHarddiskVolum1.... 
  1094. filefullname_u = ExAllocatePool( PagedPool, MAXPATHLEN*sizeof(WCHAR)+2*sizeof(ULONG));
  1095. if( !filefullname_u ) {
  1097. //
  1098. // Out of memory
  1099. // 
  1100. return;
  1101. } 
  1102. filefullname_u->MaximumLength = MAXPATHLEN*sizeof(WCHAR);
  1104. ObQueryNameString(file, filefullname_u, 1024, &retSize); 
  1106. filefullname_a.Length=0;
  1107. RtlUnicodeStringToAnsiString(&filefullname_a,filefullname_u,1);
  1108. if(filefullname_a.Length==0)
  1109. {
  1110. return;
  1111. }
  1112. strncpy(filefullname_c,filefullname_a.Buffer,Minimum(filefullname_a.Length,1023)); 
  1113. filefullname_c[Minimum(filefullname_a.Length,1023)]=''; 
  1115. if(&filefullname_a)
  1116. RtlFreeAnsiString(&filefullname_a); 
  1118. ExFreePool( filefullname_u );
  1119. }
  1120. //----------------------------------------------------------------------
  1121. //
  1122. // GetFileFullNamebyFileHandle
  1123. //
  1124. // Returns the full pathname of a file, if we can obtain one, else
  1125. // returns a handle.
  1126. // 获取一个注册项的全名
  1127. //----------------------------------------------------------------------
  1128. VOID 
  1129. GetFileFullNamebyFileHandle( 
  1130. HANDLE filehandle,
  1131. char   *filefullname_c
  1132. )
  1133. {
  1134. //文件相关的变量 
  1135. PFILE_OBJECT file=0;
  1136. PFILE_OBJECT relatedfile=0; ANSI_STRING filefullname_a; 
  1137. PUNICODE_STRING filefullname_u;
  1138. int relatedfilelength;
  1139. POBJECT_NAME_INFORMATION      fileNameInformation;
  1140. POBJECT_HANDLE_INFORMATION info=0;
  1141. ULONG retSize;
  1143. //经由文件句柄得到文件名 
  1144. ObReferenceObjectByHandle(filehandle,0,0,KernelMode,&file,info);
  1145. if(!file)return; 
  1147. filefullname_u = ExAllocatePool( PagedPool, MAXPATHLEN*sizeof(WCHAR)+2*sizeof(ULONG));
  1148. if( !filefullname_u ) { 
  1149. //
  1150. // Out of memory
  1151. //  
  1152. return;
  1153. } 
  1154. filefullname_u->MaximumLength = MAXPATHLEN*sizeof(WCHAR);
  1156. //先得到盘符
  1157. RtlVolumeDeviceToDosName(file->DeviceObject,filefullname_u);
  1158. RtlUnicodeStringToAnsiString(&filefullname_a,filefullname_u,1);
  1159. strncpy(filefullname_c,filefullname_a.Buffer,filefullname_a.Length); 
  1160. filefullname_c[filefullname_a.Length]='';
  1161. relatedfilelength=filefullname_a.Length;
  1162. //相对路径
  1163. relatedfile=file->RelatedFileObject;
  1164. RtlUnicodeStringToAnsiString(&filefullname_a,&relatedfile->FileName,1);
  1165. strncat(filefullname_c,filefullname_a.Buffer,filefullname_a.Length); 
  1166. filefullname_c[relatedfilelength+filefullname_a.Length]='';
  1167. relatedfilelength+=filefullname_a.Length;
  1168. //文件名
  1169. RtlUnicodeStringToAnsiString(&filefullname_a,&file->FileName,1);
  1170. strcat(filefullname_c,"\");
  1171. strncat(filefullname_c,filefullname_a.Buffer,filefullname_a.Length);
  1172. filefullname_c[relatedfilelength+filefullname_a.Length+1]='';
  1174. ExFreePool( filefullname_u );
  1175. if(&filefullname_a)
  1176. RtlFreeAnsiString(&filefullname_a);
  1178. }
  1179. //----------------------------------------------------------------------
  1180. //
  1181. // GetFullName
  1182. //
  1183. // Returns the full pathname of a file, if we can obtain one, else
  1184. // returns a handle.
  1185. // 获取一个注册项的全名
  1186. //----------------------------------------------------------------------
  1187. NTSTATUS   GetFullName(HANDLE     KeyHandle,char   *fullname)   
  1188. {   
  1189. NTSTATUS   ns;   
  1190. PVOID   pKey=NULL,pFile=NULL;   
  1191. UNICODE_STRING                   fullUniName;   
  1192. ANSI_STRING                           akeyname;   
  1193. ULONG   actualLen;   
  1194. UNICODE_STRING   dosName;   
  1196. fullUniName.Buffer=NULL;   
  1197. fullUniName.Length=0;   
  1198. fullname[0]=0x00;   
  1199. ns=   ObReferenceObjectByHandle(   KeyHandle,   0,   NULL,   KernelMode,   &pKey,   NULL   )   ;   
  1200. if(   !NT_SUCCESS(ns))   return   ns;   
  1202. fullUniName.Buffer   =   ExAllocatePool(   PagedPool,   MAXPATHLEN*2);//1024*2   
  1203. fullUniName.MaximumLength   =   MAXPATHLEN*2;   
  1205. __try   
  1206. {   
  1208. pFile=(PVOID)*(ULONG   *)((char   *)pKey+20);   
  1209. pFile=(PVOID)*(ULONG   *)((char   *)pFile);   
  1210. pFile=(PVOID)*(ULONG   *)((char   *)pFile+36);   
  1213. ObReferenceObjectByPointer(pFile,   0,   NULL,   KernelMode);   
  1214. RtlVolumeDeviceToDosName(((PFILE_OBJECT)pFile)->DeviceObject,&dosName);     
  1215. RtlCopyUnicodeString(&fullUniName,   &dosName);   
  1216. RtlAppendUnicodeStringToString(&fullUniName,&((PFILE_OBJECT)pFile)->FileName);   
  1218. ObDereferenceObject(pFile);   
  1219. ObDereferenceObject(pKey   );   
  1221. RtlUnicodeStringToAnsiString(   &akeyname,   &fullUniName,   TRUE   );   
  1222. if(akeyname.Length<MAXPATHLEN)     
  1223. {   
  1224. memcpy(fullname,akeyname.Buffer,akeyname.Length);   
  1225. fullname[akeyname.Length]=0x00;   
  1226. }   
  1227. else   
  1228. {   
  1229. memcpy(fullname,akeyname.Buffer,MAXPATHLEN);   
  1230. fullname[MAXPATHLEN-1]=0x00;   
  1231. }   
  1233. RtlFreeAnsiString(   &akeyname   );   
  1234. ExFreePool(dosName.Buffer);   
  1235. ExFreePool(   fullUniName.Buffer   );   
  1237. return   STATUS_SUCCESS;   
  1239. }   
  1241. __except(1)   
  1242. {   
  1243. if(fullUniName.Buffer)   ExFreePool(   fullUniName.Buffer     );   
  1244. if(pKey)   ObDereferenceObject(pKey   );   
  1245. return   STATUS_SUCCESS;   
  1247. }   
  1249. } 
  1250. void GetRealCallee(char * hookedfunname)
  1251. {
  1252. int i;
  1253. for(i=0;i<hook_num;i++)
  1254. {
  1255. if(strcmp(hook_API_info[i].nativeAPIname,hookedfunname)==0)
  1256. {
  1257. RealCallee=hook_API_info[i].RealCallee;
  1258. break;
  1259. }
  1260. }
  1261. }
  1262. NTSTATUS 
  1263. NTAPI
  1264. HookNtRestoreKey( 
  1265.  IN HANDLE               KeyHandle,
  1266.  IN HANDLE               FileHandle,
  1267.  IN ULONG                RestoreOption )
  1268. {
  1269. //函数名称
  1270. char hookedfunname[32]="NtRestoreKey";
  1271. NTSTATUS  ntstatus;
  1273. //key相关的变量
  1274. char keyfullname_c[1024]="???";
  1276. //行为Behavior相关变量
  1277. CHAR behavior[1024]="???";
  1279. //进程相关的变量
  1280. CHAR processname[32]="???";//进程名称
  1281. CHAR processfullname_c[512]="???";//进程全名
  1284. //-------------------------------------------------------------------
  1285. //输出函数地址
  1286. GetRealCallee(hookedfunname);
  1288. //获得函数返回结果
  1289. _asm{
  1290. push RestoreOption
  1291. push FileHandle
  1292. push KeyHandle
  1293. call RealCallee
  1294. mov ntstatus,eax
  1295. } 
  1296. //获取进程的全名
  1297. GetCurrentProcessFileFullName(processfullname_c);
  1298. //监控要监控的程序 
  1299. if(strcmp(processfullname_c,processname_G)!=0)
  1300. {
  1301. return ntstatus;
  1302. } 
  1304. //  //经由文件句柄得到文件名
  1305. //  GetFileFullNamebyFileHandle(FileHandle,filefullname_c);
  1307. //经由key句柄获得key全名
  1308. GetKeyFullName(KeyHandle,NULL,keyfullname_c);
  1310. //--------------------------------------------------------------------------
  1311. strcpy(behavior,"导入键"");
  1312. strcat(behavior,keyfullname_c);
  1313. strcat(behavior,""");
  1316. //这里要进行操作系统判断，不同的操作系统这个地址不同
  1317. //ProcessNameOffset=0x1FC; //2k
  1318. ProcessNameOffset=0x174;  //xp 
  1319. //------------------------------------------------------------------
  1320. LogRecord( "%st%st%st%st%s", GetProcess(processname),hookedfunname,
  1321. processfullname_c, ErrorString( ntstatus ), behavior );
  1322. //------------------------------------------------------------------
  1324. return ntstatus;
  1325. }
  1326. NTSTATUS 
  1327. NTAPI
  1328. HookNtOpenKey( 
  1329.   OUT PHANDLE             pKeyHandle,
  1330.   IN ACCESS_MASK          DesiredAccess,
  1331.   IN POBJECT_ATTRIBUTES   ObjectAttributes )
  1332. {
  1333. //函数名称
  1334. char hookedfunname[32]="NtOpenKey";
  1335. NTSTATUS ntstatus;
  1337. //key相关的变量 
  1338. char keyfullname_c[1024]="???";
  1340. //行为Behavior相关变量
  1341. CHAR behavior[1024]="???";
  1343. //进程相关的变量
  1344. CHAR processname[32]="???";//进程名称
  1345. CHAR processfullname_c[512]="???";//进程全名
  1348. //-------------------------------------------------------------------
  1349. //必须放考前一点，否则不能及时得到RealCallee
  1350. //输出函数地址
  1351. GetRealCallee(hookedfunname);
  1353. //获得函数返回结果
  1354. _asm{
  1355. push ObjectAttributes
  1356. push DesiredAccess
  1357. push pKeyHandle
  1358. call RealCallee
  1359. mov ntstatus,eax
  1360. } 
  1362. //获取进程的全名
  1363. GetCurrentProcessFileFullName(processfullname_c);
  1366. //监控要监控的程序 
  1367. if(strcmp(processfullname_c,processname_G)!=0)
  1368. {
  1369. return ntstatus;
  1370. } 
  1372. GetKeyFullName( ObjectAttributes->RootDirectory, ObjectAttributes->ObjectName, keyfullname_c );
  1374. strcpy(behavior,"打开键"");  
  1375. strcat(behavior,keyfullname_c);
  1376. strcat(behavior,"""); 
  1378.  
  1380. //这里要进行操作系统判断，不同的操作系统这个地址不同
  1381. //ProcessNameOffset=0x1FC; //2k
  1382. ProcessNameOffset=0x174;  //xp
  1383. //------------------------------------------------------------------
  1384. LogRecord( "%st%st%st%st%s", GetProcess(processname),hookedfunname,
  1385. processfullname_c, ErrorString( ntstatus ), behavior );
  1386. //------------------------------------------------------------------
  1387.  
  1389. return ntstatus;
  1390. }
  1392. NTSTATUS 
  1393. NTAPI
  1394. HookNtCreateKey( 
  1395. OUT PHANDLE             pKeyHandle,
  1396. IN ACCESS_MASK          DesiredAccess,
  1397. IN POBJECT_ATTRIBUTES   ObjectAttributes,
  1398. IN ULONG                TitleIndex,
  1399. IN PUNICODE_STRING      Class OPTIONAL,
  1400. IN ULONG                CreateOptions,
  1401. OUT PULONG              Disposition OPTIONAL )
  1402. {
  1403. //函数名称
  1404. char hookedfunname[32]="NtCreateKey";
  1405. NTSTATUS ntstatus;
  1407. //key相关的变量
  1408. char keyfullname_c[1024]="???";
  1410. //行为Behavior相关变量
  1411. CHAR behavior[1024]="???";
  1413. //进程相关的变量
  1414. CHAR processname[32];//进程名称
  1415. CHAR processfullname_c[512]="???";//进程全名
  1418. //-------------------------------------------------------------------
  1419. //输出函数地址
  1420. GetRealCallee(hookedfunname);
  1422. //获得函数返回结果
  1423. _asm{
  1424. push Disposition
  1425. push CreateOptions
  1426. push Class
  1427. push TitleIndex 
  1428. push ObjectAttributes
  1429. push DesiredAccess
  1430. push pKeyHandle
  1431. call RealCallee
  1432. mov ntstatus,eax
  1433. } 
  1435. //获取进程的全名
  1436. GetCurrentProcessFileFullName(processfullname_c);
  1437. //监控要监控的程序 
  1438. if(strcmp(processfullname_c,processname_G)!=0)
  1439. {
  1440. return ntstatus;
  1441. } 
  1443. GetKeyFullName( ObjectAttributes->RootDirectory, ObjectAttributes->ObjectName, keyfullname_c );
  1445. strcpy(behavior,"创建键"");  
  1446. strcat(behavior,keyfullname_c);
  1447. strcat(behavior,"""); 
  1449.  
  1451. //这里要进行操作系统判断，不同的操作系统这个地址不同
  1452. //ProcessNameOffset=0x1FC; //2k
  1453. ProcessNameOffset=0x174;  //xp
  1454. //------------------------------------------------------------------
  1455. LogRecord( "%st%st%st%st%s", GetProcess(processname),hookedfunname,
  1456. processfullname_c, ErrorString( ntstatus ), behavior );
  1457. //------------------------------------------------------------------
  1458.  
  1459.    
  1462. return ntstatus;
  1463. }
  1464. NTSTATUS 
  1465. NTAPI
  1466. HookNtQueryValueKey( 
  1467. IN HANDLE               KeyHandle,
  1468. IN PUNICODE_STRING      ValueName,
  1469. IN KEY_VALUE_INFORMATION_CLASS  KeyValueInformationClass,
  1470. OUT PVOID               KeyValueInformation,
  1471. IN ULONG                KeyValueInformationLength,
  1472. OUT PULONG              ResultLength )
  1473. {
  1474. //函数名称
  1475. char hookedfunname[32]="NtQueryValueKey";
  1476. NTSTATUS ntstatus;
  1478. //key相关的变量
  1479. char keyfullname_c[1024]="???";
  1480. PUNICODE_STRING         valueName;
  1482. //行为Behavior相关变量
  1483. CHAR behavior[1024]="???";
  1485. //进程相关的变量
  1486. CHAR processname[32];//进程名称
  1487. CHAR processfullname_c[512]="???";//进程全名
  1489. if( !ValueName || !ValueName->Length ) valueName = &DefaultValue;
  1490.     else                                   valueName = ValueName;
  1491. GetKeyFullName(KeyHandle,valueName,keyfullname_c);
  1493. //-------------------------------------------------------------------
  1494. //输出函数地址
  1495. GetRealCallee(hookedfunname);
  1497. //获得函数返回结果
  1498. _asm{
  1499. push ResultLength
  1500. push KeyValueInformationLength
  1501. push KeyValueInformation 
  1502. push KeyValueInformationClass 
  1503. push ValueName
  1504. push KeyHandle 
  1505. call RealCallee
  1506. mov ntstatus,eax
  1507. } 
  1509. //获取进程的全名
  1510. GetCurrentProcessFileFullName(processfullname_c);
  1511. //监控要监控的程序 
  1512. if(strcmp(processfullname_c,processname_G)!=0)
  1513. {
  1514. return ntstatus;
  1515. } 
  1517. //这里分析具体的行为---------------------------------------------------
  1518. //经由key句柄获得key全名
  1521. strcpy(behavior,"查询键值"");
  1522. strcat(behavior,keyfullname_c); 
  1523. strcat(behavior,""");
  1525.  
  1527. //这里要进行操作系统判断，不同的操作系统这个地址不同
  1528. //ProcessNameOffset=0x1FC; //2k
  1529. ProcessNameOffset=0x174;  //xp 
  1530. //------------------------------------------------------------------
  1531. LogRecord( "%st%st%st%st%s", GetProcess(processname),hookedfunname,
  1532. processfullname_c, ErrorString( ntstatus ), behavior );
  1533. //------------------------------------------------------------------
  1534.  
  1535.    
  1538. return ntstatus;
  1539. }
  1540. NTSTATUS 
  1541. NTAPI
  1542. HookNtQueryKey( 
  1543.    IN HANDLE               KeyHandle,
  1544.    IN KEY_INFORMATION_CLASS KeyInformationClass,
  1545.    OUT PVOID               KeyInformation,
  1546.    IN ULONG                KeyInformationLength,
  1547.    OUT PULONG              ResultLength )
  1548. {
  1549. //函数名称
  1550. char hookedfunname[32]="NtQueryKey";
  1551. NTSTATUS ntstatus;
  1552. //key相关的变量
  1553. char keyfullname_c[1024]="???";
  1555. //行为Behavior相关变量
  1556. CHAR behavior[1024]="???";
  1557. //进程相关的变量
  1558. CHAR processname[32];//进程名称
  1559. CHAR processfullname_c[512]="???";//进程全名
  1562. //-------------------------------------------------------------------
  1563. //输出函数地址
  1564. GetRealCallee(hookedfunname);
  1566. //获得函数返回结果
  1567. _asm{
  1568. push ResultLength
  1569. push KeyInformationLength
  1570. push KeyInformation 
  1571. push KeyInformationClass 
  1572. push KeyHandle 
  1573. call RealCallee
  1574. mov ntstatus,eax
  1575. } 
  1577. //获取进程的全名
  1578. GetCurrentProcessFileFullName(processfullname_c);
  1581. //监控要监控的程序 
  1582. if(strcmp(processfullname_c,processname_G)!=0)
  1583. {
  1584. return ntstatus;
  1585. } 
  1587. //这里分析具体的行为-----------------------------------------------
  1588. //经由key句柄获得key全名
  1589. GetKeyFullName(KeyHandle,NULL,keyfullname_c);
  1591. strcpy(behavior,"查询键"");
  1592. strcat(behavior,keyfullname_c); 
  1593. strcat(behavior,""");
  1595.  
  1597. //这里要进行操作系统判断，不同的操作系统这个地址不同
  1598. //ProcessNameOffset=0x1FC; //2k
  1599. ProcessNameOffset=0x174;  //xp
  1600. //------------------------------------------------------------------
  1601. LogRecord( "%st%st%st%st%s", GetProcess(processname),hookedfunname,
  1602. processfullname_c, ErrorString( ntstatus ), behavior );
  1603. //------------------------------------------------------------------
  1604.  
  1605.    
  1608. return ntstatus;
  1609. }
  1610. NTSTATUS 
  1611. NTAPI
  1612. HookNtDeleteKey( 
  1613. IN HANDLE               KeyHandle )
  1614. {
  1615. //函数名称
  1616. char hookedfunname[32]="NtDeleteKey";
  1617. NTSTATUS ntstatus;
  1618. //key相关的变量
  1619. char keyfullname_c[1024]="???";
  1621. //行为Behavior相关变量
  1622. CHAR behavior[1024]="???";
  1623. //进程相关的变量
  1624. CHAR processname[32];//进程名称
  1625. CHAR processfullname_c[512]="???";//进程全名
  1628. //-------------------------------------------------------------------
  1629. //输出函数地址
  1630. GetRealCallee(hookedfunname);
  1632. //获得函数返回结果
  1633. _asm{
  1634. push KeyHandle 
  1635. call RealCallee
  1636. mov ntstatus,eax
  1637. } 
  1639. //获取进程的全名
  1640. GetCurrentProcessFileFullName(processfullname_c);
  1643. //监控要监控的程序 
  1644. if(strcmp(processfullname_c,processname_G)!=0)
  1645. {
  1646. return ntstatus;
  1647. } 
  1649. //这里分析具体的行为-----------------------------------------------
  1650. //经由key句柄获得key全名
  1651. GetKeyFullName(KeyHandle,NULL,keyfullname_c);
  1653. strcpy(behavior,"删除键"");
  1654. strcat(behavior,keyfullname_c); 
  1655. strcat(behavior,""");
  1657.  
  1659. //这里要进行操作系统判断，不同的操作系统这个地址不同
  1660. //ProcessNameOffset=0x1FC; //2k
  1661. ProcessNameOffset=0x174;  //xp
  1662. //------------------------------------------------------------------
  1663. LogRecord( "%st%st%st%st%s", GetProcess(processname),hookedfunname,
  1664. processfullname_c, ErrorString( ntstatus ), behavior );
  1665. //------------------------------------------------------------------
  1666.  
  1667.    
  1670. return ntstatus;
  1671. }
  1672. NTSTATUS 
  1673. NTAPI
  1674. HookNtDeleteValueKey( 
  1675.  IN HANDLE               KeyHandle,
  1676.  IN PUNICODE_STRING      ValueName )
  1677. {
  1678. //函数名称
  1679. char hookedfunname[32]="NtDeleteValueKey";
  1680. NTSTATUS ntstatus;
  1681. //key相关的变量
  1682. char keyfullname_c[1024]="???";
  1684. //行为Behavior相关变量
  1685. CHAR behavior[1024]="???";
  1686. //进程相关的变量
  1687. CHAR processname[32];//进程名称
  1688. CHAR processfullname_c[512]="???";//进程全名
  1691. //-------------------------------------------------------------------
  1692. //输出函数地址
  1693. GetRealCallee(hookedfunname);
  1695. //获得函数返回结果
  1696. _asm{
  1697. push ValueName
  1698. push KeyHandle
  1699. call RealCallee
  1700. mov ntstatus,eax
  1701. } 
  1703. //获取进程的全名
  1704. GetCurrentProcessFileFullName(processfullname_c);
  1707. //监控要监控的程序 
  1708. if(strcmp(processfullname_c,processname_G)!=0)
  1709. {
  1710. return ntstatus;
  1711. } 
  1713. //这里分析具体的行为-----------------------------------------------
  1714. //经由key句柄获得key全名
  1715. GetKeyFullName(KeyHandle,NULL,keyfullname_c);
  1717. strcpy(behavior,"删除键值"");
  1718. strcat(behavior,keyfullname_c); 
  1719. strcat(behavior,""");
  1721.  
  1723. //这里要进行操作系统判断，不同的操作系统这个地址不同
  1724. //ProcessNameOffset=0x1FC; //2k
  1725. ProcessNameOffset=0x174;  //xp
  1726. //------------------------------------------------------------------
  1727. LogRecord( "%st%st%st%st%s", GetProcess(processname),hookedfunname,
  1728. processfullname_c, ErrorString( ntstatus ), behavior );
  1729. //------------------------------------------------------------------
  1730.  
  1731.    
  1734. return ntstatus;
  1735. }
  1736. NTSTATUS 
  1737. NTAPI
  1738. HookNtSetValueKey( 
  1739.   IN HANDLE               KeyHandle,
  1740.   IN PUNICODE_STRING      ValueName,
  1741.   IN ULONG                TitleIndex OPTIONAL,
  1742.   IN ULONG                ValueType,
  1743.   IN PVOID                Data,
  1744.   IN ULONG                DataSize )
  1745. {
  1746. //函数名称
  1747. char hookedfunname[32]="NtSetValueKey";
  1748. NTSTATUS ntstatus;
  1749. //key相关的变量
  1750. char keyfullname_c[1024]="???";
  1752. //行为Behavior相关变量
  1753. CHAR behavior[1024]="???";
  1754. //进程相关的变量
  1755. CHAR processname[32];//进程名称
  1756. CHAR processfullname_c[512]="???";//进程全名
  1759. //-------------------------------------------------------------------
  1760. //输出函数地址
  1761. GetRealCallee(hookedfunname); 
  1763. //获得函数返回结果
  1764. _asm{
  1765. push DataSize 
  1766. push Data
  1767. push ValueType
  1768. push TitleIndex
  1769. push ValueName
  1770. push KeyHandle
  1771. call RealCallee
  1772. mov ntstatus,eax
  1773. } 
  1775. //获取进程的全名
  1776. GetCurrentProcessFileFullName(processfullname_c);
  1779. //监控要监控的程序 
  1780. if(strcmp(processfullname_c,processname_G)!=0)
  1781. {
  1782. return ntstatus;
  1783. } 
  1785. //这里分析具体的行为-----------------------------------------------
  1786. //经由key句柄获得key全名
  1787. GetKeyFullName(KeyHandle,NULL,keyfullname_c);
  1789. strcpy(behavior,"设置键值"");
  1790. strcat(behavior,keyfullname_c); 
  1791. strcat(behavior,""");
  1793.  
  1795. //这里要进行操作系统判断，不同的操作系统这个地址不同
  1796. //ProcessNameOffset=0x1FC; //2k
  1797. ProcessNameOffset=0x174;  //xp
  1798. //------------------------------------------------------------------
  1799. LogRecord( "%st%st%st%st%s", GetProcess(processname),hookedfunname,
  1800. processfullname_c, ErrorString( ntstatus ), behavior );
  1801. //------------------------------------------------------------------
  1802.  
  1803.    
  1806. return ntstatus;
  1807. }
  1808. NTSTATUS 
  1809. NTAPI
  1810. HookNtEnumerateKey( 
  1811.    IN HANDLE               KeyHandle,
  1812.    IN ULONG                Index,
  1813.    IN KEY_INFORMATION_CLASS KeyInformationClass,
  1814.    OUT PVOID               KeyInformation,
  1815.    IN ULONG                KeyInformationLength,
  1816.    OUT PULONG              ResultLength )
  1817. {
  1818. //函数名称
  1819. char hookedfunname[32]="NtEnumerateKey";
  1820. NTSTATUS ntstatus;
  1821. //key相关的变量
  1822. char keyfullname_c[1024]="???";
  1824. //行为Behavior相关变量
  1825. CHAR behavior[1024]="???";
  1826. //进程相关的变量
  1827. CHAR processname[32];//进程名称
  1828. CHAR processfullname_c[512]="???";//进程全名
  1831. //-------------------------------------------------------------------
  1832. //输出函数地址
  1833. GetRealCallee(hookedfunname);  
  1835. //获得函数返回结果
  1836. _asm{
  1837. push ResultLength 
  1838. push KeyInformationLength
  1839. push KeyInformation
  1840. push KeyInformationClass
  1841. push Index
  1842. push KeyHandle
  1843. call RealCallee
  1844. mov ntstatus,eax
  1845. } 
  1847. //获取进程的全名
  1848. GetCurrentProcessFileFullName(processfullname_c);
  1851. //监控要监控的程序 
  1852. if(strcmp(processfullname_c,processname_G)!=0)
  1853. {
  1854. return ntstatus;
  1855. } 
  1857. //这里分析具体的行为-----------------------------------------------
  1858. //经由key句柄获得key全名
  1859. GetKeyFullName(KeyHandle,NULL,keyfullname_c);
  1861. strcpy(behavior,"枚举键"");
  1862. strcat(behavior,keyfullname_c); 
  1863. strcat(behavior,""");
  1865.  
  1867. //这里要进行操作系统判断，不同的操作系统这个地址不同
  1868. //ProcessNameOffset=0x1FC; //2k
  1869. ProcessNameOffset=0x174;  //xp
  1870. //------------------------------------------------------------------
  1871. LogRecord( "%st%st%st%st%s", GetProcess(processname),hookedfunname,
  1872. processfullname_c, ErrorString( ntstatus ), behavior );
  1873. //------------------------------------------------------------------
  1874.  
  1875.    
  1878. return ntstatus;
  1879. }
  1880. NTSTATUS 
  1881. NTAPI
  1882. HookNtEnumerateValueKey( 
  1883. IN HANDLE               KeyHandle,
  1884. IN ULONG                Index,
  1885. IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass ,
  1886. OUT PVOID               KeyValueInformation,
  1887. IN ULONG                KeyValueInformationLength,
  1888. OUT PULONG              ResultLength )
  1889. {
  1890. //函数名称
  1891. char hookedfunname[32]="NtEnumerateValueKey";
  1892. NTSTATUS ntstatus;
  1893. //key相关的变量
  1894. char keyfullname_c[1024]="???";
  1896. //行为Behavior相关变量
  1897. CHAR behavior[1024]="???";
  1898. //进程相关的变量
  1899. CHAR processname[32];//进程名称
  1900. CHAR processfullname_c[512]="???";//进程全名
  1903. //-------------------------------------------------------------------
  1904. //输出函数地址
  1905. GetRealCallee(hookedfunname);   
  1907. //获得函数返回结果
  1908. _asm{
  1909. push ResultLength 
  1910. push KeyValueInformationLength
  1911. push KeyValueInformation
  1912. push KeyValueInformationClass 
  1913. push Index
  1914. push KeyHandle
  1915. call RealCallee
  1916. mov ntstatus,eax
  1917. } 
  1919. //获取进程的全名
  1920. GetCurrentProcessFileFullName(processfullname_c);
  1923. //监控要监控的程序 
  1924. if(strcmp(processfullname_c,processname_G)!=0)
  1925. {
  1926. return ntstatus;
  1927. } 
  1929. //这里分析具体的行为-----------------------------------------------
  1930. //经由key句柄获得key全名
  1931. GetKeyFullName(KeyHandle,NULL,keyfullname_c);
  1933. strcpy(behavior,"枚举键值"");
  1934. strcat(behavior,keyfullname_c); 
  1935. strcat(behavior,""");
  1937.  
  1939. //这里要进行操作系统判断，不同的操作系统这个地址不同
  1940. //ProcessNameOffset=0x1FC; //2k
  1941. ProcessNameOffset=0x174;  //xp
  1942. //------------------------------------------------------------------
  1943. LogRecord( "%st%st%st%st%s", GetProcess(processname),hookedfunname,
  1944. processfullname_c, ErrorString( ntstatus ), behavior );
  1945. //------------------------------------------------------------------
  1946.  
  1947.    
  1950. return ntstatus;
  1951. }
  1952. NTSTATUS 
  1953. NTAPI
  1954. HookNtOpenFile( 
  1955.    OUT PHANDLE             FileHandle,
  1956.    IN ACCESS_MASK          DesiredAccess,
  1957.    IN POBJECT_ATTRIBUTES   ObjectAttributes,
  1958.    OUT PIO_STATUS_BLOCK    IoStatusBlock,
  1959.    IN ULONG                ShareAccess,
  1960.    IN ULONG                OpenOptions )
  1961. {
  1962. //函数名称
  1963. char hookedfunname[32]="NtOpenFile";
  1964. NTSTATUS ntstatus;
  1965.  
  1966. //文件相关的变量
  1967. char filefullname_c[1024]="???";
  1969. //key相关的变量
  1970. char keyfullname_c[1024]="???";
  1972. //行为Behavior相关变量
  1973. CHAR behavior[1024]="???";
  1974. //进程相关的变量
  1975. CHAR processname[32];//进程名称
  1976. CHAR processfullname_c[512]="???";//进程全名
  1979. //-------------------------------------------------------------------
  1983. //输出函数地址
  1984. GetRealCallee(hookedfunname); 
  1986. //获得函数返回结果
  1987. _asm{
  1988. push OpenOptions 
  1989. push ShareAccess
  1990. push IoStatusBlock
  1991. push ObjectAttributes
  1992. push DesiredAccess
  1993. push FileHandle
  1994. call RealCallee
  1995. mov ntstatus,eax
  1996. } 
  1998. //获取进程的全名
  1999. GetCurrentProcessFileFullName(processfullname_c);
  2002. //监控要监控的程序 
  2003. if(strcmp(processfullname_c,processname_G)!=0)
  2004. {
  2005. return ntstatus;
  2006. } 
  2008. //这里分析具体的行为---------------------------------------
  2009. GetFileFullName(ObjectAttributes,filefullname_c);
  2010. strcpy(behavior,"打开文件"");
  2011. strcat(behavior,filefullname_c); 
  2012. strcat(behavior,""");
  2014.  
  2016. //这里要进行操作系统判断，不同的操作系统这个地址不同
  2017. //ProcessNameOffset=0x1FC; //2k
  2018. ProcessNameOffset=0x174;  //xp
  2019. //------------------------------------------------------------------
  2020. LogRecord( "%st%st%st%st%s", GetProcess(processname),hookedfunname,
  2021. processfullname_c, ErrorString( ntstatus ), behavior );
  2022. //------------------------------------------------------------------
  2023.  
  2024.    
  2027. return ntstatus;
  2028. }
  2029. NTSTATUS 
  2030. NTAPI
  2031. HookNtWriteFile( 
  2032. IN HANDLE               FileHandle,
  2033. IN HANDLE               Event OPTIONAL,
  2034. IN PIO_APC_ROUTINE      ApcRoutine OPTIONAL,
  2035. IN PVOID                ApcContext OPTIONAL,
  2036. OUT PIO_STATUS_BLOCK    IoStatusBlock,
  2037. IN PVOID                Buffer,
  2038. IN ULONG                BufferLength,
  2039. IN PLARGE_INTEGER       ByteOffset OPTIONAL,
  2040. IN PULONG               Key OPTIONAL )
  2041. {
  2042. //函数名称
  2043. char hookedfunname[32]="NtWriteFile";
  2044. NTSTATUS ntstatus;
  2046. //文件相关的变量
  2047. char filefullname_c[1024]="???";
  2049. //key相关的变量
  2050. char keyfullname_c[1024]="???";
  2052. //行为Behavior相关变量
  2053. CHAR behavior[1024]="???";
  2055. //进程相关的变量
  2056. CHAR processname[32];//进程名称
  2057. CHAR processfullname_c[512]="???";//进程全名
  2060. //-------------------------------------------------------------------
  2061. //输出函数地址
  2062. GetRealCallee(hookedfunname); 
  2064. //获得函数返回结果
  2065. _asm{
  2066. push Key 
  2067. push ByteOffset 
  2068. push BufferLength 
  2069. push Buffer 
  2070. push IoStatusBlock
  2071. push ApcContext
  2072. push ApcRoutine
  2073. push Event
  2074. push FileHandle
  2075. call RealCallee
  2076. mov ntstatus,eax
  2077. } 
  2079. //获取进程的全名
  2080. GetCurrentProcessFileFullName(processfullname_c);
  2083. //监控要监控的程序 
  2084. if(strcmp(processfullname_c,processname_G)!=0)
  2085. {
  2086. return ntstatus;
  2087. } 
  2089. //这里分析具体的行为------------------------------------------------
  2090. //经由文件句柄得到文件名
  2091. GetFileFullNamebyFileHandle_QueryNameString(FileHandle,filefullname_c); 
  2093. //--------------------------------------------------------------------------
  2094. strcpy(behavior,"写入文件"");
  2095. strcat(behavior,filefullname_c); 
  2096. strcat(behavior,""");
  2098.  
  2100. //这里要进行操作系统判断，不同的操作系统这个地址不同
  2101. //ProcessNameOffset=0x1FC; //2k
  2102. ProcessNameOffset=0x174;  //xp
  2103. //------------------------------------------------------------------
  2104. LogRecord( "%st%st%st%st%s", GetProcess(processname),hookedfunname,
  2105. processfullname_c, ErrorString( ntstatus ), behavior );
  2106. //------------------------------------------------------------------
  2107.  
  2108.    
  2111. return ntstatus;
  2112. }
  2113. NTSTATUS 
  2114. NTAPI
  2115. HookNtCreateFile( 
  2116.  OUT PHANDLE             FileHandle,
  2117.  IN ACCESS_MASK          DesiredAccess,
  2118.  IN POBJECT_ATTRIBUTES   ObjectAttributes,
  2119.  OUT PIO_STATUS_BLOCK    IoStatusBlock,
  2120.  IN PLARGE_INTEGER       AllocationSize OPTIONAL,
  2121.  IN ULONG                FileAttributes,
  2122.  IN ULONG                ShareAccess,
  2123.  IN ULONG                CreateDisposition,
  2124.  IN ULONG                CreateOptions,
  2125.  IN PVOID                EaBuffer OPTIONAL,
  2126.  IN ULONG                EaLength )
  2127. {
  2128. //函数名称
  2129. char hookedfunname[32]="NtCreateFile";
  2130. NTSTATUS ntstatus;
  2132. //文件相关的变量
  2133. char filefullname_c[1024]="???"; 
  2135. //key相关的变量
  2136. char keyfullname_c[1024]="???";
  2138. //行为Behavior相关变量
  2139. CHAR behavior[1024]="???";
  2141. //进程相关的变量
  2142. CHAR processname[32];//进程名称
  2143. CHAR processfullname_c[512]="???";//进程全名
  2146. //-------------------------------------------------------------------
  2147. //输出函数地址
  2148. GetRealCallee(hookedfunname); 
  2150. //获得函数返回结果
  2151. _asm{
  2152. push EaLength
  2153. push EaBuffer
  2154. push CreateOptions 
  2155. push CreateDisposition 
  2156. push ShareAccess 
  2157. push FileAttributes 
  2158. push AllocationSize
  2159. push IoStatusBlock
  2160. push ObjectAttributes
  2161. push DesiredAccess
  2162. push FileHandle
  2163. call RealCallee
  2164. mov ntstatus,eax
  2165. }  
  2167. //获取进程的全名
  2168. GetCurrentProcessFileFullName(processfullname_c);
  2171. //监控要监控的程序 
  2172. if(strcmp(processfullname_c,processname_G)!=0)
  2173. {
  2174. return ntstatus;
  2175. } 
  2177. //这里分析具体的行为------------------------------------------------
  2178. //经由文件句柄得到文件名
  2179. //??????????????????函数有问题//??????????????????
  2180. //GetFileFullNamebyFileHandle_QueryNameString(FileHandle,filefullname_c); 
  2181. //--------------------------------------------------------------------------
  2182. strcpy(behavior,"创建文件"");
  2183. strcat(behavior,filefullname_c); 
  2184. strcat(behavior,""");
  2186.  
  2188. //这里要进行操作系统判断，不同的操作系统这个地址不同
  2189. //ProcessNameOffset=0x1FC; //2k
  2190. ProcessNameOffset=0x174;  //xp
  2191. //------------------------------------------------------------------
  2192. LogRecord( "%st%st%st%st%s", GetProcess(processname),hookedfunname,
  2193. processfullname_c, ErrorString( ntstatus ), behavior );
  2194. //------------------------------------------------------------------
  2195.  
  2196.    
  2199. return ntstatus;
  2200. }
  2201. NTSTATUS 
  2202. NTAPI
  2203. HookNtCreateProcess( 
  2204. OUT PHANDLE           ProcessHandle,
  2205. IN ACCESS_MASK        DesiredAccess,
  2206. IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
  2207. IN HANDLE             ParentProcess,
  2208. IN BOOLEAN            InheritObjectTable,
  2209. IN HANDLE             SectionHandle OPTIONAL,
  2210. IN HANDLE             DebugPort OPTIONAL,
  2211. IN HANDLE             ExceptionPort OPTIONAL )
  2212. {
  2213. //函数名称
  2214. char hookedfunname[32]="NtCreateProcess";
  2215. NTSTATUS ntstatus;
  2217. //key相关的变量
  2218. char keyfullname_c[1024]="???";
  2220. //行为Behavior相关变量
  2221. CHAR behavior[1024]="???";
  2223. //进程相关的变量
  2224. CHAR processname[32];//进程名称
  2225. CHAR processfullname_c[512]="???";//进程全名
  2227. WORD InheritObjectTable_W;
  2229. //-------------------------------------------------------------------
  2230. InheritObjectTable_W=InheritObjectTable;
  2232. //输出函数地址
  2233. GetRealCallee(hookedfunname);  
  2235. //获得函数返回结果
  2236. _asm{ 
  2237. push ExceptionPort 
  2238. push DebugPort 
  2239. push SectionHandle  
  2240. push InheritObjectTable_W
  2241. push ParentProcess
  2242. push ObjectAttributes
  2243. push DesiredAccess
  2244. push ProcessHandle
  2245. call RealCallee
  2246. mov ntstatus,eax
  2247. }  
  2249. //获取进程的全名
  2250. GetCurrentProcessFileFullName(processfullname_c);
  2253. //监控要监控的程序 
  2254. if(strcmp(processfullname_c,processname_G)!=0)
  2255. {
  2256. return ntstatus;
  2257. } 
  2259. //这里分析具体的行为?????????????????????????????????????????????????
  2260. strcpy(behavior,"创建进程""); 
  2261. strcat(behavior,""");
  2263.  
  2265. //这里要进行操作系统判断，不同的操作系统这个地址不同
  2266. //ProcessNameOffset=0x1FC; //2k
  2267. ProcessNameOffset=0x174;  //xp
  2268. //------------------------------------------------------------------
  2269. LogRecord( "%st%st%st%st%s", GetProcess(processname),hookedfunname,
  2270. processfullname_c, ErrorString( ntstatus ), behavior );
  2271. //------------------------------------------------------------------
  2272.  
  2273.    
  2276. return ntstatus;
  2277. }
  2278. NTSTATUS 
  2279. NTAPI
  2280. HookNtCreateProcessEx(  
  2281.   OUT PHANDLE ProcessHandle,
  2282.   IN ACCESS_MASK DesiredAccess,
  2283.   IN POBJECT_ATTRIBUTES ObjectAttributes,
  2284.   IN HANDLE InheritFromProcessHandle,
  2285.   IN ULONG CreateFlags,
  2286.   IN HANDLE SectionHandle OPTIONAL,
  2287.   IN HANDLE DebugObject OPTIONAL,
  2288.   IN HANDLE ExceptionPort OPTIONAL,
  2289.   IN ULONG JobMemberLevel)
  2290. {
  2291. //函数名称
  2292. char hookedfunname[32]="NtCreateProcessEx";
  2293. NTSTATUS ntstatus;
  2295. //key相关的变量
  2296. char keyfullname_c[1024]="???";
  2298. //行为Behavior相关变量
  2299. CHAR behavior[1024]="???";
  2301. //进程相关的变量
  2302. CHAR processname[32];//进程名称
  2303. CHAR processfullname_c[512]="???";//进程全名
  2305. //-------------------------------------------------------------------
  2306. //输出函数地址
  2307. GetRealCallee(hookedfunname);  
  2309. //获得函数返回结果
  2310. _asm{ 
  2311. push JobMemberLevel 
  2312. push ExceptionPort 
  2313. push DebugObject  
  2314. push SectionHandle
  2315. push CreateFlags
  2316. push InheritFromProcessHandle
  2317. push ObjectAttributes
  2318. push DesiredAccess
  2319. push ProcessHandle
  2320. call RealCallee
  2321. mov ntstatus,eax
  2322. }  
  2324. //获取进程的全名
  2325. GetCurrentProcessFileFullName(processfullname_c);
  2328. //监控要监控的程序 
  2329. if(strcmp(processfullname_c,processname_G)!=0)
  2330. {
  2331. return ntstatus;
  2332. } 
  2334. //这里分析具体的行为?????????????????????????????????????????????????
  2335. strcpy(behavior,"创建进程""); 
  2336. strcat(behavior,""");
  2338.  
  2340. //这里要进行操作系统判断，不同的操作系统这个地址不同
  2341. //ProcessNameOffset=0x1FC; //2k
  2342. ProcessNameOffset=0x174;  //xp
  2343. //------------------------------------------------------------------
  2344. LogRecord( "%st%st%st%st%s", GetProcess(processname),hookedfunname,
  2345. processfullname_c, ErrorString( ntstatus ), behavior );
  2346. //------------------------------------------------------------------
  2348. return ntstatus;
  2349. }
  2350. NTSTATUS 
  2351. NTAPI
  2352. HookNtCreateSection( 
  2353. OUT PHANDLE             SectionHandle,
  2354. IN ULONG                DesiredAccess,
  2355. IN POBJECT_ATTRIBUTES   ObjectAttributes OPTIONAL,
  2356. IN PLARGE_INTEGER       MaximumSize OPTIONAL,
  2357. IN ULONG                PageAttributess,
  2358. IN ULONG                SectionAttributes,
  2359. IN HANDLE               FileHandle OPTIONAL )
  2360. {
  2361. //函数名称
  2362. char hookedfunname[32]="NtCreateSection";
  2363. NTSTATUS ntstatus;
  2365. //文件相关的变量
  2366. char filefullname_c[1024]="???";
  2368. //key相关的变量
  2369. char keyfullname_c[1024]="???";
  2371. //行为Behavior相关变量
  2372. CHAR behavior[1024]="???";
  2374. //进程相关的变量
  2375. CHAR processname[32];//进程名称
  2376. CHAR processfullname_c[512]="???";//进程全名
  2379. //-------------------------------------------------------------------
  2380. //输出函数地址
  2381. GetRealCallee(hookedfunname);  
  2383. //获得函数返回结果
  2384. _asm{  
  2385. push FileHandle 
  2386. push SectionAttributes  
  2387. push PageAttributess
  2388. push MaximumSize
  2389. push ObjectAttributes
  2390. push DesiredAccess
  2391. push SectionHandle
  2392. call RealCallee
  2393. mov ntstatus,eax
  2394. }  
  2396. //获取进程的全名
  2397. GetCurrentProcessFileFullName(processfullname_c);
  2400. //监控要监控的程序 
  2401. if(strcmp(processfullname_c,processname_G)!=0)
  2402. {
  2403. return ntstatus;
  2404. } 
  2406. //这里分析具体的行为?????????????????????????????????????????????????
  2407. //经由文件句柄得到文件名 
  2408. GetFileFullNamebyFileHandle_forSection(FileHandle,filefullname_c);
  2410. strcpy(behavior,"创建Section为文件"");
  2411. strcat(behavior,filefullname_c); 
  2412. strcat(behavior,""");
  2414.  
  2416. //这里要进行操作系统判断，不同的操作系统这个地址不同
  2417. //ProcessNameOffset=0x1FC; //2k
  2418. ProcessNameOffset=0x174;  //xp
  2419. //------------------------------------------------------------------
  2420. LogRecord( "%st%st%st%st%s", GetProcess(processname),hookedfunname,
  2421. processfullname_c, ErrorString( ntstatus ), behavior );
  2422. //------------------------------------------------------------------
  2423.  
  2424.    
  2427. return ntstatus;
  2428. }
  2429. NTSTATUS 
  2430. NTAPI
  2431. HookNtOpenThread( 
  2432.  OUT PHANDLE             ThreadHandle,
  2433.  IN ACCESS_MASK          AccessMask,
  2434.  IN POBJECT_ATTRIBUTES   ObjectAttributes,
  2435.  IN PCLIENT_ID           ClientId )
  2436. {
  2437. //函数名称
  2438. char hookedfunname[32]="NtOpenThread";
  2439. NTSTATUS ntstatus;
  2441. //key相关的变量
  2442. char keyfullname_c[1024]="???";
  2444. //行为Behavior相关变量
  2445. CHAR behavior[1024]="???";
  2447. //进程相关的变量
  2448. CHAR processname[32];//进程名称
  2449. CHAR processfullname_c[512]="???";//进程全名
  2452. //-------------------------------------------------------------------
  2453. //输出函数地址
  2454. GetRealCallee(hookedfunname);  
  2456. //获得函数返回结果
  2457. _asm{  
  2458. push ClientId
  2459. push ObjectAttributes
  2460. push AccessMask
  2461. push ThreadHandle
  2462. call RealCallee
  2463. mov ntstatus,eax
  2464. }  
  2466. //获取进程的全名
  2467. GetCurrentProcessFileFullName(processfullname_c);
  2470. //监控要监控的程序 
  2471. if(strcmp(processfullname_c,processname_G)!=0)
  2472. {
  2473. return ntstatus;
  2474. } 
  2476. //这里分析具体的行为?????????????????????????????????????????????????
  2477. strcpy(behavior,"打开线程""); 
  2478. strcat(behavior,""");
  2480.  
  2482. //这里要进行操作系统判断，不同的操作系统这个地址不同
  2483. //ProcessNameOffset=0x1FC; //2k
  2484. ProcessNameOffset=0x174;  //xp
  2485. //------------------------------------------------------------------
  2486. LogRecord( "%st%st%st%st%s", GetProcess(processname),hookedfunname,
  2487. processfullname_c, ErrorString( ntstatus ), behavior );
  2488. //------------------------------------------------------------------
  2489.  
  2491. return ntstatus;
  2492. }
  2493. NTSTATUS 
  2494. NTAPI
  2495. HookNtCreateThread( 
  2496.    OUT PHANDLE             ThreadHandle,
  2497.    IN ACCESS_MASK          DesiredAccess,
  2498.    IN POBJECT_ATTRIBUTES   ObjectAttributes OPTIONAL,
  2499.    IN HANDLE               ProcessHandle,
  2500.    OUT PCLIENT_ID          ClientId,
  2501.    IN PCONTEXT             ThreadContext,
  2502.    IN PINITIAL_TEB         InitialTeb,
  2503.    IN BOOLEAN              CreateSuspended )
  2504. {
  2505. //函数名称
  2506. char hookedfunname[32]="NtCreateThread";
  2507. NTSTATUS ntstatus;
  2509. //key相关的变量
  2510. char keyfullname_c[1024]="???";
  2512. //行为Behavior相关变量
  2513. CHAR behavior[1024]="???";
  2515. //进程相关的变量
  2516. CHAR processname[32];//进程名称
  2517. CHAR processfullname_c[512]="???";//进程全名
  2519. WORD CreateSuspended_W;
  2520. //-------------------------------------------------------------------
  2521. CreateSuspended_W=CreateSuspended;
  2523. //输出函数地址
  2524. GetRealCallee(hookedfunname);  
  2526. //获得函数返回结果
  2527. _asm{ 
  2528. push CreateSuspended_W 
  2529. push InitialTeb 
  2530. push ThreadContext  
  2531. push ClientId
  2532. push ProcessHandle
  2533. push ObjectAttributes
  2534. push DesiredAccess
  2535. push ThreadHandle
  2536. call RealCallee
  2537. mov ntstatus,eax
  2538. }  
  2540. //获取进程的全名
  2541. GetCurrentProcessFileFullName(processfullname_c);
  2544. //监控要监控的程序 
  2545. if(strcmp(processfullname_c,processname_G)!=0)
  2546. {
  2547. return ntstatus;
  2548. } 
  2550. //这里分析具体的行为?????????????????????????????????????????????????
  2551. strcpy(behavior,"创建线程""); 
  2552. strcat(behavior,""");
  2554.  
  2556. //这里要进行操作系统判断，不同的操作系统这个地址不同
  2557. //ProcessNameOffset=0x1FC; //2k
  2558. ProcessNameOffset=0x174;  //xp
  2559. //------------------------------------------------------------------
  2560. LogRecord( "%st%st%st%st%s", GetProcess(processname),hookedfunname,
  2561. processfullname_c, ErrorString( ntstatus ), behavior );
  2562. //------------------------------------------------------------------
  2563.  
  2565. return ntstatus;
  2566. }
  2567. NTSTATUS 
  2568. NTAPI
  2569. HookNtOpenProcess( 
  2570.   OUT PHANDLE             ProcessHandle,
  2571.   IN ACCESS_MASK          AccessMask,
  2572.   IN POBJECT_ATTRIBUTES   ObjectAttributes,
  2573.   IN PCLIENT_ID           ClientId )
  2574. {
  2575. //函数名称
  2576. char hookedfunname[32]="NtOpenProcess";
  2577. NTSTATUS ntstatus;
  2579. //key相关的变量
  2580. char keyfullname_c[1024]="???";
  2582. //行为Behavior相关变量
  2583. CHAR behavior[1024]="???";
  2585. //进程相关的变量
  2586. CHAR processname[32];//进程名称
  2587. CHAR processfullname_c[512]="???";//进程全名
  2590. //-------------------------------------------------------------------
  2591. //输出函数地址
  2592. GetRealCallee(hookedfunname);   
  2594. //获得函数返回结果
  2595. _asm{ 
  2596. push ClientId
  2597. push ObjectAttributes
  2598. push AccessMask
  2599. push ProcessHandle
  2600. call RealCallee
  2601. mov ntstatus,eax
  2602. }  
  2604. //获取进程的全名
  2605. GetCurrentProcessFileFullName(processfullname_c);
  2608. //监控要监控的程序 
  2609. if(strcmp(processfullname_c,processname_G)!=0)
  2610. {
  2611. return ntstatus;
  2612. } 
  2614. //这里分析具体的行为?????????????????????????????????????????????????
  2615. strcpy(behavior,"打开进程""); 
  2616. strcat(behavior,""");
  2618. //这里要进行操作系统判断，不同的操作系统这个地址不同
  2619. //ProcessNameOffset=0x1FC; //2k
  2620. ProcessNameOffset=0x174;  //xp
  2621. //------------------------------------------------------------------
  2622. LogRecord( "%st%st%st%st%s", GetProcess(processname),hookedfunname,
  2623. processfullname_c, ErrorString( ntstatus ), behavior );
  2624. //------------------------------------------------------------------
  2625.  
  2626.    
  2627. return ntstatus;
  2628. }
  2629. NTSTATUS 
  2630. NTAPI
  2631. HookNtOpenSection( 
  2632.   OUT PHANDLE             SectionHandle,
  2633.   IN ACCESS_MASK          DesiredAccess,
  2634.   IN POBJECT_ATTRIBUTES   ObjectAttributes )
  2635. {
  2636. //函数名称
  2637. char hookedfunname[32]="NtOpenSection";
  2638. NTSTATUS ntstatus;
  2640. //文件相关的变量
  2641. ANSI_STRING filefullname_a;
  2642. char filefullname_c[1024]="???";
  2644. //key相关的变量
  2645. char keyfullname_c[1024]="???";
  2647. //行为Behavior相关变量
  2648. CHAR behavior[1024]="???";
  2650. //进程相关的变量
  2651. CHAR processname[32];//进程名称
  2652. CHAR processfullname_c[512]="???";//进程全名
  2655. //-------------------------------------------------------------------
  2656. //输出函数地址
  2657. GetRealCallee(hookedfunname);   
  2659. //获得函数返回结果
  2660. _asm{  
  2661. push ObjectAttributes
  2662. push DesiredAccess
  2663. push SectionHandle
  2664. call RealCallee
  2665. mov ntstatus,eax
  2666. }  
  2668. //获取进程的全名
  2669. GetCurrentProcessFileFullName(processfullname_c);
  2672. //监控要监控的程序 
  2673. if(strcmp(processfullname_c,processname_G)!=0)
  2674. {
  2675. return ntstatus;
  2676. } 
  2678. //这里分析具体的行为?????????????????????????????????????????????????
  2679. RtlUnicodeStringToAnsiString( &filefullname_a, ObjectAttributes->ObjectName, TRUE );
  2681. if(filefullname_a.Length!=0)
  2682. {
  2683. strncpy(filefullname_c,filefullname_a.Buffer,Minimum(filefullname_a.Length,1023)); 
  2684. filefullname_c[Minimum(filefullname_a.Length,1023)]=''; 
  2685. }
  2687. strcpy(behavior,"打开Section""); 
  2688. strcat(behavior,filefullname_c);
  2689. strcat(behavior,""");
  2691.  
  2693. //这里要进行操作系统判断，不同的操作系统这个地址不同
  2694. //ProcessNameOffset=0x1FC; //2k
  2695. ProcessNameOffset=0x174;  //xp
  2696. //------------------------------------------------------------------
  2697. LogRecord( "%st%st%st%st%s", GetProcess(processname),hookedfunname,
  2698. processfullname_c, ErrorString( ntstatus ), behavior );
  2699. //------------------------------------------------------------------
  2700.  
  2702. return ntstatus;
  2703. }
  2704. NTSTATUS 
  2705. NTAPI
  2706. HookNtCreateSymbolicLinkObject( 
  2707.    OUT PHANDLE             pHandle,
  2708.    IN ACCESS_MASK          DesiredAccess,
  2709.    IN POBJECT_ATTRIBUTES   ObjectAttributes,
  2710.    IN PUNICODE_STRING      DestinationName )
  2711. {
  2712. //函数名称
  2713. char hookedfunname[32]="NtCreateSymbolicLinkObject";
  2714. NTSTATUS ntstatus;
  2716. //key相关的变量
  2717. char keyfullname_c[1024]="???";
  2719. //行为Behavior相关变量
  2720. CHAR behavior[1024]="???";
  2722. //进程相关的变量
  2723. CHAR processname[32];//进程名称
  2724. CHAR processfullname_c[512]="???";//进程全名
  2727. //-------------------------------------------------------------------
  2728. //输出函数地址
  2729. GetRealCallee(hookedfunname);    
  2731. //获得函数返回结果
  2732. _asm{  
  2733. push DestinationName
  2734. push ObjectAttributes
  2735. push DesiredAccess
  2736. push pHandle
  2737. call RealCallee
  2738. mov ntstatus,eax
  2739. }  
  2741. //获取进程的全名
  2742. GetCurrentProcessFileFullName(processfullname_c);
  2745. //监控要监控的程序 
  2746. if(strcmp(processfullname_c,processname_G)!=0)
  2747. {
  2748. return ntstatus;
  2749. } 
  2751. //这里分析具体的行为?????????????????????????????????????????????????
  2752. strcpy(behavior,"创建符号链接""); 
  2753. strcat(behavior,"""); 
  2756. //这里要进行操作系统判断，不同的操作系统这个地址不同
  2757. //ProcessNameOffset=0x1FC; //2k
  2758. ProcessNameOffset=0x174;  //xp
  2759. //------------------------------------------------------------------
  2760. LogRecord( "%st%st%st%st%s", GetProcess(processname),hookedfunname,
  2761. processfullname_c, ErrorString( ntstatus ), behavior );
  2762. //------------------------------------------------------------------
  2763.  
  2764.    
  2767. return ntstatus;
  2768. }
  2769. NTSTATUS 
  2770. NTAPI
  2771. HookNtSetSystemTime( 
  2772. IN PLARGE_INTEGER       SystemTime,
  2773. OUT PLARGE_INTEGER      PreviousTime OPTIONAL )
  2774. {
  2775. //函数名称
  2776. char hookedfunname[32]="NtSetSystemTime";
  2777. NTSTATUS ntstatus;
  2779. //key相关的变量
  2780. char keyfullname_c[1024]="???";
  2782. //行为Behavior相关变量
  2783. CHAR behavior[1024]="???";
  2785. //进程相关的变量
  2786. CHAR processname[32];//进程名称
  2787. CHAR processfullname_c[512]="???";//进程全名
  2790. //-------------------------------------------------------------------
  2791. //输出函数地址
  2792. GetRealCallee(hookedfunname);    
  2794. //获得函数返回结果
  2795. _asm{   
  2796. push PreviousTime
  2797. push SystemTime
  2798. call RealCallee
  2799. mov ntstatus,eax
  2800. }  
  2802. //获取进程的全名
  2803. GetCurrentProcessFileFullName(processfullname_c);
  2806. //监控要监控的程序 
  2807. if(strcmp(processfullname_c,processname_G)!=0)
  2808. {
  2809. return ntstatus;
  2810. } 
  2812. //这里分析具体的行为?????????????????????????????????????????????????
  2813. strcpy(behavior,"设置系统时间""); 
  2814. strcat(behavior,"""); 
  2816.  
  2818. //这里要进行操作系统判断，不同的操作系统这个地址不同
  2819. //ProcessNameOffset=0x1FC; //2k
  2820. ProcessNameOffset=0x174;  //xp
  2821. //------------------------------------------------------------------
  2822. LogRecord( "%st%st%st%st%s", GetProcess(processname),hookedfunname,
  2823. processfullname_c, ErrorString( ntstatus ), behavior );
  2824. //------------------------------------------------------------------
  2825.  
  2826.    
  2828. return ntstatus;
  2829. }
  2831. //////////////////////////////////////////////////////////////////////////
  2832. //驱动控制相关
  2833. void unhook()
  2834. {
  2835. ULONG a,base;
  2836. int i=0;
  2838. for(i=0;i<hook_num;i++)
  2839. {
  2840. if(hook_API_info[i].hooked)
  2841. {
  2842. Index=hook_API_info[i].Index;
  2843. RealCallee=hook_API_info[i].RealCallee;
  2845. //unhook dispatch table
  2846. a=4*Index+(ULONG)KeServiceDescriptorTable->ServiceTable;
  2847. base=(ULONG)MmMapIoSpace(MmGetPhysicalAddress((void*)a),4,0);
  2849. //恢复ssdt中的函数地址
  2850. _asm
  2851. {
  2852. mov eax,base
  2853. mov ebx,RealCallee
  2854. mov dword ptr[eax],ebx
  2855. }
  2857. tmp=(char*)base;
  2858. MmUnmapIoSpace(tmp,4);
  2860. hook_API_info[i].hooked=FALSE;
  2861. }
  2862. }
  2863. }
  2864. //////////////////////////////////////////////////////////////////////////
  2865. //IRP派遣例程——IRP_MJ_DEVICE_CONTROL 
  2866. //driver->MajorFunction[IRP_MJ_DEVICE_CONTROL]=DrvDispatch;
  2867. NTSTATUS DrvDispatch(IN PDEVICE_OBJECT device,IN PIRP Irp)
  2868. {
  2869. UCHAR*buff=0; ULONG a,base;
  2870. int offsetbuff=0;
  2871. DWORD numHookAPI=0;
  2872. CHAR nativeAPIname[64];
  2873. int i=0;
  2874. int j=0;
  2876. PIO_STATUS_BLOCK IoStatus;
  2877. BOOLEAN               retval = FALSE;
  2878. PLOG_BUF              old;
  2879. BOOLEAN               logMutexReleased;
  2881. PIO_STACK_LOCATION      irpStack;
  2882. PVOID                   inputBuffer;
  2883. PVOID                   outputBuffer;
  2884. ULONG                   inputBufferLength;
  2885. ULONG                   outputBufferLength;
  2886. PIO_STACK_LOCATION loc;
  2887. ULONG                   ioControlCode;
  2889. irpStack = IoGetCurrentIrpStackLocation (Irp);
  2890. inputBuffer             = Irp->AssociatedIrp.SystemBuffer;
  2891. inputBufferLength       = irpStack->Parameters.DeviceIoControl.InputBufferLength;
  2892. outputBuffer            = Irp->AssociatedIrp.SystemBuffer;
  2893. outputBufferLength      = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
  2894. loc=IoGetCurrentIrpStackLocation(Irp);//获得IRP Stack
  2895. ioControlCode           = irpStack->Parameters.DeviceIoControl.IoControlCode;
  2897. //使buff指向controlbuff
  2898. buff=(UCHAR*)Irp->AssociatedIrp.SystemBuffer; 
  2899. //
  2900. // Its a message from our GUI!
  2901. //
  2902. IoStatus=&Irp->IoStatus;
  2903. IoStatus->Status      = STATUS_SUCCESS; // Assume success
  2904. IoStatus->Information = 0;              // Assume nothing returned
  2905. //
  2906. // See if the output buffer is really a user buffer that we
  2907. // can just dump data into.
  2908. //
  2909. if( IOCTL_TRANSFER_TYPE(ioControlCode) == METHOD_NEITHER ) {
  2911. outputBuffer = Irp->UserBuffer;
  2912. }
  2913. switch(ioControlCode)
  2914. {
  2915. case IOCTL_BEHAVIORMON_HOOK://hook Native API function
  2916. offsetbuff=0;
  2917. //获得要Hook的NativeAPI函数的个数
  2918. numHookAPI=(DWORD)buff[8];
  2919. offsetbuff+=12;
  2920. //hook
  2921. for(i=0;i<(int)numHookAPI;i++)
  2922. {
  2923. //获得要Hook的NativeAPI函数的name
  2924. strcpy(nativeAPIname,buff+offsetbuff);
  2925. offsetbuff+=strlen(nativeAPIname);
  2926. offsetbuff+=1;
  2927. //获得要Hook的NativeAPI函数的Index
  2928. memmove(&Index,buff+offsetbuff,4);//读出从前台输入的SSDT函数服务Index
  2929. offsetbuff+=4;
  2930. //将上面得到的信息放在对应的Hook_API_Info中
  2931. for(j=0;j<hook_num;j++)
  2932. {
  2933. if(strcmp(nativeAPIname,hook_API_info[j].nativeAPIname)==0)
  2934. {
  2935. break;
  2936. }
  2937. }
  2938. if(j==hook_num)
  2939. {
  2940. continue;
  2941. }
  2942. //获得该函数的真实地址，并开始Hook
  2943. a=4*Index+(ULONG)KeServiceDescriptorTable->ServiceTable;
  2944. //把正确的SSDT函数调用地址先备份到base中
  2945. base=(ULONG)MmMapIoSpace(MmGetPhysicalAddress((void*)a),4,0);
  2946. a=hook_API_info[j].proxyfunadd;
  2947. _asm
  2948. {
  2949. mov eax,base//把正确的SSDT函数调用地址复制到eax中
  2950. mov ebx,dword ptr[eax]//使ebx=eax
  2951. mov RealCallee,ebx//RealCallee=eax
  2952. mov ebx,a//使ebx指向HookRegRestoreKey()函数
  2953. mov dword ptr[eax],ebx//把SSDT中的正确的函数调用地址改为HookRegRestoreKey()函数所在的地址！！！
  2954. } 
  2955. //将上面得到的信息放在对应的Hook_API_Info中 
  2956. hook_API_info[j].Index=Index;
  2957. hook_API_info[j].RealCallee=RealCallee; 
  2958. hook_API_info[j].hooked=TRUE;
  2960. tmp=(char*)base;
  2961. MmUnmapIoSpace(tmp,4);
  2962. }
  2963. //获取与用户的交互缓冲区，buff中第一个DW就是其地址
  2964. memmove(&a,buff,4);
  2965. plog_behavior=(PLOG_BEHAVIOR)MmMapIoSpace(MmGetPhysicalAddress((void*)a),LOG_BEHAVIOR_NUM*sizeof(LOG_BEHAVIOR),0);
  2966. break;
  2967. case IOCTL_BEHAVIORMON_PROC:
  2968. //设置要监控的程序全路径
  2969. strcpy(processname_G,buff);
  2970. break;
  2971. case IOCTL_BEHAVIORMON_UNHOOK:
  2972. unhook();
  2973. break;
  2974. case IOCTL_BEHAVIORMON_GETSTATS:
  2975. //
  2976. // Probe the output buffer
  2977. //
  2978. try {                 
  2980. ProbeForWrite( outputBuffer,
  2981. outputBufferLength,
  2982. sizeof( UCHAR ));
  2984. } except( EXCEPTION_EXECUTE_HANDLER ) {
  2986. IoStatus->Status = STATUS_INVALID_PARAMETER;
  2987. return FALSE;
  2988. }            
  2990. MUTEX_ACQUIRE( LogMutex );
  2991. if( LOGBUFSIZE > outputBufferLength )  {
  2993. //
  2994. // Output buffer isn't big enough
  2995. //
  2996. MUTEX_RELEASE( LogMutex );
  2997. IoStatus->Status = STATUS_INVALID_PARAMETER;
  2998. return FALSE;
  3000. } else if( Log->Len  ||  Log->Next ) {
  3002. //
  3003. // Switch to a new Log
  3004. //
  3005. RegmonNewLog();
  3007. //
  3008. // Fetch the oldest to give to user
  3009. //
  3010. old = RegmonOldestLog();
  3012. if( old != Log ) {
  3014. logMutexReleased = TRUE;
  3015. MUTEX_RELEASE( LogMutex );
  3017. } else {
  3019. logMutexReleased = FALSE;
  3020. }
  3022. //
  3023. // Copy it
  3024. //
  3025. memcpy( outputBuffer, old->Data, old->Len );
  3027. //
  3028. // Return length of copied info
  3029. //
  3030. IoStatus->Information = old->Len;
  3032. //
  3033. // Deallocate buffer - unless its the last one
  3034. //
  3035. if( logMutexReleased ) {
  3037. ExFreePool( old );
  3039. } else {
  3041. Log->Len = 0;
  3042. MUTEX_RELEASE( LogMutex );
  3043. }
  3045. } else {
  3047. //
  3048. // No unread data
  3049. //
  3050. MUTEX_RELEASE( LogMutex );
  3051. IoStatus->Information = 0;
  3052. }
  3053. break;
  3054. case IOCTL_BEHAVIORMON_ZEROSTATS: 
  3055. //
  3056. // Zero contents of buffer
  3057. // 
  3059. MUTEX_ACQUIRE( LogMutex );
  3060. while( Log->Next )  {
  3062. //
  3063. // Free all but the first output buffer
  3064. //
  3065. old = Log->Next;
  3066. Log->Next = old->Next;
  3067. ExFreePool( old );
  3068. NumLog--;
  3069. }
  3071. //
  3072. // Set the output pointer to the start of the output buffer
  3073. //
  3074. Log->Len = 0;
  3076. //
  3077. // Reset sequence and relative start time
  3078. //
  3079. Sequence = 0;
  3080. StartTime = KeQueryPerformanceCounter( NULL );
  3081. MUTEX_RELEASE( LogMutex );
  3082. break;
  3083. default:
  3084. break;
  3085. } 
  3086. Irp->IoStatus.Status=0;
  3087. IoCompleteRequest(Irp,IO_NO_INCREMENT);
  3088. return 0;
  3089. }
  3091. // nothing special
  3092. NTSTATUS DrvCreateClose(IN PDEVICE_OBJECT device,IN PIRP Irp)
  3093. {
  3094. Irp->IoStatus.Information=0;
  3095. Irp->IoStatus.Status=0;
  3096. IoCompleteRequest(Irp,IO_NO_INCREMENT);
  3097. return 0;
  3098. }
  3100. // nothing special -just a cleanup
  3101. void DrvUnload(IN PDRIVER_OBJECT driver)
  3102. {
  3103. UNICODE_STRING devlink;
  3104. ULONG a,base;
  3105. int i=0;
  3107. for(i=0;i<hook_num;i++)
  3108. {
  3109. if(hook_API_info[i].hooked)
  3110. {
  3111. Index=hook_API_info[i].Index;
  3112. RealCallee=hook_API_info[i].RealCallee;
  3114. //unhook dispatch table
  3115. a=4*Index+(ULONG)KeServiceDescriptorTable->ServiceTable;
  3116. base=(ULONG)MmMapIoSpace(MmGetPhysicalAddress((void*)a),4,0);
  3118. //恢复ssdt中的函数地址
  3119. _asm
  3120. {
  3121. mov eax,base
  3122. mov ebx,RealCallee
  3123. mov dword ptr[eax],ebx
  3124. }
  3126. tmp=(char*)base;
  3127. MmUnmapIoSpace(tmp,4);
  3129. hook_API_info[i].hooked=FALSE;
  3130. }
  3131. }
  3132. MmUnmapIoSpace(plog_behavior,LOG_BEHAVIOR_NUM*sizeof(LOG_BEHAVIOR));
  3134. RtlInitUnicodeString(&devlink,devicelink);
  3135. IoDeleteSymbolicLink(&devlink);
  3136. IoDeleteDevice(driver->DeviceObject);
  3138. //
  3139. // Now we can free any memory we have outstanding
  3140. //
  3141. RegmonHashCleanup();
  3142. RegmonFreeLog(); 
  3143. ExDeletePagedLookasideList( &FullPathLookaside );
  3144. }
  3145. //****************************************************************************
  3146. //驱动程序的入口点，相当于c语言的main函数，它在驱动程序被加载进内存的时候调用
  3147. //第一个重要的任务——就是要设定驱动程序对象的几个函数指针;
  3148. /*
  3149. pDriverObj->DriverUnload = DriverUnload;//卸载函数
  3150. pDriverObj->MajorFunction[IRP_MJ_CREATE] =
  3151. pDriverObj->MajorFunction[IRP_MJ_CLOSE] =
  3152. pDriverObj->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DriverDispatch;//派遣函数
  3153. */
  3154. //第二个重要的任务——就是要创建设备对象并为其建立符号连接;
  3155. /*
  3156. NTKERNELAPI
  3157. NTSTATUS
  3158. IoCreateDevice(
  3159. IN PDRIVER_OBJECT DriverObject,
  3160. IN ULONG DeviceExtensionSize,
  3161. IN PUNICODE_STRING DeviceName OPTIONAL,
  3162. IN DEVICE_TYPE DeviceType,
  3163. IN ULONG DeviceCharacteristics,
  3164. IN BOOLEAN Exclusive,
  3165. OUT PDEVICE_OBJECT *DeviceObject
  3166. );
  3167. //例子：
  3168. IoCreateDevice( pDriverObj,
  3169. 0,
  3170. &deviceName,
  3171. FILE_DEVICE_UNKNOWN,
  3172. FILE_DEVICE_SECURE_OPEN,
  3173. true,
  3174. &pDeviceObj ); //创建设备对象
  3175. IoCreateSymbolicLink( &linkName, &deviceName );   //建立符号连接
  3176. */
  3177. //DriverEntry just creates our device - nothing special here
  3178. NTSTATUS DriverEntry(IN PDRIVER_OBJECT driver,IN PUNICODE_STRING path)
  3179. {
  3180. PDEVICE_OBJECT devobject=0;//设备对象
  3181. UNICODE_STRING devlink,devname;//设备链接，设备名称
  3182. ULONG a,b; 
  3183. RtlInitUnicodeString(&devname,devicename);
  3184. RtlInitUnicodeString(&devlink,devicelink);
  3186. //初始化要监控的程序全路径
  3187. processname_G[0]='X';
  3188. processname_G[1]='X';
  3189. processname_G[2]='X';
  3190. processname_G[3]='';
  3191. //初始化哈希表，存放注册表全名
  3192. MUTEX_INIT( HashMutex );
  3193. MUTEX_INIT( LogMutex );
  3194. //
  3195. // Initialize a lookaside for key names
  3196. //
  3197. ExInitializePagedLookasideList( &FullPathLookaside, NULL, NULL,
  3198. 0, MAXPATHLEN, 'mgeR', 256 );
  3199. //
  3200. // Allocate the initial output buffer
  3201. //
  3202. Log = ExAllocatePool( PagedPool, sizeof(*Log) );
  3203. if( !Log ) {  
  3204. RtlInitUnicodeString(&devlink,devicelink);
  3205. IoDeleteSymbolicLink(&devlink);
  3206. IoDeleteDevice(driver->DeviceObject);
  3207. return STATUS_INSUFFICIENT_RESOURCES;
  3208. }
  3209. Log->Len  = 0;
  3210. Log->Next = NULL;
  3211. NumLog = 1;
  3213. //
  3214. // Initialize rootkey lengths
  3215. //
  3216. for( i = 0; i < NUMROOTKEYS; i++ ) {
  3218. RootKey[i].RootNameLen = strlen( RootKey[i].RootName );
  3219. }
  3220. for( i = 0; i < 2; i++ ) {
  3222. CurrentUser[i].RootNameLen = strlen( CurrentUser[i].RootName );
  3223. }
  3226. //创建设备＋创建符号链接
  3227. IoCreateDevice(driver,2048,&devname,FILE_DEVICE_UNKNOWN,0,TRUE,&devobject);
  3228. IoCreateSymbolicLink(&devlink,&devname);
  3230. //设定驱动程序对象的几个函数指针
  3231. driver->MajorFunction[IRP_MJ_DEVICE_CONTROL]=DrvDispatch;//派遣函数
  3232. driver->MajorFunction[IRP_MJ_CREATE]=DrvCreateClose;
  3233. driver->MajorFunction[IRP_MJ_CLOSE]=DrvCreateClose;
  3234. driver->DriverUnload=DrvUnload;//卸载函数
  3237. ProcessNameOffset = GetProcessNameOffset();
  3239. //初始化Hook_API_Info
  3240. //NtRestoreKey
  3241. hook_API_info[hook_num].nativeAPIname="NtRestoreKey";
  3242. hook_API_info[hook_num].proxyfunadd=(ULONG)&HookNtRestoreKey;
  3243. hook_API_info[hook_num].hooked=FALSE;
  3244. hook_num++;
  3245. //NtOpenKey 
  3246. hook_API_info[hook_num].nativeAPIname="NtOpenKey";
  3247. hook_API_info[hook_num].proxyfunadd=(ULONG)&HookNtOpenKey;
  3248. hook_API_info[hook_num].hooked=FALSE;
  3249. hook_num++; 
  3250. //NtCreateKey 
  3251. hook_API_info[hook_num].nativeAPIname="NtCreateKey";
  3252. hook_API_info[hook_num].proxyfunadd=(ULONG)&HookNtCreateKey;
  3253. hook_API_info[hook_num].hooked=FALSE;
  3254. hook_num++;
  3255. //NtQueryValueKey 
  3256. hook_API_info[hook_num].nativeAPIname="NtQueryValueKey";
  3257. hook_API_info[hook_num].proxyfunadd=(ULONG)&HookNtQueryValueKey;
  3258. hook_API_info[hook_num].hooked=FALSE;
  3259. hook_num++;
  3260. //NtQueryKey 
  3261. hook_API_info[hook_num].nativeAPIname="NtQueryKey";
  3262. hook_API_info[hook_num].proxyfunadd=(ULONG)&HookNtQueryKey;
  3263. hook_API_info[hook_num].hooked=FALSE;
  3264. hook_num++;
  3265. //NtDeleteKey 
  3266. hook_API_info[hook_num].nativeAPIname="NtDeleteKey";
  3267. hook_API_info[hook_num].proxyfunadd=(ULONG)&HookNtDeleteKey;
  3268. hook_API_info[hook_num].hooked=FALSE;
  3269. hook_num++;
  3270. //NtDeleteValueKey 
  3271. hook_API_info[hook_num].nativeAPIname="NtDeleteValueKey";
  3272. hook_API_info[hook_num].proxyfunadd=(ULONG)&HookNtDeleteValueKey;
  3273. hook_API_info[hook_num].hooked=FALSE;
  3274. hook_num++;
  3275. //NtSetValueKey 
  3276. hook_API_info[hook_num].nativeAPIname="NtSetValueKey";
  3277. hook_API_info[hook_num].proxyfunadd=(ULONG)&HookNtSetValueKey;
  3278. hook_API_info[hook_num].hooked=FALSE;
  3279. hook_num++;
  3280. //NtEnumerateKey 
  3281. hook_API_info[hook_num].nativeAPIname="NtEnumerateKey";
  3282. hook_API_info[hook_num].proxyfunadd=(ULONG)&HookNtEnumerateKey;
  3283. hook_API_info[hook_num].hooked=FALSE;
  3284. hook_num++;
  3285. //NtEnumerateValueKey 
  3286. hook_API_info[hook_num].nativeAPIname="NtEnumerateValueKey";
  3287. hook_API_info[hook_num].proxyfunadd=(ULONG)&HookNtEnumerateValueKey;
  3288. hook_API_info[hook_num].hooked=FALSE;
  3289. hook_num++;
  3290. //NtOpenFile 
  3291. hook_API_info[hook_num].nativeAPIname="NtOpenFile";
  3292. hook_API_info[hook_num].proxyfunadd=(ULONG)&HookNtOpenFile;
  3293. hook_API_info[hook_num].hooked=FALSE;
  3294. hook_num++;
  3295. //NtWriteFile 
  3296. hook_API_info[hook_num].nativeAPIname="NtWriteFile";
  3297. hook_API_info[hook_num].proxyfunadd=(ULONG)&HookNtWriteFile;
  3298. hook_API_info[hook_num].hooked=FALSE;
  3299. hook_num++;
  3300. //  //NtCreateFile 
  3301. //  hook_API_info[hook_num].nativeAPIname="NtCreateFile";
  3302. //  hook_API_info[hook_num].proxyfunadd=(ULONG)&HookNtCreateFile;
  3303. //  hook_API_info[hook_num].hooked=FALSE;
  3304. //  hook_num++;
  3305. //NtCreateProcess 
  3306. hook_API_info[hook_num].nativeAPIname="NtCreateProcess";
  3307. hook_API_info[hook_num].proxyfunadd=(ULONG)&HookNtCreateProcess;
  3308. hook_API_info[hook_num].hooked=FALSE;
  3309. hook_num++;
  3310. //NtCreateProcessEx 
  3311. hook_API_info[hook_num].nativeAPIname="NtCreateProcessEx";
  3312. hook_API_info[hook_num].proxyfunadd=(ULONG)&HookNtCreateProcessEx;
  3313. hook_API_info[hook_num].hooked=FALSE;
  3314. hook_num++;
  3315. //NtCreateSection 
  3316. hook_API_info[hook_num].nativeAPIname="NtCreateSection";
  3317. hook_API_info[hook_num].proxyfunadd=(ULONG)&HookNtCreateSection;
  3318. hook_API_info[hook_num].hooked=FALSE;
  3319. hook_num++;
  3320. //NtOpenThread 
  3321. hook_API_info[hook_num].nativeAPIname="NtOpenThread";
  3322. hook_API_info[hook_num].proxyfunadd=(ULONG)&HookNtOpenThread;
  3323. hook_API_info[hook_num].hooked=FALSE;
  3324. hook_num++;
  3325. //NtCreateThread 
  3326. hook_API_info[hook_num].nativeAPIname="NtCreateThread";
  3327. hook_API_info[hook_num].proxyfunadd=(ULONG)&HookNtCreateThread;
  3328. hook_API_info[hook_num].hooked=FALSE;
  3329. hook_num++;
  3330. //NtOpenProcess 
  3331. hook_API_info[hook_num].nativeAPIname="NtOpenProcess";
  3332. hook_API_info[hook_num].proxyfunadd=(ULONG)&HookNtOpenProcess;
  3333. hook_API_info[hook_num].hooked=FALSE;
  3334. hook_num++;
  3335. //NtOpenSection 
  3336. hook_API_info[hook_num].nativeAPIname="NtOpenSection";
  3337. hook_API_info[hook_num].proxyfunadd=(ULONG)&HookNtOpenSection;
  3338. hook_API_info[hook_num].hooked=FALSE;
  3339. hook_num++;
  3340. //NtCreateSymbolicLinkObject 
  3341. hook_API_info[hook_num].nativeAPIname="NtCreateSymbolicLinkObject";
  3342. hook_API_info[hook_num].proxyfunadd=(ULONG)&HookNtCreateSymbolicLinkObject;
  3343. hook_API_info[hook_num].hooked=FALSE;
  3344. hook_num++;
  3345. //NtSetSystemTime 
  3346. hook_API_info[hook_num].nativeAPIname="NtSetSystemTime";
  3347. hook_API_info[hook_num].proxyfunadd=(ULONG)&HookNtSetSystemTime;
  3348. hook_API_info[hook_num].hooked=FALSE;
  3349. hook_num++; 
  3351. return 0;
  3352. }