漏洞概述

该漏洞是一个 Array.prototype.reverse 在操作时没有控制数据完整性而导致的数组越界访问

漏洞样本

样本来自 Projectzero

var a = [1];
a.length = 1000;
var j = [];

var o = {};
  Object.defineProperty(o, '1', {
    get: function() {
      a.length = 1002;
      j.fill.call(a, 7.7);
      return 2;
    }
  });

a.__proto__ = o;

var r = j.reverse.call(a);
r.length = 0xfffffffe;
r[0xfffffffe - 1] = 10;

详细分析

触发漏洞的语句为 var r = j.reverse.call(a); Chakra 引擎调用函数 JavascriptArray::EntryRevers 来处理这个请求。JavascriptArray::EntryRevers 的流程如下

    Var JavascriptArray::EntryReverse(RecyclableObject* function, CallInfo callInfo, ...)
    {
        JavascriptArray* pArr = JavascriptArray::FromVar(args[0]);
        if (scriptContext->GetConfig()->IsES6TypedArrayExtensionsEnabled() || pArr == nullptr)
        {
            if (scriptContext->GetConfig()->IsES6ToLengthEnabled())
            {
                length = (uint64) JavascriptConversion::ToLength(JavascriptOperators::OP_GetLength(obj, scriptContext), scriptContext);
            }
            else
            {
                length = JavascriptConversion::ToUInt32(JavascriptOperators::OP_GetLength(obj, scriptContext), scriptContext);
            }
        }
        else
        {
            length = pArr->length;
        }
            return JavascriptArray::ReverseHelper(pArr, nullptr, obj, length.GetSmallIndex(), scriptContext);
    }

函数首先获取 Length，调用 JavascriptArray::ReverseHelper 完成数组的翻转，由于 reverse 操作是发生在当前数组本身的，因此也不需要新建数组，直接在当前数组操作即可。

进入函数 JavascriptArray::ReverseHelper 对数组中的 segment 逐个进行翻转，翻转操作实质上是一系列的取值和赋值操作，因此需要调用其 js 层的 Getter 完成一遍 copy-from-prototype。下面是对 segment 逐个翻转的过程

JavascriptArray::ReverseHelper
{
        //......
            while (seg)
            {
                nextSeg = seg->next;
                // If seg.length == 0, it is possible that (seg.left + seg.length == prev.left + prev.length),
                // resulting in 2 segments sharing the same "left".
                if (seg->length > 0)
                {
                    if (isIntArray)
                    {
                        ((SparseArraySegment<int32>*)seg)->ReverseSegment(recycler);
                    }
                    else if (isFloatArray)
                    {
                        ((SparseArraySegment<double>*)seg)->ReverseSegment(recycler);
                    }
                    else
                    {
                        ((SparseArraySegment<Var>*)seg)->ReverseSegment(recycler);
                    }
                    seg->left = ((uint32)length) - (seg->left + seg->length);
                    seg->next = prevSeg;
                    // Make sure size doesn't overlap with next segment.
                    // An easy fix is to just truncate the size...
                    seg->EnsureSizeInBound();
                    // If the last segment is a leaf, then we may be losing our last scanned pointer to its previous
                    // segment. Hold onto it with pinPrevSeg until we reallocate below.
                    pinPrevSeg = prevSeg;
                    prevSeg = seg;
                }
                seg = nextSeg;
            }
        //......
}

其中 seg->left = ((uint32)length) - (seg->left + seg->length); 语句是为了将 segment 的left 与 right 进行翻转，设计上并没有什么问题，但是注意到这里的 length 是从之前 Array 中获取的，而 seg->length 是从当前的segment中获取。然而 Length 是易变的，期间 copy-from-prototype 操作可以对 length 进行修改，从而造成这里的 seg->Length > length。导致 seg->left 发生下溢。

当 seg->left 很大的时候 EnsureSizeInBound 便有可能将 seg 的size 变小，从而导致 segment 发生溢出

补丁分析

这个漏洞的补丁如下，发生在交换 segment 的 left 和 right 时。这里添加了判断，如果可能发生下溢则将 left 直接设置为0 ，否则才进行计算。

 seg->left = ((uint32)length) > (seg->left + seg->length) ? ((uint32)length) - (seg->left + seg->length) : 0;

经过补丁的修改 seg->left 将不会再发生下溢。

然而这里并没有从根本上对补丁进行修补。当 length 大于 (seg->left + seg->length) 时，seg->left 会被设置为 0 。设想一种情况，copy-from-prototype 函数增加数组长度并因此增加了一个segment

seg1  =>  seg1->seg2

处理 seg1 时按正常流程，seg1->left依然为0，当处理 seg2 时发生 length 大于 (seg->left + seg->length) ，则 seg->left 被设置成为 0 ，此时出现两个 seg->left 为 0 的segment。进入后续函数 EnsureSizeInBound

    void SparseArraySegmentBase::EnsureSizeInBound(uint32 left, uint32 length, uint32& size, SparseArraySegmentBase* next)
    {
        uint32 nextLeft = next ? next->left : JavascriptArray::MaxArrayLength;
        if(size != 0)
        {
            size = min(size, nextLeft - left);
        }
    }

此时 seg2->next 为 seg1 ，从而导致 nextLeft = seg1->left == 0！！，显然 seg2 的 size 便被设置成为了 0 ，进而导致 segment 发生溢出。

于是，这里出现了第二个漏洞~ CVE-2017-0141，漏洞样本如下

let arr = [];
arr[1000] = 321321;
let proto = {};
Object.defineProperty(proto, "0", {get: function() {
    arr[2000] = 0x41414141;
    return 123;
}});

arr.__proto__ = proto;
Array.prototype.reverse.call(arr);
Array.prototype.sort.call(arr);

最后的补丁发生在 copy-from-prototype 之后。length 被重新获取了。同时修改了 JavascriptArray::EntryRevers 函数获取 length 的方式~回归了原始的 slot 方法。。。

            // Above FillFromPrototypes call can change the length of the array. Our segment calculation below will
             // not work with the stale length. Update the length.
             // Note : since we are reversing the whole segment below - the functionality is not spec compliant already.
             length = pArr->length;