C++ 反反调试（PEB）

最新推荐文章于 2023-09-25 09:00:58 发布
最新推荐文章于 2023-09-25 09:00:58 发布
阅读量828 收藏 5
点赞数
分类专栏： 调试&检测
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Simon798/article/details/100705423
版权

PEB 反调试参考这篇文章

没错，这也是我写的。（/手动滑稽）

把之前的程序用原版 OD 打开，根据控制台里的 PEB 地址，找到对应的内存地址：
在这里插入图片描述

根据 BeingDebugged 、 NtGlobalFlag 在 _PEB 结构体中的位置，可以发现 01、70 这两个标志（注意这里 main函数还没开始运行，所以程序不会退出，只有当你第一次点击 “运行” 时才会执行到 main，检测代码才会有效。所以我们的任务就是在 main 执行之前，将调试标志擦除）
在这里插入图片描述
依次把 01 和 70 都改成 00，如图：
在这里插入图片描述
再点击 OD 的运行按钮，发现已经 bypass 成功了：
在这里插入图片描述
但是现在还没有完，要知道，一般情况下我们是不知道目标进程 PEB 地址的，所以我们还需要用代码获取 PEB 地址。（主要是获取指定 PID 的 PEB地址，而不是程序本身的 PEB 地址）
在这里插入图片描述

代码：参考样本


// Test_Console.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

#include <iostream>
#include <windows.h>
#include <subauth.h>

#pragma region 依赖 

#define NT_SUCCESS(x) ((x) >= 0)
#define ProcessBasicInformation 0

typedef
NTSTATUS(WINAPI *pfnNtWow64QueryInformationProcess64)
(HANDLE ProcessHandle, UINT32 ProcessInformationClass,
    PVOID ProcessInformation, UINT32 ProcessInformationLength,
    UINT32* ReturnLength);
 
typedef
NTSTATUS(WINAPI *pfnNtWow64ReadVirtualMemory64)
(HANDLE ProcessHandle, PVOID64 BaseAddress,
    PVOID BufferData, UINT64 BufferLength,
    PUINT64 ReturnLength);
 
typedef
NTSTATUS(WINAPI *pfnNtQueryInformationProcess)
(HANDLE ProcessHandle, ULONG ProcessInformationClass,
    PVOID ProcessInformation, UINT32 ProcessInformationLength,
    UINT32* ReturnLength);
 
template <typename T>
struct _UNICODE_STRING_T
{
    WORD Length;
    WORD MaximumLength;
    T Buffer;
};
 
template <typename T>
struct _LIST_ENTRY_T
{
    T Flink;
    T Blink;
};
 
template <typename T, typename NGF, int A>
struct _PEB_T
{
    typedef T type;
 
    union
    {
        struct
        {
            BYTE InheritedAddressSpace;
            BYTE ReadImageFileExecOptions;
            BYTE BeingDebugged;
            BYTE BitField;
        };
        T dummy01;
    };
    T Mutant;
    T ImageBaseAddress;
    T Ldr;
    T ProcessParameters;
    T SubSystemData;
    T ProcessHeap;
    T FastPebLock;
    T AtlThunkSListPtr;
    T IFEOKey;
    T CrossProcessFlags;
    T UserSharedInfoPtr;
    DWORD SystemReserved;
    DWORD AtlThunkSListPtr32;
    T ApiSetMap;
    T TlsExpansionCounter;
    T TlsBitmap;
    DWORD TlsBitmapBits[2];
    T ReadOnlySharedMemoryBase;
    T HotpatchInformation;
    T ReadOnlyStaticServerData;
    T AnsiCodePageData;
    T OemCodePageData;
    T UnicodeCaseTableData;
    DWORD NumberOfProcessors;
    union
    {
        DWORD NtGlobalFlag;
        NGF dummy02;
    };
    LARGE_INTEGER CriticalSectionTimeout;
    T HeapSegmentReserve;
    T HeapSegmentCommit;
    T HeapDeCommitTotalFreeThreshold;
    T HeapDeCommitFreeBlockThreshold;
    DWORD NumberOfHeaps;
    DWORD MaximumNumberOfHeaps;
    T ProcessHeaps;
    T GdiSharedHandleTable;
    T ProcessStarterHelper;
    T GdiDCAttributeList;
    T LoaderLock;
    DWORD OSMajorVersion;
    DWORD OSMinorVersion;
    WORD OSBuildNumber;
    WORD OSCSDVersion;
    DWORD OSPlatformId;
    DWORD ImageSubsystem;
    DWORD ImageSubsystemMajorVersion;
    T ImageSubsystemMinorVersion;
    T ActiveProcessAffinityMask;
    T GdiHandleBuffer[A];
    T PostProcessInitRoutine;
    T TlsExpansionBitmap;
    DWORD TlsExpansionBitmapBits[32];
    T SessionId;
    ULARGE_INTEGER AppCompatFlags;
    ULARGE_INTEGER AppCompatFlagsUser;
    T pShimData;
    T AppCompatInfo;
    _UNICODE_STRING_T<T> CSDVersion;
    T ActivationContextData;
    T ProcessAssemblyStorageMap;
    T SystemDefaultActivationContextData;
    T SystemAssemblyStorageMap;
    T MinimumStackCommit;
    T FlsCallback;
    _LIST_ENTRY_T<T> FlsListHead;
    T FlsBitmap;
    DWORD FlsBitmapBits[4];
    T FlsHighIndex;
    T WerRegistrationData;
    T WerShipAssertPtr;
    T pContextData;
    T pImageHeaderHash;
    T TracingFlags;
    T CsrServerReadOnlySharedMemoryBase;
};
 
