[原创]天堂之门 (Heaven's Gate) C语言实现-逆向工程-看雪安全社区

天堂之门 (Heaven's Gate) 是一种在32位WoW64进程中执行64位代码，以及直接调用64位WIN32 API函数的技术。从安全角度看，天堂之门可以作为一种软件保护技术，用于防止静态分析以及跨进程的API Hook；从恶意代码角度看，该技术可以绕过沙盒对WIN32 API调用的检测。

本文介绍了天堂之门技术的原理及C语言实现。

# 0x00. 原理分析

天堂之门技术的最早应用已经不可考究，我找到的最早的一篇详解天堂之门的文章是2012年的<a href="elink@c92K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6J5j5$3g2Q4x3X3g2U0L8#2)9J5c8X3E0F1L8$3y4C8K9h3&6Q4x3X3c8G2L8W2)9J5k6r3S2W2j5i4k6W2L8Y4y4Q4x3X3c8Y4j5i4c8W2i4K6u0V1k6s2W2F1j5h3#2A6j5#2)9J5k6s2m8J5L8$3y4W2M7%4y4G2M7W2)9J5k6r3#2G2k6r3g2Q4x3X3c8K6N6$3W2@1j5$3S2A6L8X3N6Q4x3V1j5`.">Knockin’ on Heaven’s Gate – Dynamic Processor Mode Switching</a>，内容非常详细，目前能找到的有关天堂之门的文章大多都引用了这篇。比较新的一个是<a href="elink@a5aK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6K6i4K6u0W2K9i4c8Z5L8#2)9J5k6h3#2W2i4K6u0r3j5$3y4E0M7#2)9#2k6Y4y4D9K9h3c8W2M7#2)9J5c8U0t1H3x3U0q4Q4x3V1j5#2i4K6u0r3x3e0y4Q4x3V1k6S2x3U0x3I4y4o6c8W2x3#2)9J5k6o6b7K6x3e0y4Q4x3X3b7@1j5U0W2T1i4K6u0V1z5o6W2U0x3W2)9J5k6o6V1^5y4h3k6T1x3K6R3K6x3X3t1@1k6g2)9J5k6i4m8V1k6R3`.`.">Rebuild The Heaven's Gate: from 32-bit Hell back to 64-bit Wonderland</a>，貌似是一个台湾人（《惡意程式前線戰術指南》作者馬聖豪）的讲座PPT，比较简短。

## 什么是WoW64？

简单来说WoW64是Windows x64提供的一种兼容机制，可以认为WoW64是64位Windows系统创建的一个32位的模拟环境，使得32位可执行程序能够在64位的操作系统上正常运行。

推荐一篇讲解WoW64的深度好文<a href="elink@3b4K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6%4j5X3g2F1L8Y4W2Q4x3X3g2Y4K9i4c8Z5N6h3u0Q4x3X3g2A6L8#2)9J5c8U0t1H3x3e0S2Q4x3V1j5I4x3g2)9J5c8U0l9@1i4K6u0r3N6$3!0%4y4U0c8Q4x3X3c8A6L8Y4c8W2M7X3&6S2L8s2y4Q4x3X3g2Z5N6r3#2D9">WoW64 internals</a>，这里就不再赘述了。

## 32位进程的API调用过程（WoW64）

下图（来自<a href="elink@e84K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6K6i4K6u0W2K9i4c8Z5L8#2)9J5k6h3#2W2i4K6u0r3j5$3y4E0M7#2)9#2k6Y4y4D9K9h3c8W2M7#2)9J5c8U0t1H3x3U0q4Q4x3V1j5#2i4K6u0r3x3e0y4Q4x3V1k6S2x3U0x3I4y4o6c8W2x3#2)9J5k6o6b7K6x3e0y4Q4x3X3b7@1j5U0W2T1i4K6u0V1z5o6W2U0x3W2)9J5k6o6V1^5y4h3k6T1x3K6R3K6x3X3t1@1k6g2)9J5k6i4m8V1k6R3`.`.">Rebuild The Heaven's Gate: from 32-bit Hell back to 64-bit Wonderland</a>）展示了正常情况下32位进程通过WoW64机制调用WIN32 API的过程。以`ZwOpenProcess`函数的调用为例：

1. a.exe首先调用32位`ntdll.dll`（以下简称ntdll32）中的`ZwOpenProcess`函数
2. ntdll32调用`wow64cpu.dll`中的`X86SwitchTo64BitMode`，顾名思义，调用该函数后进程从32位模式切换到64位模式
3. 由`wow64.dll`将32位的系统调用转化为64位
4. 调用64位`ntdll.dll`的`ZwOpenProcess`函数
5. 切换到内核态（Ring0）执行系统调用

![image-20211106105559585](upload/attach/202111/910514_JB5CY6FJ4ZMMUJZ.png)

## 32位进程的API调用过程（天堂之门）

下图展示了通过天堂之门技术调用WIN32 API的过程。这里我们通过一些操作绕过了WoW64机制，手动切换到64位模式并调用64位下的ZwOpenProcess函数，大致流程如下（和图中不太一样）：

1. 将cs段寄存器设为0x33，切换到64位模式
2. 从gs:0x60读取64位PEB
3. 从64位PEB中定位64位ntdll基址
4. 遍历ntdll64导出表，读取`ZwOpenProcess`函数地址
5. 构造64位函数调用

如果需要调用的是ntdll之外的函数，以`kernel32.dll`中的`CreateFile`函数为例，还需要：

6. 遍历ntdll64导出表，读取`LdrLoadDll`函数地址
7. 调用`LdrLoadDll("kernel32.dll")`加载64位`kernel32.dll`
8. 从64位的kernel32中读取`GetProcAddress`等函数，获取`CreateFile`函数地址
9. 调用`CreateFile`函数

![image-20211106111544450](upload/attach/202111/910514_SBBBUJSMN9DJFZ9.png)

从上述过程中我们可以发现通过天堂之门的API调用并没有调用ntdll32中的函数，而目前大多数沙箱在检测32位程序时仅仅会对32位函数进行Hook，通过天堂之门，我们成功绕过了沙箱的API检测：

![image-20211106114019275](upload/attach/202111/910514_QJZA4VE5KQ288GK.png)

# 0x01. 代码实现

GitHub仓库：<a href="elink@4c2K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6T1L8s2g2W2M7$3q4V1K9g2)9J5c8V1S2W2j5i4k6W2L8Y4y4Q4x3X3c8s2j5i4c8W2">bluesadi/Heavens-Gate</a>

实现天堂之门大概需要实现到以下几个函数：

1. `memcpy64`：在64位地址之间拷贝数据
2. `GetPEB64`：获取64位的PEB地址
3. `GetModuleHandle64`：获取64位的模块基址
4. `GetProcAddress64`：获取64位模块中的函数地址
5. `X64Call`：调用64位函数
6. `MakeUTFStr`：构造`UNICODE_STRING`结构体

7. `GetKernel32`：加载64位`kernel32.dll`及其依赖`kernelbase.dll`
8. `LoadLibrary64`：在加载`kernel32.dll`后用于加载`user32.dll`

接下来我们将一一讲解这些函数的实现。

## 环境准备

- Visual Studio 2019
- WinDbg(x64)
- Windows 10 x64 20H2

VS项目属性中选择"Release", "Win32"，切记关闭优化（**不关优化会出现玄学错误！！！**）：

![image-20211106104714162](upload/attach/202111/910514_EHD99ANVEDQZMRZ.png)

C/C++->代码生成->运行库改为“多线程(/MT)”，即静态编译：

![image-20211106132721846](upload/attach/202111/910514_5TGCTZ5V58C2FBT.png)

## memcpy64

函数声明：

```cpp
void memcpy64(uint64_t dst, uint64_t src, uint64_t sz);
```

该函数的作用是将64位地址`src`的内容拷贝到`dst`，拷贝`sz`个字节，因为我们操作的地址是64位的，所以我们必须**切换到64位模式用64位的汇编实现**。

由32位切换到64位的代码如下，`[bits 32]`表示接下来的汇编要以32位模式编译，`_next_x64_code`为64位汇编代码的地址：

```asm
[bits 32]
push 0x33
push _next_x64_code
retf
```

`retf`表示远返回，该指令会从栈顶取出一个返回地址，再取出一个cs段选择子，在上述代码中，retf指令会跳转到`0x33:_next_x64_code`，并将cs段寄存器置为0x33，此时程序切换到64位模式（Windows下cs段寄存器为0x23则以32位模式执行指令，为0x33则以64位模式执行指令）。

随后执行64位汇编指令，将`src`的数据拷贝到`dst`中，这里不再做解释：

```asm
[bits 64]
push rsi
push rdi
mov rsi, src
mov rdi, dst
mov rcx, sz
rep movsb
pop rsi
pop rdi
```

执行完64位代码后，我们需要切回32位模式并返回。`retfq`中的q表示qword，即返回到64位的地址：

```asm
[bits 64]
push 0x23
push _next_x86_code
retfq
[bits 32]
ret
```

汇编的编译我们可以用Python的`keystone`模块实现：

```python
from keystone import *

code = '''
push 0x33
push 0x12345678
retf
'''

ks = Ks(KS_ARCH_X86, KS_MODE_32)
asm, cnt = ks.asm(code)
print(code)
for b in asm:
    print('0x' + hex(b)[2:].upper(), end=', ')
```

输出得到shellcode，其中0x12345678我们要替换成`_next_x64_code`，也就是下一段64位汇编指令的地址：

```
push 0x33      
push 0x12345678
retf

0x6A, 0x33, 0x68, 0x78, 0x56, 0x34, 0x12, 0xCB, 
```

完整的shellcode：

```cpp
static uint8_t code[] = {
    /*	[bits 32]
		push 0x33
		push _next_x64_code
		retf
	*/
    0x6A, 0x33, 0x68, 0x78, 0x56, 0x34, 0x12, 0xCB,
    /*	[bits 64]
		push rsi
		push rdi
		mov rsi, src
		mov rdi, dst
		mov rcx, sz
		rep movsb
		pop rsi
		pop rdi
	*/
    0x56, 0x57,
    0x48, 0xBE, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11,
    0x48, 0xBF, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11,
    0x48, 0xB9, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11,
    0xF3, 0xA4,
    0x5E, 0x5F,
    /*	[bits 64]
		push 0x23
		push _next_x86_code
		retfq
	*/
    0x6A, 0x23, 0x68, 0x78, 0x56, 0x34, 0x12, 0x48, 0xCB,
    /*	[bits 32]
		ret
	*/
    0xC3
};
```

要执行这段shellcode，我们需要在堆中开辟新的空间，属性为`PAGE_EXECUTE_READWRITE`，即可读可写可执行，将shellcode拷贝到这块区域，替换`_next_x64_code`、`src`、`dst`、`_next_x86_code`的地址后执行：

```cpp
static uint32_t ptr = NULL;
if (!ptr) {
    ptr = (uint32_t)VirtualAlloc(NULL, sizeof(code), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    for (int i = 0; i < sizeof(code); i++) ((PBYTE)ptr)[i] = code[i];
}
*(uint32_t*)(ptr + 3) = ptr + 8;
*(uint64_t*)(ptr + 12) = src;
*(uint64_t*)(ptr + 22) = dst;
*(uint64_t*)(ptr + 32) = sz;
*(uint32_t*)(ptr + 47) = ptr + 53;
((void(*)())ptr)();
```

完整代码：

```cpp
void memcpy64(uint64_t dst, uint64_t src, uint64_t sz) {
	static uint8_t code[] = {
		/*	[bits 32]
			push 0x33
			push _next_x64_code
			retf
		*/
		0x6A, 0x33, 0x68, 0x78, 0x56, 0x34, 0x12, 0xCB,
		/*	[bits 64]
			push rsi
			push rdi
			mov rsi, src
			mov rdi, dst
			mov rcx, sz
			rep movsb
			pop rsi
			pop rdi
		*/
		0x56, 0x57,
		0x48, 0xBE, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11,
		0x48, 0xBF, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11,
		0x48, 0xB9, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11,
		0xF3, 0xA4,
		0x5E, 0x5F,
		/*	[bits 64]
			push 0x23
			push _next_x86_code
			retfq
		*/
		0x6A, 0x23, 0x68, 0x78, 0x56, 0x34, 0x12, 0x48, 0xCB,
		/*	[bits 32]
			ret
		*/
		0xC3
	};

static uint32_t ptr = NULL;
	if (!ptr) {
		ptr = (uint32_t)VirtualAlloc(NULL, sizeof(code), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
		for (int i = 0; i < sizeof(code); i++) ((PBYTE)ptr)[i] = code[i];
	}
	*(uint32_t*)(ptr + 3) = ptr + 8;
	*(uint64_t*)(ptr + 12) = src;
	*(uint64_t*)(ptr + 22) = dst;
	*(uint64_t*)(ptr + 32) = sz;
	*(uint32_t*)(ptr + 47) = ptr + 53;
	((void(*)())ptr)();
}
```

## GetPEB64

函数声明：

```cpp
void GetPEB64(void* peb64);
```

该函数的作用是获取PEB64的地址。

64位中`gs:[0x30]`指向TEB，`gs:[0x60]`指向PEB，获取PEB64的地址很简单，只需要将`gs:[0x60]`拷贝到rax作为返回值即可：

```asm
[bits 64]
mov rax, gs:[0x60]
mov [esi], rax
```

完整代码：

```cpp
void GetPEB64(void *peb64) {
	static uint8_t code[] = {
		/*	[bits 32]
			mov esi, peb64
			push 0x33
			push _next_x64_code
			retf
		*/
		0xBE, 0x78, 0x56, 0x34, 0x12, 0x6A, 0x33, 0x68, 0x78, 0x56, 0x34, 0x12, 0xCB,
		/*	[bits 64]
			mov rax, gs:[0x60]
			mov [esi], rax
		*/
		0x65, 0x48, 0xA1, 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x67, 0x48, 0x89, 0x6,
		/*	[bits 64]
			push 0x23
			push _next_x86_code
			retfq
		*/
		0x6A, 0x23, 0x68, 0x78, 0x56, 0x34, 0x12, 0x48, 0xCB,
		/*	[bits 32]
			ret
		*/
		0xC3
	};

static uint32_t ptr = NULL;
	if (!ptr) {
		ptr = (uint32_t)VirtualAlloc(NULL, sizeof(code), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
		for (int i = 0; i < sizeof(code); i++) ((PBYTE)ptr)[i] = code[i];
	}
	*(uint32_t*)(ptr + 1) = (uint32_t)peb64;
	*(uint32_t*)(ptr + 8) = ptr + 13;
	*(uint32_t*)(ptr + 31) = ptr + 37;
	((void(*)())ptr)();
}
```

## GetModuleHandle64

函数声明：

```cpp
uint64_t GetModuleHandle64(const WCHAR *moduleName);
```

该函数的作用是获取名为`moduleName`的模块的基址。

实现步骤如下：

1. 从`PEB+0x18`获取Ldr的地址
2. 从`Ldr+0x10`获取InLoadOrderModuleList地址
3. 遍历InLoadOrderModuleList获取模块基址
4. 通过模块基址获取模块名，并与`moduleName`比对，比对成功则返回该模块基址

![img](upload/attach/202111/910514_2P63EXJUZEMVXD9.png)

在WinDbg中使用`dt`指令查看结构体，可以看到Ldr的地址在PEB中的偏移为0x018：

```
0:000> dt _PEB
ntdll!_PEB
   +0x000 InheritedAddressSpace : UChar
   +0x001 ReadImageFileExecOptions : UChar
   +0x002 BeingDebugged    : UChar
   +0x003 BitField         : UChar
   +0x003 ImageUsesLargePages : Pos 0, 1 Bit
   +0x003 IsProtectedProcess : Pos 1, 1 Bit
   +0x003 IsImageDynamicallyRelocated : Pos 2, 1 Bit
   +0x003 SkipPatchingUser32Forwarders : Pos 3, 1 Bit
   +0x003 IsPackagedProcess : Pos 4, 1 Bit
   +0x003 IsAppContainer   : Pos 5, 1 Bit
   +0x003 IsProtectedProcessLight : Pos 6, 1 Bit
   +0x003 IsLongPathAwareProcess : Pos 7, 1 Bit
   +0x004 Padding0         : [4] UChar
   +0x008 Mutant           : Ptr64 Void
   +0x010 ImageBaseAddress : Ptr64 Void
   +0x018 Ldr              : Ptr64 _PEB_LDR_DATA
```

用之前实现的`memcpy64`函数拷贝Ldr的地址：

```cpp
uint64_t peb64;
uint64_t ldrData;

GetPEB64(&peb64);
memcpy64((uint64_t)&ldrData, peb64 + 0x18, 8);
```

打印`_PEB_LDR_DATA`结构体，可以看到`InLoadOrderModuleList`在Ldr中的偏移为0x10：

```
0:000> dt _PEB_LDR_DATA
ntdll!_PEB_LDR_DATA
   +0x000 Length           : Uint4B
   +0x004 Initialized      : UChar
   +0x008 SsHandle         : Ptr64 Void
   +0x010 InLoadOrderModuleList : _LIST_ENTRY
   +0x020 InMemoryOrderModuleList : _LIST_ENTRY
   +0x030 InInitializationOrderModuleList : _LIST_ENTRY
   +0x040 EntryInProgress  : Ptr64 Void
   +0x048 ShutdownInProgress : UChar
   +0x050 ShutdownThreadId : Ptr64 Void
```

拷贝`InLoadOrderModuleList`的地址：

```cpp
uint64_t head;
uint64_t pNode;

head = ldrData + 0x10;
memcpy64((uint64_t)&pNode, head, 8);
```

`InLoadOrderModuleList`的实际类型为`_LDR_DATA_TABLE_ENTRY`，`BaseDllName`中存储了DLL的名称，类型为`_UNICODE_STRING`：

```
0:000> dt _LDR_DATA_TABLE_ENTRY
ntdll!_LDR_DATA_TABLE_ENTRY
   +0x000 InLoadOrderLinks : _LIST_ENTRY
   +0x010 InMemoryOrderLinks : _LIST_ENTRY
   +0x020 InInitializationOrderLinks : _LIST_ENTRY
   +0x030 DllBase          : Ptr64 Void
   +0x038 EntryPoint       : Ptr64 Void
   +0x040 SizeOfImage      : Uint4B
   +0x048 FullDllName      : _UNICODE_STRING
   +0x058 BaseDllName      : _UNICODE_STRING
   
0:000> dt _UNICODE_STRING
ntdll!_UNICODE_STRING
   +0x000 Length           : Uint2B
   +0x002 MaximumLength    : Uint2B
   +0x008 Buffer           : Ptr64 Wchar
```

所以Buffer的偏移量在`_LDR_DATA_TABLE_ENTRY`中的偏移为`0x58+0x08`，即96。

遍历链表的代码如下：

```cpp
while (pNode != head) {
    uint64_t buffer;
    memcpy64((uint64_t)(unsigned)(&buffer), pNode + 96, 8);	// tmp = pNode->BaseDllName->Buffer
    if (buffer) {
        WCHAR curModuleName[32] = {0};
        memcpy64((uint64_t)curModuleName, buffer, 60);
        if (!lstrcmpiW(moduleName, curModuleName)) {
            uint64_t base;
            memcpy64((uint64_t)&base, pNode + 48, 8);
            return base;
        }
    }
    memcpy64((uint64_t)&pNode, pNode, 8);	// pNode = pNode->Flink
}
```

完整代码如下：

```cpp
uint64_t GetModuleHandle64(const WCHAR *moduleName) {
	uint64_t peb64;
	/*	nt!_PEB_LDR_DATA
	   +0x000 Length           : Uint4B
	   +0x004 Initialized      : UChar
	   +0x008 SsHandle         : Ptr64 Void
	   +0x010 InLoadOrderModuleList : _LIST_ENTRY
	*/
	uint64_t ldrData;
	/*
		ptr to InLoadOrderModuleList
	*/
	uint64_t head;
	/*
		typedef struct _LDR_MODULE {
		  +0x000 LIST_ENTRY              InLoadOrderModuleList;
		  +0x010 LIST_ENTRY              InMemoryOrderModuleList;
		  +0x020 LIST_ENTRY              InInitializationOrderModuleList;
		  +0x030 PVOID                   BaseAddress;
		  +0x038 PVOID                   EntryPoint;
		  +0x040 ULONG                   SizeOfImage;
		  +0x048 UNICODE_STRING          FullDllName;
		  +0x058 UNICODE_STRING          BaseDllName;
		  ...
		} LDR_MODULE, *PLDR_MODULE;
	*/
	uint64_t pNode;
	GetPEB64(&peb64);
	memcpy64((uint64_t)&ldrData, peb64 + 0x18, 8);
	head = ldrData + 0x10;
	memcpy64((uint64_t)&pNode, head, 8);
	while (pNode != head) {
		uint64_t buffer;
		memcpy64((uint64_t)(unsigned)(&buffer), pNode + 96, 8);	// tmp = pNode->BaseDllName->Buffer
		if (buffer) {
			WCHAR curModuleName[32] = {0};
			memcpy64((uint64_t)curModuleName, buffer, 60);
			if (!lstrcmpiW(moduleName, curModuleName)) {
				uint64_t base;
				memcpy64((uint64_t)&base, pNode + 48, 8);
				return base;
			}
		}
		memcpy64((uint64_t)&pNode, pNode, 8);	// pNode = pNode->Flink
	}
	return NULL;
}
```

## MyGetProcAddress

函数声明：

```cpp
uint64_t MyGetProcAddress64(uint64_t hModule, const char* func);
```

通过`GetModuleHandle64`获取模块地址后，此时还无法通过`kernel32.dll`中的`GetProcAddress`函数获取模块中函数的地址，可以通过遍历模块的导出表获取函数地址作为过渡方案。

![img](upload/attach/202111/910514_2RYXWQUEJFER6MW.png)

首先获取导出表地址，这部分涉及PE文件结构，不再赘述了：

```cpp
IMAGE_DOS_HEADER dos;
memcpy64((uint64_t)&dos, hModule, sizeof(dos));
IMAGE_NT_HEADERS64 nt;
memcpy64((uint64_t)&nt, hModule + dos.e_lfanew, sizeof(nt));
IMAGE_EXPORT_DIRECTORY expo;
memcpy64((uint64_t)&expo, hModule + nt.OptionalHeader.DataDirectory[0].VirtualAddress, sizeof(expo));
```

随后遍历导出表，从导出表中读取函数的名称和地址，将函数名称与`func`进行比对，比对成功则返回函数地址：

```cpp
for (uint64_t i = 0; i < expo.NumberOfNames; i++) {
    DWORD pName;
    memcpy64((uint64_t)&pName, hModule + expo.AddressOfNames + (4 * i), 4);
    char name[64] = {0};
    memcpy64((uint64_t)name, hModule + pName, 64);
    if (!lstrcmpA(name, func)) {
        WORD ord;
        memcpy64((uint64_t)&ord, hModule + expo.AddressOfNameOrdinals + (2 * i), 2);
        uint32_t addr;
        memcpy64((uint64_t)&addr, hModule + expo.AddressOfFunctions + (4 * ord), 4);
        return hModule + addr;
    }
}
```

完整代码如下：

```cpp
uint64_t MyGetProcAddress(uint64_t hModule, const char* func) {
	IMAGE_DOS_HEADER dos;
	memcpy64((uint64_t)&dos, hModule, sizeof(dos));
	IMAGE_NT_HEADERS64 nt;
	memcpy64((uint64_t)&nt, hModule + dos.e_lfanew, sizeof(nt));
	IMAGE_EXPORT_DIRECTORY expo;
	memcpy64((uint64_t)&expo, hModule + nt.OptionalHeader.DataDirectory[0].VirtualAddress, sizeof(expo));

for (uint64_t i = 0; i < expo.NumberOfNames; i++) {
		DWORD pName;
		memcpy64((uint64_t)&pName, hModule + expo.AddressOfNames + (4 * i), 4);
		char name[64] = {0};
		memcpy64((uint64_t)name, hModule + pName, 64);
		if (!lstrcmpA(name, func)) {
			WORD ord;
			memcpy64((uint64_t)&ord, hModule + expo.AddressOfNameOrdinals + (2 * i), 2);
			uint32_t addr;
			memcpy64((uint64_t)&addr, hModule + expo.AddressOfFunctions + (4 * ord), 4);
			return hModule + addr;
		}
	}
	return NULL;
}
```

## X64Call

函数声明：

```cpp
uint64_t X64Call(uint64_t proc, uint32_t argc, ...);
```

由于32位与64位的函数调用的传参方式不同，以及在上一步中我们通过`MyGetProcAddress`函数获取的函数地址为64位，肯定不能直接转化为函数指针调用，所以我们需要用64位汇编实现一个64位函数的调用。

首先来简单了解一下64位中WINAPI调用的传参方式：

- 前四个参数从左往右依次存放到`rcx`, `rdx`, `r8`, `r9`寄存器中
- 后面的参数从右往左依次入栈
- rsp与最后一个参数之间直接需要保留大小为20字节的空间，被调函数可能会使用

![image-20211106141230284](upload/attach/202111/910514_F927YAMXB9WKZ8D.png)

构造shellcode，因为接下来我们需要对栈指针进行操作，所以首先将`esp`保存到`ebx`中，shellcode执行完毕后需要复原。`and esp, 0xFFFFFFF8`的作用是使`rsp`与8对齐，这是64位汇编的栈对齐要求，否则在执行某些系统调用时可能会出错：

```asm
[bits 32]
push ebx
mov ebx, esp
and esp, 0xFFFFFFF8

push 0x33
push _next_x64_code
retf
```

切换到64位后按照64位WINAPI调用协定传参，调用函数之前保留32字节的空间，将函数返回值保存到rax。在shellcode执行前后保存和复原`rsi`和`rdi`：

```asm
[bits 64]
push rsi
push rdi

mov rsi, args
mov rcx, [rsi]
mov rdx, [rsi+8]
mov r8, [rsi+16]
mov r9, [rsi+24]

mov rax, argc
args_start:
cmp rax, 4
jle args_end
mov rdi, [rsi+8*rax-8]
push rdi
dec rax
jmp args_start
args_end:

mov rax, proc
sub rsp, 32
call rax

mov rdi, &ret
mov [rdi], rax

pop rdi
pop rsi
```

最后切换回32位模式，并还原`esp`和`ebx`：

```asm
[bits 64]
push 0x23
push _next_x86_code
retfq
[bits 32]
mov esp, ebx
pop ebx
ret
```

完整代码如下：

```cpp
uint64_t X64Call(uint64_t proc, uint32_t argc, ...) {
	uint64_t* args = (uint64_t*)(&argc + 1);
	uint64_t ret = 0;
	static uint8_t code[] = {
		/*	[bits 32]
			push ebx
			mov ebx, esp
			and esp, 0xFFFFFFF8

push 0x33
			push _next_x64_code
			retf
		*/
		0x53, 0x89, 0xE3, 0x83, 0xE4, 0xF8,
		0x6A, 0x33, 0x68, 0x78, 0x56, 0x34, 0x12, 0xCB,
		/*	[bits 64]
			push rsi
			push rdi
			
			mov rsi, args
			mov rcx, [rsi]
			mov rdx, [rsi+8]
			mov r8, [rsi+16]
			mov r9, [rsi+24]
			
			mov rax, argc
			args_start:
				cmp rax, 4
				jle args_end
				mov rdi, [rsi+8*rax-8]
				push rdi
				dec rax
				jmp args_start
			args_end:

mov rax, proc
			sub rsp, 32
			call rax

mov rdi, &ret
			mov [rdi], rax

pop rdi
			pop rsi
		*/
		0x56, 0x57,
		0x48, 0xBE, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11, 0x48, 0x8B, 0xE, 0x48, 0x8B, 0x56, 0x8, 0x4C, 0x8B, 0x46, 0x10, 0x4C, 0x8B, 0x4E, 0x18,
		0x48, 0xB8, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11, 0x48, 0x83, 0xF8, 0x4, 0x7E, 0xB, 0x48, 0x8B, 0x7C, 0xC6, 0xF8, 0x57, 0x48, 0xFF, 0xC8, 0xEB, 0xEF,
		0x48, 0xB8, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11, 0x48, 0x83, 0xEC, 0x20, 0xFF, 0xD0,
		0x48, 0xBF, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11, 0x48, 0x89, 0x7,
		0x5F, 0x5E,
		/*	[bits 64]
			push 0x23
			push _next_x86_code
			retfq
		*/
		0x6A, 0x23, 0x68, 0x78, 0x56, 0x34, 0x12, 0x48, 0xCB,
		/*	[bits 32]
			mov esp, ebx
			pop ebx
			ret
		*/
		0x89, 0xDC, 0x5B,
		0xC3
	};

static uint32_t ptr = NULL;
	if (!ptr) {
		ptr = (uint32_t)VirtualAlloc(NULL, sizeof(code), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
		for (int i = 0; i < sizeof(code); i++) ((PBYTE)ptr)[i] = code[i];
	}
	*(uint32_t*)(ptr + 9) = ptr + 14;
	*(uint64_t*)(ptr + 18) = (uint64_t)args;
	*(uint64_t*)(ptr + 43) = (uint64_t)argc;
	*(uint64_t*)(ptr + 70) = proc; 
	*(uint64_t*)(ptr + 86) = (uint64_t)&ret;
	*(uint32_t*)(ptr + 102) = ptr + 108;
	((void(*)())ptr)();
	return ret;
}
```

## MakeUTFStr

函数原型如下：

```cpp
char* MakeUTFStr(const char* str);
```

构造一个`_UNICODE_STRING`结构体并返回64位的地址。代码实现如下：

```cpp
char* MakeUTFStr(const char* str) {
	uint32_t len = lstrlenA(str);
	char* out = (char*)malloc(16 + (len + 1) * 2);
	*(uint16_t*)(out) = (uint16_t)(len * 2); //Length
	*(uint16_t*)(out + 2) = (uint16_t)((len + 1) * 2); //Max Length

uint16_t* outstr = (uint16_t*)(out + 16);
	for (uint32_t i = 0; i <= len; i++) outstr[i] = str[i];
	*(uint64_t*)(out + 8) = (uint64_t)(out + 16);
	return out;
}
```

## GetKernel32

函数声明：

```cpp
uint64_t GetKernel32();
```

加载`kernel32.dll`以及`kernelbase.dll`

在上面提到的<a href="elink@7e3K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6J5j5$3g2Q4x3X3g2U0L8#2)9J5c8X3E0F1L8$3y4C8K9h3&6Q4x3X3c8G2L8W2)9J5k6r3S2W2j5i4k6W2L8Y4y4Q4x3X3c8Y4j5i4c8W2i4K6u0V1k6s2W2F1j5h3#2A6j5#2)9J5k6s2m8J5L8$3y4W2M7%4y4G2M7W2)9J5k6r3#2G2k6r3g2Q4x3X3c8K6N6$3W2@1j5$3S2A6L8X3N6Q4x3V1j5`.">Knockin’ on Heaven’s Gate – Dynamic Processor Mode Switching</a>这篇文章中对这一部分有很复杂的叙述。`kernel32.dll`在Windows中的加载地址是固定的，并且只能被加载到那个地址。在该作者测试的环境下64位`kernel32.dll`的加载地址所在的空间已经被分配并且被映射为私有的了，会导致调用`LdrLoadDll`函数加载`kernel32.dll`时失败并返回*0xC0000018* ( STATUS_CONFLICTING_ADDRESSES )。

> Any attempts to load kernel32.dll using the *LdrLoadDll* function would result to the error code *0xC0000018* ( STATUS_CONFLICTING_ADDRESSES ). This is due to the fact that the default memory location of kernel32 is already mapped as private.

解决的思路非常简单：即调用`NtFreeVirtualMemory`函数将这块已经分配的空间释放掉，再用`LdrLoadDll`重新加载。但代码写起来非常复杂，可以参考<a href="elink@dd4K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6V1j5h3c8S2M7K6p5&6x3q4)9J5c8V1S2W2j5i4k6W2L8Y4y4Q4x3X3c8s2j5i4c8W2i4K6u0V1x3W2)9J5k6e0m8Q4x3V1k6T1L8r3!0T1i4K6u0r3L8h3q4K6N6r3g2J5i4K6u0r3d9r3g2S2N6X3g2F1M7@1N6S2N6r3g2Q4x3X3g2Z5">dadas190/Heavens-Gate-2.0</a>的实现。

但是在我的操作系统上（Windows 10 x64 20H2），并没有找到作者提到的分配和映射过程，并且直接调用`LdrLoadDll`函数也能正常加载`kernel32.dll`，可能是在某个Windows版本中被移除了吧。

所以加载kernel64这部分的代码就变得非常简单了：

```cpp
uint64_t GetKernel32() {
	static uint64_t kernel32 = 0;
	if (kernel32) return kernel32;

uint64_t ntdll = GetModuleHandle64(L"ntdll.dll");
	uint64_t LdrLoadDll = MyGetProcAddress(ntdll, "LdrLoadDll");
	char* str = MakeUTFStr("kernel32.dll");
	X64Call(LdrLoadDll, 4, (uint64_t)0, (uint64_t)0, (uint64_t)str, (uint64_t)(&kernel32));
	return kernel32;
}
```

## GetProcAddress64

函数原型：

```cpp
uint64_t GetProcAddress64(uint64_t hModule, const char* func);
```

获取了kernel64的地址后我们就能直接通过`GetProcAddress`函数获取模块中函数的地址了。代码实现如下：

```cpp
uint64_t GetProcAddress64(uint64_t module, const char* func) {
	static uint64_t K32GetProcAddress = 0;
	if (!K32GetProcAddress)K32GetProcAddress = MyGetProcAddress(GetKernel32(), "GetProcAddress");

return X64Call(K32GetProcAddress, 2, module, (uint64_t)func);
}
```

## LoadLibrary64

函数原型：

```cpp
uint64_t LoadLibrary64(const char* name)
```

调用kernel64的`LoadLibraryA`函数加载其他DLL，如`user32.dll`等等。

代码实现如下：

```cpp
uint64_t LoadLibrary64(const char* name) {
	static uint64_t LoadLibraryA = 0;
	if (!LoadLibraryA) LoadLibraryA = GetProcAddress64(GetKernel32(), "LoadLibraryA");

return X64Call(LoadLibraryA, 1, (uint64_t)name);
}
```

## MessageBox测试

测试一下典中典之MessageBox弹窗：

```cpp
void Test() {
	uint64_t kernel32 = GetKernel32();
	uint64_t user32 = LoadLibrary64("user32.dll");
	uint64_t MessageBox64 = GetProcAddress64(user32, "MessageBoxA");
	X64Call(MessageBox64, 4, (uint64_t)NULL, (uint64_t)"Wowowowowow", (uint64_t)"Wowowowowow", (uint64_t)NULL);
}

int main() {
	Test();
}
```

运行效果：

![image-20211106145257165](upload/attach/202111/910514_2SYJ9JU5ATF7QDM.png)

# 0x02. 沙箱&火绒剑测试

## 微步云沙箱测试

首先测试一段正常的文件读写代码：

```cpp
void TestNormal() {
	char path[MAX_PATH];
	char hacked[] = "Hacked by 34r7hm4n";
	HANDLE hFile;
	char buffer[100] = { 0 };
	GetCurrentDirectoryA(MAX_PATH, path);
	lstrcatA(path, "\\test.txt");
	hFile = CreateFileA(path, GENERIC_WRITE, NULL, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
	CloseHandle(hFile);
	hFile = CreateFileA(path, GENERIC_WRITE, NULL, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	WriteFile(hFile, hacked, lstrlenA(hacked), NULL, NULL);
	CloseHandle(hFile);
	hFile = CreateFileA(path, GENERIC_READ, NULL, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	ReadFile(hFile, buffer, sizeof(buffer), NULL, NULL);
	CloseHandle(hFile);
	printf("%s\n", buffer);
	system("pause");
}
```

检测到了文件释放：

![image-20211106145521139](upload/attach/202111/910514_F4896DCNXH58YAZ.png)

再测试一下用天堂之门实现的同样功能的代码：

```cpp
void TestHeavensGate() {
	uint64_t kernel32 = GetKernel32();
	uint64_t user32 = LoadLibrary64("user32.dll");
	uint64_t CreateFile64 = GetProcAddress64(kernel32, "CreateFileA");
	uint64_t WriteFile64 = GetProcAddress64(kernel32, "WriteFile");
	uint64_t ReadFile64 = GetProcAddress64(kernel32, "ReadFile");
	uint64_t CloseHandle64 = GetProcAddress64(kernel32, "CloseHandle");
	char path[MAX_PATH];
	char hacked[] = "Hacked by 34r7hm4n";
	uint64_t hFile;
	char buffer[100] = { 0 };

GetCurrentDirectoryA(MAX_PATH, path);
	lstrcatA(path, "\\test.txt");
	hFile = X64Call(CreateFile64, 7, (uint64_t)path, (uint64_t)GENERIC_WRITE, (uint64_t)NULL, (uint64_t)NULL, (uint64_t)CREATE_NEW, (uint64_t)FILE_ATTRIBUTE_NORMAL, (uint64_t)NULL);
	X64Call(CloseHandle64, 1, hFile);
	hFile = X64Call(CreateFile64, 7, (uint64_t)path, (uint64_t)GENERIC_WRITE, (uint64_t)NULL, (uint64_t)NULL, (uint64_t)OPEN_EXISTING, (uint64_t)FILE_ATTRIBUTE_NORMAL, (uint64_t)NULL);
	X64Call(WriteFile64, 5, (uint64_t)hFile, (uint64_t)hacked, (uint64_t)lstrlenA(hacked), (uint64_t)NULL, (uint64_t)NULL);
	X64Call(CloseHandle64, 1, hFile);
	hFile = X64Call(CreateFile64, 7, (uint64_t)path, (uint64_t)GENERIC_READ, (uint64_t)NULL, (uint64_t)NULL, (uint64_t)OPEN_EXISTING, (uint64_t)FILE_ATTRIBUTE_NORMAL, (uint64_t)NULL);
	X64Call(ReadFile64, 5, (uint64_t)hFile, (uint64_t)buffer, (uint64_t)sizeof(buffer), (uint64_t)NULL, (uint64_t)NULL);
	X64Call(CloseHandle64, 1, hFile);
	printf("%s\n", buffer);
	system("pause");
}
```

没有检测到文件释放：

![image-20211106145630433](upload/attach/202111/910514_64DRCRG9WUEP4EW.png)

## 魔盾测试

直接崩了，无语：

![image-20211106150139913](upload/attach/202111/910514_KXX3R45HBBRZ2E9.png)

## 火绒剑测试

最终没能逃出火绒剑的魔爪：

![image-20211106150000934](upload/attach/202111/910514_KWFRWTHR8UT8ATF.png)

# 0x03. 玄学Bug

目前还有一些玄学Bug，原因不明：

1. **只能生成后双击运行**。在VS中运行或在cmd中运行会导致无法加载`kernel32.dll`，`LdrLoadDll("kernel32.dll")`返回*0xC0000142* (STATUS_DLL_INIT_FAILED)
2. **在DLL中无法加载user32.dll**。至少在我的环境下，`LoadLibrary64("user32.dll")`直接导致整个程序崩溃

最后，由于我在Windows和恶意代码这块还是新手，难免有理解不当的地方，如果文章内容有什么问题欢迎各位师傅指正！

# 0x04. 参考资料

1. <a href="elink@d2aK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6J5j5$3g2Q4x3X3g2U0L8#2)9J5c8X3E0F1L8$3y4C8K9h3&6Q4x3X3c8G2L8W2)9J5k6r3S2W2j5i4k6W2L8Y4y4Q4x3X3c8Y4j5i4c8W2i4K6u0V1k6s2W2F1j5h3#2A6j5#2)9J5k6s2m8J5L8$3y4W2M7%4y4G2M7W2)9J5k6r3#2G2k6r3g2Q4x3X3c8K6N6$3W2@1j5$3S2A6L8X3N6Q4x3V1j5`.">Knockin’ on Heaven’s Gate – Dynamic Processor Mode Switching by george_nicolaou</a>
2. <a href="elink@06eK9s2c8@1M7q4)9K6b7g2)9J5c8W2)9J5c8X3u0D9L8$3N6Q4x3X3g2J5k6i4N6G2L8r3k6Q4x3X3g2H3L8q4)9J5c8X3u0D9L8$3N6Q4x3V1k6Q4x3@1k6H3i4K6y4p5x3e0l9J5">Mixing x86 with x64 code by ReWolf</a>
3. <a href="elink@f12K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6%4j5X3g2F1L8Y4W2Q4x3X3g2Y4K9i4c8Z5N6h3u0Q4x3X3g2A6L8#2)9J5c8U0t1H3x3e0S2Q4x3V1j5I4x3g2)9J5c8U0l9@1i4K6u0r3N6$3!0%4y4U0c8Q4x3X3c8A6L8Y4c8W2M7X3&6S2L8s2y4Q4x3X3g2Z5N6r3#2D9">WoW64 internals by wbenny</a>
4. <a href="elink@013K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6V1j5h3c8S2M7K6p5&6x3q4)9J5c8V1S2W2j5i4k6W2L8Y4y4Q4x3X3c8s2j5i4c8W2i4K6u0V1x3W2)9J5k6e0l9`.">Heavens-Gate-2.0 by sdadas190</a>

5. <a href="elink@5d5K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6@1j5h3q4J5k6r3W2K6j5h3q4Q4x3X3g2Y4K9i4c8Z5N6h3u0Q4x3X3g2A6L8#2)9J5c8U0t1H3x3U0q4Q4x3V1j5H3z5g2)9J5c8U0t1#2i4K6u0r3d9r3g2S2N6X3g2F1i4K6t1%4M7@1N6S2N6r3g2Q4x3V1j5`.">天堂之门技术 by Tardis</a>
6. <a href="elink@cc8K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6K6i4K6u0W2K9i4c8Z5L8#2)9J5k6h3#2W2i4K6u0r3j5$3y4E0M7#2)9#2k6Y4y4D9K9h3c8W2M7#2)9J5c8U0t1H3x3U0q4Q4x3V1j5#2i4K6u0r3x3e0y4Q4x3V1k6S2x3U0x3I4y4o6c8W2x3#2)9J5k6o6b7K6x3e0y4Q4x3X3b7@1j5U0W2T1i4K6u0V1z5o6W2U0x3W2)9J5k6o6V1^5y4h3k6T1x3K6R3K6x3X3t1@1k6g2)9J5k6i4m8V1k6R3`.`.">Rebuild The Heaven's Gate: from 32-bit Hell back to 64-bit Wonderland by Sheng-Hao Ma</a>

7. <a href="elink@943K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6%4N6%4N6Q4x3X3g2U0L8X3u0D9L8$3N6K6i4K6u0W2j5$3!0E0i4K6u0r3N6$3!0D9k6U0R3&6i4K6u0r3j5i4u0U0K9r3W2$3k6g2)9J5c8U0t1H3x3e0u0Q4x3V1j5I4x3W2)9J5c8U0p5#2i4K6u0r3x3U0R3I4z5e0R3#2z5q4)9J5k6h3S2@1L8h3H3`.">通过PEB结构遍历进程模块</a>

8. <a href="elink@acfK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6%4N6%4N6Q4x3X3g2U0L8X3u0D9L8$3N6K6i4K6u0W2j5$3!0E0i4K6u0r3L8s2c8&6j5h3&6V1P5g2)9J5c8Y4m8Q4x3V1j5I4x3e0l9^5x3K6R3J5x3g2)9J5k6h3S2@1L8h3H3`.">PE基础2-导出表-导入表</a>

登录后可查看完整内容

冰与火的战歌：Windows内核攻防实战高级班！从零到实战，融合AI与Windows内核攻防全技术栈，打造具备自动化能力的内核开发高手。

最后于 2021-11-6 15:41 被34r7hm4n编辑，原因：

#病毒木马

最新回复 (24)
沉迷于雪币： 6103 活跃值： (5972) 能力值： ( LV2，RANK：10 ) 在线值：发帖 19 回帖 171 粉丝 2 关注私信	沉迷于 2 楼谢谢分享要些时间才可以消化 2021-11-6 15:58 0
微启宇雪币： 4767 活跃值： (9006) 能力值： ( LV2，RANK：10 ) 在线值：发帖 19 回帖 568 粉丝 78 关注私信	微启宇 3 楼不错赞一个 2021-11-6 16:33 0
v0id_ 雪币： 8659 活跃值： (5436) 能力值： ( LV4，RANK：45 ) 在线值：发帖 7 回帖 243 粉丝 36 关注私信	v0id_ 4 楼地球人，我的超人 2021-11-6 18:53 0
34r7hm4n 雪币： 14379 活跃值： (10932) 能力值： ( LV12，RANK：360 ) 在线值：发帖 19 回帖 54 粉丝 411 关注私信	34r7hm4n 7 5 楼 v0id_ 地球人，我的超人 void orzorzorz 2021-11-6 18:55 0
小希希雪币： 2901 活跃值： (5705) 能力值： ( LV2，RANK：10 ) 在线值：发帖 17 回帖 360 粉丝 18 关注私信	小希希 6 楼感谢分享.. 2021-11-6 20:28 0
huojier 雪币： 137 活跃值： (1550) 能力值： ( LV2，RANK：10 ) 在线值：发帖 4 回帖 86 粉丝 8 关注私信	huojier 7 楼很好的文章 2021-11-6 20:57 0
dearfuture 雪币： 2413 活跃值： (3266) 能力值： ( LV2，RANK：10 ) 在线值：发帖 6 回帖 66 粉丝 1 关注私信	dearfuture 8 楼天堂之门似乎只能应付一些纯应用层检测，但现在大部分都是火绒剑这样的文件过滤驱动或者sysmon/etw之类的 2021-11-8 13:52 0
34r7hm4n 雪币： 14379 活跃值： (10932) 能力值： ( LV12，RANK：360 ) 在线值：发帖 19 回帖 54 粉丝 411 关注私信	34r7hm4n 7 9 楼 dearfuture 天堂之门似乎只能应付一些纯应用层检测，但现在大部分都是火绒剑这样的文件过滤驱动或者sysmon/etw之类的是的，毕竟是非常老的技术了，学习一下还是可以，但是实战可能没什么作用了 2021-11-8 13:57 0
luskyc 雪币： 248 活跃值： (3789) 能力值： ( LV2，RANK：10 ) 在线值：发帖 25 回帖 938 粉丝 11 关注私信	luskyc 10 楼棒子的ngs就是用的这招 2021-11-24 07:46 0
wx_ ╰☆L玄V0心E☆╮ 雪币： 330 活跃值： (1149) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 41 粉丝 1 关注私信	wx_ ╰☆L玄V0心E☆╮ 11 楼 dearfuture 天堂之门似乎只能应付一些纯应用层检测，但现在大部分都是火绒剑这样的文件过滤驱动或者sysmon/etw之类的我觉得，现在很多不是专业的二进制样本分析人员，都喜欢用微步、哈勃这些产品扫扫，所以能过微步这些的检测，还是有一定意义的。 2021-11-26 17:50 0
sky科雪币： 243 活跃值： (534) 能力值： ( LV3，RANK：30 ) 在线值：发帖 21 回帖 172 粉丝 1 关注私信	sky科 12 楼精品文章, vmp里面曾见过用到这种技术 2021-11-26 18:03 0
kanxue 雪币： 22697 活跃值： (24880) 能力值： (RANK：350 ) 在线值：发帖 2406 回帖 17125 粉丝 746 关注私信	kanxue 8 13 楼精彩文章！感谢分享！ 2021-11-26 18:34 0
niuzuoquan 雪币： 258 活跃值： (3682) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 536 粉丝 3 关注私信	niuzuoquan 14 楼 mark 2021-11-28 13:24 0
Izalith 雪币： 577 活跃值： (297) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 9 粉丝 0 关注私信	Izalith 15 楼 mark 2022-4-18 11:45 0
小希希雪币： 2901 活跃值： (5705) 能力值： ( LV2，RANK：10 ) 在线值：发帖 17 回帖 360 粉丝 18 关注私信	小希希 16 楼文章写的很工整 2022-4-19 09:50 0
DXXXXxxxxx 雪币： 2 能力值： ( LV1，RANK：0 ) 在线值：发帖 1 回帖 4 粉丝 1 关注私信	DXXXXxxxxx 17 楼 64aK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6J5N6$3k6H3L8q4)9J5c8Y4u0W2N6$3!0D9k6W2)9J5k6s2N6G2N6K6j5@1k6i4S2@1 2022-4-26 01:34 0
停舟观鱼雪币： 5563 活跃值： (4305) 能力值： ( LV3，RANK：20 ) 在线值：发帖 2 回帖 16 粉丝 0 关注私信	停舟观鱼 18 楼 mark 2022-9-26 10:25 0
Gift1a 雪币： 177 活跃值： (3129) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 12 粉丝 9 关注私信	Gift1a 19 楼 mark 2022-10-24 17:27 0
SYJ-Re 雪币： 3672 活跃值： (9915) 能力值： ( LV9，RANK：319 ) 在线值：发帖 37 回帖 68 粉丝 177 关注私信	SYJ-Re 3 20 楼只能生成后双击运行其实导致马子受到的限制比较多只能生成后双击运行的原因：6fcK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6V1L8%4y4T1L8%4S2Q4x3X3c8K6N6r3q4Y4K9h3&6Y4i4K6u0r3k6r3!0K6j5X3!0^5i4K6u0V1M7%4c8S2k6$3W2F1k6#2)9J5c8X3W2K6M7%4g2W2M7#2)9J5c8U0p5K6y4K6W2Q4c8e0g2Q4z5e0u0Q4z5p5y4Z5N6s2c8H3M7#2)9K6b7g2)9J5c8W2)9J5c8X3q4K6M7s2u0G2M7%4W2K6i4K6u0W2j5X3I4G2k6%4y4H3L8%4c8Q4x3X3g2U0L8$3#2Q4x3V1j5J5x3o6l9&6i4K6u0r3x3o6y4Q4x3V1k6H3k6i4u0A6L8s2y4Q4x3X3c8S2L8X3c8Q4x3X3c8H3K9i4c8X3j5h3I4D9M7#2)9J5k6r3!0X3i4K6u0V1L8r3q4#2L8X3y4Z5K9h3&6Y4i4K6u0W2K9s2c8E0L8q4!0q4z5q4!0n7c8W2)9&6z5g2!0q4y4q4!0n7z5q4!0m8b7g2!0q4y4W2)9&6y4W2)9^5y4#2!0q4y4q4!0n7z5q4!0m8c8q4!0q4y4W2)9&6b7#2)9^5z5g2!0q4y4W2)9^5c8W2)9&6x3q4!0q4y4g2)9^5z5q4!0n7x3q4!0q4c8W2!0n7b7#2)9^5b7#2!0q4y4g2!0m8y4q4!0m8y4#2!0q4y4W2!0m8y4W2)9^5x3W2!0q4y4W2)9^5y4q4)9^5c8W2!0q4y4W2)9^5x3q4)9&6c8q4!0q4y4W2)9&6z5q4!0m8c8W2!0q4y4g2)9&6x3q4!0m8c8W2!0q4y4g2)9^5b7g2!0m8z5q4!0q4y4W2)9&6y4#2!0n7y4W2!0q4y4q4!0n7c8q4!0n7c8W2!0q4y4#2)9&6y4q4!0m8z5q4!0q4y4#2)9&6b7g2)9^5y4q4!0q4y4#2)9&6y4q4!0m8z5q4!0q4y4W2)9^5z5q4!0n7y4#2!0q4y4W2!0n7x3W2!0m8x3g2!0q4y4W2)9&6b7#2)9^5z5g2!0q4z5q4!0m8c8g2!0n7c8W2!0q4z5g2)9&6y4#2!0m8c8b7`.`. Window Station 和桌面的权限，并且您的进程正在其中启动，因此它无法初始化，去调整 Window Station 和桌面的安全描述符，以向正在启动进程的用户授予AllAccess权限的话太过麻烦，源码cpp最开始加一句 #pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"") 生成一个不带控制台窗口的 Windows 应用程序然后可以加载成功 2024-3-21 12:06 2
xyzliao 雪币： 690 活跃值： (5653) 能力值： ( LV3，RANK：20 ) 在线值：发帖 4 回帖 129 粉丝 4 关注私信	xyzliao 21 楼骚操作 2024-3-26 14:28 0
金坷垃彩虹雪币： 447 活跃值： (5572) 能力值： ( LV3，RANK：25 ) 在线值：发帖 4 回帖 62 粉丝 29 关注私信	金坷垃彩虹 22 楼 SYJ-Re 只能生成后双击运行其实导致马子受到的限制比较多只能生成后双击运行的原因：c19K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6V1L8%4y4T1L8%4S2Q4x3X3c8K6N6r3q4Y4K9h3&6Y4i4K6u0r3k6r3!0K6j5X3!0^5i4K6u0V1M7%4c8S2k6$3W2F1k6#2)9J5c8X3W2K6M7%4g2W2M7#2)9J5c8U0p5K6y4K6W2Q4c8e0g2Q4z5e0u0Q4z5p5y4Z5N6s2b7`. ... 貌似这玩意不能直接通过x64call的方式调用cs或者msf生成的shellcode，我也尝试过从kernel32中获取CreateThread，再通过CreateThread创建线程传入shellcode的方式运行也没有成功不知道是为什么 2024-4-16 06:41 0
程序Dylan 雪币： 320 活跃值： (85) 能力值： ( LV2，RANK：10 ) 在线值：发帖 3 回帖 12 粉丝 0 关注私信	程序Dylan 23 楼收藏学习一下，外行人的我居然看懂，orzorzorzorzorzorz！膜拜学习。其中get到的新知识是WoW64层的那张图。 2024-4-29 11:23 0
sonyps 雪币： 6770 活跃值： (8783) 能力值： ( LV4，RANK：40 ) 在线值：发帖 33 回帖 393 粉丝 30 关注私信	sonyps 24 楼目前市面上这些都无法兼容ARM64等新WOW64平台，我这个可以 80cK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6K6L8$3&6&6M7s2x3#2x3U0l9I4x3K6p5@1i4K6u0r3N6$3!0%4y4U0c8W2P5s2b7`. 另外无法加载kerner32.dll，和user32.dll是操作系统设计限制，就算你加载成功并调用了里面的函数，之后程序也会问题，因为程序已经进入一个混乱的状态了（同时拥有了32位和64位的窗口态等），会让系统分不清楚你这个进程到底是64位的还是32位的，比如你显示了窗口后，那些第三方的64位的窗口钩子DLL也会出现在你的进程中，而工作异常。所以这项技术就不是拿来加载64位dll用的，加载dll还是老实通过新建原生进程吧，如rundll32.exe。这个只能实现读写64位内存，注入远程线程级别的操作。最后于 2024-4-29 21:32 被sonyps编辑，原因： 2024-4-29 15:18 1
如风少年雪币： 4 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 2 粉丝 0 关注私信	如风少年 25 楼 eccK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6X3M7X3g2W2L8s2W2X3L8s2W2&6P5g2)9J5c8V1&6@1c8i4S2@1i4K6t1$3L8X3u0K6M7q4)9K6b7W2!0q4y4W2)9^5c8g2!0m8y4#2!0q4y4g2)9^5z5q4!0n7y4W2!0q4y4g2)9^5c8W2!0n7x3q4!0q4y4#2!0m8z5q4)9^5b7W2!0q4y4g2!0n7b7g2)9^5c8W2!0q4y4g2)9^5b7g2!0m8x3q4!0q4z5q4!0n7c8q4!0n7c8q4)9J5y4X3&6T1M7%4m8Q4x3@1t1$3y4q4!0q4y4q4!0n7c8q4)9^5c8r3E0W2M7X3&6W2L8o6x3J5i4K6u0W2k6r3I4D9i4K6t1$3L8X3u0K6M7q4)9K6b7W2!0q4y4g2)9^5c8W2!0m8c8W2!0q4y4q4!0n7b7W2!0m8y4g2!0q4y4#2)9&6b7#2)9^5b7W2!0q4y4W2)9^5z5q4)9&6x3g2!0q4y4#2)9&6b7g2)9^5y4q4!0q4z5q4!0n7c8W2)9&6z5g2!0q4y4q4!0n7z5q4!0m8b7g2!0q4z5g2!0m8x3g2!0n7z5g2!0q4y4#2)9&6b7W2!0m8c8b7`.`. 32 位的控制台程序里，强行去加载 64 位的 kernel32.dll，系统在初始化控制台相关资源时会发生严重的逻辑错乱，可以先用 VirtualProtect 解除内存保护，把程序的身份强行篡改成 WINDOWS_GUI，加载完 kerneldll 之后再恢复成 CUI 最后于 2026-3-22 23:47 被如风少年编辑，原因： 2026-3-16 01:04 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复