设为首页收藏本站
开启辅助访问 切换到宽版

看流星社区

 找回密码
 注册账号
看流星社区»看流星社区 › » 【编程技术】 › 驱动开发技术 › X64环境遍历32位进程的模块驱动代码
返回列表 发新帖
查看: 3280|回复: 0

X64环境遍历32位进程的模块驱动代码

[复制链接]
zy530900999

该用户从未签到
发表于 2018-2-28 11:20:32 | 显示全部楼层 |阅读模式
  1. typedef struct _PEB_LDR_DATA
  2. {
  3.         ULONG Length;
  4.         ULONG Initialized;
  5.         PVOID64 SsHandle;
  6.         LIST_ENTRY InLoadOrderModuleList;
  7.         LIST_ENTRY InMemoryOrderModuleList;
  8.         LIST_ENTRY InInitializationOrderModuleList;
  9.         PVOID64 EntryInProgress;
  10.         ULONG64 ShutdownInProgress;
  11.         PVOID64 ShutdownThreadId;
  12. }PEB_LDR_DATA, *PPEB_LDR_DATA;

  14. typedef struct _LDR_DATA_TABLE_ENTRY {
  15.         LIST_ENTRY64 InLoadOrderLinks;
  16.         LIST_ENTRY64 InMemoryOrderLinks;
  17.         LIST_ENTRY64 InInitializationOrderLinks;
  18.         PVOID64 DllBase;
  19.         PVOID64 EntryPoint;
  20.         ULONG64 SizeOfImage;
  21.         UNICODE_STRING64 FullDllName;
  22.         UNICODE_STRING64 BaseDllName;
  23.         ULONG Flags;
  24.         USHORT LoadCount;
  25.         USHORT TlsIndex;
  26.         union {
  27.                 LIST_ENTRY64 HashLinks;
  28.                 struct {
  29.                         PVOID64 SectionPointer;
  30.                         ULONG64 CheckSum;
  31.                 };
  32.         };
  33.         union {
  34.                 struct {
  35.                         ULONG TimeDateStamp;
  36.                 };
  37.                 struct {
  38.                         PVOID64 LoadedImports;
  39.                 };
  40.         };
  41.         ULONG64 * EntryPointActivationContext;
  42.         PVOID64 PatchInformation;
  43.         LIST_ENTRY64 ForwarderLinks;
  44.         LIST_ENTRY64 ServiceTagLinks;
  45.         LIST_ENTRY64 StaticLinks;
  46. } LDR_DATA_TABLE_ENTRY, *PLDR_DATA_TABLE_ENTRY;
复制代码

  1. //枚举进程并返回进程对象
  2. PEPROCESS EnumProcessALL(char *ProcessName)//通过进程对象的对向链表遍历进程，缺点是进程名只能取十五个非中文字符
  3. {
  4.         CHAR TProcessName[32] = { 0 };
  5.         CHAR CProcessName[16] = { 0 };
  6.         RtlZeroMemory(TProcessName, 32);
  7.         memcpy(TProcessName, ProcessName, strlen(ProcessName));//一般传进来的进程名不超过32个字符
  8.         _strupr(TProcessName); //转换成大写

  10.         PEPROCESS process;
  11.         PLIST_ENTRY64 plist, plist1;
  12.         process = PsGetCurrentProcess();
  13.         plist1 = plist = *(PULONG64)((ULONG64)process + 0x188);

  15.         do
  16.         {
  17.                 process = (ULONG64)plist1 - 0x188;
  18.                 RtlZeroMemory(CProcessName, 16);
  19.                 memcpy(CProcessName, (char*)process + 0x2e0, 16);//一般传进来的进程名不超过32个字符
  20.                 _strupr(CProcessName);
  21.                 if (strstr(CProcessName, TProcessName) != 0 && *(ULONG64*)((ULONG64)process + 0x200)!=0)//句柄表中有值才是活的进程，句柄表中无值是同名的死进程
  22.                 {
  23.                         return process;
  24.                 }
  25.             //进程对象从链表中摘除
  26.             //((PLIST_ENTRY64)(plist1->Flink))->Blink = plist1->Blink;//让前一个节点的后指针指向我的后一个节点,抹hashlinks
  27.                 //((PLIST_ENTRY64)(plist1->Blink))->Flink = plist1->Flink;//让后一个节点的前指针指向我的前一个节点
  28.                 //64位KdPrint 输出十进制用%ld，输出十六进制%p
  29.                 //KdPrint(("count %ld -- process name is %15s --process id is %ld\n", count, (char*)process + 0x2e0, *(ULONG64*)((ULONG64)process + 0x180)));
  30.                 plist1 = plist1->Blink;
  31.         } while (plist1 != plist);
  32.         return 0;
  33. }
