rewolf-wow64ext的目的就是让运行在Wow64环境中的x86应用程序可以直接调用x64下ntdll.dll中的Native API。
学习中可以得到几个结论
- 在X64环境下的进程，32位程序，映射了两个地址空间，一个32位，一个64位。而且这两种工作模式是可以切换的的。
- WOW64进程中的R12寄存器指向其64位的TEB结构（线程环境块）。
- 我们可以将进程的32位模式改为64位模式，然后来调用64位的函数。
进程的32位模式改为64位模式的具体代码
主要方法是 借助retf将CS寄存器的值设置为0x33。
在CPU中，CS的全拼为"Code Segment"，翻译为"代码段寄存器"，对应于内存中的存放代码的内存区域，用来存放内存代码段区域的入口地址(段基址)。
在CPU执行指令时，通过代码段寄存器(CS，Code Segment)和指令指针寄存器(IP，Instruction Pointer)来确定要执行的下一条指令的内存地址。
至于为什么要将CS寄存器的值设置为0x33。因为我们所需CPU的解码模式需要是64位模式，而当前模式是32位。64位CPU是通过GDT表中CS段所对应的表项中L标志位来确定当前解码模式的。
看雪论坛上这篇关于Wow64的原理的文章https://bbs.pediy.com/thread-221236.htm 介绍了这一机制
#pragma once #define EMIT(a) __asm __emit (a) #define X64_Start_with_CS(_cs) \ { \ EMIT(0x6A) EMIT(_cs) /*1 push _cs 压入我们传入的cs */ \ EMIT(0xE8) EMIT(0) EMIT(0) EMIT(0) EMIT(0) /*2 call $+5 压入eip，jmp到3 */ \ EMIT(0x83) EMIT(4) EMIT(0x24) EMIT(5) /*3 add dword [esp], 5 跳过接下来五个字节 得到下下条指令的地址 */ \ EMIT(0xCB) /*4 retf 先弹出堆栈中的IP/EIP，然后弹出CS */ \ } /* 00EE169E 6A 33 push 33h 00EE16A0 E8 00 00 00 00 call main+25h (0EE16A5h) 00EE16A5 83 04 24 05 add dword ptr [esp],5 00EE16A9 CB retf //当代码执行完这一句以后 eip的值为00EE16AA cs=33h 00EE16AA E8 00 00 00 00 call main+2Fh (0EE16AFh) 00EE16AF C7 44 24 04 23 00 00 00 mov dword ptr [esp+4],23h 00EE16B7 83 04 24 0D add dword ptr [esp],0Dh 00EE16BB CB retf */ #define X64_End_with_CS(_cs) \ { EMIT(0xE8) EMIT(0) EMIT(0) EMIT(0) EMIT(0) /* call $+5 */ \ EMIT(0xC7) EMIT(0x44) EMIT(0x24) EMIT(4) EMIT(_cs) EMIT(0) EMIT(0) EMIT(0) /* mov dword [rsp + 4], _cs */ \ EMIT(0x83) EMIT(4) EMIT(0x24) EMIT(0xD) /* add dword [rsp], 0xD */ \ EMIT(0xCB) /* retf */ \ } #define X64_Start() X64_Start_with_CS(0x33) #define X64_End() X64_End_with_CS(0x23)
ret，iret和retf的区别 ,call $+5的意思
ret：也可以叫做近返回，即段内返回。处理器从堆栈中弹出IP或者EIP，然后根据当前的CS：IP跳转到新的执行地址。如果之前压栈的还有其余的参数，则这些参数也会被弹出。 retf：也叫远返回，从一个段返回到另一个段。先弹出堆栈中的IP/EIP，然后弹出CS，有之前压栈的参数也会弹出。（近跳转与远跳转的区别就在于CS是否压栈。） iret：用于从中断返回，会弹出IP/EIP，然后CS，以及一些标志。然后从CS：IP执行。 $表示当前地址,call $+5表示,调用用 本地址+5字节后的 子程序
我们首先要自己定义一个拷贝内存的函数。
void getMem64(void* dstMem, DWORD64 srcMem, size_t sz) { if ((nullptr == dstMem) || (0 == srcMem) || (0 == sz)) return; reg64 _src = { srcMem }; __asm { X64_Start(); ;// below code is compiled as x86 inline asm, but it is executed as x64 code ;// that's why it need sometimes REX_W() macro, right column contains detailed ;// transcription how it will be interpreted by CPU push edi ;// push rdi push esi ;// push rsi ;// mov edi, dstMem ;// mov edi, dword ptr [dstMem] ; high part of RDI is zeroed REX_W mov esi, _src.dw[0] ;// mov rsi, qword ptr [_src] mov ecx, sz ;// mov ecx, dword ptr [sz] ; high part of RCX is zeroed ;// mov eax, ecx ;// mov eax, ecx and eax, 3 ;// and eax, 3 最后2位 shr ecx, 2 ;// shr ecx, 2 除4 因为接下来 每次MOVSD 传送四个字节. ;// rep movsd ;// rep movs dword ptr [rdi], dword ptr [rsi] ;// test eax, eax ;// test eax, eax 比较是否为空 je _move_0 ;// je _move_0 cmp eax, 1 ;// cmp eax, 1 是否为一 je _move_1 ;// je _move_1 ;// movsw ;// movs word ptr [rdi], word ptr [rsi] cmp eax, 2 ;// cmp eax, 2 je _move_0 ;// je _move_0 ;// _move_1: ;// movsb ;// movs byte ptr [rdi], byte ptr [rsi] ;// _move_0: ;// 还原后返回 pop esi ;// pop rsi pop edi ;// pop rdi X64_End(); } }
现在我们可以去查找目标函数地址
思想是 目标函数从动态库（ntdll）中获得，我们需要从LDR中匹配动态库，LDR可以在PEB中找到，PEB可以在TEB中找到，TEB可以通过R12寄存器获得。
故 R12-TEB-PEB-LDR-NTDLL。
获得R12 #define _R12 12 #define X64_Push(r) EMIT(0x48 | ((r) >> 3)) EMIT(0x50 | ((r) & 7)) #define X64_Pop(r) EMIT(0x48 | ((r) >> 3)) EMIT(0x58 | ((r) & 7)) 获得TEB DWORD64 getTEB64() { reg64 reg; reg.v = 0; X64_Start(); // R12 register should always contain pointer to TEB64 in WoW64 processes X64_Push(_R12); // below pop will pop QWORD from stack, as we're in x64 mode now __asm pop reg.dw[0] X64_End(); return reg.v; } 获得PEB PEB64 peb64; getMem64(&peb64, teb64.ProcessEnvironmentBlock, sizeof(PEB64)); 获得LDR PEB_LDR_DATA64 ldr; getMem64(&ldr, peb64.Ldr, sizeof(PEB_LDR_DATA64)); 获得ntdll基地址 wchar_t lpModuleName=L"ntdll.dll" DWORD64 LastEntry = peb64.Ldr + offsetof(PEB_LDR_DATA64, InLoadOrderModuleList); LDR_DATA_TABLE_ENTRY64 head; head.InLoadOrderLinks.Flink = ldr.InLoadOrderModuleList.Flink; do { getMem64(&head, head.InLoadOrderLinks.Flink, sizeof(LDR_DATA_TABLE_ENTRY64)); wchar_t* tempBuf = (wchar_t*)malloc(head.BaseDllName.MaximumLength); if (nullptr == tempBuf) return 0; WATCH(tempBuf); getMem64(tempBuf, head.BaseDllName.Buffer, head.BaseDllName.MaximumLength); if (0 == _wcsicmp(lpModuleName, tempBuf)) return head.DllBase; } while (head.InLoadOrderLinks.Flink != LastEntry);
找到模块基地址以后，我们就可以通过PE文件结构去获得我们需要的函数了
思想是 得到目标函数地址，需要利用函数名找到对应函数的相对偏移RVA，那就需要找到IMAGE_EXPORT_DIRECTORY结构体下的 AddressOfNames，AddressOfNameOrdinals，AddressOfFunctions 三个成员。
故 IMAGE_DOS_HEADER---IMAGE_NT_HEADERS64---IMAGE_DATA_DIRECTORY---IMAGE_EXPORT_DIRECTORY-AddressOfNames，AddressOfNameOrdinals，AddressOfFunctions---目标函数RVA
DWORD64 getLdrGetProcedureAddress() { DWORD64 modBase = getNTDLL64(); if (0 == modBase) return 0; IMAGE_DOS_HEADER idh; getMem64(&idh, modBase, sizeof(idh)); IMAGE_NT_HEADERS64 inh; getMem64(&inh, modBase + idh.e_lfanew, sizeof(IMAGE_NT_HEADERS64)); IMAGE_DATA_DIRECTORY & idd = inh.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT]; if (0 == idd.VirtualAddress) return 0; IMAGE_EXPORT_DIRECTORY ied; getMem64(&ied, modBase + idd.VirtualAddress, sizeof(ied)); DWORD* rvaTable = (DWORD*)malloc(sizeof(DWORD)*ied.NumberOfFunctions); if (nullptr == rvaTable) return 0; WATCH(rvaTable); getMem64(rvaTable, modBase + ied.AddressOfFunctions, sizeof(DWORD)*ied.NumberOfFunctions); WORD* ordTable = (WORD*)malloc(sizeof(WORD)*ied.NumberOfFunctions); if (nullptr == ordTable) return 0; WATCH(ordTable); getMem64(ordTable, modBase + ied.AddressOfNameOrdinals, sizeof(WORD)*ied.NumberOfFunctions); DWORD* nameTable = (DWORD*)malloc(sizeof(DWORD)*ied.NumberOfNames); if (nullptr == nameTable) return 0; WATCH(nameTable); getMem64(nameTable, modBase + ied.AddressOfNames, sizeof(DWORD)*ied.NumberOfNames); // lazy search, there is no need to use binsearch for just one function for (DWORD i = 0; i < ied.NumberOfFunctions; i++) { if (!cmpMem64("LdrGetProcedureAddress", modBase + nameTable[i], sizeof("LdrGetProcedureAddress"))) continue; else return modBase + rvaTable[ordTable[i]]; } return 0; }
注意！我们得到函数地址以后，不能直接调用
需要通过X64Call（）来执行。 X64调用约定前4个参数通过rcx,rdx,r8,r9来传递，之后通过堆栈传递。
#pragma warning(push) #pragma warning(disable : 4409) DWORD64 __cdecl X64Call(DWORD64 func, int argC, ...) { if (!g_isWow64) return 0; va_list args;//VA_LIST 是在C语言中解决变参问题的一组宏，所在头文件：#include <stdarg.h>，用于获取不确定个数的参数。 va_start(args, argC);//VA_START宏，获取可变参数列表的第一个参数的地址（ap是类型为va_list的指针，v是可变参数最左边的参数）： reg64 _rcx = { (argC > 0) ? argC--, va_arg(args, DWORD64) : 0 }; reg64 _rdx = { (argC > 0) ? argC--, va_arg(args, DWORD64) : 0 };//VA_ARG宏，获取可变参数的当前参数，返回指定类型并将指针指向下一参数（t参数描述了当前参数的类型）： reg64 _r8 = { (argC > 0) ? argC--, va_arg(args, DWORD64) : 0 }; reg64 _r9 = { (argC > 0) ? argC--, va_arg(args, DWORD64) : 0 }; reg64 _rax = { 0 }; reg64 restArgs = { (DWORD64)&va_arg(args, DWORD64) };//剩余成员用堆栈传递 // conversion to QWORD for easier use in inline assembly reg64 _argC = { (DWORD64)argC }; DWORD back_esp = 0; WORD back_fs = 0; __asm { ;// reset FS segment, to properly handle RFG mov back_fs, fs mov eax, 0x2B mov fs, ax ;// keep original esp in back_esp variable mov back_esp, esp ;// align esp to 0x10, without aligned stack some syscalls may return errors ! ;// (actually, for syscalls it is sufficient to align to 8, but SSE opcodes ;// requires 0x10 alignment), it will be further adjusted according to the ;// number of arguments above 4 ;//对齐 and esp, 0xFFFFFFF0 X64_Start(); ;// below code is compiled as x86 inline asm, but it is executed as x64 code ;// that's why it need sometimes REX_W() macro, right column contains detailed ;// transcription how it will be interpreted by CPU ;// fill first four arguments REX_W mov ecx, _rcx.dw[0] ;// mov rcx, qword ptr [_rcx] REX_W mov edx, _rdx.dw[0] ;// mov rdx, qword ptr [_rdx] push _r8.v ;// push qword ptr [_r8] X64_Pop(_R8); ;// pop r8 push _r9.v ;// push qword ptr [_r9] X64_Pop(_R9); ;// pop r9 ;// REX_W mov eax, _argC.dw[0] ;// mov rax, qword ptr [_argC] ;// ;// final stack adjustment, according to the ;// ;// number of arguments above 4 ;// test al, 1 ;// test al, 1 jnz _no_adjust ;// jnz _no_adjust sub esp, 8 ;// sub rsp, 8 对齐对齐对齐！假如有单个参数 需要对齐！！！ _no_adjust: ;// ;// push edi ;// push rdi REX_W mov edi, restArgs.dw[0] ;// mov rdi, qword ptr [restArgs] ;// ;// put rest of arguments on the stack ;// REX_W test eax, eax ;// test rax, rax jz _ls_e ;// je _ls_e REX_W ea edi, dword ptr [edi + 8*eax - 8] ;// lea rdi, [rdi + rax*8 - 8]取最后一个的地址 ;// _ls: ;// REX_W test eax, eax ;// test rax, rax 判断是否为0 jz _ls_e ;// je _ls_e push dword ptr [edi] ;// push qword ptr [rdi] REX_W sub edi, 8 ;// sub rdi, 8 REX_W sub eax, 1 ;// sub rax, 1 jmp _ls ;// jmp _ls _ls_e: ;// ;// ;// create stack space for spilling registers ;// REX_W sub esp, 0x20 ;// sub rsp, 20h ;// call func ;// call qword ptr [func] ;// ;// cleanup stack ;// REX_W mov ecx, _argC.dw[0] ;// mov rcx, qword ptr [_argC] REX_W lea esp, dword ptr [esp + 8*ecx + 0x20] ;// lea rsp, [rsp + rcx*8 + 20h] ;// pop edi ;// pop rdi ;// // set return value ;// REX_W mov _rax.dw[0], eax ;// mov qword ptr [_rax], rax X64_End(); mov ax, ds mov ss, ax mov esp, back_esp ;// restore FS segment mov ax, back_fs mov fs, ax } return _rax.v; }
一个例子
DWORD64 __cdecl GetProcAddress64(DWORD64 hModule, char* funcName) { static DWORD64 _LdrGetProcedureAddress = 0; if (0 == _LdrGetProcedureAddress) { _LdrGetProcedureAddress = getLdrGetProcedureAddress();//从ntdll中获得的目标函数地址 if (0 == _LdrGetProcedureAddress) return 0; } _UNICODE_STRING_T<DWORD64> fName = { 0 }; fName.Buffer = (DWORD64)funcName; fName.Length = (WORD)strlen(funcName); fName.MaximumLength = fName.Length + 1; DWORD64 funcRet = 0; X64Call(_LdrGetProcedureAddress, 4, (DWORD64)hModule, (DWORD64)&fName, (DWORD64)0, (DWORD64)&funcRet); return funcRet; }
最近在学反调试，其中就用到了这个方法，等学习完以后会将例子放上来
