代码实现#

1
#include <stdio.h>
2
#include <Windows.h>
3
#include <stdlib.h>
4

5
int main()
6
{
7
    if(IsDebuggerPresent()){
8
        printf("I am debugged\n");
9
        exit(0);
10
    }
11
    else{
12
        printf("not debugged\n");
13
    }
14
    return 0;
15
}

对抗#

实际上是使用IsDebuggerPresent和exit来实现反调试，只要处于调试状态，就会触发exit(0)结束进程

对抗它的方法，一般是patch RAX寄存器的值

使得检测到调试状态也不触发exit(0)

代码实现#

1
#include <stdio.h>
2
#include <windows.h>
3

4
int main(int argc, char* argv[])
5
{
6

7
    DWORD Debug = 0;
8
    __asm
9
    {
10
        mov eax, fs: [0x18]      // TEB基地址
11
        mov eax, [eax + 0x30]    // 找到PEB
12
        mov eax, [eax + 0x68]    // 找到 NtGlobalFlag
13
        mov Debug, eax           // 取出值
14
    }
15

16
    if (Debug == 0x70)
17
    {
18
        printf("Debugger! \n");
19
        exit(-1);
20
    }
21
    else
22
    {
23
        printf("No debugger \n");
24
    }
25

26
    system("pause");
27
    return 0;
28
}

对抗#

可以通过修改NtGlobalFlag结果来绕过

• BeingDebugged同理，把1 patch 为0即可

HeapFlags#

• 对于 x64 系统，vista 以上版本的 HeapFlags 位于 *ProcessHeap+ 0x70，剩余低版本的 windows 中的 HeapFlags 位于 *ProcessHeap+ 0x14

• 对于 x86 系统 vista 以上版本的 HeapFlags 位于 *ProcessHeap + 0x40，剩余低版本的 windows 中的 HeapFlags 位于 *ProcessHeap + 0x0c

1
ULONG64 ul_processHeap = (ULONG64)(__readgsqword + 0x30);
2
ULONG64 ul_heapFlags = (ULONG64)(*ul_processHeap + 0x70);
3
if(*ul_heapFlags > 2){
4
  cout << "发现调试器" << endl;
5
}
6
else{
7
  cout << "没有调试器" << endl;
8
}
9

10
// win11 x64

HeapForceFlags#

• 对于 x64 系统，vista 以上版本的 HeapForceFlags位于 *ProcessHeap+ 0x74，剩余低版本的 windows 中的 HeapForceFlags 位于 *ProcessHeap+ 0x18

• 对于 x86 系统 vista 以上版本的 HeapForceFlags 位于 *ProcessHeap + 0x44，剩余低版本的 windows 中的 HeapForceFlags 位于 *ProcessHeap + 0x10

代码实现#

要调用NtQueryInformationProcess函数，需要动态加载

1
#include <windows.h>
2
#include <stdio.h>
3

4
// 定义 PROCESSINFOCLASS 枚举类型和 ProcessDebugPort 常量
5
typedef enum _PROCESSINFOCLASS {
6
    ProcessDebugPort = 7
7
} PROCESSINFOCLASS;
8

9
int main()
10
{
11
    // 动态加载 ntdll.dll
12
    HMODULE hNtdll = GetModuleHandleA("ntdll.dll");
13
    if (!hNtdll) {
14
        printf("Failed to load ntdll.dll\n");
15
        return -1;
16
    }
17

18
    // 获取 NtQueryInformationProcess 函数的地址
19
    FARPROC NtQueryInformationProcess = GetProcAddress(hNtdll, "NtQueryInformationProcess");
20
    if (!NtQueryInformationProcess) {
21
        printf("Failed to get NtQueryInformationProcess address\n");
22
        return -1;
23
    }
24

25
    // 检查进程的调试端口
26
    HANDLE hProcess = GetCurrentProcess();
27
    UINT64 debugPort;
28
    NTSTATUS status = ((NTSTATUS(WINAPI*)(HANDLE, PROCESSINFOCLASS, PVOID, UINT64, PULONG))NtQueryInformationProcess)(
29
        hProcess,
30
        ProcessDebugPort,
31
        &debugPort,
32
        sizeof(debugPort),
33
        NULL
34
        );
35

36
    if (status == 0 && debugPort != 0) {
37
        printf("Debugger is attached.\n");
38
        exit(-1);
39
    }
40
    else {
41
        printf("No debugger is attached.\n");
42
    }
43
    return 0;
44
}

