应用层常见的反调试方法

最新推荐文章于 2023-03-24 23:26:32 发布
最新推荐文章于 2023-03-24 23:26:32 发布
阅读量947 收藏 1
点赞数

转载于:https://www.cnblogs.com/lanrenxinxin/p/5193920.html

稍稍总结一下在Crack或Rervese中比较常见的一些反调试方法，实现起来也比较简单，之后有写的Demo源码参考，没有太大的难度。

①最简单也是最基础的，Windows提供的API接口：IsDebuggerPresent()，这API实际上就是访问PEB的BeingDebugged标志来判断是否处于调试状态。

复制代码
if (IsDebuggerPresent()) //API接口
{
AfxMessageBox(L"检测到调试器");
}
else
{
AfxMessageBox(L"没有检测到调试器");
}
复制代码
②自己用汇编实现实现IsDebuggerPresent，如何获得PEB呢？在应用层，fs寄存器是指向当前线程的TEB结构的，而在内核层，fs寄存器指向PCR（Processor Control Region）的内存，其数据类型是KPCR。所以可以通过当前线程的TEB获得PEB，再取出BeingDebugged的值。

mov eax, fs:18h // TEB Self指针
mov eax, [eax+30h] // PEB
movzx eax, [eax+2] // PEB->BeingDebugged
复制代码
_asm
{
push eax; //TEB
mov eax, fs:[0x30]; // PEB
movzx eax, byte ptr[eax + 2]; //BeingDebugged
mov dword ptr[Value], eax; //取值
pop eax;
}
if (Value) //判断
{
AfxMessageBox(L"检测到调试器");
}
else
{
AfxMessageBox(L"没有检测到调试器");
}
复制代码
讲个题外话，也是关于FS寄存器的前两天有人是问了我一个问题，说是怎么让dll只被特定的进程加载，了解fs寄存器之后就很简单了，在dll加载的DllMain()函数中对加载的当前进程进行判断，看是否是自己的目标进程，如果不是，就拒绝被加载。下面是一段测试代码，可以获得当前进程的进程名。

复制代码
#include “windows.h” //这段测试代码可以获得当前进程名
#include “stdio.h”
int main(void)
{
LPSTR name;
__asm{
mov eax,fs:[0x18] //得到Teb 当线程运行于用户空间时段寄存器FS指向当前线程的TEB，FS:[0x18] 就是指在 //Self，其内容就是TEB的起点
mov eax,[eax+0x30] //Teb偏移0x30处指向Peb
mov eax,[eax+0xc] //Peb偏移 0xc 处指向 进程加载的模块的信息 _PEB_LDR_DATA结构
mov eax,[eax+0xc]
mov eax,[eax+0x30]
mov name,eax
}
wprintf(L"%s\n",name);
return 0;
}
复制代码
③NtGlobalFlag 也是类似于BeingDebugged的一个标志，在Peb中取出。如果是调试状态下,

NtGlobalFlag的值会是0x70，正常情况下不是。之前是利用fs寄存器获得的Peb基地址，这里使用Native API 的方法。

