VC32位程序通过NtWow64ReadVirtualMemory64 PEB枚举32-64位程序进程模块及基址

已于 2022-11-09 22:33:10 修改
阅读量3.4k 收藏 8
点赞数 6
分类专栏： C++ 文章标签： 32位枚举64位进程模块
于 2020-08-07 17:46:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wh445306/article/details/107867375
版权 
 
//#include "pch.h"
#include <stdio.h>
#include "windows.h"
 
#define NT_SUCCESS(x) ((x) >= 0)
#define ProcessBasicInformation 0
 
typedef NTSTATUS(NTAPI *pfnNtWow64QueryInformationProcess64)(
    IN HANDLE ProcessHandle,
    IN ULONG ProcessInformationClass,
    OUT PVOID ProcessInformation,
    IN ULONG ProcessInformationLength,
    OUT PULONG ReturnLength OPTIONAL
    );
 
 
typedef NTSTATUS(NTAPI *pfnNtWow64ReadVirtualMemory64)(
    IN HANDLE ProcessHandle,
    IN PVOID64 BaseAddress,
    OUT PVOID Buffer,
    IN ULONG64 Size,
    OUT PULONG64 NumberOfBytesRead
    );
 
typedef
NTSTATUS(WINAPI *pfnNtQueryInformationProcess)
(HANDLE ProcessHandle, ULONG ProcessInformationClass,
    PVOID ProcessInformation, UINT32 ProcessInformationLength,
    UINT32* ReturnLength);
 
typedef struct _PROCESS_BASIC_INFORMATION32 {
    NTSTATUS ExitStatus;
    UINT32 PebBaseAddress;
    UINT32 AffinityMask;
    UINT32 BasePriority;
    UINT32 UniqueProcessId;
    UINT32 InheritedFromUniqueProcessId;
} PROCESS_BASIC_INFORMATION32;
 
typedef struct _UNICODE_STRING32
{
    USHORT Length;
    USHORT MaximumLength;
    PWSTR Buffer;
} UNICODE_STRING32, *PUNICODE_STRING32;
 
typedef struct _PEB32
{
    UCHAR InheritedAddressSpace;
    UCHAR ReadImageFileExecOptions;
    UCHAR BeingDebugged;
    UCHAR BitField;
    ULONG Mutant;
    ULONG ImageBaseAddress;
    ULONG Ldr;
    ULONG ProcessParameters;
    ULONG SubSystemData;
    ULONG ProcessHeap;
    ULONG FastPebLock;
    ULONG AtlThunkSListPtr;
    ULONG IFEOKey;
    ULONG CrossProcessFlags;
    ULONG UserSharedInfoPtr;
    ULONG SystemReserved;
    ULONG AtlThunkSListPtr32;
    ULONG ApiSetMap;
} PEB32, *PPEB32;
 
typedef struct _PEB_LDR_DATA32
{
    ULONG Length;
    BOOLEAN Initialized;
    ULONG SsHandle;
    LIST_ENTRY32 InLoadOrderModuleList;
    LIST_ENTRY32 InMemoryOrderModuleList;
    LIST_ENTRY32 InInitializationOrderModuleList;
    ULONG EntryInProgress;
} PEB_LDR_DATA32, *PPEB_LDR_DATA32;
 
typedef struct _LDR_DATA_TABLE_ENTRY32
{
    LIST_ENTRY32 InLoadOrderLinks;
    LIST_ENTRY32 InMemoryOrderModuleList;
    LIST_ENTRY32 InInitializationOrderModuleList;
    ULONG DllBase;
    ULONG EntryPoint;
    ULONG SizeOfImage;
    UNICODE_STRING32 FullDllName;
    UNICODE_STRING32 BaseDllName;
    ULONG Flags;
    USHORT LoadCount;
    USHORT TlsIndex;
    union
    {
        LIST_ENTRY32 HashLinks;
        ULONG SectionPointer;
    };
    ULONG CheckSum;
    union
    {
        ULONG TimeDateStamp;
        ULONG LoadedImports;
    };
    ULONG EntryPointActivationContext;
    ULONG PatchInformation;
} LDR_DATA_TABLE_ENTRY32, *PLDR_DATA_TABLE_ENTRY32;
 