ProcessDebugPort设置为7的原因参考NtQueryInformationProcess 函数 (winternl.h) - Win32 apps | Microsoft Learn

这里被小坑了一手，官方里的debugPort定义用的ULONG(win32)，为32位。

而我是64位系统，需要改为UINT64

对抗#

修改NtQueryInformationProcess得到的结果debugPort即可绕过

对抗#

同上修改函数的第三个参数即可

对抗#

同上修改函数第三个参数即可

代码实现#

1
#include <iostream>
2
#include <Windows.h>
3
#include <intrin.h>
4

5
using namespace std;
6

7
typedef struct _SYSTEM_KERNEL_DEBUGGER_INFORMATION {
8
  BOOLEAN KernelDebuggerEnabled;
9
  BOOLEAN KernelDebuggerNotPresent;
10
} SYSTEM_KERNEL_DEBUGGER_INFORMATION, * PSYSTEM_KERNEL_DEBUGGER_INFORMATION;
11
typedef NTSTATUS(WINAPI* pNtQuerySystemInformation)(IN UINT SystemInformationClass, OUT PVOID SystemInformation, IN ULONG SystemInformationLength, OUT PULONG ReturnLength);
12

13
int main()
14
{
15
  // 取 NtQuerySystemInformation 地址
16
  pNtQuerySystemInformation NtQuerySystemInformation = (pNtQuerySystemInformation)GetProcAddress(LoadLibrary(L"ntdll.dll"), "NtQuerySystemInformation");
17
  if (NtQuerySystemInformation == NULL) {
18
    goto main_end;
19
  }
20

21
  // 获取系统信息
22
  SYSTEM_KERNEL_DEBUGGER_INFORMATION KdDebuggerInfo;
23
  if (NtQuerySystemInformation(
24
    0x23,                      // 要检索的系统信息的类型: SystemInterruptInformation
25
    &KdDebuggerInfo,                // 接受请求信息
26
    sizeof(SYSTEM_KERNEL_DEBUGGER_INFORMATION),    // 请求信息的字节大小
27
    NULL
28
  ) != 0) {
29
    goto main_end;
30
  }
31

32
  if (KdDebuggerInfo.KernelDebuggerEnabled || !KdDebuggerInfo.KernelDebuggerNotPresent) {
33
    cout << "Debugger!" << endl;
34
  }
35
  else {
36
    cout << "No debugger" << endl;
37
  }
38

39
main_end:
40
  getchar();
41
  return 0;
42
}

对抗#

在jz/jnz指令处直接修改IP寄存器跳到后⾯的正常代码

为什么我们要使用异常处理机制？#

当我们敲代码时，我们都知道，程序出现bug是很正常的，有些比较简单的错误，或者有些强大编译工具，在编译的时候能够将我们的错误直接寻找出来，然后告诉你某某行出现了错误，你直接去该地方，但是如果你写的程序，在编译时并没有出现错误，由于一些未考虑到的地方，和一些运行时，错误的输入，就如以下情况

例如： 1、做除法的时候除数为 0； 2、用户输入年龄时输入了一个负数； 3、用 new 运算符动态分配空间时，空间不够导致无法分配； 4、访问数组元素时，下标越界；打开文件读取时，文件不存在。

在这些情况下，虽然我们能通过编译，但是，运行的时候，我们可以发现，我们的程序会莫名其妙的强行停止，没有任何的信息和提示，出错点有这么多，我们如何才能知道到底出现的是什么错误呢？如何才能在程序g掉的时候，在最后一刻给我们发送一个信息告诉我们错在哪儿呢？

这个时候，我们创造出异常处理机制来帮我们解决这个问题。

什么是异常处理？#

正如其名，所谓异常就是在应用程序正常执行过程中发生了不正常的运行。

简单来理解，就是我们写一段代码，在发生一些可预测的异常，甚至或者不可预测的异常时执行我们想要它做的代码，可以是反馈给我们错误信息，可以是修复，使得程序继续正常运行等操作。

说到异常，我们必须要分辨一下，我们平常所说的异常和中断的区别。

中断，由外部硬件设备或异步事件产生。

异常由程序的内部事件产生，异常可以分为故障，陷阱，和终止。

异常处理的栈展开的实现#