复制代码
HANDLE hProcess = NULL;
DWORD ProcessId = 0;
PROCESS_BASIC_INFORMATION Pbi;
PFNZwQueryInformationProcess pfunc_ZwQueryInformationProcess = NULL;
ProcessId = GetCurrentProcessId();
hProcess = OpenProcess(
PROCESS_ALL_ACCESS,
FALSE,
ProcessId
);
if (hProcess != NULL)
{
HMODULE hModule = LoadLibrary(L"ntdll.dll");
pfunc_ZwQueryInformationProcess = (PFNZwQueryInformationProcess)GetProcAddress(hModule, “ZwQueryInformationProcess”);
NTSTATUS Status = pfunc_ZwQueryInformationProcess(
hProcess,
ProcessBasicInformation,
&Pbi,
sizeof(PROCESS_BASIC_INFORMATION),
NULL
);
if (NT_SUCCESS(Status))
{
DWORD ByteRead = 0;
WORD NtGlobalFlag = 0;
bool bIsDebug = false;
ULONG PebBase = (ULONG)Pbi.PebBaseAddress;
if (ReadProcessMemory(hProcess, (LPCVOID)(PebBase + 0x68), &NtGlobalFlag, 2, &ByteRead) && ByteRead == 2)
{
// PEB.NtGlobalFlag
// +0x068 NtGlobalFlag : Uint4B
if (NtGlobalFlag == 0x70) //判断是否处于调试状态
{
bIsDebug = true;
}
}
if (bIsDebug)
{
AfxMessageBox(L"检测到调试器");
}
else
{
AfxMessageBox(L"没有检测到调试器");
}
}
CloseHandle(hProcess);
复制代码
④PEB.ProcessHeap.Flags 和ForceFlags

进程堆标志，系统创建进程时会将Flags置为0x02（HEAP_GROWABLE），将ForceFlags置为0。但是进程被调试时，这两个标志通常被设置为0x50000062h和0x40000060h。下面是检测代码

复制代码
HANDLE hProcess = NULL;
DWORD ProcessId = 0;
PROCESS_BASIC_INFORMATION Pbi;
PFNZwQueryInformationProcess pfunc_pZwQueryInformationProcess = NULL;
ULONG Flags = 0;
ULONG ForceFlags = 0;
switch (g_WinVersion)
{
case WINDOWS_VERSION_XP:
Flags = 0xC;
ForceFlags = 0x10;
break;
case WINDOWS_VERSION_2K3_SP1_SP2:
Flags = 0xC;
ForceFlags = 0x10;
break;
case WINDOWS_VERSION_7:
Flags = 0x40;
ForceFlags = 0x44;
break;
}
ProcessId = GetCurrentProcessId();
hProcess = OpenProcess(
PROCESS_ALL_ACCESS,
FALSE,
ProcessId
);

if (hProcess != NULL)
{
    HMODULE hModule = LoadLibrary(L"ntdll.dll");
    pfunc_pZwQueryInformationProcess = (PFNZwQueryInformationProcess)GetProcAddress(hModule, "ZwQueryInformationProcess");
    NTSTATUS Status = pfunc_pZwQueryInformationProcess(
        hProcess,
        ProcessBasicInformation,
        &Pbi,
        sizeof(PROCESS_BASIC_INFORMATION),
        NULL
        );
    if (NT_SUCCESS(Status))
    {
        DWORD ByteRead = 0;
        ULONG ProcessHeap = 0;
        DWORD HeapFlags = 0;
        DWORD ForceFlagsValue = 1;
        bool bIsDebug = false;
        ULONG PebBase = (ULONG)Pbi.PebBaseAddress;
        if (ReadProcessMemory(hProcess, (LPCVOID)(PebBase + 0x18), &ProcessHeap, 4, &ByteRead))
        {
            if (ReadProcessMemory(hProcess, (LPCVOID)(ProcessHeap + Flags), &HeapFlags, 4, &ByteRead))
            {
                // PEB.ProcessHeap.Flags

                // nt!_PEB
                // +0x018 ProcessHeap      : Ptr32 Void _HEAP

                // nt!_HEAP

                // WIN7 ProcessHeap 还有一个 Heap
                // +0x018 Heap : Ptr32 _HEAP


                // WIN7
                // +0x040 Flags            : Uint4B
                // +0x044 ForceFlags       : Uint4B

                // WIN2K3
                // +0x00C Flags            : Uint4B
                // +0x010 ForceFlags       : Uint4B

                // WINXP
                // +0x00C Flags            : Uint4B
                // +0x010 ForceFlags       : Uint4B

                if (HeapFlags != 2) //系统创建进程时会将其设置为HEAP_GROEABLE(0x2)
                {
                    bIsDebug = true;
                }

                else
                {
                    ReadProcessMemory(hProcess,(LPCVOID)(PebBase+ForceFlags),&ForceFlagsValue,4,&ByteRead);
                    if (ForceFlagsValue != 0)
                    {
                        bIsDebug = true;
                    }
                }
            }
        }
        if (bIsDebug)
        {
            AfxMessageBox(L"检测到调试器");
        }
        else
        {
            AfxMessageBox(L"没有检测到调试器");
        }
    }
    CloseHandle(hProcess);
}

复制代码
⑤检测父进程

一般双击运行的进程的父进程都是explorer.exe，但是如果进程被调试，父进程则是调试器进程，也就是说如果父进程不是explorer.exe，就可以认为有调试器存在。

复制代码
DWORD ExplorerId = 0;
PROCESSENTRY32 pe32 = {0};
CString str;
BOOL bIsDebug = FALSE;
DWORD ProcessId = GetCurrentProcessId();
// 获取 Explorer 进程ID
::GetWindowThreadProcessId(::FindWindow(L"Progman", NULL), &ExplorerId);
HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
if (hProcessSnap != INVALID_HANDLE_VALUE)
{
pe32.dwSize = sizeof(PROCESSENTRY32);
if (Process32First(hProcessSnap, &pe32))
{
do
{
if (ProcessId == pe32.th32ProcessID)
{
str.Format(L"进程ID:%d 父进程ID:%d Explorer进程ID:%d", ProcessId, pe32.th32ParentProcessID, ExplorerId);
if (pe32.th32ParentProcessID != ExplorerId)
{
bIsDebug = TRUE;
break;
}
}
}
while (Process32Next(hProcessSnap, &pe32));
}
AfxMessageBox(str);
}
if (bIsDebug)
{
AfxMessageBox(L"检测到调试器");
}
else
{
AfxMessageBox(L"没有检测到调试器");
}
CloseHandle (hProcessSnap);
复制代码
⑥SeDebugPrivilege权限判断

默认情况下进程是没有SeDebugPrivilege权限的，但是当进程通过OD或者xdbg等调试器启动时，由于调试器本身启动了SeDebugPrivilege权限，当调试进程被加载时SeDebugPrivilege也就被继承了。所以我们可以检测进程的SeDebugPrivilege权限来间接判断是否存在调试器，而对SeDebugPrivilege权限的判断可以用能否打开csrss.exe进程来判断

复制代码
HANDLE hProcess = NULL;
PROCESSENTRY32 Pe32 = {0};
HANDLE hProcessSnap = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hProcessSnap == INVALID_HANDLE_VALUE)
{
return;
}
Pe32.dwSize = sizeof(PROCESSENTRY32);