typedef _PEB_T<DWORD, DWORD64, 34> _PEB32;
typedef _PEB_T<DWORD64, DWORD, 30> _PEB64;
 
typedef struct _STRING_32
{
    WORD Length;
    WORD MaximumLength;
    UINT32 Buffer;
} STRING32, *PSTRING32;
 
typedef struct _STRING_64
{
    WORD Length;
    WORD MaximumLength;
    UINT64 Buffer;
} STRING64, *PSTRING64;
 
typedef struct _RTL_DRIVE_LETTER_CURDIR_32
{
    WORD Flags;
    WORD Length;
    ULONG TimeStamp;
    STRING32 DosPath;
} RTL_DRIVE_LETTER_CURDIR32, *PRTL_DRIVE_LETTER_CURDIR32;
 
typedef struct _RTL_DRIVE_LETTER_CURDIR_64
{
    WORD Flags;
    WORD Length;
    ULONG TimeStamp;
    STRING64 DosPath;
} RTL_DRIVE_LETTER_CURDIR64, *PRTL_DRIVE_LETTER_CURDIR64;
 
typedef struct _UNICODE_STRING_32
{
    WORD Length;
    WORD MaximumLength;
    UINT32 Buffer;
} UNICODE_STRING32, *PUNICODE_STRING32;
 
typedef struct _UNICODE_STRING_64
{
    WORD Length;
    WORD MaximumLength;
    UINT64 Buffer;
} UNICODE_STRING64, *PUNICODE_STRING64;
 
 
typedef struct _CURDIR_32
{
    UNICODE_STRING32 DosPath;
    UINT32 Handle;
} CURDIR32, *PCURDIR32;
 
typedef struct _RTL_USER_PROCESS_PARAMETERS_32
{
    ULONG MaximumLength;
    ULONG Length;
    ULONG Flags;
    ULONG DebugFlags;
    UINT32 ConsoleHandle;
    ULONG ConsoleFlags;
    UINT32 StandardInput;
    UINT32 StandardOutput;
    UINT32 StandardError;
    CURDIR32 CurrentDirectory;
    UNICODE_STRING32 DllPath;
    UNICODE_STRING32 ImagePathName;
    UNICODE_STRING32 CommandLine;
    UINT32 Environment;
    ULONG StartingX;
    ULONG StartingY;
    ULONG CountX;
    ULONG CountY;
    ULONG CountCharsX;
    ULONG CountCharsY;
    ULONG FillAttribute;
    ULONG WindowFlags;
    ULONG ShowWindowFlags;
    UNICODE_STRING32 WindowTitle;
    UNICODE_STRING32 DesktopInfo;
    UNICODE_STRING32 ShellInfo;
    UNICODE_STRING32 RuntimeData;
    RTL_DRIVE_LETTER_CURDIR32 CurrentDirectores[32];
    ULONG EnvironmentSize;
} RTL_USER_PROCESS_PARAMETERS32, *PRTL_USER_PROCESS_PARAMETERS32;
 
 
typedef struct _CURDIR_64
{
    UNICODE_STRING64 DosPath;
    UINT64 Handle;
} CURDIR64, *PCURDIR64;
 