typedef struct _PROCESS_BASIC_INFORMATION64 {
    NTSTATUS ExitStatus;
    UINT32 Reserved0;
    UINT64 PebBaseAddress;
    UINT64 AffinityMask;
    UINT32 BasePriority;
    UINT32 Reserved1;
    UINT64 UniqueProcessId;
    UINT64 InheritedFromUniqueProcessId;
} PROCESS_BASIC_INFORMATION64;
typedef struct _PEB64
{
    UCHAR InheritedAddressSpace;
    UCHAR ReadImageFileExecOptions;
    UCHAR BeingDebugged;
    UCHAR BitField;
    ULONG64 Mutant;
    ULONG64 ImageBaseAddress;
    ULONG64 Ldr;
    ULONG64 ProcessParameters;
    ULONG64 SubSystemData;
    ULONG64 ProcessHeap;
    ULONG64 FastPebLock;
    ULONG64 AtlThunkSListPtr;
    ULONG64 IFEOKey;
    ULONG64 CrossProcessFlags;
    ULONG64 UserSharedInfoPtr;
    ULONG SystemReserved;
    ULONG AtlThunkSListPtr32;
    ULONG64 ApiSetMap;
} PEB64, *PPEB64;
 
typedef struct _PEB_LDR_DATA64
{
    ULONG Length;
    BOOLEAN Initialized;
    ULONG64 SsHandle;
    LIST_ENTRY64 InLoadOrderModuleList;
    LIST_ENTRY64 InMemoryOrderModuleList;
    LIST_ENTRY64 InInitializationOrderModuleList;
    ULONG64 EntryInProgress;
} PEB_LDR_DATA64, *PPEB_LDR_DATA64;
 
typedef struct _UNICODE_STRING64
{
    USHORT Length;
    USHORT MaximumLength;
    ULONG64 Buffer;
} UNICODE_STRING64, *PUNICODE_STRING64;
 
typedef struct _LDR_DATA_TABLE_ENTRY64
{
    LIST_ENTRY64 InLoadOrderLinks;
    LIST_ENTRY64 InMemoryOrderModuleList;
    LIST_ENTRY64 InInitializationOrderModuleList;
    ULONG64 DllBase;
    ULONG64 EntryPoint;
    ULONG SizeOfImage;
    UNICODE_STRING64 FullDllName;
    UNICODE_STRING64 BaseDllName;
    ULONG Flags;
    USHORT LoadCount;
    USHORT TlsIndex;
    union
    {
        LIST_ENTRY64 HashLinks;
        ULONG64 SectionPointer;
    };
    ULONG CheckSum;
    union
    {
        ULONG TimeDateStamp;
        ULONG64 LoadedImports;
    };
    ULONG64 EntryPointActivationContext;
    ULONG64 PatchInformation;
} LDR_DATA_TABLE_ENTRY64, *PLDR_DATA_TABLE_ENTRY64;
 