if (Process32First(hProcessSnap, &Pe32))
{
    do
    {
        if (_wcsicmp(L"csrss.exe", Pe32.szExeFile) == 0)
        {
            HANDLE hProcess = OpenProcess(
                PROCESS_ALL_ACCESS,
                FALSE,
                Pe32.th32ProcessID
                );

            if (hProcess)
            {
                AfxMessageBox(L"检测到调试器");
            }
            else
            {
                AfxMessageBox(L"没有检测到调试器");
            }
            CloseHandle(hProcess);
        }
    }
    while (Process32Next(hProcessSnap, &Pe32));
}
CloseHandle(hProcessSnap);

复制代码
⑦检测硬件断点，其实也不能算是完完全全对调试器的检测，只能说是检测硬件断点，通过设置SHE处理例程，然后自己手动触发异常来检测硬件断点。

复制代码
#pragma data_seg(".Hardware")
BOOL Hardwarei = FALSE;
DWORD addr = 0;
#pragma data_seg()
#pragma comment(linker, “/section:.Hardware,RWS”)

LONG WINAPI HardwareExceptionFilter(
PEXCEPTION_POINTERS ExceptionInfo
)
{
if (ExceptionInfo->ContextRecord->Dr0 != 0
|| ExceptionInfo->ContextRecord->Dr1 != 0
|| ExceptionInfo->ContextRecord->Dr2 != 0
|| ExceptionInfo->ContextRecord->Dr3 != 0)
{
Hardwarei = TRUE;
ExceptionInfo->ContextRecord->Dr0 = 0;
ExceptionInfo->ContextRecord->Dr1 = 0;
ExceptionInfo->ContextRecord->Dr2 = 0;
ExceptionInfo->ContextRecord->Dr3 = 0;
}
// 设置新的eip 让程序调转到safe执行
ExceptionInfo->ContextRecord->Eip = addr;
return EXCEPTION_CONTINUE_EXECUTION;
}

BOOL IsHardware()
{
LPTOP_LEVEL_EXCEPTION_FILTER lpsetun;
lpsetun = ::SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)HardwareExceptionFilter);
_asm
{
mov addr, offset safe;
int 3;
}
safe:
::SetUnhandledExceptionFilter(lpsetun);
return Hardwarei;
}

void CAntiDebugDlg::OnBnClickedButton12()
{
char *p = “aaaaaaaaaaaaaaddddddddddddddbbbbbbbbbbbb”;
if (IsHardware())
{
AfxMessageBox(L"检测到硬件执行断点");
}
else
{
AfxMessageBox(L"没有检测到硬件执行断点");
}
}
复制代码
⑧上面是通过SHE来检测硬件断点，当然还可以通过VEH来检测，思路是一样的，差别就是SHE与VEH，一个是针对线程的，一个是针对进程的。