复制代码
  1. WCHAR removeName[256] = { 0 };
  2. PEPROCESS pebprocess=0;
  3. VOID HideDLLByPEBandNThash()//遍历进程用户层模块by PEB
  4. {
  5.         pebprocess = EnumProcessALL("dnf");
  6.         if (pebprocess == NULL)
  7.         {
  8.                 KdPrint(("dnf process is null \n"));
  9.                 return;
  10.         }
  11.         PPEB processPEB=0;
  12.         PPEB_LDR_DATA  pldr_data, pldr_dataT;
  13.         LIST_ENTRY InLoadOrderModuleList;
  14.         LIST_ENTRY InMemoryOrderModuleList;
  15.         LIST_ENTRY InInitializationOrderModuleList;
  16.         PLIST_ENTRY plistLDR, plistLDR1;
  17.         PLDR_DATA_TABLE_ENTRY ldr_table_entry;
  18.         UNICODE_STRING KeattachProce;
  19.         UNICODE_STRING KeDetachProce;
  20.         PIMAGE_DOS_HEADER pimage_dos_header;
  21.         PIMAGE_NT_HEADERS pimage_nt_header;

  23.         MyKeAttachProcess((PKPROCESS)pebprocess);//附加到我们要摘链的用户层进程
  24.         processPEB = *(ULONG64*)((ULONG64)pebprocess + 0x338);//取得PEB
  25.         if (processPEB==0)
  26.         {
  27.                 KdPrint(("peb is null \n"));
  28.                 MyKeDetachProcess(pebprocess);
  29.                 return;
  30.         }
  31.         KdPrint(("X64peb is %x\n", processPEB));
  32.         pldr_data = *(ULONG64*)((ULONG64)processPEB + 0x18);//取得_PEB_LDR_DATA
  33.         InLoadOrderModuleList = pldr_data->InLoadOrderModuleList;//从_PEB_LDR_DATA取得按加载顺序组织的模块链表
  34.         InMemoryOrderModuleList = pldr_data->InMemoryOrderModuleList;//从_PEB_LDR_DATA取得按内存顺序组织的模块链表
  35.         InInitializationOrderModuleList = pldr_data->InInitializationOrderModuleList;
  36.         /**********先处理x64NT模块中的那份HASH表，此表里面保存的是进程所有已加载模块******/
  37.         PLIST_ENTRY pNThash, pnt;
  38.         PLDR_DATA_TABLE_ENTRY pNTHashTalbeList;
  39.         plistLDR = InLoadOrderModuleList.Blink;
  40.         plistLDR1 = plistLDR;
  41.         do
  42.         {
  43.                 ldr_table_entry = plistLDR;
  44.                 memset(removeName, 0, 256 * 2);
  45.                 RtlCopyMemory(removeName, ldr_table_entry->FullDllName.Buffer, ldr_table_entry->FullDllName.Length);
  46.                 _wcsupr(removeName);
  47.                 if (wcsstr(removeName, L"NTDLL") != 0 )//通过PEB遍历模块,如果找到NT模块就处理里面的HASHTABLE
  48.                 {
  49.                         //64位WIN7环境下syswow64目录下的NT模块基址加偏移0x13A940就是那份HASH数组的地址
  50.                         pNThash = (PLIST_ENTRY)((ULONG64)ldr_table_entry->DllBase + 0x13A940);//在NTDLL里搜字符串LdrpHashTable可以定位此数组地址
  51.                         KdPrint(("X64NT base is %p--hashtable is %p\n", ldr_table_entry->DllBase, pNThash));
  52.                         //nt模块里的HASHtable是个数组，该数组有32个成员,每个成员是LIST_ENTRY,
  53.                         //每个(LIST_ENTRY)双向链表维护了一组哈希值相同的模块
  54.                         //每个进程中的NT基址是相同的,但是这个hashtalbe是和进程相关的,
  55.                         //也就是说每一个进程有一份独立的hashtalbe
  56.                         for (ULONG64 i = 0; i < 32; i++, pNThash++)
  57.                         {
  58.                                 //如果数组中某个(LIST_ENTRY)双向链表成员是空,那么该元素的Blink和Flink的值就是LIST_ENTRY的地址
  59.                                 if (pNThash->Blink != pNThash)
  60.                                 {
  61.                                         pnt = pNThash->Blink;
  62.                                         do
  63.                                         {
  64.                                                 pNTHashTalbeList = (ULONG64)pnt - 0x70;//X64 WIN7环境下hashlinks在_LDR_DATA_TABLE_ENTRY中的偏移是0x70
  65.                                                 //memset(removeName, 0, 256 * 2);
  66.                                                 if (MmIsAddressValid(pNTHashTalbeList->FullDllName.Buffer))
  67.                                                 {
  68.                                                         //RtlCopyMemory(removeName, pNTHashTalbeList->FullDllName.Buffer, pNTHashTalbeList->FullDllName.Length);
  69.                                                         //_wcsupr(removeName);
  70.                                                         //if (wcsstr(removeName, L"AACD") != 0 || wcsstr(removeName, L"ABCD") != 0 || wcsstr(removeName, L"ACCD") != 0)
  71.                                                         //{
  72.                                                         //        KdPrint(("find AACD IN NTDLL HASHTABLE AND REMOVE\n"));
  73.                                                         //        //pnt->Flink->Blink = pnt->Blink;//让前一个节点的后指针指向我的后一个节点,抹hashlinks
  74.                                                         //        //pnt->Blink->Flink = pnt->Flink;//让后一个节点的前指针指向我的前一个节点
  75.                                                         //}
  76.                                                         KdPrint(("X64nt hash index %d--dll base is %x  -size %x--name %wZ\n", i, pNTHashTalbeList->DllBase, pNTHashTalbeList->SizeOfImage, &pNTHashTalbeList->FullDllName));
  77.                                                 }
  78.                                                 pnt = pnt->Blink;
  79.                                         } while (pnt != pNThash);//如果某个成员有值就循环遍历
  80.                                 }
  81.                         }
  82.                         break;
  83.                 }
  84.                 plistLDR = plistLDR->Blink;
  85.         } while (plistLDR != plistLDR1);

  87.         /*****************遍历x64PEB LDR第一个链表并将指定模块摘链******************************/
  88.         plistLDR = InLoadOrderModuleList.Blink;
  89.         plistLDR1 = plistLDR;
  90.         ULONG64 count = 0;
  91.         do
  92.         {
  93.                 count = count + 1;
  94.                 ldr_table_entry = plistLDR;
  95.                 //memset(removeName, 0, 256 * 2);
  96.                 //RtlCopyMemory(removeName, ldr_table_entry->BaseDllName.Buffer, ldr_table_entry->BaseDllName.Length);
  97.                 //_wcsupr(removeName);
  98.                 //if (wcsstr(removeName, L"AACD") != 0 || wcsstr(removeName, L"ABCD") != 0 || wcsstr(removeName, L"ACCD") != 0)//如果是我们要摘链的模块就进行摘链
  99.                 //{
  100.                 //        KdPrint(("find and remove"));
  101.                 //        pimage_dos_header = ldr_table_entry->DllBase;
  102.                 //        KdPrint(("e_magic is %s\n", &pimage_dos_header->e_magic));
  103.                 //        PageProtectOff();
  104.                 //        //pimage_dos_header->e_magic= "0x1234";
  105.                 //        pimage_nt_header = pimage_dos_header->e_lfanew + (ULONG64)ldr_table_entry->DllBase;
  106.                 //        ULONG64 sizeheader = pimage_nt_header->OptionalHeader.SizeOfHeaders;
  107.                 //        KdPrint(("size of header is %d\n", sizeheader));
  108.                 //        memset(pimage_dos_header, 0, sizeheader);//整个PE头全部清零
  109.                 //        //pimage_nt_header->Signature = "0x87654321";
  110.                 //        PageProtectOn();
  111.                 //        plistLDR->Flink->Blink = plistLDR->Blink;//让前一个节点的后指针指向我的后一个节点
  112.                 //        plistLDR->Blink->Flink = plistLDR->Flink;//让后一个节点的前指针指向我的前一个节点
  113.                 //        break;
  114.                 //}
  115.                 KdPrint(("X64 LDR one index %d--base is %x--size %x--file name is %wZ\n",count, ldr_table_entry->DllBase, ldr_table_entry->SizeOfImage, &ldr_table_entry->FullDllName));
  116.                 plistLDR = plistLDR->Blink;
  117.         } while (plistLDR != plistLDR1);
  118.         /*****************遍历x64PEB LDR第二个链表并将指定模块摘链***************************/
  119.         plistLDR = InMemoryOrderModuleList.Blink;
  120.         plistLDR1 = plistLDR;
  121.         count = 0;
  122.         do
  123.         {
  124.                 count = count + 1;
  125.                 ldr_table_entry = (ULONG64)plistLDR - 0x10;
  126.                 //memset(removeName, 0, 128 * 2);
  127.                 //RtlCopyMemory(removeName, ldr_table_entry->BaseDllName.Buffer, ldr_table_entry->BaseDllName.Length);
  128.                 //_wcsupr(removeName);
  129.                 //if (wcsstr(removeName, L"AACD") != 0 || wcsstr(removeName, L"ABCD") != 0 || wcsstr(removeName, L"ACCD") != 0)//如果是我们要摘链的模块就进行摘链
  130.                 //{
  131.                 //        KdPrint(("find and remove"));
  132.                 //        plistLDR->Flink->Blink = plistLDR->Blink;//让前一个节点的后指针指向我的后一个节点
  133.                 //        plistLDR->Blink->Flink = plistLDR->Flink;//让后一个节点的前指针指向我的前一个节点
  134.                 //        break;
  135.                 //}
  136.                 KdPrint(("X64 LDR two index %d--base is %x--size %x--file name is %wZ\n", count, ldr_table_entry->DllBase, ldr_table_entry->SizeOfImage, &ldr_table_entry->FullDllName));
  137.                 plistLDR = plistLDR->Blink;
  138.         } while (plistLDR1 != plistLDR);
  139.         /*****************遍历x64PEB LDR第三个链表并将指定模块摘链***************************/
  140.         plistLDR = InInitializationOrderModuleList.Blink;
  141.         plistLDR1 = plistLDR;
  142.         count = 0;
  143.         do
  144.         {
  145.                 count = count + 1;
  146.                 ldr_table_entry = (ULONG64)plistLDR - 0x20;
  147.                 //memset(removeName, 0, 128 * 2);
  148.                 //RtlCopyMemory(removeName, ldr_table_entry->BaseDllName.Buffer, ldr_table_entry->BaseDllName.Length);
  149.                 //_wcsupr(removeName);
  150.                 //if (wcsstr(removeName, L"AACD") != 0 || wcsstr(removeName, L"ABCD") != 0 || wcsstr(removeName, L"ACCD") != 0)//如果是我们要摘链的模块就进行摘链
  151.                 //{
  152.                 //        KdPrint(("find and remove"));
  153.                 //        plistLDR->Flink->Blink = plistLDR->Blink;//让前一个节点的后指针指向我的后一个节点
  154.                 //        plistLDR->Blink->Flink = plistLDR->Flink;//让后一个节点的前指针指向我的前一个节点
  155.                 //        break;
  156.                 //}
  157.                 KdPrint(("X64 LDR  three index %d--base is %x--size %x--file name is %wZ\n", count, ldr_table_entry->DllBase, ldr_table_entry->SizeOfImage, &ldr_table_entry->FullDllName));
  158.                 plistLDR = plistLDR->Blink;
  159.         } while (plistLDR1 != plistLDR);
  160.         /*****************x64PEB三个链表指定模块摘链完毕***************************/

  162.         //////开始遍历x64环境中的 PEB32三个链表中的模块，X64平台中的32位程序有两个PEB，一个里面保存了X64模块，一个里面保存了X86模块
  163.         ULONG processPEB32=0;
  164.         PPEB_LDR_DATA32  pldr_data32, pldr_dataT32;
  165.         LIST_ENTRY32 InLoadOrderModuleList32;
  166.         LIST_ENTRY32 InMemoryOrderModuleList32;
  167.         LIST_ENTRY32 InInitializationOrderModuleList32;
  168.         PLIST_ENTRY32 plistLDR32, plistLDR132;
  169.         PLDR_DATA_TABLE_ENTRY32 ldr_table_entry32;

  171.         processPEB32 = *(ULONG*)((ULONG64)pebprocess + 0x320);//取得PEB32 //process是ulong64类型
  172.         if (processPEB32==0)
  173.         {
  174.                 KdPrint(("processPEB32 if null \n"));
  175.                 MyKeDetachProcess(pebprocess);
  176.                 return;
  177.         }
  178.         KdPrint(("wow64peb is %x\n", processPEB32));
  179.         pldr_data32 = *(ULONG*)((ULONG)processPEB32 + 0xc);//取得_PEB_LDR_DATA
  180.         InLoadOrderModuleList32 = pldr_data32->InLoadOrderModuleList;//从_PEB_LDR_DATA取得按加载顺序组织的模块链表
  181.         InMemoryOrderModuleList32 = pldr_data32->InMemoryOrderModuleList;//从_PEB_LDR_DATA取得按内存顺序组织的模块链表
  182.         InInitializationOrderModuleList32 = pldr_data32->InInitializationOrderModuleList;
  183.         /**********先处理x64NT32模块中的那份HASH表，此表里面保存的是进程所有已加载的32位模块******/
  184.         PLIST_ENTRY32 pNThash32, pnt32;
  185.         PLDR_DATA_TABLE_ENTRY32 pNTHashTalbeList32;
  186.         plistLDR32 = InLoadOrderModuleList32.Blink;
  187.         plistLDR132 = plistLDR32;
  188.         do
  189.         {
  190.                 ldr_table_entry32 = plistLDR32;
  191.                 memset(removeName, 0, 256 * 2);
  192.                 RtlCopyMemory(removeName, ldr_table_entry32->FullDllName.Buffer, ldr_table_entry32->FullDllName.Length);
  193.                 _wcsupr(removeName);
  194.                 if (wcsstr(removeName, L"NTDLL") != 0)//通过PEB遍历模块,如果找到NT模块就处理里面的HASHTABLE
  195.                 {
  196.                         //64位WIN7环境下syswow64目录下的NT模块基址加偏移0x104800就是那份HASH数组的地址
  197.                         pNThash32 = (PLIST_ENTRY32)((ULONG)ldr_table_entry32->DllBase + 0x104800);//在NTDLL里搜字符串LdrpHashTable可以定位此数组地址
  198.                         KdPrint(("NT base is %x--hashtable is %x\n", ldr_table_entry32->DllBase, pNThash32));
  199.                         //nt模块里的HASHtable是个数组，该数组有32个成员,每个成员是LIST_ENTRY,
  200.                         //每个(LIST_ENTRY)双向链表维护了一组哈希值相同的模块
  201.                         //每个进程中的NT基址是相同的,但是这个hashtalbe是和进程相关的,
  202.                         //也就是说每一个进程有一份独立的hashtalbe
  203.                         for (ULONG i = 0; i < 32; i++, pNThash32++)
  204.                         {
  205.                                 //如果数组中某个(LIST_ENTRY)双向链表成员是空,那么该元素的Blink和Flink的值就是LIST_ENTRY的地址
  206.                                 if (pNThash32->Blink != pNThash32)
  207.                                 {
  208.                                         pnt32 = pNThash32->Blink;
  209.                                         do
  210.                                         {
  211.                                                 pNTHashTalbeList32 = (ULONG)pnt32 - 0x3C;
  212.                                                 if (MmIsAddressValid(pNTHashTalbeList32->FullDllName.Buffer))
  213.                                                 {
  214.                                                         KdPrint(("wow64 nt hush index %d--dll base is %x -size %x --name %S\n", i, pNTHashTalbeList32->DllBase, pNTHashTalbeList32->SizeOfImage,pNTHashTalbeList32->FullDllName.Buffer));
  215.                                                 }
  216.                                                 pnt32 = pnt32->Blink;
  217.                                         } while (pnt32 != pNThash32);//如果某个成员有值就循环遍历
  218.                                 }
  219.                         }
  220.                         break;
  221.                 }
  222.                 plistLDR32 = plistLDR32->Blink;
  223.         } while (plistLDR32 != plistLDR132);

  225.         /*****************遍历x64 PEB32 LDR第一个链表并将指定模块摘链******************************/
  226.         plistLDR32 = InLoadOrderModuleList32.Blink;
  227.         plistLDR132 = plistLDR32;
  228.     count = 0;
  229.         do
  230.         {
  231.                 count = count + 1;
  232.                 ldr_table_entry32 = plistLDR32;
  233.                 KdPrint(("wow64 LDR one index %d--base is %x--size %x--file name is %ws\n", count, ldr_table_entry32->DllBase, ldr_table_entry32->SizeOfImage, ldr_table_entry32->FullDllName.Buffer));
  234.                 plistLDR32 = plistLDR32->Blink;
  235.         } while (plistLDR32 != plistLDR132);
  236.         /*****************遍历x64 PEB32 LDR第二个链表并将指定模块摘链***************************/
  237.         plistLDR32 = InMemoryOrderModuleList32.Blink;
  238.         plistLDR132 = plistLDR32;
  239.         count = 0;
  240.         do
  241.         {
  242.                 count = count + 1;
  243.                 ldr_table_entry32 = (ULONG)plistLDR32 - 8;
  244.                 KdPrint(("wow64 LDR two index %d--base is %x--size %x--file name is %S\n", count, ldr_table_entry32->DllBase, ldr_table_entry32->SizeOfImage, ldr_table_entry32->FullDllName.Buffer));
  245.                 plistLDR32 = plistLDR32->Blink;
  246.         } while (plistLDR132 != plistLDR32);
  247.         /*****************遍历x64 PEB32 LDR第三个链表并将指定模块摘链***************************/
  248.         plistLDR32 = InInitializationOrderModuleList32.Blink;
  249.         plistLDR132 = plistLDR32;
  250.         count = 0;
  251.         do
  252.         {
  253.                 count = count + 1;
  254.                 ldr_table_entry32 = (ULONG)plistLDR32 - 0x10;
  255.                 KdPrint(("wow64 LDR three index %d--base is %x--size %x--file name is %ws\n", count, ldr_table_entry32->DllBase, ldr_table_entry32->SizeOfImage, ldr_table_entry32->FullDllName.Buffer));
  256.                 plistLDR32 = plistLDR32->Blink;
  257.         } while (plistLDR132 != plistLDR32);
  258.         MyKeDetachProcess(pebprocess);
  259. }
复制代码

回复

举报

返回列表 发新帖
点击按钮快速添加回复内容: 支持 高兴 激动 给力 加油 苦寻 生气 回帖 路过 感恩
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册账号

本版积分规则

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

GMT+8, 2024-4-23 20:33

Powered by Kanliuxing X3.4

© 2010-2019 kanliuxing.com

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