// ianbeer

iOS 10.2 के लिए CVE-2017-2370 के लिए कर्नेल मनमाना पढ़ने/लिखने का शोषण

केवल iPod Touch 6G 14C92 पर परीक्षण किया गया - अन्य डिवाइस/फर्मवेयर बॉक्स के बाहर काम नहीं करेंगे!

*** बग ***

mach_voucher_extract_attr_recipe_trap एक मैक ट्रैप है जिसे किसी भी संदर्भ से कॉल किया जा सकता है। यह बिल्कुल नया कोड है, जिसे iOS 10 में जोड़ा गया है।

kern_return_t mach_voucher_extract_attr_recipe_trap(struct mach_voucher_extract_attr_recipe_args *args) { ipc_voucher_t voucher = IV_NULL; kern_return_t kr = KERN_SUCCESS; mach_msg_type_number_t sz = 0;

if (copyin(args->recipe_size, (void *)&sz, sizeof(sz)))              <---------- (a)
  return KERN_MEMORY_ERROR;

if (sz > MACH_VOUCHER_ATTR_MAX_RAW_RECIPE_ARRAY_SIZE)
  return MIG_ARRAY_TOO_LARGE;

voucher = convert_port_name_to_voucher(args->voucher_name);
if (voucher == IV_NULL)
  return MACH_SEND_INVALID_DEST;

mach_msg_type_number_t __assert_only max_sz = sz;

if (sz < MACH_VOUCHER_TRAP_STACK_LIMIT) {
  /* keep small recipes on the stack for speed */
  uint8_t krecipe[sz];
  if (copyin(args->recipe, (void *)krecipe, sz)) {
    kr = KERN_MEMORY_ERROR;
    goto done;
  }
  kr = mach_voucher_extract_attr_recipe(voucher, args->key,
      (mach_voucher_attr_raw_recipe_t)krecipe, &sz);
  assert(sz <= max_sz);

  if (kr == KERN_SUCCESS && sz > 0)
    kr = copyout(krecipe, (void *)args->recipe, sz);
} else {
  uint8_t *krecipe = kalloc((vm_size_t)sz);                          <---------- (b)
  if (!krecipe) {
    kr = KERN_RESOURCE_SHORTAGE;
    goto done;
  }

  if (copyin(args->recipe, (void *)krecipe, args->recipe_size)) {    <----------- (c)
    kfree(krecipe, (vm_size_t)sz);
    kr = KERN_MEMORY_ERROR;
    goto done;
  }

  kr = mach_voucher_extract_attr_recipe(voucher, args->key,
        (mach_voucher_attr_raw_recipe_t)krecipe, &sz);
  assert(sz <= max_sz);

  if (kr == KERN_SUCCESS && sz > 0)
    kr = copyout(krecipe, (void *)args->recipe, sz);
  kfree(krecipe, (vm_size_t)sz);
}

kr = copyout(&sz, args->recipe_size, sizeof(sz));

done:
ipc_voucher_release(voucher);
return kr;

}

यहाँ तर्क संरचना है (यूज़रस्पेस से नियंत्रित)

struct mach_voucher_extract_attr_recipe_args { PAD_ARG_(mach_port_name_t, voucher_name); PAD_ARG_(mach_voucher_attr_key_t, key); PAD_ARG_(mach_voucher_attr_raw_recipe_t, recipe); PAD_ARG_(user_addr_t, recipe_size); };

recipe और recipe_size यूज़रस्पेस पॉइंटर्स हैं।

बिंदु (a) पर, यूज़रस्पेस पॉइंटर recipe_size से चार बाइट्स sz में पढ़े जाते हैं।

बिंदु (b) पर, यदि sz MACH_VOUCHER_ATTR_MAX_RAW_RECIPE_ARRAY_SIZE (5120) से कम और MACH_VOUCHER_TRAP_STACK_LIMIT (256) से अधिक था, तो sz का उपयोग कर्नेल हीप बफर आवंटित करने के लिए किया जाता है।

बिंदु (c) पर, अभी आवंटित बफर में यूज़रस्पेस मेमोरी कॉपी करने के लिए फिर से copyin कॉल किया जाता है, लेकिन sz (मान्य आकार जो आवंटित किया गया था) पास करने के बजाय, args->recipe_size को आकार के रूप में पास किया जाता है। यह आकार का यूज़रस्पेस पॉइंटर है, न कि आकार!

इससे पूरी तरह से नियंत्रित कर्नेल हीप ओवरफ्लो होता है। ध्यान दें कि कोड वास्तव में ठीक से काम नहीं कर सकता :)

*** शोषण ***

मैं प्री-आवंटित मैक संदेश बफ़र्स को लक्षित करता हूं जो kalloc के माध्यम से आवंटित किए जाते हैं। पहले 4 बाइट एक आकार फ़ील्ड हैं जिसका उपयोग यह निर्धारित करने के लिए किया जाता है कि बफर में संदेश को कहाँ पढ़ना और लिखना है। इस फ़ील्ड को दूषित करके हम मैक संदेशों को kmsg को बैक करने वाले kalloc आवंटन की सीमाओं के बाहर पढ़ और लिख सकते हैं।

एक छोटी सी जटिलता यह है कि एक पोर्ट का प्री-आवंटित kmsg केवल कर्नेल द्वारा वास्तविक mach_msg भेजने के लिए उपयोग किया जाएगा (उदाहरण के लिए MIG विधियों के उत्तरों के लिए नहीं।) इससे उनमें पर्याप्त नियंत्रित सामग्री प्राप्त करना थोड़ा मुश्किल हो जाता है।

एक प्रकार का मैक संदेश जो कर्नेल बहुत अधिक उपयोगकर्ता-नियंत्रित डेटा के साथ भेजता है, वह एक अपवाद संदेश है, जो एक थ्रेड क्रैश होने पर भेजा जाता है।

फ़ाइल load_regs_and_crash.s में ARM64 असेंबली है जो ARM64 सामान्य-उद्देश्य रजिस्टरों को एक बफर की सामग्री से लोड करती है ताकि जब यह क्रैश हो, तो अपवाद संदेश में वह डेटा बफर (लगभग 0x70 बाइट्स नियंत्रित) हो।

पोर्ट के ikm_size फ़ील्ड को किसी अन्य पोर्ट के हेडर की ओर इंगित करने के लिए ओवरराइट करके हम दूसरे पोर्ट के हेडर को पढ़ और लिख सकते हैं और यह पता लगा सकते हैं कि वह मेमोरी में कहाँ है। फिर हम उस दूसरे पोर्ट को मुक्त कर सकते हैं और उसके स्थान पर एक यूज़र क्लाइंट को पुनः आवंटित कर सकते हैं जिसे हम पढ़ और लिख भी सकते हैं।

मैं यूज़र क्लाइंट के vtable पॉइंटर को पढ़ता हूं फिर OSSerializer::serialize गैजेट तकनीक का उपयोग करता हूं जैसा कि विस्तार से बताया गया है [https://info.lookout.com/rs/051-ESQ-475/images/pegasus-exploits-technical-details.pdf] में दो नियंत्रित तर्कों के साथ एक मनमाना फ़ंक्शन कॉल करने के लिए।

मैं uuid_copy को कॉल करता हूं जो memmove(arg0, arg1, 0x10) को कॉल करता है। arg0 या arg1 को यूज़र क्लाइंट में ही इंगित करके (जिसे हम अपवाद संदेश प्राप्त करके पढ़ सकते हैं) हम 16 बाइट चंक में मनमाना कर्नेल मेमोरी पढ़ और लिख सकते हैं।

extra_recipe

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