复制代码
/***********************************************************************/
/ 硬件执行断点，VEH /
/***********************************************************************/
#pragma data_seg(".VehHardware")
BOOL VehHardwarei = FALSE;
DWORD Vehaddr;
#pragma data_seg()
#pragma comment(linker, “/section:.VehHardware,RWS”)

LONG NTAPI VehHardwareExceptionFilter(
PEXCEPTION_POINTERS ExceptionInfo
)
{
if (ExceptionInfo->ContextRecord->Dr0 != 0
|| ExceptionInfo->ContextRecord->Dr1 != 0
|| ExceptionInfo->ContextRecord->Dr2 != 0
|| ExceptionInfo->ContextRecord->Dr3 != 0)
{
VehHardwarei = TRUE;
ExceptionInfo->ContextRecord->Dr0 = 0;
ExceptionInfo->ContextRecord->Dr1 = 0;
ExceptionInfo->ContextRecord->Dr2 = 0;
ExceptionInfo->ContextRecord->Dr3 = 0;
}
// 设置新的eip 让程序调转到safe执行
ExceptionInfo->ContextRecord->Eip = Vehaddr;
return EXCEPTION_CONTINUE_EXECUTION;
}

BOOL IsVehHardware()
{
PVOID VEHandle = ::AddVectoredExceptionHandler(1, VehHardwareExceptionFilter);
_asm
{
mov Vehaddr, offset vehsafe;
int 3;
}
vehsafe:

if (VEHandle != NULL)
{
    RemoveVectoredExceptionHandler(VEHandle);
}
return VehHardwarei;

}

void CAntiDebugDlg::OnBnClickedButton16()
{
// TODO: 在此添加控件通知处理程序代码
char *p = “aaaaaaaaaaaaaaddddddddddddddbbbbbbbbbbbb”;

if (IsVehHardware())
{
    AfxMessageBox(L"检测到硬件执行断点");
}
else
{
    AfxMessageBox(L"没有检测到硬件执行断点");
}

}
复制代码
⑨利用异常处理 通过我们自己安装异常处理例程，然后手动触发异常，如果存在OD则不会走异常处理

复制代码
/***********************************************************************/
/ 异常处理判断是否存在OD /
/***********************************************************************/
#pragma data_seg(".excep")
BOOL Exceptioni = FALSE;
#pragma data_seg()
#pragma comment(linker, “/section:.excep,RWS”)

LONG WINAPI ExceptionFilter(
PEXCEPTION_POINTERS ExceptionInfo
)
{
Exceptioni = TRUE; //进行异常处理，则不存在OD
return EXCEPTION_CONTINUE_EXECUTION;
}
BOOL IsException()
{
ULONG OldProtect = 0;
LPTOP_LEVEL_EXCEPTION_FILTER lpsetun;
lpsetun = ::SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)ExceptionFilter); //安装自己的异常处理
LPVOID pBuff = ::VirtualAlloc(NULL, 0x1000, MEM_COMMIT, PAGE_READWRITE);
*((PWORD)pBuff) = 0xc3;
::VirtualProtect(pBuff, 0x1000, PAGE_EXECUTE_READ | PAGE_GUARD, &OldProtect);
_asm
{
call pBuff; //如果存在OD，会把这里的call 当成中断处理，不会进行异常处理
}
::SetUnhandledExceptionFilter(lpsetun); //将原来的异常处理恢复顶层
return Exceptioni;
}
void CAntiDebugDlg::OnBnClickedButton13()
{
// TODO: 在此添加控件通知处理程序代码
if (IsException())
{
AfxMessageBox(L"没有检测到调试器");
}
else
{
AfxMessageBox(L"检测到调试器");
}
}
复制代码
⑩单步异常检测

单步异常是调试器用来单步调试时使用，我们也可以用来检测调试器的存在，由我们自己设置标志寄存器的值，触发单步异常。如果存在调试器，这里的单步异常会由调试器进行处理，而不会走__except()异常处理，但这种检测方法的局限性就在于检测代码需要被调试器单步调试的时候才有效。扯个题外话，这里我还打算尝试一下C++11新支持的异常处理try{} /catch(){},没想到一弄直接就崩溃了，还是老老实实用__try/__except吧！

