天马阁

 找回密码
 立即注册
                                        →→→→→→→→→→→→ 1点击查看所有VIP教程目录长列表(总教程数269个) 2办理VIP详情进入 ←←←←←←←←←←←←
1 x64CE与x64dbg入门基础教程 7课 已完结 2 x64汇编语言基础教程 16课 已完结 3 x64辅助入门基础教程 9课 已完结 4 C++x64内存辅助实战技术教程 149课 已完结
5 C++x64内存检测与过检测技术教程 10课 已完结 6 C+x64二叉树分析遍历与LUA自动登陆教程 19课已完结 7 C++BT功能原理与x64实战教程 29课 已完结 8 C+FPS框透视与自瞄x64实现原理及防护思路 30课完结
64驱?封? 9 64反驱? 10 64位V? 11 绝? 12 ???课?
13 64透 ? 14 64U ? 15 64Q ? 16 64功 ?
17 64U ? 18 64模 ? 19 64多 ? 20 64网 ?
21 64注 ? 22 64火 ? 23 64棋 ? 24 64自二链L?
25 64破 ? VIP会员办理QQ: 89986068   
【请先加好友,然后到好友列表双击联系客服办理,不然可能无法接受到信息。】
27 加入2000人交流群637034024 3 28 免责声明?
查看: 1137|回复: 0

PEB32 + PEB64遍历模块源码

[复制链接]

13

主题

0

回帖

16

积分

编程入门

Rank: 1