typedef struct _RTL_USER_PROCESS_PARAMETERS_64
{
    ULONG MaximumLength;
    ULONG Length;
    ULONG Flags;
    ULONG DebugFlags;
    UINT64 ConsoleHandle;
    ULONG ConsoleFlags;
    UINT64 StandardInput;
    UINT64 StandardOutput;
    UINT64 StandardError;
    CURDIR64 CurrentDirectory;
    UNICODE_STRING64 DllPath;
    UNICODE_STRING64 ImagePathName;
    UNICODE_STRING64 CommandLine;
    UINT64 Environment;
    ULONG StartingX;
    ULONG StartingY;
    ULONG CountX;
    ULONG CountY;
    ULONG CountCharsX;
    ULONG CountCharsY;
    ULONG FillAttribute;
    ULONG WindowFlags;
    ULONG ShowWindowFlags;
    UNICODE_STRING64 WindowTitle;
    UNICODE_STRING64 DesktopInfo;
    UNICODE_STRING64 ShellInfo;
    UNICODE_STRING64 RuntimeData;
    RTL_DRIVE_LETTER_CURDIR64 CurrentDirectores[32];
    ULONG EnvironmentSize;
} RTL_USER_PROCESS_PARAMETERS64, *PRTL_USER_PROCESS_PARAMETERS64;
 
 
 
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 _PROCESS_BASIC_INFORMATION32 {
    NTSTATUS ExitStatus;
    UINT32 PebBaseAddress;
    UINT32 AffinityMask;
    UINT32 BasePriority;
    UINT32 UniqueProcessId;
    UINT32 InheritedFromUniqueProcessId;
} PROCESS_BASIC_INFORMATION32;

#pragma endregion

int _tmain(int argc, _TCHAR* argv[])
{
	HANDLE m_ProcessHandle = 
		OpenProcess(
			PROCESS_ALL_ACCESS,		// 所有权限
			FALSE,					// 不继承句柄
			8016					// 进程ID，此处为了方便直接写死
		);
 
    BOOL bSource = FALSE;			// 判断自身进程是否为 64位
    BOOL bTarget = FALSE;			// 判断目标进程是否为 64位
    IsWow64Process(
		GetCurrentProcess(),		// 进程句柄
		&bSource					// 用来接收返回值的变量，64位 FLASE | 32位 TRUE
		);
    IsWow64Process(
		m_ProcessHandle,			// 进程句柄
		&bTarget					// 用来接收返回值的变量，64位 FLASE | 32位 TRUE
		);

	// 目标 64位，自身 32位
    if(bTarget == FALSE && bSource == TRUE)
    {
		// 获取 ntdll.dll 模块句柄
        HMODULE NtdllModule = GetModuleHandle("ntdll.dll");

		pfnNtWow64QueryInformationProcess64 NtWow64QueryInformationProcess64 = (pfnNtWow64QueryInformationProcess64)GetProcAddress(NtdllModule,"NtWow64QueryInformationProcess64");
		pfnNtWow64ReadVirtualMemory64 NtWow64ReadVirtualMemory64 = (pfnNtWow64ReadVirtualMemory64)GetProcAddress(NtdllModule,"NtWow64ReadVirtualMemory64");
        PROCESS_BASIC_INFORMATION64 pbi = {0};
        UINT64 ReturnLength = 0;
        NTSTATUS Status = NtWow64QueryInformationProcess64(m_ProcessHandle,ProcessBasicInformation,&pbi,(UINT32)sizeof(pbi),(UINT32*)&ReturnLength);
 
        if (NT_SUCCESS(Status)){
            _PEB64* Peb = (_PEB64*)malloc(sizeof(_PEB64));
            RTL_USER_PROCESS_PARAMETERS64* ProcessParameters = (RTL_USER_PROCESS_PARAMETERS64*)malloc(sizeof(RTL_USER_PROCESS_PARAMETERS64));
            Status = NtWow64ReadVirtualMemory64(m_ProcessHandle,(PVOID64)pbi.PebBaseAddress,(_PEB64*)Peb,sizeof(_PEB64),&ReturnLength);
			
            std::cout << "PEB地址:" << std::hex << pbi.PebBaseAddress << std::endl;
            //cout << "Ldr:" << hex << Peb->Ldr << endl;
            //cout << "ImageBaseAddress:" << hex << Peb->ImageBaseAddress << endl;
        }
    }
 
    // 目标 32位，自身 32位
    else if (bTarget == TRUE && bSource == TRUE)
    {
        HMODULE NtdllModule = GetModuleHandle("ntdll.dll");
        pfnNtQueryInformationProcess NtQueryInformationProcess = (pfnNtQueryInformationProcess)GetProcAddress(NtdllModule,"NtQueryInformationProcess");
        PROCESS_BASIC_INFORMATION32 pbi = {0};
        UINT32  ReturnLength = 0;
        NTSTATUS Status = NtQueryInformationProcess(m_ProcessHandle,ProcessBasicInformation,&pbi,(UINT32)sizeof(pbi),(UINT32*)&ReturnLength);
        
		if (NT_SUCCESS(Status)){
            _PEB32* Peb = (_PEB32*)malloc(sizeof(_PEB32));
            ReadProcessMemory(m_ProcessHandle, (PVOID)pbi.PebBaseAddress,(_PEB32*)Peb,sizeof(_PEB32),NULL);
           
			std::cout << "PEB地址:" << std::hex << pbi.PebBaseAddress << std::endl;
            //printf("LdrAddress:%x\r\n", ((_PEB32*)Peb)->Ldr);
            //printf("ImageBaseAddress:%x\r\n", ((_PEB32*)Peb)->ImageBaseAddress);
        }
    }

	getchar();
	return 0;
}