复制代码
/***********************************************************************/
/ 单步异常检测 /
/***********************************************************************/
//这种方法需要下面的汇编代码在单步跟中的时候才有效
void CAntiDebugDlg::OnBnClickedButton14()
{
// TODO: 在此添加控件通知处理程序代码
__try
{
// 触发单步异常
_asm
{
pushfd; //标志寄存器入栈
or dword ptr [esp], 100h; // 将 TF =1 单步
popfd;
}
AfxMessageBox(L"检测到调试器"); //如果不触发异常，说明有调试器
}
//catch(…) 用C++ 11的catch（）还是没有原生__except强大，用catch(…)这里会崩溃
__except(EXCEPTION_EXECUTE_HANDLER)
{
AfxMessageBox(L"没有检测到调试器");
}
}
复制代码
11.into使调试器一直循环。使用溢出中断，在没有调试器的情况下会走异常处理，然后正常的执行下去，如果存在OD则会自己处理中断，导致一直在这里循环。其实这里用into的溢出中断和int 3的中断效果是一样的，这里采用的是平时使用较少的into溢出中断。

复制代码
#pragma data_seg(".VehInto")
DWORD VehintoAddr = 0;
#pragma data_seg()
#pragma comment(linker, “/section:.VehInto,RWS”)
LONG NTAPI VehIntoExceptionFilter(
PEXCEPTION_POINTERS ExceptionInfo
)
{
// 设置新的eip 让程序调转到safe执行
ExceptionInfo->ContextRecord->Eip = VehintoAddr;
return EXCEPTION_CONTINUE_EXECUTION;
}
void IsVehIntoBreak()
{
PVOID VEHandle = ::AddVectoredExceptionHandler(1, VehIntoExceptionFilter);

_asm
{
    // 存放异常处理之后的偏移地址
    mov VehintoAddr, offset Intosafe;
    mov ecx, 1;
}

here:
_asm
{
/*
如果存在OD调试器，这里会一直循环下去。
*/
rol ecx, 1; //不停的循环左移，直至产生溢出，OF位为1
into; //溢出中断 ，会调用异常处理
jmp here;
}
Intosafe:

if (VEHandle != NULL)
{
    RemoveVectoredExceptionHandler(VEHandle);
}

}
void CAntiDebugDlg::OnBnClickedButton15()
{
// TODO: 在此添加控件通知处理程序代码
IsVehIntoBreak();
}
复制代码
12 . int 2d

复制代码
/***********************************************************************/
/ INT 2D /
/***********************************************************************/
BOOL IsInt2d()
{
__try
{
__asm
{
int 2dh;
inc eax;//any opcode of singlebyte.如果开启VT会崩溃
//;or u can put some junkcode,“0xc8”…“0xc2”…“0xe8”…“0xe9”
}
return TRUE;
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
return FALSE;
}
}
void CAntiDebugDlg::OnBnClickedButton21()
{
// TODO: 在此添加控件通知处理程序代码
if (IsInt2d())
{
AfxMessageBox(L"检测到调试器");
}
else
{
AfxMessageBox(L"没有检测到调试器");
}
}
复制代码
13. 检验内存校验和

调试器（OD）在设置断点会改变内存属性，改写为0xCC，我们需要检验自身的某一个段内存的校验和就可以判断是否有调试器的存在

复制代码
/***********************************************************************/
/ CheckSum /
/***********************************************************************/
BOOL CheckSum()
{
BOOL bFoundOD;
bFoundOD = FALSE;
DWORD CHECK_SUM = 5555; //正确校验值
DWORD dwAddr;
dwAddr = (DWORD)CheckSum;

__asm
{
    ; 检测代码开始
    mov     esi, dwAddr;
    mov     ecx, 100;
    xor     eax, eax;

checksum_loop:
movzx ebx, byte ptr [esi];
add eax, ebx;
rol eax, 1;
inc esi;
loop checksum_loop;

    cmp     eax, CHECK_SUM;
    jz      ODNotFound;
    mov     bFoundOD, 1;

ODNotFound:
}
return bFoundOD;
}
void CAntiDebugDlg::OnBnClickedButton27()
{
// TODO: 在此添加控件通知处理程序代码
if (CheckSum())
{
AfxMessageBox(L"检测到调试器");
}
else
{
AfxMessageBox(L"没有检测到调试器");
}
}
复制代码
14. 保护页异常

