看流星社区

 找回密码
 注册账号
查看: 1560|回复: 0

x64通过PspCidTable遍历进程

[复制链接]

该用户从未签到

发表于 2017-6-1 12:52:08 | 显示全部楼层 |阅读模式
PspCidTable可以在PsLookupProcessByProcessId下寻找
我这硬编码了 只适用于win7 x64 其它版本需要自己改下特征码

  1. #include <ntddk.h>
  2. extern "C" NTKERNELAPI PVOID NTAPI  
  3. ObGetObjectType(  
  4.       IN PVOID pObject  
  5.       );
  6. extern "C" NTKERNELAPI UCHAR*
  7. PsGetProcessImageFileName(
  8.           IN PEPROCESS Process
  9.           );
  10. #define   MAX_ENTRY_COUNT (0x1000/16)  //一级表中的 HANDLE_TABLE_ENTRY个数
  11. #define   MAX_ADDR_COUNT   (0x1000/8) //二级表和 三级表中的地址个数
  12. ULONG g_ProcessCount = 0;
  13. typedef struct _EX_PUSH_LOCK                 // 7 elements, 0x8 bytes (sizeof)
  14. {                                                                              
  15.               union                                    // 3 elements, 0x8 bytes (sizeof)
  16.               {                                                                          
  17.                   struct                               // 5 elements, 0x8 bytes (sizeof)
  18.                   {                                                                     
  19. /*0x000*/             UINT64       Locked : 1;         // 0 BitPosition                  
  20. /*0x000*/             UINT64       Waiting : 1;        // 1 BitPosition                  
  21. /*0x000*/             UINT64       Waking : 1;         // 2 BitPosition                  
  22. /*0x000*/             UINT64       MultipleShared : 1; // 3 BitPosition                  
  23. /*0x000*/             UINT64       Shared : 60;        // 4 BitPosition                  
  24.                   };                                                                     
  25. /*0x000*/         UINT64       Value;                                                   
  26. /*0x000*/         VOID*        Ptr;                                                      
  27.               };                                                                        
  28. }EX_PUSH_LOCK, *PEX_PUSH_LOCK;                                                
  29.                
  30. typedef struct _HANDLE_TRACE_DB_ENTRY // 4 elements, 0xA0 bytes (sizeof)
  31.           {                                                                        
  32. /*0x000*/     struct _CLIENT_ID ClientId;       // 2 elements, 0x10 bytes (sizeof)
  33. /*0x010*/     VOID*        Handle;                                                
  34. /*0x018*/     ULONG32      Type;                                                   
  35. /*0x01C*/     UINT8        _PADDING0_[0x4];                                       
  36. /*0x020*/     VOID*        StackTrace[16];                                         
  37. }HANDLE_TRACE_DB_ENTRY, *PHANDLE_TRACE_DB_ENTRY;                                   
  38.                                                                                    
  39. typedef struct _HANDLE_TRACE_DEBUG_INFO       // 6 elements, 0xF0 bytes (sizeof)
  40. {                                                                                
  41. /*0x000*/     LONG32       RefCount;                                                      
  42. /*0x004*/     ULONG32      TableSize;                                                      
  43. /*0x008*/     ULONG32      BitMaskFlags;                                                   
  44. /*0x00C*/     UINT8        _PADDING0_[0x4];                                                
  45. /*0x010*/     struct _FAST_MUTEX CloseCompactionLock;   // 5 elements, 0x38 bytes (sizeof)
  46. /*0x048*/     ULONG32      CurrentStackIndex;                                             
  47. /*0x04C*/     UINT8        _PADDING1_[0x4];                                                
  48. /*0x050*/     struct _HANDLE_TRACE_DB_ENTRY TraceDb[];                                    
  49. }HANDLE_TRACE_DEBUG_INFO, *PHANDLE_TRACE_DEBUG_INFO;                                   
  50.                                                                                           
  51. typedef struct _HANDLE_TABLE_ENTRY                  // 8 elements, 0x10 bytes (sizeof)
  52. {                                                                                      
  53.               union                                           // 4 elements, 0x8 bytes (sizeof)  
  54.               {                                                                                 
  55. /*0x000*/         VOID*        Object;                                                           
  56. /*0x000*/         ULONG32      ObAttributes;                                                     
  57. /*0x000*/         struct _HANDLE_TABLE_ENTRY_INFO* InfoTable;                                    
  58. /*0x000*/         UINT64       Value;                                                            
  59.               };                                                                                 
  60.               union                                           // 3 elements, 0x8 bytes (sizeof)  
  61.               {                                                                                 
  62. /*0x008*/         ULONG32      GrantedAccess;                                                   
  63.                   struct                                      // 2 elements, 0x8 bytes (sizeof)  
  64.                   {                                                                              
  65. /*0x008*/             UINT16       GrantedAccessIndex;                                          
  66. /*0x00A*/             UINT16       CreatorBackTraceIndex;                                       
  67. /*0x00C*/             UINT8        _PADDING0_[0x4];                                             
  68.                   };                                                                             
  69. /*0x008*/         ULONG32      NextFreeTableEntry;                                               
  70.               };                                                                                 
  71. }HANDLE_TABLE_ENTRY, *PHANDLE_TABLE_ENTRY;                                             
  72.                                                                                                 
  73. typedef struct _HANDLE_TABLE
  74. {
  75.         ULONG64 TableCode;
  76.         PEPROCESS QuotaProcess;
  77.         PVOID UniqueProcessId;
  78.         EX_PUSH_LOCK HandleLock;
  79.         LIST_ENTRY HandleTableList;
  80.         EX_PUSH_LOCK HandleContentionEvent;
  81.         PHANDLE_TRACE_DEBUG_INFO DebugInfo;
  82.         LONG ExtraInfoPages;
  83.         ULONG Flags;
  84.         //ULONG StrictFIFO : 1;
  85.         LONG64 FirstFreeHandle;
  86.         PHANDLE_TABLE_ENTRY LastFreeHandleEntry;
  87.         LONG HandleCount;
  88.         ULONG NextHandleNeedingPool;
  89. } HANDLE_TABLE, *PHANDLE_TABLE;
  90. typedef BOOLEAN (*MY_ENUMERATE_HANDLE_ROUTINE)(
  91.         IN PHANDLE_TABLE_ENTRY HandleTableEntry,
  92.         IN HANDLE Handle,
  93.         IN PVOID EnumParameter);
  94. SIZE_T FindCidTable()
  95. {
  96.         SIZE_T  CidTableAddr = 0;
  97.         UNICODE_STRING ustPsFuncName;
  98.         RtlInitUnicodeString(&ustPsFuncName, L"PsLookupProcessByProcessId");
  99.         PUCHAR startAddr = (PUCHAR)MmGetSystemRoutineAddress(&ustPsFuncName);
  100.         for (ULONG64 i = 0; i < 100; i++)
  101.         {
  102.                 if (*(startAddr + i) == 0x48 &&
  103.                 *(startAddr + i + 1) == 0x8b &&
  104.                 *(startAddr + i + 2) == 0x0d)
  105.                 {
  106.                         CidTableAddr = (SIZE_T)(*(PULONG)(startAddr + i + 3) + (startAddr + i + 3 + 4)) & 0xFFFFFFFEFFFFFFFF;
  107.                         DbgPrint("CidTableAddr:%p\n", CidTableAddr);
  108.                         break;
  109.                 }
  110.         }
  111.         return CidTableAddr;
  112. }
  113. BOOLEAN MyEnumerateHandleRoutine(
  114. IN PHANDLE_TABLE_ENTRY HandleTableEntry,
  115. IN HANDLE Handle,
  116. IN PVOID EnumParameter
  117. )
  118. {
  119.         BOOLEAN Result = FALSE;
  120.         ULONG64 ProcessObject;
  121.         POBJECT_TYPE ObjectType;
  122.         PVOID Object;
  123.         UNICODE_STRING ustObjectName;
  124.         UNREFERENCED_PARAMETER(EnumParameter);
  125.         UNREFERENCED_PARAMETER(ustObjectName);
  126.         ProcessObject = (HandleTableEntry->Value)&~7; //掩去低三位
  127.         Object = (PVOID)((ULONG64)HandleTableEntry->Object&~7);
  128.         ObjectType = (POBJECT_TYPE)ObGetObjectType(Object);
  129.         if (MmIsAddressValid(HandleTableEntry))
  130.         {
  131.                 if (ObjectType == *PsProcessType)//判断是否为Process
  132.                 {
  133.                         //注意PID其实就是Handle,而 不是从EPROCESS中取,可以对付伪pid
  134.                         g_ProcessCount++;
  135.                         DbgPrint("PID=%4d\t EPROCESS=0x%p %s\n", Handle, ProcessObject, PsGetProcessImageFileName((PEPROCESS)ProcessObject));
  136.                 }
  137.         }
  138.         return Result;//返回FALSE继续
  139. }
  140. //自己实现一个山寨的MyEnumHandleTable,接口和ExEnumHandleTable一样
  141. BOOLEAN
  142. MyEnumHandleTable(
  143.         PHANDLE_TABLE HandleTable,
  144.         MY_ENUMERATE_HANDLE_ROUTINE EnumHandleProcedure,
  145.         PVOID EnumParameter,
  146.         PHANDLE Handle
  147. )
  148. {
  149.         ULONG64 i, j, k;
  150.         ULONG_PTR CapturedTable;
  151.         ULONG64 TableLevel;
  152.         PHANDLE_TABLE_ENTRY TableLevel1, *TableLevel2, **TableLevel3;
  153.         BOOLEAN CallBackRetned = FALSE;
  154.         BOOLEAN ResultValue = FALSE;
  155.         ULONG64 MaxHandle;
  156.         //判断几个参数是否有效
  157.         if (!HandleTable
  158.         && !EnumHandleProcedure
  159.         && !MmIsAddressValid(Handle))
  160.         {
  161.                 return ResultValue;
  162.         }
  163.         //取表基址和表的级数
  164.         CapturedTable = (HandleTable->TableCode)&~3;
  165.         TableLevel = (HandleTable->TableCode) & 3;
  166.         MaxHandle = HandleTable->NextHandleNeedingPool;
  167.         DbgPrint("句柄上限值为0x%X\n", MaxHandle);
  168.         //判断表的等级
  169.         switch (TableLevel)
  170.         {
  171.                 case 0:
  172.                         {
  173.                           //一级表
  174.                           TableLevel1 = (PHANDLE_TABLE_ENTRY)CapturedTable;
  175.                           DbgPrint("解析一级表 0x%p...\n", TableLevel1);
  176.                           for (i = 0; i < MAX_ENTRY_COUNT; i++)
  177.                           {
  178.                                   *Handle = (HANDLE)(i * 4);
  179.                                   if (TableLevel1[i].Object && MmIsAddressValid(TableLevel1[i].Object))
  180.                                   {
  181.                                           //对象有效时,再调用回调函数
  182.                                           CallBackRetned = EnumHandleProcedure(&TableLevel1[i], *Handle, EnumParameter);
  183.                                           if (CallBackRetned)  break;
  184.                                   }
  185.                           }
  186.                           ResultValue = TRUE;
  187.                         }
  188.                                 break;
  189.                 case 1:
  190.                         {
  191.                           //二级表
  192.                           TableLevel2 = (PHANDLE_TABLE_ENTRY*)CapturedTable;
  193.                           DbgPrint("解析二级表 0x%p...\n", TableLevel2);
  194.                           DbgPrint("二级表的个 数:%d\n", MaxHandle / (MAX_ENTRY_COUNT*4));
  195.                           for (j = 0; j < MaxHandle / (MAX_ENTRY_COUNT * 4); j++)
  196.                           {
  197.                                   TableLevel1 = TableLevel2[j];
  198.                                   if (!TableLevel1)
  199.                                         break; //为零则跳出
  200.                                   for (i = 0; i < MAX_ENTRY_COUNT; i++)
  201.                                   {
  202.                                           *Handle = (HANDLE)(j*MAX_ENTRY_COUNT * 4 + i * 4);
  203.                                           if (TableLevel1[i].Object && MmIsAddressValid(TableLevel1[i].Object))
  204.                                           {
  205.                                                   //对象有效时,再调用回调函数
  206.                                                   CallBackRetned = EnumHandleProcedure(&TableLevel1[i], *Handle, EnumParameter);
  207.                                                   if (CallBackRetned)  break;
  208.                                           }
  209.                                   }
  210.                           }
  211.                           ResultValue = TRUE;
  212.                         }
  213.                                 break;
  214.                 case 2:
  215.                 {
  216.                   //三级表
  217.                   TableLevel3 = (PHANDLE_TABLE_ENTRY**)CapturedTable;
  218.                   DbgPrint("解析三级表 0x%p...\n", TableLevel3);
  219.                   DbgPrint("三级表的个 数:%d\n", MaxHandle / (MAX_ENTRY_COUNT * 4 * MAX_ADDR_COUNT));
  220.                   for (k = 0; k < MaxHandle / (MAX_ENTRY_COUNT * 4 * MAX_ADDR_COUNT); k++)
  221.                   {
  222.                           TableLevel2 = TableLevel3[k];
  223.                           if (!TableLevel2)
  224.                           break; //为零则跳出
  225.                           for (j = 0; j < MaxHandle / (MAX_ENTRY_COUNT * 4); j++)
  226.                           {
  227.                                   TableLevel1 = TableLevel2[j];
  228.                                   if (!TableLevel1)
  229.                                         break; //为零则跳出
  230.                                   for (i = 0; i < MAX_ENTRY_COUNT; i++)
  231.                                   {
  232.                                           *Handle = (HANDLE)(k*MAX_ENTRY_COUNT*MAX_ADDR_COUNT + j*MAX_ENTRY_COUNT + i * 4);
  233.                                           if (TableLevel1[i].Object && MmIsAddressValid(TableLevel1[i].Object))
  234.                                           {
  235.                                                   //对象有效时,再调用回调函数
  236.                                                   CallBackRetned = EnumHandleProcedure(&TableLevel1[i], *Handle, EnumParameter);
  237.                                                   if (CallBackRetned)  break;
  238.                                           }
  239.                                   }
  240.                           }
  241.                   }
  242.                   ResultValue = TRUE;
  243.                 }
  244.                                 break;
  245.                 default:
  246.                 {
  247.                    DbgPrint("BOOM!\n");
  248.                 }
  249.                 break;
  250.         }
  251.         DbgPrint("ProcessCount:0x%x",g_ProcessCount);
  252.         return ResultValue;
  253. }
  254. void EnumProcessByPspCidTable()
  255. {
  256.         PHANDLE_TABLE pHandleTable = NULL;
  257.         pHandleTable =(PHANDLE_TABLE)*(PSIZE_T)FindCidTable();
  258.         HANDLE hHanel;
  259.         UNICODE_STRING usObGetObjectType;
  260.         DbgPrint("pHandleTable:%p\n", pHandleTable);
  261.         MyEnumHandleTable(pHandleTable, MyEnumerateHandleRoutine, NULL, &hHanel);
  262. }
  263. void DriverUnload(PDRIVER_OBJECT pDriverObject)
  264. {
  265.         UNREFERENCED_PARAMETER(pDriverObject);
  266.         DbgPrint("GoodBye!\n");
  267. }
  268. extern "C" NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObject,PUNICODE_STRING pRegPath)
  269. {
  270.         UNREFERENCED_PARAMETER(pRegPath);
  271.        
  272.         pDriverObject->DriverUnload = DriverUnload;
  273.         DbgPrint("DriverEntry!\n");
  274.         EnumProcessByPspCidTable();
  275.         return STATUS_SUCCESS;
  276. }
复制代码
点击按钮快速添加回复内容: 支持 高兴 激动 给力 加油 苦寻 生气 回帖 路过 感恩
您需要登录后才可以回帖 登录 | 注册账号

本版积分规则

小黑屋|手机版|Archiver|看流星社区 |网站地图

GMT+8, 2024-3-19 16:44

Powered by Kanliuxing X3.4

© 2010-2019 kanliuxing.com

快速回复 返回顶部 返回列表