效果图：
在这里插入图片描述

注意：

以上所有的操作都是基于本身程序是32位的前提下，如果本身代码被编译成64位则不会有效果！

(-: LYSM :-)
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PEB_Test.cpp
12-17
1：读取进程的PEB信息 2：进程反调试 3：https://blog.csdn.net/sinat_34260423/article/details/55096488
反调试技术
nareku的博客
06-21 669
思来想去还是先写反反调试，壳的话打算在PE文件内容里写反调试顾名思义就是用尽一切手段防止运行时对程序的非法篡改和窥视，加大代码的复杂度和分析等以下只是遇到的一些反调试，其中有一些知识都没有学习到，不过慢慢来也慢慢补坑。
PEB结构的获取
SauceJ的专栏
08-15 3465
PEB结构----枚举用户模块列表。 PEB
32位/64位 获得进程peb的方法
HsinTsao的博客
03-05 3217
逐渐将博客园的文章搬到CSDN来吧。基于上一篇文章获取peb结构，大概了解了peb的获取方法，但是那个方法只能获得当前进程的PEB，不能获得其他的进程的PEB。根据那个思想，获得其他进程PEB则需要注入，得到进程信息，然后进程间通信，将信息返回来，经过考虑，这个方法太复杂。下面介绍的方法是 用了一个未公开的函数NtQueryInformationProcess，获得进程信息，然后去读对方进程Rea...
C++ 反调试（ZwSetInformationThread）
LYSM
09-18 2664
这个 API 的功能是：如果程序正在被调试，则强制将自己从调试器里分离出来。 代码： #include "stdafx.h" #include <iostream> #include <tchar.h> #include <Windows.h> #include <stdio.h> #pragma region 全局变量 /* ZwSet...
C++ 反调试（NtSetInformationThread）
LYSM
11-20 3238
先上代码： // Test_Console.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include <afx.h> #include <tchar.h> #include <afxwin.h> #include <Windows.h> #include <vector> #inclu...
C++ 获取进程启动参数
CAir2的专栏
09-21 1356
C++获取其他进程启动参数
7.7 实现进程内存读写
最新发布
CSDN
09-25 4742
内存进程读写可以让我们访问其他进程的内存空间并读取或修改其中的数据。这种技术通常用于各种调试工具、进程监控工具和反作弊系统等场景。在`Windows`系统中，内存进程读写可以通过一些`API`函数来实现，如`OpenProcess`、`ReadProcessMemory`和`WriteProcessMemory`等。这些函数提供了一种通用的方式来访问其他进程的内存，并且可以用来读取或写入不同类型的数据，例如整数、字节集、浮点数等。
大神修改版OD，反反调试，过驱动保护.zip
09-12
自带驱动级的反反调试插件 反反调试，过数字签名校验，过虚拟机检测，，过PG，隐藏PEB(R3)，隐藏进程，保护进程，伪装调试器，伪装父进程
PEB_Test.rar
12-26
1. IsDebuggerPresent 2. PEB（进程环境块） 3. 软件断点防止 4. CheckRemoteDebuggerPresent和NtQueryInformationProcess ...5：参考于https://www.4hou.com/web/15211.html，介绍的调试和反调试方法
关于一些调试器的反调试技术
09-29
反调试技术 2 发现OD的处理 2 1. 窗口类名、窗口名 3 2. 检测调试器进程 4 3. 父进程是否是Explorer 5 4. RDTSC/ GetTickCount时间敏感程序段 7 5. StartupInfo结构 7 6. BeingDebugged 8 7. PEB.NtGlobalFlag , ...
反调试技术源码与实例汇编版
10-05
汇总归纳了各种反调试技术，提供各种反调试实例及源代码。 http://www.ucooper.com/anti-debug-methods-asm.html 反调试技术 2 发现OD的处理 2 1. 窗口类名、窗口名 3 2. 检测调试器进程 4 3. 父进程是否是Explorer...
windbg学习23（!peb和PEB结构）
weixin_30487201的博客
01-10 498
调试器用户经常会需要查看在启动调试目标时使用了哪些命令行参数，这个信息是保存在PEB中的，可以通过!peb来获取，这个命令将解析PEB并给出完整的命令行，所有已加载DLL的位置，以及环境变量等. 0:000> !peb PEB at 7ffdf000 InheritedAddressSpace: No ReadImageFileExecOptions: N...
PEB结构块解析
热门推荐
liutianheng654的博客
03-22 1万+
peb结构块解析： 项目需要获取程序运行的一些状态，目前只能获取寄存器信息，故采用fs寄存器获取peb信息，本文主要探索peb中可以获得的进程信息。 windbg信息如下：win xp 下，和win7不一样，下面为xp环境dt nt!_peb +0x000 InheritedAddressSpace : UChar +0x001 ReadImageFileExecOptions :
通过PEB遍历当前进程中的模块(C语言实现)
aigo10000的博客
05-14 585
0x00 相关说明： Windows应用层如果要遍历当前进程所加载的模块可以使用WIN32API通过进程快照来实现 通过PEB来遍历进程模块没有WIN32API的使用痕迹，在某些场合更加好用 其中32位应用程序的 PEB 的地址可以通过 fs:[0x30]获取，fs:[0]为TEB结构的地址 0x01 相关数据结构： 下面的数据结构可以在windbg中使用命令查看(使用 dt ...
夺取应用程序 “制空权“：内存数据
深耕安全技术研究
03-15 1304
文章目录1.技术背景2.效果展示3.代码实现4. 知识清单PE结构概述PEB结构概述调用系统未导出函数方法5. 关键函数及结构解析1.ReadProcessMemory函数2. _LIST_ENTRY结构3. _PEB_LDR_DATAS结构4. _LDR_MODULE 结构 1.技术背景 在病毒查杀，应用安全对抗，静态逆向应用，动态逆向应用，最重要的对象就是，应用程序的内存数据。 病毒查杀对抗：需要获取查杀对象的内存数据进行和病毒库的特征做比对。 应用安全对抗：需要保护自身的内存数据不被转存。 静态逆向
Python 获取指定模块基址
Wrpzkb
05-14 3654
因为昨天研究FPS游戏时候，发现有个动态地址每次重启电脑都会不同，然后因为有过用C和易语言编写指定模块名获取基址的经验，所以打算用Python来试试 在网上搜索了一点资料，发现有吾爱有一篇是使用Python32位，通过Ntdll库进行模块遍历。 将代码复制粘贴，因为我使用的是 Python64位的，改了改代码，但是发现失败了，搜不出来，因为代码涉及到PE头，目前还没碰到这块区域，代码作者也说他只是复制粘贴的，所以也不甚清楚为什么，就只能另寻出路了。 def _ReadMemeryInt(hGameHand.
反调试 - SetUnhandledExceptionFilter
LYSM
07-12 5097
原理 SetUnhandledExceptionFilter 可以注册一个异常处理函数，当一个异常产生且我们的 try - catch（或 try - expect）没有处理处理这个异常时，异常会转交给 SetUnhandledExceptionFilter ，这是我们的应用程序处理异常的最后机会。 我们可以自己触发一个异常，然后不在 try-catch 中处理它，如果存在调试器则调试器就会接管这个异常，那么这个异常就不会走到我们的 SetUnhandledExceptionFilter 注册的异常处理
C语言实现windows反调试
05-21
在 Windows 平台上实现反调试可以采取多种方法，其中一种是使用 C 语言，以下是一些实现反调试的技术和方法： 1. 检测调试器 可在程序中使用 IsDebuggerPresent 函数来检测是否存在调试器。 2. 检测 PEB 可在程序中使用 PEB 结构体来检测进程是否正在被调试，通过检查 PEB 结构体中的 BeingDebugged 标志位来确定进程是否被调试。 3. 检测硬件断点 硬件断点是一种调试技术，可以在指定内存地址上设置断点，以便在访问该地址时触发断点。可以在程序中检测是否存在硬件断点。 4. 检测调试器附加 可以通过检查进程的父进程是否为调试器来检测调试器附加。 5. 防止反汇编 可以使用加密或混淆技术来防止反汇编，使得调试者难以分析代码。 需要注意的是，以上方法并不能完全保证程序不被调试，只能增加调试者的难度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值