当执行一个属性为PAGE_GUARD的页面时，触发EXCEPTION_GUARD_PAGE的异常，如果存在调试器一般都是由调试器处理了。

复制代码
/***********************************************************************/
/ “保护页异常” /
/***********************************************************************/
//当应用程序尝试执行保护页内的代码时，将会产生一个EXCEPTION_GUARD_PAGE(0x80000001)异常

BOOL IsGuardPages()
{
SYSTEM_INFO sSysInfo;
DWORD dwPageSize = 0;
DWORD OldProtect = 0;
GetSystemInfo(&sSysInfo);
dwPageSize = sSysInfo.dwPageSize;
LPVOID lpvBase = VirtualAlloc(NULL, dwPageSize, MEM_COMMIT, PAGE_READWRITE);
if (lpvBase == NULL)
{
return FALSE;
}
PBYTE lptmpB = (PBYTE)lpvBase;
*lptmpB = 0xc3; //retn
VirtualProtect(lpvBase, dwPageSize, PAGE_EXECUTE_READ | PAGE_GUARD, &OldProtect);
__try
{
__asm call dword ptr[lpvBase];
VirtualFree(lpvBase, 0, MEM_RELEASE);
return TRUE;
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
VirtualFree(lpvBase, 0, MEM_RELEASE);
return FALSE;
}
}

void CAntiDebugDlg::OnBnClickedButton25()
{
// TODO: 在此添加控件通知处理程序代码
if (IsGuardPages())
{
AfxMessageBox(L"检测到调试器");
}
else
{
AfxMessageBox(L"没有检测到调试器");
}
}
复制代码
14. 还有就是关于调试对象的检测，这里就牵扯到内核层的问题，一些基础内容就不进行赘述了。如果往深了研究可以学习系统的内核调试引擎，折腾TX的游戏TP反双机调试。这里只给出一些在应用层利用的比较简单的检测方法。

检测调试对象DebugObject

复制代码
/***********************************************************************/
/ ZwQueryObject /
/***********************************************************************/

#ifndef STATUS_INFO_LENGTH_MISMATCH
#define STATUS_INFO_LENGTH_MISMATCH ((NTSTATUS)0xC0000004L)
#endif
void CAntiDebugDlg::OnBnClickedButton24()
{
POBJECT_TYPES_INFORMATION pTypesInfo = NULL;
ULONG dwSize = 0;
PFNZwQueryObject pfunc_ZwQueryObject;

HMODULE hModule = LoadLibrary(L"ntdll.dll");

pfunc_ZwQueryObject = (PFNZwQueryObject)GetProcAddress(hModule, "ZwQueryObject");

if (pfunc_ZwQueryObject)
{
    NTSTATUS Status = pfunc_ZwQueryObject(
        NULL,
        ObjectAllTypesInformation,
        NULL,
        0,
        &dwSize
        );

    if (Status == STATUS_INFO_LENGTH_MISMATCH)
    {
        pTypesInfo = (POBJECT_TYPES_INFORMATION)VirtualAlloc(NULL, dwSize, MEM_COMMIT, PAGE_READWRITE);

        if (pTypesInfo == NULL) return;

        Status = pfunc_ZwQueryObject(
            NULL,
            ObjectAllTypesInformation,
            pTypesInfo,
            dwSize,
            &dwSize
            );

        if (!NT_SUCCESS(Status))
        {
            AfxMessageBox(L"查询错误");
            VirtualFree (pTypesInfo, 0, MEM_RELEASE);
            return;
        }
        for (UINT i = 0; i < pTypesInfo->NumberOfTypes; i++)
        {
            if (pTypesInfo->TypeInformation[i].TypeName.Buffer != NULL)
            {
                if (_wcsicmp(pTypesInfo->TypeInformation[i].TypeName.Buffer, L"DebugObject") == 0)
                {
                    AfxMessageBox(L"发现OD");
                    VirtualFree (pTypesInfo, 0, MEM_RELEASE);
                    return;
                }
            }
        }
        AfxMessageBox(L"没有OD!");
        VirtualFree (pTypesInfo, 0, MEM_RELEASE);
    }
}

}
复制代码

DebugObjectHandle