C++ 引入了异常处理机制。其基本思想是：函数 A 在执行过程中发现异常时可以不加处理，而只是“拋出一个异常”给 A 的调用者，假定为函数 B。 拋出异常而不加处理会导致函数 A 立即中止，在这种情况下，函数 B 可以选择捕获 A 拋出的异常进行处理，也可以选择置之不理。如果置之不理，这个异常就会被拋给 B 的调用者，以此类推。 如果一层层的函数都不处理异常，异常最终会被拋给最外层的 main 函数。main 函数应该处理异常。如果main函数也不处理异常，那么程序就会立即异常地中止

栈展开 Q:简述一下“栈展开”的过程?A:栈展开的就是指匹配catch子句的过程。具体匹配过程如下：1）当程序抛出一个异常或者在try块中检测到异常时就会停止执行当前的调用链，开始寻找与异常匹配的catch子句。2）当在try块中出现一个throw语句或者在try块中调用了可能出现异常的函数时，首先检查与该try块匹配的catch语句（一个try可能对应多个catch），逐个检查，直到找到匹配的即停止寻找，进入该catch执行处理异常的程序。（注意，匹配不代表最佳匹配，所以最佳的匹配要放在catch的最前端）。3）如果执行过程2）还是没有找到匹配的catch，且当前try嵌套在外部的try块中，则程序就会在外部的try块中查找，直到找到匹配的为止。4）如果执行过程3）还是没有找到匹配的catch语句，则退出当前调用的函数，继续在退出为止的函数的其他函数中寻找，以此类推。5）如果最终执行完上述步骤后还是没有找到匹配的catch，则就是说异常得不到处理（没有被捕获），程序会调用标准库函数terminate终止函数的执行。

c++异常处理的代码简单探索#

通过写代码，我们能对异常处理有一个更直观的认识。

c++在代码的异常处理上，运用的是，try..throw…catch

首先运行try里面，如果遇到异常，就throw抛出一个异常，然后直接调转到catch块，执行我们catch块的代码，这个catch代码里面我们可以打印错误信息，也可以修复错误让程序恢复正常，或者是当发生无可挽回的终止错误，我们可以紧急保存状态，将一些操作执行完，比如将数据输出到文件等。

try-catch 是一种异常处理机制，用于捕获和处理异常。通过使用 try 关键字将可能引发异常的代码块括起来，然后使用 catch 关键字来指定对特定类型的异常进行处理。

下面是 try-catch 异常处理的基本语法形式：

1
try {
2
    // 可能引发异常的代码块
3
} catch (异常类型1 异常对象1) {
4
    // 对异常类型1 的处理代码
5
} catch (异常类型2 异常对象2) {
6
    // 对异常类型2 的处理代码
7
}
8
// 可选的其它代码

当 try 代码块中的代码引发异常时，异常会被抛出，然后依次检查 catch 块的异常类型，如果匹配到相应的异常类型，则执行对应的 catch 块中的代码。

在 catch 块中，您可以根据需要对捕获的异常做相应处理，例如输出错误消息、记录日志、重新抛出异常或采取其他适当的措施。

例如，以下示例演示了如何使用 try-catch 来找到并处理 std::exception 类型的异常：

1
#include <iostream>
2
#include <exception>
3
int main() {
4
    try {
5
        // 可能引发异常的代码块
6
        throw std::exception();
7
    } catch (const std::exception& e) {
8
        // 对 std::exception 类型的异常进行处理
9
        std::cout << "捕获到异常: " << e.what() << std::endl;
10
    }
11

12
    return 0;
13
}

在这个示例中，我们使用 throw 语句故意引发 std::exception 异常，并在 catch 块中捕获该异常，然后输出异常信息。

需要注意的是，catch 块中指定的异常类型应该与实际引发的异常类型相匹配或为其基类。

通过使用多个 catch 块，可以针对不同的异常类型编写特定的处理代码，以实现对特定异常的处理。

关于异常处理我们还需了解的点#