int main()
{
    DWORD dwPid = 4848;
    HANDLE m_ProcessHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPid);
    BOOL bTarget = FALSE;
    BOOL bSource = FALSE;
 
    IsWow64Process(GetCurrentProcess(), &bSource);
    IsWow64Process(m_ProcessHandle, &bTarget);
 
    SYSTEM_INFO si;
    GetSystemInfo(&si);
 
    if (bTarget == FALSE && bSource == TRUE)
    {
        HMODULE NtdllModule = GetModuleHandle(L"ntdll.dll");
        pfnNtWow64QueryInformationProcess64 NtWow64QueryInformationProcess64 = (pfnNtWow64QueryInformationProcess64)GetProcAddress(NtdllModule, "NtWow64QueryInformationProcess64");
        pfnNtWow64ReadVirtualMemory64 NtWow64ReadVirtualMemory64 = (pfnNtWow64ReadVirtualMemory64)GetProcAddress(NtdllModule, "NtWow64ReadVirtualMemory64");
        PROCESS_BASIC_INFORMATION64 pbi64 = { 0 };
        if (NT_SUCCESS(NtWow64QueryInformationProcess64(m_ProcessHandle, ProcessBasicInformation, &pbi64, sizeof(pbi64), NULL)))
        {
            DWORD64 Ldr64 = 0;
            LIST_ENTRY64 ListEntry64 = { 0 };
            LDR_DATA_TABLE_ENTRY64 LDTE64 = { 0 };
            wchar_t ProPath64[256];
            if (NT_SUCCESS(NtWow64ReadVirtualMemory64(m_ProcessHandle, (PVOID64)(pbi64.PebBaseAddress + offsetof(PEB64, Ldr)), &Ldr64, sizeof(Ldr64), NULL)))
            {
                if (NT_SUCCESS(NtWow64ReadVirtualMemory64(m_ProcessHandle, (PVOID64)(Ldr64 + offsetof(PEB_LDR_DATA64, InLoadOrderModuleList)), &ListEntry64, sizeof(LIST_ENTRY64), NULL)))
                {
                    if (NT_SUCCESS(NtWow64ReadVirtualMemory64(m_ProcessHandle, (PVOID64)(ListEntry64.Flink), &LDTE64, sizeof(_LDR_DATA_TABLE_ENTRY64), NULL)))
                    {
                        while (1)
                        {
                            if (LDTE64.InLoadOrderLinks.Flink == ListEntry64.Flink) break;
                            if (NT_SUCCESS(NtWow64ReadVirtualMemory64(m_ProcessHandle, (PVOID64)LDTE64.FullDllName.Buffer, ProPath64, sizeof(ProPath64), NULL)))
                            {
                                printf("模块基址:0x%llX\t模块大小:0x%X\t模块路径:%ls\n", LDTE64.DllBase, LDTE64.SizeOfImage, ProPath64);
                            }
                            if (!NT_SUCCESS(NtWow64ReadVirtualMemory64(m_ProcessHandle, (PVOID64)LDTE64.InLoadOrderLinks.Flink, &LDTE64, sizeof(_LDR_DATA_TABLE_ENTRY64), NULL))) break;
                        }
                    }
                }
            }
        }
 
    }
    else if (bTarget == TRUE && bSource == TRUE || si.wProcessorArchitecture != PROCESSOR_ARCHITECTURE_AMD64 ||
        si.wProcessorArchitecture != PROCESSOR_ARCHITECTURE_IA64)
    {
        HMODULE NtdllModule = GetModuleHandle(L"ntdll.dll");
        pfnNtQueryInformationProcess NtQueryInformationProcess = (pfnNtQueryInformationProcess)GetProcAddress(NtdllModule, "NtQueryInformationProcess");
        PROCESS_BASIC_INFORMATION32 pbi32 = { 0 };
        if (NT_SUCCESS(NtQueryInformationProcess(m_ProcessHandle, ProcessBasicInformation, &pbi32, sizeof(pbi32), NULL)))
        {
            DWORD Ldr32 = 0;
            LIST_ENTRY32 ListEntry32 = { 0 };
            LDR_DATA_TABLE_ENTRY32 LDTE32 = { 0 };
            wchar_t ProPath32[256];
            if (ReadProcessMemory(m_ProcessHandle, (PVOID)(pbi32.PebBaseAddress + offsetof(PEB32, Ldr)), &Ldr32, sizeof(Ldr32), NULL))
            {
                if (ReadProcessMemory(m_ProcessHandle, (PVOID)(Ldr32 + offsetof(PEB_LDR_DATA32, InLoadOrderModuleList)), &ListEntry32, sizeof(LIST_ENTRY32), NULL))
                {
                    if (ReadProcessMemory(m_ProcessHandle, (PVOID)(ListEntry32.Flink), &LDTE32, sizeof(_LDR_DATA_TABLE_ENTRY32), NULL))
                    {
                        while (1)
                        {
                            if (LDTE32.InLoadOrderLinks.Flink == ListEntry32.Flink) break;
                            if (ReadProcessMemory(m_ProcessHandle, (PVOID)LDTE32.FullDllName.Buffer, ProPath32, sizeof(ProPath32), NULL))
                            {
                               printf("模块基址:0x%X\t模块大小:0x%X\t模块路径:%ls\n", LDTE32.DllBase, LDTE32.SizeOfImage, ProPath32);
                            }
                            if (!ReadProcessMemory(m_ProcessHandle, (PVOID)LDTE32.InLoadOrderLinks.Flink, &LDTE32, sizeof(_LDR_DATA_TABLE_ENTRY32), NULL)) break;
                        }
                    }
                }
            }
        }
    }
    CloseHandle(m_ProcessHandle);
    getchar();
}