复制代码
/***********************************************************************/
/ ProcessDebugObjectHandle /
/***********************************************************************/
void CAntiDebugDlg::OnBnClickedButton22()
{
// TODO: 在此添加控件通知处理程序代码
HANDLE hProcess = NULL;
DWORD dwResult;
PFNZwQueryInformationProcess pfunc_ZwQueryInformationProcess;

HMODULE hModule = LoadLibrary(L"ntdll.dll");

pfunc_ZwQueryInformationProcess = (PFNZwQueryInformationProcess)GetProcAddress(hModule, "ZwQueryInformationProcess");

pfunc_ZwQueryInformationProcess(
    GetCurrentProcess(),
    ProcessDebugObjectHandle,
    &dwResult,
    4,
    NULL
    );
if (dwResult != 0)
{
    AfxMessageBox(L"检测到调试器");
}
else
{
    AfxMessageBox(L"没有检测到调试器");
}

}
复制代码
一篇关于Anti不错的文章，不过是英文的，可以参考：anti-unpackers.pdf

http://www.openrce.org/reference_library/anti_reversing_view/34/INT 2D Debugger Detection/

xlaomlng
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
.NET下的终极反调试
12-23
.NET下的终极反调试
Windows 下常见的反调试方法
r250414958的博客
11-15 1159
稍稍总结一下在Crack或Rervese中比较常见的一些反调试方法，实现起来也比较简单，之后有写的Demo源码参考，没有太大的难度。 ①最简单也是最基础的，Windows提供的API接口： IsDebuggerPresent()，这API实际上就是访问PEB的BeingDebugged标志来判断是否处于调试状态。 if (IsDebuggerPresent()) //API接口 { ...
一些反调试手段及对应的逆向思路
iopoint的专栏
07-06 1433
实践还少，暂且没遇到，不过先来打个预防针，熟悉下。 首先什么是反调试：防止程序被调试，保护代码。一种加固手段。 万事无绝对，不能阻止，但能缓解，让破解者消费精力。一般的，该手段会与加壳并用。 如何来反调试呢？大方向有两类：检测，攻击。 1. 检测 检测程序是否被调试，若是的话做出一些“反”措施，例如退出，跳到其他位置等。 2. 攻击 让调试器崩溃，阻止调试。 1.一般的，大多通过另启进程或线程。 基础知识：一个进程最多只能被一个进程ptrace：调试状态下，linux向/proc/p.
反调试 - TrapFlag
LYSM
07-13 902
原理 TrapFlag（陷阱标志位）。这种反调试手段属于异常的范畴，通过设置 eflags 寄存器的值来触发某个异常，当存在调试器时这个异常由调试器接管（不走我们 的异常处理回调函数），但调试器也可以选择不接管这个异常，所以这属于一种低级的反调试手段 ????。 代码（以单步异常为例） // Test_Console_1.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // #include <iostream> #include <Windows.h>
C & C 深入理解Windows X64调试
xlaomlng的博客
03-14 225
http://www.cnblogs.com/lanrenxinxin/p/4762858.html
易语言源码易语言反调试模块源码.rar
02-18
易语言是一种基于中文编程的计算机程序设计语言，它旨在降低编程的难度，让不懂英文的用户也能进行软件开发。...然而，需要注意的是，不正当使用反调试技术可能涉及法律问题，因此在实际应用中应遵守相关法律法规。
Android中的反调试代码
05-29
本文将深入探讨Android应用中的反调试策略及其实施方法。 首先，我们需要理解调试的基本原理。调试器（如Android Debug Bridge, ADB或第三方工具如DDMS）允许开发者查看和控制应用程序的运行过程，以便查找和修复...
Android 反动态调试
05-07
Android 检查动态调试 最近项目中，三方安全报告中一直存在动态调试检测的高危漏洞。经过多次探索研究，参考了网上不少示例，集大家所成，研究在Android studio 3.0以上，可以使用的示例代码。
Android安卓安全加固反调试检测手段（java层+native层）（附代码实现）.pdf
11-25
本文档实现了java层和native层的反调试手段 对于学习Android安卓逆向和安全的人来说有非常大的借鉴意义 里面附有详细的实现代码
关于滴水的VT调试器
whatday的专栏
04-06 7241
关于滴水的VT调试器 by 海风月影 论坛上今天吵的比较火热，主要是关于滴水的VT调试器，很多人不了解这个东西，我对Intel的VT技术略有了解，所以我来简单的介绍一下。 第一，什么是VT技术 VT是Intel的硬件虚拟化技术，说到VT，就不得不提虚拟机（例如VMWare）。在硬件还没有支持VT前，系统级的虚拟机其实是很难做的，要考虑的 东西非常多（主要是效率问题，因为用软件模拟
关于Win7 x64下过TP保护(应用层)（转）
weixin_30565327的博客
07-21 1058
非常感谢大家那么支持我上一篇教程。Win10 快出了，所以我打算尽快把应用层的部分说完。调试对象：DXF调试工具：CE、OD、PCHunter、Windbg调试先言：TP的应用层保护做得比较多，包括对调试器的检测，比如CE工具会被DXF报非法。有的保护还是内核与应用层交替保护。应用层：1、TP让调试器卡死(内核互动)现象:<ignore_js_op>如图，TP会检测调试器让调试器暂...
原神反调试分析
u011442768的博客
10-21 1万+
打开CE，打开原神启动器。 至此，游戏未加载驱动。启动器可以被CE正常读写。 打开原神，CE中选择YuanShen.exe,发现原神并不能被读写。 尝试分析不能读写的原因。 CE调用的读取内存函数是NtReadVirtualMemory 猜测有三种可能 1.NtReadVirtualMemory被HOOK 2.ObCallBack 3.infinityhook 第一种情况因为X64系统PatchGuard的存在排除。当然VT也是有可能的，现在先不考虑。 第二种情况是最有可能的。 第三种情况感觉不大靠谱。
汇编级别反调试（2）
最新发布
青月的成长记录吖
03-24 469
如果可执行文件最初是在没有上述结构的情况下创建的，或者 GlobalFlagsClear = 0，则在磁盘或内存中，该字段将具有非零值，表示存在隐藏的调试器。如果程序是32位的，但是运行在64位系统上，遇到 WOW64 “天堂门”技术，可以通过下面代码，获取到单独创建的PEB结构： 你可以参考Get 32bit PEB of another process from a x64 process 同样的需求： 64位进程需要获取运行在WOW64中32位程序的PEB环境。并在原始调用结束后恢复线程环境。
无限debugger反调试和设置打开调试工具回调
热门推荐
Army-海军的博客
07-05 1万+
有的时候不想让别人知道网站的源代码，比如网站是视频网站，资源网站，或者非常安全类的用户交互网站，都不想让别人看到自己源码或者不想让爬虫那么轻易就进来。但是道高一尺魔高一丈的，总有办法破开的、、防护一下中级还是可以的 有的时候比如网站中有下载链接或者播放链接，想要再打开调试模式时就删除，这个时候就用到了，话不多说上代码。 setInterval(function() { debugger }...
4.VEH（向量化异常处理）
My classmates
10-30 6869
当用户异常产生后,内核函数KiDispatchException并不是像处理内核异常那样在0环直接进行处理,而是修正3环EIP为KiUserExceptionDispatcher函数后就结束了。 这样,当线程再次回到3环时,将会从KiUserExceptionDispatcher函数开始执行。 (ntdll.dll) KiUserExceptionDispatcher函数分析 调用 RtIDis...
给游戏或代码增加反调试功能（应用层级）
weixin_44389943的博客
02-27 688
前言： 感谢：易道云学院 tiger老师指导： 调试分为：打开一个调试进程和调试一个现有的进程。 DebugByCreate为真时调用CreateProcess()函数打开一个调试进程，当DebugByCreate为假时调用DebugActiveProcess(dwPID)函数调试一个现有的程序。 一、调用CreateProcess()函数打开一个调试进程： 调用CreateProcess()函数实际底层调用： 二、调用DebugActiveProcess(dwPID)函数调试一个现有的程序
利用veh完成内存补丁功能，以躲避运行时内存检测
LLC
03-31 1660
点击打开链接
从异常分发流程的实现看反用户调试器
xlaomlng的博客
06-21 247
https://www.jianshu.com/p/9071fd7e4388
SPAD：硬件虚拟化技术在反调试中的应用
目前的反调试策略包括各种通用方法，但它们的弱点在于容易被破解，尤其是当其原理和代码公开时。此外，这些方法往往开销较大，且不能动态加载。 为解决这些问题，基于硬件虚拟化的反调试技术应运而生。硬件虚拟化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值