栈展开: 异常抛出后如果在当前函数内没有被捕捉(catch)，它就要沿着函数的调用链继续往上抛，直到走完整个调用链，或者在某个函数中找到相应的 catch。如果走完调用链都没有找到相应的 catch，那么 std::terminate() 就会被调用(也就是传到主函数那），这个函数默认是把程序终止掉(abort)，而如果最后找到了相应的 catch，就会进入该 catch 代码块，执行相应的操作。在这个不断向上抛出异常的过程中，如果不能得到对应catch的处理，就退出当前函数，并且释放当前函数的内存并销毁局部对象，继续到上层的调用函数中查找，直到找到一个可以处理该异常的 catch 。这个过程就是栈展开。

为什么要进行栈展开？

1.当程序出现异常时，可以将函数调用栈展开，查找能够处理该异常的代码位置，并执行相应的异常处理操作。

2.可以为程序调试提供帮助。在程序崩溃时，调试器可以通过栈展开来获取函数调用栈的信息，包括每个函数的参数、局部变量和返回值等，从而方便开发人员分析和修复问题。

3.当函数中存在需要释放内存的对象时，栈展开可以确保这些对象在函数退出时被正确地清理。如果没有栈展开，这些对象可能会在函数未正常退出时被遗留下来，导致内存泄漏等问题。

SEH的机制#

异常处理程序或 __except 块，可以根据 *filter-expression* 值响应或消除异常。

终止处理程序或 __finally 块，无论异常是否导致终止，都始终调用这两者

这两种类型的处理程序是不同的，但会通过称为“展开堆栈”的过程紧密关联。 发生结构化异常时，系统将查找当前处于活动状态的最新安装的异常处理程序。 该处理程序可以执行以下三个操作之一：

• 无法识别异常并将控件传递给其他处理程序 (EXCEPTION_CONTINUE_SEARCH)。
• 识别异常，但将其消除 (EXCEPTION_CONTINUE_EXECUTION)。
• 识别异常并处理它 (EXCEPTION_EXECUTE_HANDLER)。

识别异常的异常处理程序可能不在异常发生时正在运行的函数中。 它可能在堆栈上高得多的函数中。 当前正在运行的函数和堆栈帧上的所有其他函数都将终止。 在此过程中，堆栈会展开。 也就是说，已终止函数的局部非静态变量会从堆栈中清除。

当它展开堆栈时，操作系统将调用你为每个函数编写的任何终止处理程序。 通过使用终止处理程序清理资源，否则资源将由于异常终止而保持打开状态。 如果你已输入了关键部分，可以在终止处理程序中退出它。 程序将要关闭时，你可以执行其他维护任务，如关闭和删除临时文件。

CTF中SEH的使用#

Windows中有一个机制叫异常处理机制，当出现异常的时候操作系统会先把异常抛给调试器并停止在该指令位置，如果没有调试器就会抛给SEH来处理，SEH实现的原理是内部是一个SEH链表包含了一系列异常处理函数，当有异常类添加进来的时候操作系统会把异常添加到SEH链表里面，然后当异常出现的时候遍历异常类看看有没有对应的异常处理，如果该异常没有异常处理则直接程序崩溃。

所以对于此方面的处理，由于出题人会将我们的关键代码，放入SEH断下来之后，从而实现了代码的隐藏，所以处理此类题目我们的思路就是，就是去寻找出题人隐藏的代码，其中有两方面，一方面就是观察主程序的汇编，对于jmp要特别主要，大多数，就会出现一个莫名的jmp跳过了一大段的内容，这是因为使用了SEH处理机制，将SEH断入，就会执行我们那跳过的代码。所以我们只需修改跳转即可，另外如果主程序没有而是在其他地方调用，这就需要我们进行动态调试了，通过动态调试确定我们数据被修改的地方，也能找到被出题人隐藏的代码。

对抗#

注意到该处 ZwSetInformationThread 函数的第 2 个参数为 ThreadHideFromDebugger，其值为 0x11。调试执行到该函数时，若发现第 2 个参数值为 0x11，跳过或者将 0x11 修改为其他值即可

绕过方法#

对ZwCreateThreadEx进行hook过滤，去掉线程ThreadHideFromDebugger属性

[SP]代码完整性校验反调#

此类反调试也是基于INT 3实现，比如取main函数的地址去进行某个计算，得到的值是固定的(因为main函数完整)。假如在main函数中下了软件断点，就会破坏代码完整性，导致运算值匹配不上，从而触发反调试逻辑

代码实现#

结合使用GetCurrentProcess()来获得当前进程的伪句柄，来实现反调试

1
#include <windows.h>
2
#include <stdio.h>
3

4
int main()
5
{
6
    BOOL isDebugger = FALSE;
7
    CheckRemoteDebuggerPresent(GetCurrentProcess(), &isDebugger);
8
    if (isDebugger)
9
    {
10
        printf("debugger is attached.\n");
11
        exit(-1);
12
    }
13
    else
14
    {
15
        printf("No debugger is attached.\n");
16
    }
17
    return 0;
18
}

对抗#

• 可以在此处patch RAX的值为0，相当于把伪句柄改为0，自然而然isDebugger返回0

• 也可以在下面test eax eax处把rax patch为0，相当于把true改为flase

(一) 基础知识#

天堂之门，是建立在WoW64技术上的逆向反调试技术

要去认识它，需要先明白64位系统中32位应用程序的执行过程以及WoW64是什么

(二) WoW64实现过程#

32位程序首先调用32位ntdll.dll中的32位函数

再由ntdll.dll调用wow64cpu.dll中的X86SwitchTo64BitMode，就是调用该函数后进程从32位模式切换到64位模式，wow64.dll将32位的系统调用转化为64位

再调用64位ntdll.dll中的64位函数

1
// x86 to x64
2
6A 33                    ; push 0x33      ; 将值 0x33 压入栈顶（此值将用于修改 CS 段寄存器）
3
E8 00 00 00 00           ; call $+5       ; 将下一条指令的地址（即当前 EIP+5）压入栈中，并继续执行下一条指令
4
83 04 24 05              ; add dword [esp], 5  ; 修改栈顶的返回地址，将其增加 5，指向 `retf` 之后的下一条指令
5
CB                       ; retf           ; 通过 `retf`（返回并修改段寄存器），使程序跳转到返回地址，同时将 `CS` 段寄存器修改为 0x33，切换到 64 位模式
6

7
// x64 to x86
8
E8 00 00 00 00           ; call $+5       ; 将下一条指令的地址（即当前 RIP+5）压入栈中，并继续执行下一条指令
9
C7 44 24 04 23 00 00 00  ; mov dword [rsp + 4], 0x23 ; 将栈中返回地址的高 32 位修改为 0x23，指示程序返回时切换到 32 位模式
10
83 04 24 0D              ; add dword [rsp], 0xD ; 修改栈顶的返回地址，将其增加 0xD，指向 `retf` 之后的下一条指令
11
CB                       ; retf           ; 通过 `retf`，程序跳转回 32 位模式，并继续执行跳转后的代码

1
#include "stdio.h"
2
#include "windows.h"
3
#include "Shlobj.h"
4
#include "tchar.h"
5
#pragma comment(lib, "Shell32.lib")
6

7
int _tmain(int argc, TCHAR* argv[])
8
{
9
    HKEY    hKey = NULL;
10
    HANDLE  hFile = INVALID_HANDLE_VALUE;
11
    TCHAR   szPath[MAX_PATH] = { 0, };
12
    ////////////////
13
    // system32 folder
14
    if (GetSystemDirectory(szPath, MAX_PATH))
15
    {
16
        _tprintf(L"1) system32 path = %s\n", szPath);
17
    }
18
    ////////////////
19
    // File size
20
    _tcscat_s(szPath, L"\\kernel32.dll");
21
    hFile = CreateFile(szPath, GENERIC_READ, FILE_SHARE_READ, NULL,
22
        OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
23
    if (hFile != INVALID_HANDLE_VALUE)
24
    {
25
        _tprintf(L"2) File size of \"%s\" = %d\n",
26
            szPath, GetFileSize(hFile, NULL));
27
        CloseHandle(hFile);
28
    }
29
    ////////////////
30
    // Program Files
31
    if (SHGetSpecialFolderPath(NULL, szPath,
32
        CSIDL_PROGRAM_FILES, FALSE))
33
    {
34
        _tprintf(L"3) Program Files path = %s\n", szPath);
35
    }
36
    ////////////////
37
    // Registry
38
    if (ERROR_SUCCESS == RegCreateKey(HKEY_LOCAL_MACHINE,
39
        L"SOFTWARE\\ReverseCore", &hKey))
40
    {
41
        RegCloseKey(hKey);
42
        _tprintf(L"4) Create Registry Key : HKLM\\SOFTWARE\\ReverseCore\n");
43
    }
44
    return 0;
45
}

(三) 对抗#

遇到32位程序调用64位函数的天堂之门，解题思路:根据汇编和机器码找到64位函数，dump到64位程序中阅读动调

参考文章中提到还可能出现动态天堂之门，只有动调手撕了。。。