天马币
26
发表于 2024-3-3 09:19:41 | 显示全部楼层 |阅读模式
  1. #pragma pack(4)

  2. typedef struct _UNICODE_STRING32
  3. {
  4.         USHORT Length;
  5.         USHORT MaximumLength;
  6.         ULONG Buffer;
  7. } UNICODE_STRING32, *PUNICODE_STRING32;

  8. typedef struct _PEB32
  9. {
  10.         UCHAR InheritedAddressSpace;
  11.         UCHAR ReadImageFileExecOptions;
  12.         UCHAR BeingDebugged;
  13.         UCHAR BitField;
  14.         ULONG Mutant;
  15.         ULONG ImageBaseAddress;
  16.         ULONG Ldr;
  17.         ULONG ProcessParameters;
  18.         ULONG SubSystemData;
  19.         ULONG ProcessHeap;
  20.         ULONG FastPebLock;
  21.         ULONG AtlThunkSListPtr;
  22.         ULONG IFEOKey;
  23.         ULONG CrossProcessFlags;
  24.         ULONG UserSharedInfoPtr;
  25.         ULONG SystemReserved;
  26.         ULONG AtlThunkSListPtr32;
  27.         ULONG ApiSetMap;
  28. } PEB32, *PPEB32;

  29. typedef struct _PEB_LDR_DATA32
  30. {
  31.         ULONG Length;
  32.         BOOLEAN Initialized;
  33.         ULONG SsHandle;
  34.         LIST_ENTRY32 InLoadOrderModuleList;
  35.         LIST_ENTRY32 InMemoryOrderModuleList;
  36.         LIST_ENTRY32 InInitializationOrderModuleList;
  37.         ULONG EntryInProgress;
  38. } PEB_LDR_DATA32, *PPEB_LDR_DATA32;

  39. typedef struct _LDR_DATA_TABLE_ENTRY32
  40. {
  41.         LIST_ENTRY32 InLoadOrderLinks;
  42.         LIST_ENTRY32 InMemoryOrderModuleList;
  43.         LIST_ENTRY32 InInitializationOrderModuleList;
  44.         ULONG DllBase;
  45.         ULONG EntryPoint;
  46.         ULONG SizeOfImage;
  47.         UNICODE_STRING32 FullDllName;
  48.         UNICODE_STRING32 BaseDllName;
  49.         ULONG Flags;
  50.         USHORT LoadCount;
  51.         USHORT TlsIndex;
  52.         union
  53.         {
  54.                 LIST_ENTRY32 HashLinks;
  55.                 ULONG SectionPointer;
  56.         };
  57.         ULONG CheckSum;
  58.         union
  59.         {
  60.                 ULONG TimeDateStamp;
  61.                 ULONG LoadedImports;
  62.         };
  63.         ULONG EntryPointActivationContext;
  64.         ULONG PatchInformation;
  65. } LDR_DATA_TABLE_ENTRY32, *PLDR_DATA_TABLE_ENTRY32;

  66. #pragma pack()

  67. #pragma pack(8)

  68. typedef struct _PROCESS_BASIC_INFORMATION64 {
  69.         ULONG64 ExitStatus;
  70.         ULONG64 PebBaseAddress;
  71.         ULONG64 AffinityMask;
  72.         ULONG64 BasePriority;
  73.         ULONG64 UniqueProcessId;
  74.         ULONG64 InheritedFromUniqueProcessId;
  75. } PROCESS_BASIC_INFORMATION64, *PPROCESS_BASIC_INFORMATION64;

  76. typedef struct _PEB64
  77. {
  78.         UCHAR InheritedAddressSpace;
  79.         UCHAR ReadImageFileExecOptions;
  80.         UCHAR BeingDebugged;
  81.         UCHAR BitField;
  82.         ULONG64 Mutant;
  83.         ULONG64 ImageBaseAddress;
  84.         ULONG64 Ldr;
  85.         ULONG64 ProcessParameters;
  86.         ULONG64 SubSystemData;
  87.         ULONG64 ProcessHeap;
  88.         ULONG64 FastPebLock;
  89.         ULONG64 AtlThunkSListPtr;
  90.         ULONG64 IFEOKey;
  91.         ULONG64 CrossProcessFlags;
  92.         ULONG64 UserSharedInfoPtr;
  93.         ULONG SystemReserved;
  94.         ULONG AtlThunkSListPtr32;
  95.         ULONG64 ApiSetMap;
  96. } PEB64, *PPEB64;

  97. typedef struct _PEB_LDR_DATA64
  98. {
  99.         ULONG Length;
  100.         BOOLEAN Initialized;
  101.         ULONG64 SsHandle;
  102.         LIST_ENTRY64 InLoadOrderModuleList;
  103.         LIST_ENTRY64 InMemoryOrderModuleList;
  104.         LIST_ENTRY64 InInitializationOrderModuleList;
  105.         ULONG64 EntryInProgress;
  106. } PEB_LDR_DATA64, *PPEB_LDR_DATA64;

  107. typedef struct _UNICODE_STRING64
  108. {
  109.         USHORT Length;
  110.         USHORT MaximumLength;
  111.         ULONG64 Buffer;
  112. } UNICODE_STRING64, *PUNICODE_STRING64;

  113. typedef struct _LDR_DATA_TABLE_ENTRY64
  114. {
  115.         LIST_ENTRY64 InLoadOrderLinks;
  116.         LIST_ENTRY64 InMemoryOrderModuleList;
  117.         LIST_ENTRY64 InInitializationOrderModuleList;
  118.         ULONG64 DllBase;
  119.         ULONG64 EntryPoint;
  120.         ULONG SizeOfImage;
  121.         UNICODE_STRING64 FullDllName;
  122.         UNICODE_STRING64 BaseDllName;
  123.         ULONG Flags;
  124.         USHORT LoadCount;
  125.         USHORT TlsIndex;
  126.         union
  127.         {
  128.                 LIST_ENTRY64 HashLinks;
  129.                 ULONG64 SectionPointer;
  130.         };
  131.         ULONG CheckSum;
  132.         union
  133.         {
  134.                 ULONG TimeDateStamp;
  135.                 ULONG64 LoadedImports;
  136.         };
  137.         ULONG64 EntryPointActivationContext;
  138.         ULONG64 PatchInformation;
  139. } LDR_DATA_TABLE_ENTRY64, *PLDR_DATA_TABLE_ENTRY64;

  140. #pragma pack()

  141. ULONG NewEnumProcsssModules(ULONG ProcessId, fnEnumProcessModuleProc fnEnumProc)
  142. {
  143.         std::wstring ImagePath;
  144.         ULONG nCount = 0;

  145.         HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, ProcessId);
  146.         if (hProcess)
  147.         {
  148.                 if (IsAMD64())
  149.                 {
  150.                         if (IsWow64())//wow64 read 64bit or 32 bit
  151.                         {
  152.                                 PROCESS_BASIC_INFORMATION64 pbi64 = {0};
  153.                                 if (NT_SUCCESS(NtWow64QueryInformationProcess64(hProcess, ProcessBasicInformation, &pbi64, sizeof(pbi64), NULL)))
  154.                                 {
  155.                                         ULONG64 LdrAddress = 0;
  156.                                         if (InternalReadVirtualMemory(hProcess, (ULONG64)(pbi64.PebBaseAddress + offsetof(PEB64, Ldr)), sizeof(LdrAddress), &LdrAddress, NULL))
  157.                                         {
  158.                                                 LIST_ENTRY64 ListEntry = { 0 };
  159.                                                 if (InternalReadVirtualMemory(hProcess, (ULONG64)(LdrAddress + offsetof(PEB_LDR_DATA64, InLoadOrderModuleList)), sizeof(LIST_ENTRY64), &ListEntry, NULL))
  160.                                                 {
  161.                                                         LDR_DATA_TABLE_ENTRY64 CurrentModule = { 0 };

  162.                                                         if (InternalReadVirtualMemory(hProcess, (ULONG64)ListEntry.Flink, sizeof(CurrentModule), &CurrentModule, NULL))
  163.                                                         {
  164.                                                                 ULONG64 hFristModule = (ULONG64)CurrentModule.DllBase;
  165.                                                                 while (1)
  166.                                                                 {
  167.                                                                         if (CurrentModule.DllBase)
  168.                                                                         {
  169.                                                                                 ImagePath.resize(CurrentModule.FullDllName.Length / sizeof(WCHAR));
  170.                                                                                 if (InternalReadVirtualMemory(hProcess, (ULONG64)CurrentModule.FullDllName.Buffer, CurrentModule.FullDllName.Length, (void *)ImagePath.c_str(), NULL))
  171.                                                                                 {
  172.                                                                                         nCount += fnEnumProc(ProcessId, (ULONG64)CurrentModule.DllBase, CurrentModule.SizeOfImage, ImagePath.c_str());
  173.                                                                                 }
  174.                                                                         }

  175.                                                                         if (!InternalReadVirtualMemory(hProcess, (ULONG64)CurrentModule.InLoadOrderLinks.Flink, sizeof(CurrentModule), &CurrentModule, NULL))
  176.                                                                                 break;

  177.                                                                         if (hFristModule == (ULONG64)CurrentModule.DllBase)
  178.                                                                                 break;
  179.                                                                 }
  180.                                                         }
  181.                                                 }
  182.                                         }
  183.                                 }
  184.                         }
  185.                         else if(!Is64BitProcess(hProcess))//64bit read wow64
  186.                         {
  187.                                 ULONG Peb32 = 0;
  188.                                 if (NT_SUCCESS(NtQueryInformationProcess(hProcess, ProcessWow64Information, &Peb32, sizeof(Peb32), NULL)))
  189.                                 {
  190.                                         ULONG64 LdrAddress = 0;
  191.                                         if (InternalReadVirtualMemory(hProcess, (ULONG64)Peb32 + offsetof(PEB32, Ldr), sizeof(ULONG), &LdrAddress, NULL))
  192.                                         {
  193.                                                 LIST_ENTRY32 ListEntry = { 0 };
  194.                                                 if (InternalReadVirtualMemory(hProcess, (ULONG64)(LdrAddress + offsetof(PEB_LDR_DATA32, InLoadOrderModuleList)), sizeof(LIST_ENTRY64), &ListEntry, NULL))
  195.                                                 {
  196.                                                         LDR_DATA_TABLE_ENTRY32 CurrentModule = { 0 };
  197.                                                         if (InternalReadVirtualMemory(hProcess, (ULONG64)ListEntry.Flink, sizeof(CurrentModule), &CurrentModule, NULL))
  198.                                                         {
  199.                                                                 PVOID hFirstModule = (PVOID)CurrentModule.DllBase;
  200.                                                                 while (1)
  201.                                                                 {
  202.                                                                         if (CurrentModule.DllBase)
  203.                                                                         {
  204.                                                                                 ImagePath.resize(CurrentModule.FullDllName.Length / sizeof(WCHAR));
  205.                                                                                 if (InternalReadVirtualMemory(hProcess, (ULONG64)CurrentModule.FullDllName.Buffer, CurrentModule.FullDllName.Length, (void *)ImagePath.c_str(), NULL))
  206.                                                                                 {
  207.                                                                                         nCount += fnEnumProc(ProcessId, (ULONG64)CurrentModule.DllBase, CurrentModule.SizeOfImage, ImagePath.c_str());
  208.                                                                                 }
  209.                                                                         }

  210.                                                                         if (!InternalReadVirtualMemory(hProcess, (ULONG64)CurrentModule.InLoadOrderLinks.Flink, sizeof(CurrentModule), &CurrentModule, NULL))
  211.                                                                                 break;

  212.                                                                         if (hFirstModule == (PVOID)CurrentModule.DllBase)
  213.                                                                                 break;
  214.                                                                 }
  215.                                                         }
  216.                                                 }
  217.                                         }
  218.                                 }
  219.                         }
  220.                 }//IsAMD64
  221.                
  222.                 //Native PEB
  223.                 PROCESS_BASIC_INFORMATION pbi = { 0 };
  224.                 if (NT_SUCCESS(NtQueryInformationProcess(hProcess, ProcessBasicInformation, &pbi, sizeof(pbi), NULL)))
  225.                 {
  226.                         ULONG64 LdrAddress = 0;
  227.                         if (InternalReadVirtualMemory(hProcess, (ULONG64)pbi.PebBaseAddress + offsetof(PEB, Ldr), sizeof(PVOID), &LdrAddress, NULL))
  228.                         {
  229.                                 LIST_ENTRY ListEntry = { 0 };
  230.                                 if (InternalReadVirtualMemory(hProcess, (ULONG64)(LdrAddress + offsetof(PEB_LDR_DATA, InLoadOrderModuleList)), sizeof(LIST_ENTRY64), &ListEntry, NULL))
  231.                                 {
  232.                                         LDR_DATA_TABLE_ENTRY CurrentModule = { 0 };
  233.                                         if (InternalReadVirtualMemory(hProcess, (ULONG64)ListEntry.Flink, sizeof(CurrentModule), &CurrentModule, NULL))
  234.                                         {
  235.                                                 PVOID hFirstModule = CurrentModule.DllBase;
  236.                                                 while (1)
  237.                                                 {
  238.                                                         if (CurrentModule.DllBase)
  239.                                                         {
  240.                                                                 ImagePath.resize(CurrentModule.FullDllName.Length / sizeof(WCHAR));
  241.                                                                 if (InternalReadVirtualMemory(hProcess, (ULONG64)CurrentModule.FullDllName.Buffer, CurrentModule.FullDllName.Length, (void *)ImagePath.c_str(), NULL))
  242.                                                                 {
  243.                                                                         nCount += fnEnumProc(ProcessId, (ULONG64)CurrentModule.DllBase, CurrentModule.SizeOfImage, ImagePath.c_str());
  244.                                                                 }
  245.                                                         }

  246.                                                         if (!InternalReadVirtualMemory(hProcess, (ULONG64)CurrentModule.InLoadOrderLinks.Flink, sizeof(CurrentModule), &CurrentModule, NULL))
  247.                                                                 break;

  248.                                                         if (hFirstModule == CurrentModule.DllBase)
  249.                                                                 break;
  250.                                                 }
  251.                                         }
  252.                                 }
  253.                         }
  254.                 }
  255.                
  256.                 CloseHandle(hProcess);
  257.         }

  258.         return nCount;
  259. }
复制代码


回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

天马阁|C/C++辅助教程|安卓逆向安全| 论坛导航|免责申明|Archiver||网站地图
拒绝任何人以任何形式在本论坛发表与中华人民共和国法律相抵触的言论,本站内容均为会员发表,并不代表天马阁立场!
任何人不得以任何方式翻录、盗版或出售本站视频,一经发现我们将追究其相关责任!
我们一直在努力成为最好的编程论坛!
Copyright© 2010-2021 All Right Reserved.
快速回复 返回顶部 返回列表