搬运参考此连接地址：https://www.52pojie.cn/forum.php?mod=viewthread&tid=872501

左眼看成爱
关注
  • 6
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用ZwQueryVirtualMemory枚举进程模块支持x64
zhuhuibeishadiao
05-02 7908
#include "stdio.h" #include "windows.h"typedef struct _LSA_UNICODE_STRING { USHORT Length; USHORT MaximumLength; PWSTR Buffer; } LSA_UNICODE_STRING, *PLSA_UNICODE_STRING, UNICODE_STRING, *PUNICO
WOW64通过PEB获取32/64位进程以及模块信息（附带DEMO）
06-23
DELPHI代码实现。使用API NtWow64QueryInformationProcess64 获取进程的64位PEB结构地址。使用API NtWow64ReadVirtualMemory64 读取进程的64位内存地址的数据。通过PEB64结构进行遍历进程的64位模块。对于32位进程，通过 CreateToolhelp32Snapshot，Process32First，Process32Next，Module32First，Module32Next进行进程和模块的遍历。 特别说明：由于对于WINDOWS系统权限掌握尚不深入，对于WINDOWS系统进程，仅能读取进程信息，无法读取模块信息。
32位进程枚举64位进程模块信息
06-02
资源介绍：。' WOW64的32位程序其实拥有64位程序的全部功能,包括32注入64位、枚举64位进程模块、Hook64位模块、调用64位API等等等等....' 因为WOW64程序不是完全的虚拟化的，是伪虚拟化，本身就是一个64位进程,只是自己以为是32位程序而已. 所以Wow64进程 里面。' 既有 64位环境结构,又有32位环境结构, 使用api  NtWow64QueryInformationProcess64 可以获取 进程的64位PEB结构地址,。' 使用api  NtWow64ReadVirtualMemory64 可以读取进程的64位内存地址的数据. 通过PEB64结构进行遍历进程的64位模块!。资源作者：。@iokey。资源下载：。Tags：64位进程。
64位环境下32位进程获取64位进程的命令行参数和当前目录
weixin_34205076的博客
11-18 1006
BOOL GetProcessCurDir(HANDLE hProcess,mystring&strCurDir){ BOOL bSuccess = FALSE; // PROCESS_BASIC_INFORMATION pbi; TNtQueryInformationProcess pfnNtQueryInformationProcess = NULL; ...
准确在64位系统下枚举进程模块
04-08
在32位进程中使用WMI枚举其他进程的模块，支持32位系统和64位系统。
枚举64位进程模块+查询64位进程的线程所属模块文件路径-易语言
06-12
该源码是 eWOW64Ext v1.21 的一个演示例子，完全使用了 eWOW64Ext 的方法 来枚举64位进程模块； 提供了两种方法来cha询64位进程的线程所属模块文件路径，该功能还没有易语言 方面的开源资料，本次为首次开源。
wow64
a31602222的博客
11-04 545
WOW64的32位程序其实拥有64位程序的全部功能包括32注入64位、枚举64位进程模块、Hook64位模块、调用64位API等等等等....因为WOW64程序不是完全的虚拟化的，是伪虚拟化，本身就是一个64位进程只是自己以为是32位程序而已就如黑客帝国里面一样，只要你意识到了，就能超越你认为所不能的。RtlGetNativeSystemInformation = _NtWow64G...
e语言-32位进程枚举64位进程模块信息
08-23
资源介绍：' WOW64的32位程序其实拥有64位程序的全部功能,包括32注入64位、枚举64位进程模块、Hook64位模块、调用64位API等等等等....' 因为WOW64程序不是完全的虚拟化的，是伪虚拟化，本身就是一个64位进程,只是自己以为是32位程序而已. 所以Wow64进程 里面' 既有 64位环境结构,又有32位环境结构, 使用api  NtWow64QueryInformationProcess64 可以获取 进程的64位PEB结构地址,' 使用api  NtWow64ReadVirtualMemory64 可以读取进程的64位内存地址的数据. 通过PEB64结构进行遍历进程的64位模块!资源作者：
E语言枚举64位进程模块源码
09-10
E语言枚举64位进程模块,纯API调用.来枚举32和64位进程的进程模块.
易语言-32位进程枚举64位进程模块信息
06-29
' WOW64的32位程序其实拥有64位程序的全部功能,包括32注入64位、枚举64位进程模块、Hook64位模块、调用64位API等等等等.... ' 因为WOW64程序不是完全的虚拟化的，是伪虚拟化，本身就是一个64位进程,只是自己以为是32...
直接从WoW64层（C ++）调用32位NtDLL API-C/C++开发
05-27
直接从WoW64层（C ++）调用32位NtDLL API wowJit直接从WoW64层（C ++）调用32bit NtDLL API主要是受到ReWolf的启发：将x86与x64代码混合
枚举进程模块
qq_41490873的博客
08-25 310
在winternl.h中定义了PEB 和TEB typedef struct _PEB_LDR_DATA { BYTE Reserved1[8]; PVOID Reserved2[3]; LIST_ENTRY InMemoryOrderModuleList; } PEB_LDR_DATA, *PPEB_LDR_DATA; typedef struct _LDR_DATA_TABLE_ENTRY { PVOID Reserved1[2]; LIST_ENTRY InM
枚举进程 模块 堆栈
x
10-22 329
void walkProcess() { HANDLE hSnap = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 ); if(hSnap == INVALID_HANDLE_VALUE) return; PROCESSENTRY32 p32; p32.dwSize = sizeof(PROCES...
枚举进程的内存块
zzz3265的专栏
11-10 3674
#include "ProcMemInfo.h" #include "../NSimple.h" #include CProcMemInfo::CProcMemInfo() { Init(); } CProcMemInfo::~CProcMemInfo() { } BOOL CProcMemInfo::Init() { m_pMinAddr = NSys::GetSystemInfo()->lpMinimumApplicationAddress;
枚举windows进程模块的几种方法—PEB内核结构详解
阔野的专栏
11-18 5008
1. 引言 在诸多的场景中（例如软件测试，软件安全研究等领域）经常需要分析在目标进程中具体加载了哪些模块(DLL)，以及所加载的模块的信息（如模块基地址，映射文件大小等）。获取这windows进程加载的模块信息，曾经有一个行之有效又很便捷的方法，使用windows提供PSAPI(psapi.dll，windows进程状态信息接口)提供的相关的接口就可以快捷的获取进程及进程加载的模块信息。有关PSAPI接口可以参考psapi.h或者微软的官方文档Psapi.h heade...
x64进程如何获得wow64进程的PEB
lif12345的专栏
07-23 6256
介绍了如何获得wow64进程的PEB
64位操作系统下R3枚举进程及模块的两种方式
最新发布
qq_31548855的博客
10-22 317
综上，第一种方法使用快照枚举进程和模块，优点是代码量少，缺点是32位进程无法枚举64位进程模块。第二种方法使用Nt函数枚举进程和模块，优点是32位进程可以枚举64位进程模块，缺点是代码量多且要使用未文档化的数据结构。
32位程序读取64位进程内存
htpidk的博客
10-09 1463
//第一步：//定義函數參數結構 typedef NTSTATUS(NTAPI *LPFN_NTWOW64READVIRTUALMEMORY64)( IN HANDLE ProcessHandle, IN ULONG64 BaseAddress, OUT PVOID BufferData, IN ULONG64 BufferLength, OUT PULONG64 ReturnLength OPTIONAL); typedef NTSTATUS(NTAPI *LPFN_NTWOW64WR
VB6.0超级模块函数.GetProcessModuleHandleByPid得到目标进程的模块地址-用PID
追逐光芒，追随内心
09-28 507
Public Function GetProcessModuleHandleByPid(ByVal GamePid As String, ByVal ModuleName As String) As Long Dim pr As PROCESSENTRY32 Dim lp As Long Dim mo As MODULEENTRY32 Dim LM As Long Dim i As .
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值