Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-15 09:27:32 +00:00
Code Issues Projects Releases Packages Wiki Activity

Translated ['binary-exploitation/heap/bins-and-memory-allocations.md', '

Browse source
This commit is contained in:
Translator 2024-06-13 00:51:44 +00:00
parent b547487c48
commit fdc674be0d
5 changed files with 155 additions and 95 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
SUMMARY.md
View file

@ -731,6 +731,7 @@
* [Use After Free](binary-exploitation/heap/use-after-free/README.md) * [Use After Free](binary-exploitation/heap/use-after-free/README.md)
* [First Fit](binary-exploitation/heap/use-after-free/first-fit.md) * [First Fit](binary-exploitation/heap/use-after-free/first-fit.md)
* [Double Free](binary-exploitation/heap/double-free.md) * [Double Free](binary-exploitation/heap/double-free.md)
* [Overwriting a freed chunk](binary-exploitation/heap/overwriting-a-freed-chunk.md)
* [Heap Overflow](binary-exploitation/heap/heap-overflow.md) * [Heap Overflow](binary-exploitation/heap/heap-overflow.md)
* [Unlink Attack](binary-exploitation/heap/unlink-attack.md) * [Unlink Attack](binary-exploitation/heap/unlink-attack.md)
* [Fast Bin Attack](binary-exploitation/heap/fast-bin-attack.md) * [Fast Bin Attack](binary-exploitation/heap/fast-bin-attack.md)

108
binary-exploitation/heap/bins-and-memory-allocations.md
View file

@ -6,7 +6,7 @@
HackTricks का समर्थन करने के अन्य तरीके: HackTricks का समर्थन करने के अन्य तरीके:
* यदि आप अपनी **कंपनी का विज्ञापन HackTricks में देखना चाहते हैं** या **HackTricks को PDF में डाउनलोड करना चाहते हैं** तो [**सब्सक्रिप्शन प्लान्स देखें**](https://github.com/sponsors/carlospolop)! * अगर आप चाहते हैं कि आपकी **कंपनी HackTricks में विज्ञापित हो** या **HackTricks को PDF में डाउनलोड करें** तो [**सब्सक्रिप्शन प्लान्स देखें**](https://github.com/sponsors/carlospolop)!
* [**आधिकारिक PEASS और HackTricks स्वैग**](https://peass.creator-spring.com) प्राप्त करें * [**आधिकारिक PEASS और HackTricks स्वैग**](https://peass.creator-spring.com) प्राप्त करें
* हमारा विशेष [**NFTs**](https://opensea.io/collection/the-peass-family) संग्रह, [**The PEASS Family**](https://opensea.io/collection/the-peass-family) खोजें * हमारा विशेष [**NFTs**](https://opensea.io/collection/the-peass-family) संग्रह, [**The PEASS Family**](https://opensea.io/collection/the-peass-family) खोजें
* **शामिल हों** 💬 [**डिस्कॉर्ड समूह**](https://discord.gg/hRep4RUj7f) या [**टेलीग्राम समूह**](https://t.me/peass) या हमें **ट्विटर** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** पर फॉलो** करें। * **शामिल हों** 💬 [**डिस्कॉर्ड समूह**](https://discord.gg/hRep4RUj7f) या [**टेलीग्राम समूह**](https://t.me/peass) या हमें **ट्विटर** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** पर फॉलो** करें।
@ -16,24 +16,24 @@ HackTricks का समर्थन करने के अन्य तरी
## मूल जानकारी ## मूल जानकारी
चंक्स को स्टोर करने की कुशलता को बढ़ाने के लिए हर चंक सिर्फ एक लिंक्ड सूची में नहीं है, बल्कि कई प्रकार के होते हैं। ये बिन्स होते हैं और 5 प्रकार के बिन्स होते हैं: [62](https://sourceware.org/git/gitweb.cgi?p=glibc.git;a=blob;f=malloc/malloc.c;h=6e766d11bc85b6480fa5c9f2a76559f8acf9deb5;hb=HEAD#l1407) small bins, 63 large bins, 1 unsorted bin, 10 fast bins और 64 tcache bins प्रति थ्रेड। चंक्स को स्टोर करने की कुशलता को बढ़ाने के लिए हर चंक्स को केवल एक लिंक्ड सूची में नहीं रखा जाता है, बल्कि कई प्रकार के होते हैं। ये बिन्स होते हैं और 5 प्रकार के बिन्स होते हैं: [62](https://sourceware.org/git/gitweb.cgi?p=glibc.git;a=blob;f=malloc/malloc.c;h=6e766d11bc85b6480fa5c9f2a76559f8acf9deb5;hb=HEAD#l1407) small bins, 63 large bins, 1 unsorted bin, 10 fast bins और 64 tcache bins प्रति थ्रेड।
प्रत्येक अनसॉर्टेड, small और large bins के लिए प्रारंभिक पता एक ही एरे में होता है। इंडेक्स 0 अप्रयुक्त है, 1 अनसॉर्टेड बिन है, बिन्स 2-64 small bins हैं और बिन्स 65-127 large bins हैं। प्रत्येक अनसॉर्टेड, स्मॉल और लार्ज बिन्स के लिए प्रारंभिक पता एक ही एरे में होता है। इंडेक्स 0 अप्रयुक्त है, 1 अनसॉर्टेड बिन है, बिन्स 2-64 स्मॉल बिन्स हैं और बिन्स 65-127 लार्ज बिन्स हैं।
### Tcache (प्रति-थ्रेड कैश) बिन्स ### Tcache (प्रति-थ्रेड कैश) बिन्स
हालांकि थ्रेड्स अपनी खुद की हीप रखने की कोशिश करते हैं (देखें [Arenas](bins-and-memory-allocations.md#arenas) और [Subheaps](bins-and-memory-allocations.md#subheaps)), ऐसा मौका है कि एक प्रक्रिया जिसमें कई थ्रेड्स होते हैं (जैसे एक वेब सर्वर) **हीप को दूसरे थ्रेड्स के साथ साझा करने की संभावना है**। इस मामले में, मुख्य समाधान है **लॉकर्स** का उपयोग, जो **थ्रेड्स को काफी धीमा कर सकता है**। हालांकि थ्रेड्स अपनी खुद की हीप रखने की कोशिश करते हैं (देखें [Arenas](bins-and-memory-allocations.md#arenas) और [Subheaps](bins-and-memory-allocations.md#subheaps)), ऐसे प्रकार के प्रक्रियाओं के साथ (जैसे एक वेब सर्वर) **हीप को दूसरे थ्रेड्स के साथ साझा करने की संभावना** होती है। इस मामले में, मुख्य समाधान है **लॉकर्स** का उपयोग, जो **थ्रेड्स को काफी धीमा कर सकता है**।
इसलिए, एक tcache एक fast bin के प्रति थ्रेड के समान है उस तरीके से कि यह एक **एकल लिंक्ड सूची** है जो चंक्स को मर्ज नहीं करती। प्रत्येक थ्रेड के पास **64 सिंगल-लिंक्ड tcache bins** होते हैं। प्रत्येक बिन में [24 से 1032B तक के चंक्स](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l323) हो सकते हैं 64-बिट सिस्टम्स पर और 12 से 516B तक के 32-बिट सिस्टम्स पर। इसलिए, एक tcache एक फास्ट बिन के समान है उस प्रकार की यह एक **सिंगल लिंक्ड सूची** है जो चंक्स को मर्ज नहीं करती। प्रत्येक थ्रेड के पास **64 सिंगल-लिंक्ड tcache बिन्स** होते हैं। प्रत्येक बिन में [24 से 1032B तक के चंक्स](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l323) हो सकते हैं 64-बिट सिस्टम्स पर और 12 से 516B तक के चंक्स 32-बिट सिस्टम्स पर।
जब एक थ्रेड एक चंक फ्री करता है, **अगर यह बहुत बड़ा नहीं है** ताकि इसे tcache में आवंटित किया जा सके और संबंधित tcache bin **भरा नहीं है** (पहले से ही 7 चंक्स हैं), **तो वहां आवंटित किया जाएगा**। यदि यह tcache में नहीं जा सकता है, तो यह हीप लॉक का इंतजार करना होगा ताकि वह सार्वजनिक रूप से फ्री ऑपरेशन कर सके। जब एक थ्रेड एक चंक्स को मुक्त करता है, **अगर यह इतना बड़ा नहीं है** कि टीकैश में आवंटित किया जा सके और संबंधित tcache बिन **भरा नहीं है** (पहले से ही 7 चंक्स), **तो वहां आवंटित किया जाएगा**। अगर यह टीकैश में नहीं जा सकता है, तो यह हीप लॉक का इंतजार करना होगा ताकि वह सार्वजनिक रूप से मुक्ति कार्रवाई कर सके।
जब एक **चंक आवंटित किया जाता है**, अगर **Tcache में आवश्यक आकार का एक फ्री चंक है** तो वह इस्तेमाल करेगा, अगर नहीं, तो वह सार्वजनिक बिन्स में एक ढूंढने के लिए हीप लॉक का इंतजार करना होगा या एक नया बनाना होगा।\ जब एक **चंक्स आवंटित किया जाता है**, अगर **टीकैश में आवश्यक आकार का एक मुक्त चंक्स है** तो उसे उसका उपयोग करेगा, अगर नहीं, तो वह सार्वजनिक बिन्स में से एक ढूंढने के लिए हीप लॉक का इंतजार करना होगा या एक नया बनाना होगा।\
इस मामले में एक और अनुकूलन भी है, इस मामले में, हीप लॉक के साथ, थ्रेड **अपने Tcache को हीप चंक्स (7) से भरेगा** जिनकी आवश्यक आकार है, इसलिए यदि इसे और चाहिए, तो वह उन्हें Tcache में पाएगा। इस मामले में एक और अनुकूलन भी है, इस मामले में, हीप लॉक के साथ होते हुए, थ्रेड **अपना टीकैश हीप चंक्स के साथ भरेगा (7) अनुरोधित आकार के**, इसलिए यदि इसे अधिक चाहिए, तो वह उन्हें टीकैश में पाएगा।
<details> <details>
<summary>एक tcache चंक उदाहरण जोड़ें</summary> <summary>एक टीकैश चंक्स उदाहरण जोड़ें</summary>
```c ```c
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
@ -58,11 +58,7 @@ Tcachebins[idx=0, size=0x20, count=1] ← Chunk(addr=0xaaaaaaac12a0, size=0x20,
#### Tcache संरचनाएँ और कार्य #### Tcache संरचनाएँ और कार्य
निम्नलिखित कोड में देखना संभव है **अधिकतम बिन** और **प्रति सूची टुकड़े**, **`tcache_entry`** संरचित करने के लिए बनाया गया संरचना डबल मुक्तियों से बचने के लिए और **`tcache_perthread_struct`**, एक संरचना जिसका प्रत्येक धागा बिन के प्रत्येक सूची के पते को संग्रहित करने के लिए प्रयोग करता है। निम्नलिखित कोड में **अधिकतम बिन** और **प्रति सूची टुकड़े**, **`tcache_entry`** संरचित को दोहरी मुक्त करने से बचाने के लिए बनाया गया है और **`tcache_perthread_struct`**, एक संरचना जिसे प्रत्येक धागे का पता रखने के लिए उपयोग करता है।
<details>
<summary><code>tcache_entry</code> और <code>tcache_perthread_struct</code></summary>
```c ```c
// From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c // From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c
@ -159,21 +155,25 @@ memset (tcache, 0, sizeof (tcache_perthread_struct));
``` ```
</details> </details>
### तेज़ बिन #### Tcache Indexes
तेज़ बिन छोटे चंकों के लिए मेमोरी आवंटन की गति को तेज़ करने के लिए डिज़ाइन किए गए हैं, इन बिन्स में हाल ही में फ्री किए गए चंक्स को एक त्वरित पहुंच संरचना में रखकर उपयोग किया जाता है। ये बिन्स एक लास्ट-इन, फर्स्ट-आउट (LIFO) दृष्टिकोण का उपयोग करते हैं, जिसका मतलब है कि **हाल ही में फ्री किए गए चंक को पहले** पुनः उपयोग किया जाएगा जब एक नई आवंटन अनुरोध हो। यह व्यवहार गति के लिए फायदेमंद है, क्योंकि एक स्टैक (LIFO) से ऊपर से डालना और हटाना (एलआईएफओ) एक कतार (FIFO) की तुलना में तेज़ होता है। टीकैश में कई बिन होते हैं जो आकार और प्रारंभिक पॉइंटर्स के आधार पर निर्भर करते हैं **प्रत्येक इंडेक्स के पहले चंक और प्रति इंडेक्स चंक की मात्रा एक चंक के अंदर स्थित होती हैं**। इसका मतलब है कि इस जानकारी के साथ चंक को ढूंढना (सामान्यत: पहला), टीकैश के सभी प्रारंभिक पॉइंट्स और टीकैश चंक की मात्रा ढूंढना संभव है।
इसके अतिरिक्त, **तेज़ बिन्स में एकल लिंक्ड लिस्ट का उपयोग** किया जाता है, डबल लिंक्ड लिस्ट नहीं, जो गति को और बढ़ाता है। क्योंकि तेज़ बिन्स में चंक्स को पड़ोसियों के साथ मिलाया नहीं जाता, इसलिए उन्हें मध्य से हटाने की अनुमति देने वाली एक जटिल संरचना की आवश्यकता नहीं है। एक एकल लिंक्ड लिस्ट इन ऑपरेशन के लिए सरल और तेज़ है। ### Fast bins
मूल रूप से, यहाँ क्या होता है कि हेडर (पहले चंक के लिए पॉइंटर) हमेशा उस आकार के नवीनतम फ्री किए गए चंक की ओर पॉइंट कर रहा है। तो: फास्ट बिन्स को **छोटे चंकों के लिए मेमोरी आवंटन की गति बढ़ाने के लिए डिज़ाइन किया गया है** जिन्हें एक त्वरित पहुंच संरचना में हाल ही में फ्री किए गए चंक रखकर उपयोग में लाने के लिए उपयोग करते हैं। ये बिन्स एक लास्ट-इन, फर्स्ट-आउट (LIFO) दृष्टिकोण का उपयोग करते हैं, जिसका मतलब है कि **सबसे हाल ही में फ्री किया गया चंक सबसे पहले** उपयोग के लिए पुनः उपयोग किया जाएगा जब एक नई आवंटन अनुरोध हो। यह व्यवहार गति के लिए फायदेमंद है, क्योंकि एक स्टैक (LIFO) से ऊपर से डालना और हटाना तेज होता है तुलनात्मक रूप से एक कतार (FIFO) के साथ।
* जब उस आकार का नया चंक आवंटित किया जाता है, हेडर एक उपयुक्त चंक की ओर पॉइंट कर रहा है। क्योंकि यह फ्री चंक उपयोग के लिए अगले चंक की ओर पॉइंट कर रहा है, इस पते को हेडर में स्टोर किया जाता है ताकि अगली आवंटन जाने की जानकारी हो इसके अतिरिक्त, **फास्ट बिन्स एकल लिंक्ड लिस्ट का उपयोग करते हैं**, डबल लिंक्ड नहीं, जो गति को और बढ़ाता है। क्योंकि फास्ट बिन्स में चंक्स को पड़ोसियों के साथ मिलाया नहीं जाता, इसके लिए एक जटिल संरचना की आवश्यकता नहीं है जो मध्य से हटाने की अनुमति देती है। एकल लिंक्ड लिस्ट इन ऑपरेशन के लिए इसे सरल और तेज बनाता है।
* जब एक चंक फ्री किया जाता है, तो फ्री चंक वर्तमान उपलब्ध चंक का पता सहेजेगा और इस नवीनतम फ्री किए गए चंक का पता हेडर में डाल दिया जाएगा
लिंक्ड लिस्ट का अधिकतम आकार `0x80` है और वे इस प्रकार से संगठित हैं कि आकार `0x20-0x2f` का एक चंक सूची `0` में होगा, आकार `0x30-0x3f` का एक चंक `idx` `1` में होगा... मूल रूप से, यहाँ यह होता है कि हेडर (पहले चंक के पॉइंटर) हमेशा उस आकार के सबसे हाल ही में फ्री किए गए चंक की ओर पॉइंट कर रहा है। तो:
* जब उस आकार का नया चंक आवंटित किया जाता है, हेडर एक उपयोग के लिए एक फ्री चंक की ओर पॉइंट कर रहा है। क्योंकि यह फ्री चंक उपयोग के लिए अगले चंक की ओर पॉइंट कर रहा है, इस पते को हेडर में संग्रहीत किया जाता है ताकि अगली आवंटन जाने की जानकारी हो कि कहाँ से एक उपलब्ध चंक प्राप्त करना है
* जब एक चंक फ्री किया जाता है, तो फ्री चंक वर्तमान उपलब्ध चंक का पता सहेजेगा और इस नए फ्री चंक का पता हेडर में डाल दिया जाएगा
लिंक्ड लिस्ट का अधिकतम आकार `0x80` है और वे इस प्रकार से संगठित हैं कि आकार `0x20-0x2f` का एक चंक इंडेक्स `0` में होगा, आकार `0x30-0x3f` `idx` `1` में होगा...
{% hint style="danger" %} {% hint style="danger" %}
तेज़ बिन्स में चंक उपलब्ध नहीं होते हैं इसलिए वे कुछ समय तक तेज़ बिन चंक के रूप में रखे जाते हैं और उन्हें उनके आसपास के अन्य फ्री चंक्स के साथ मिलाने की क्षमता नहीं होती। फास्ट बिन्स में चंक उपलब्ध नहीं होते हैं इसलिए वे कुछ समय तक फास्ट बिन चंक के रूप में रखे जाते हैं बजाय इसके कि उन्हें उनके आसपास के अन्य फ्री चंक्स के साथ मर्ज किया जा सके।
{% endhint %} {% endhint %}
```c ```c
// From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1711 // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1711
@ -240,7 +240,7 @@ return 0;
``` ```
नोट करें कि हम एक ही आकार के 8 चंक को आवंटित और मुक्त करते हैं ताकि वे टीकैश भर जाएं और आठवां चंक तेज चंक में संग्रहीत हो। नोट करें कि हम एक ही आकार के 8 चंक को आवंटित और मुक्त करते हैं ताकि वे टीकैश भर जाएं और आठवां चंक तेज चंक में संग्रहीत हो।
इसे कंपाइल करें और मुख्य कार्य से रेट ओपकोड में ब्रेकपॉइंट के साथ डीबग करें। फिर gef के साथ आप टीकैश बिन भरते हुए और तेज बिन में एक चंक देख सकते हैं: इसे कंपाइल करें और मुख्य कार्य से रेट ऑपकोड में ब्रेकपॉइंट के साथ डीबग करें। फिर gef के साथ आप टीकैश बिन भरते हुए और तेज बिन में एक चंक देख सकते हैं:
```bash ```bash
gef➤ heap bins gef➤ heap bins
──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ──────────────────────────────────────────────────────────────────────────────── ──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
@ -251,23 +251,23 @@ Fastbins[idx=1, size=0x30] 0x00
``` ```
</details> </details>
### अव्यवर्तित बिन ### अवर्गीकृत बिन
अव्यवर्तित बिन एक **कैश** है जिसका हीप प्रबंधक द्वारा उपयोग किया जाता है ताकि मेमोरी आवंटन तेजी से हो सके। यहाँ यह कैसे काम करता है: जब कोई प्रोग्राम एक चंक को मुक्त करता है, और यदि यह चंक एक टीकैश या फास्ट बिन में आवंटित नहीं किया जा सकता है और यह टॉप चंक के साथ टकरा नहीं रहा है, तो हीप प्रबंधक इसे तुरंत किसी विशिष्ट छोटे या बड़े बिन में नहीं डालता है। बजाय इसके, यह पहले किसी भी पड़ोसी फ्री चंक के साथ **मर्ज** करने की कोशिश करता है ताकि एक अधिक बड़ा फ्री मेमोरी ब्लॉक बना सके। फिर, यह इस नए चंक को "अव्यवर्तित बिन" नामक एक सामान्य बिन में रखता है। अवर्गीकृत बिन एक **कैश** है जिसे हीप प्रबंधक द्वारा मेमोरी आवंटन को तेज़ बनाने के लिए उपयोग किया जाता है। यहाँ यह कैसे काम करता है: जब एक प्रोग्राम एक टुकड़ा मुक्त करता है, और यदि यह टुकड़ा एक टीकैश या फास्ट बिन में आवंटित नहीं किया जा सकता है और यह ऊपरी टुकड़े के साथ टकरा नहीं रहा है, तो हीप प्रबंधक इसे तुरंत किसी विशिष्ट छोटे या बड़े बिन में नहीं डालता है। बजाय इसके, यह पहले किसी भी पड़ोसी फ्री टुकड़ों के साथ **मर्ज** करने की कोशिश करता है ताकि एक अधिक बड़ा फ्री मेमोरी ब्लॉक बना सके। फिर, यह नया टुकड़ा एक सामान्य बिन में रखता है जिसे "अवर्गीकृत बिन" कहा जाता है।
जब कोई प्रोग्राम **मेमोरी के लिए मांग करता है**, तो हीप प्रबंधक **अव्यवर्तित बिन की जाँच** करता है कि क्या कोई पर्याप्त आकार का चंक है। अगर वह एक पाता है, तो वह इसे तुरंत उपयोग करता है। अगर अव्यवर्तित बिन में उपयुक्त चंक नहीं मिलता है, तो यह सभी चंक्स को इस सूची से उनके संबंधित बिन में ले जाता है, या तो छोटे या बड़े, उनके आकार के आधार पर। जब एक प्रोग्राम **मेमोरी के लिए मांग करता है**, तो हीप प्रबंधक **अवर्गीकृत बिन की जाँच** करता है कि क्या कोई पर्याप्त आकार का टुकड़ा है। अगर वह एक पाता है, तो वह इसे तुरंत उपयोग करता है। अगर अवर्गीकृत बिन में एक उपयुक्त टुकड़ा नहीं मिलता है, तो यह सभी टुकड़े इस सूची को उनके संबंधित बिन में ले जाता है, या तो छोटे या बड़े, उनके आकार के आधार पर।
ध्यान दें कि अगर एक बड़ा चंक 2 भागों में विभाजित होता है और बाकी भाग MINSIZE से अधिक है, तो यह अव्यवर्तित बिन में वापस रखा जाएगा। ध्यान दें कि अगर एक बड़ा टुकड़ा 2 हिस्सों में विभाजित किया गया है और बाकी भाग MINSIZE से अधिक है, तो यह अवर्गीकृत बिन में वापस रखा जाएगा।
इसलिए, अव्यवर्तित बिन एक तरीका है मेमोरी आवंटन को तेजी से बढ़ाने का जिससे हाल ही में मुक्त मेमोरी को त्वरित रूप से पुनः उपयोग किया जा सके और समय ग्राहक खोज और मर्ज की आवश्यकता को कम किया जा सके। इसलिए, अवर्गीकृत बिन मेमोरी आवंटन को तेज़ करने का एक तरीका है जिसमें हाल ही में मुक्त की गई मेमोरी को तेज़ी से पुनः उपयोग किया जाता है और समय ग्राहक खोज और मर्ज की आवश्यकता को कम किया जाता है।
{% hint style="danger" %} {% hint style="danger" %}
ध्यान दें कि यदि चंक विभिन्न श्रेणियों के हों, अगर एक उपलब्ध चंक किसी अन्य उपलब्ध चंक के साथ टकरा रहा है (यदि वे मूल रूप से विभिन्न बिनों से हैं), तो वे मर्ज किए जाएंगे। ध्यान दें कि यदि चंक्स विभिन्न श्रेणियों के हों, अगर एक उपलब्ध चंक दूसरे उपलब्ध चंक के साथ टकरा रहा है (यदी वे मूल रूप से विभिन्न बिनों में हैं), तो वे मर्ज किए जाएंगे।
{% endhint %} {% endhint %}
<details> <details>
<summary>एक अव्यवर्तित चंक उदाहरण जोड़ें</summary> <summary>एक अवर्गीकृत टुकड़ा उदाहरण जोड़ें</summary>
```c ```c
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
@ -295,9 +295,9 @@ free(chunks[i]);
return 0; return 0;
} }
``` ```
नोट करें कि हम एक ही आकार के 9 चंक को आवंटित और मुक्त करते हैं ताकि वे **टीकैश** भर जाएं और आठवां चंक अनुपयुक्त बिन में स्टोर किया जाए क्योंकि यह **फास्टबिन के लिए बहुत बड़ा** है और नौवां चंक मुक्त नहीं किया गया है इसलिए नौवां और आठवां **टॉप चंक के साथ मर्ज नहीं होते**। नोट करें कि हम एक ही आकार के 9 चंक को आवंटित और मुक्त करते हैं ताकि वे **टीकैश** भर जाएं और आठवां चंक अनुक्रमणिक बिन में स्टोर किया जाता है क्योंकि यह **फास्टबिन के लिए बहुत बड़ा** है और नौवां चंक मुक्त नहीं किया गया है इसलिए नौवां और आठवां **टॉप चंक के साथ मर्ज नहीं होते**।
इसे कंपाइल करें और मुख्य फ़ंक्शन से रिट ओपकोड में ब्रेकपॉइंट के साथ डीबग करें। फिर gef के साथ आप टीकैश बिन भरते हुए और अनुपयुक्त बिन में एक चंक देख सकते हैं: इसे कंपाइल करें और मुख्य फ़ंक्शन से रेट ओपकोड में ब्रेकपॉइंट के साथ डीबग करें। फिर gef के साथ आप टीकैश बिन भरते हुए और अनुक्रमित बिन में एक चंक देख सकते हैं:
```bash ```bash
gef➤ heap bins gef➤ heap bins
──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ──────────────────────────────────────────────────────────────────────────────── ──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
@ -319,11 +319,11 @@ Fastbins[idx=6, size=0x80] 0x00
### छोटे बिन ### छोटे बिन
छोटे बिन बड़े बिनों से तेज होते हैं लेकिन फास्ट बिनों से धीमे होते हैं। छोटे बिन बड़े बिनों से तेज होते हैं लेकिन फास्ट बिन्स से धीमे होते हैं।
62 के प्रत्येक बिन में **एक ही आकार के चंक्स** होंगे: 16, 24, ... (जिनका अधिकतम आकार 32 बिट में 504 बाइट और 64 बिट में 1024 बाइट है)। यह एक बिन को खाली करने और एक स्थान को आवंटित करने के लिए बिन को खोजने में और इन सूचियों पर एंट्री डालने और हटाने में गति में मदद करता है। 62 के प्रत्येक बिन में **एक ही आकार के चंक्स** होंगे: 16, 24, ... (32 बिट्स में 504 बाइट तक और 64 बिट्स में 1024 तक का अधिकतम आकार)। यह एक जगह को आवंटित करने और इन सूचियों पर प्रविष्टियों को डालने और हटाने में गति में मदद करता है।
यह है कि छोटे बिन का आकार बिन के सूचकांक के अनुसार कैसे गणित किया जाता है: यहां छोटे बिन का आकार बिन के सूचकांक के अनुसार कैसे निर्धारित किया जाता है:
* सबसे छोटा आकार: 2\*4\*सूचकांक (उदाहरण: सूचकांक 5 -> 40) * सबसे छोटा आकार: 2\*4\*सूचकांक (उदाहरण: सूचकांक 5 -> 40)
* सबसे बड़ा आकार: 2\*8\*सूचकांक (उदाहरण: सूचकांक 5 -> 80) * सबसे बड़ा आकार: 2\*8\*सूचकांक (उदाहरण: सूचकांक 5 -> 80)
@ -378,9 +378,9 @@ chunks[9] = malloc(0x110);
return 0; return 0;
} }
``` ```
नोट करें कि हम एक ही आकार के 9 चंक को आवंटित और मुक्त करते हैं ताकि वे **टीकैश** भर जाएं और आठवां चंक अनुक्रमित बिन में संग्रहित हो क्योंकि यह **फास्टबिन के लिए बहुत बड़ा है** और नौवां चंक मुक्त नहीं है ताकि नौवां और आठवां **शीर्ष चंक के साथ मर्ज न हों**। फिर हम 0x110 का एक बड़ा चंक आवंटित करते हैं जिससे **अनुक्रमित बिन में चंक छोटे बिन में जाता है**। नोट करें कि हम कैसे 9 बड़े चंक को आवंटित और फ्री करते हैं जो **टीकैश** को भर देते हैं और आठवां चंक अनुक्रमित बिन में स्टोर किया जाता है क्योंकि यह **फास्टबिन के लिए बहुत बड़ा है** और नौवां चंक फ्री नहीं है इसलिए नौवां और आठवां **टॉप चंक के साथ मर्ज नहीं होते हैं**। फिर हम 0x110 का एक बड़ा चंक आवंटित करते हैं जिससे **अनुक्रमित बिन में चंक छोटे बिन में जाता है**।
इसे कंपाइल करें और मुख्य कार्य से रेट ओपकोड में ब्रेकपॉइंट के साथ डीबग करें। फिर gef के साथ आप टीकैश बिन भरने और छोटे बिन में एक चंक देख सकते हैं: इसे कंपाइल करें और मुख्य फ़ंक्शन से रेट ओपकोड में ब्रेकपॉइंट के साथ डीबग करें। फिर gef के साथ आप टीकैश बिन भरते हुए और छोटे बिन में एक चंक देख सकते हैं:
```bash ```bash
gef➤ heap bins gef➤ heap bins
──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ──────────────────────────────────────────────────────────────────────────────── ──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
@ -404,13 +404,13 @@ Fastbins[idx=6, size=0x80] 0x00
### बड़े बिन ### बड़े बिन
छोटे बिनों की तरह, जो निश्चित आकारों के टुकड़ों का प्रबंधन करते हैं, प्रत्येक **बड़े बिन एक चंक आकारों की श्रेणी का संभालन करता है**। यह अधिक लचीला है, जिससे प्रणाली **विभिन्न आकारों** को समायोजित करने के लिए हर आकार के लिए एक अलग बिन की आवश्यकता नहीं होती है। छोटे बिनों की तरह, जो निश्चित आकारों के टुकड़ों का प्रबंधन करते हैं, प्रत्येक **बड़े बिन एक चंक आकारों की श्रेणी का प्रबंधन करता है**। यह अधिक लचीला है, विभिन्न आकारों को समायोजित करने के लिए प्रणाली को **अलग-अलग आकार के लिए एक अलग बिन की आवश्यकता नहीं होती**।
एक मेमोरी आवंटक, बड़े बिन छोटे बिनों के समाप्त होने पर शुरू होते हैं। बड़े बिनों के लिए सीमाएँ प्रगतिशील रूप से बढ़ती हैं, जिसका मतलब है पहला बिन 512 से 576 बाइट तक के चंक को कवर कर सकता है, जबकि अगला 576 से 640 बाइट को कवर करता है। यह पैटर्न जारी रहता है, सबसे बड़े बिन में सभी चंक्स को 1MB से ऊपर कवर करते हुए। एक मेमोरी आवंटक, बड़े बिन छोटे बिनों के समाप्त होने पर शुरू होते हैं। बड़े बिनों के लिए सीमाएँ प्रगतिशील रूप से बढ़ती हैं, जिसका मतलब है पहला बिन 512 से 576 बाइट तक के चंक को कवर कर सकता है, जबकि अगला 576 से 640 बाइट को कवर करता है। यह पैटर्न जारी रहता है, सबसे बड़े बिन में सभी 1MB से ऊपर के चंक शामिल होते हैं।
बड़े बिन छोटे बिनों की तुलना में ऑपरेट करने में धीमे होते हैं क्योंकि उन्हें **एक सूची के माध्यम से विभिन्न चंक आकारों को खोजने और उनके लिए सर्वोत्तम मेल ढूंढने की आवश्यकता होती है**। जब एक चंक बड़े बिन में डाला जाता है, तो उसे क्रमबद्ध करना होता है, और जब मेमोरी आवंटित की जाती है, तो प्रणाली को सही चंक ढूंढना होता है। यह अतिरिक्त काम उन्हें **धीमा** बनाता है, लेकिन क्योंकि बड़ी आवंटन छोटे से कम होते हैं, इसे स्वीकार्य व्यापार माना जाता है। बड़े बिन छोटे बिनों की तुलना में धीमे होते हैं क्योंकि उन्हें **एक भिन्न चंक आकारों की सूची के माध्यम से क्रमबद्ध और खोजना** पड़ता है ताकि आवंटन के लिए सर्वोत्तम फिट ढूंढा जा सके। जब एक चंक बड़े बिन में डाला जाता है, तो उसे क्रमबद्ध किया जाना चाहिए, और जब मेमोरी आवंटित की जाती है, तो प्रणाली को सही चंक ढूंढना पड़ता है। यह अतिरिक्त काम उन्हें **धीमा** बनाता है, लेकिन क्योंकि बड़े आवंटन छोटे से कम होते हैं, इसे स्वीकार्य व्यापार माना जाता है।
यहाँ हैं: हैं:
* 32 बिन 64B रेंज के (छोटे बिनों के साथ टकराते हैं) * 32 बिन 64B रेंज के (छोटे बिनों के साथ टकराते हैं)
* 16 बिन 512B रेंज के (छोटे बिनों के साथ टकराते हैं) * 16 बिन 512B रेंज के (छोटे बिनों के साथ टकराते हैं)
@ -478,7 +478,7 @@ chunks[0] = malloc(0x2000);
return 0; return 0;
} }
``` ```
2 बड़ी आवंटनें की जाती हैं, फिर एक को मुक्त किया जाता है (जिससे यह अनसॉर्टेड बिन में जाता है) और एक बड़ी आवंटन की जाती है (जिससे मुक्त वाला वाला बिन से बड़े बिन में जाता है)। 2 बड़ी आवंटन किए जाते हैं, फिर एक को मुक्त किया जाता है (जिससे यह अनसॉर्टेड बिन में जाता है) और एक बड़ी आवंटन किया जाता है (जिससे मुक्त वाला अनसॉर्टेड बिन से बड़े बिन में जाता है)।
इसे कंपाइल करें और मुख्य कार्य से रेट ओपकोड में ब्रेकपॉइंट के साथ डीबग करें। फिर gef के साथ आप टीकैश बिन भरने और बड़े बिन में एक चंक देख सकते हैं: इसे कंपाइल करें और मुख्य कार्य से रेट ओपकोड में ब्रेकपॉइंट के साथ डीबग करें। फिर gef के साथ आप टीकैश बिन भरने और बड़े बिन में एक चंक देख सकते हैं:
```bash ```bash
@ -504,7 +504,7 @@ Fastbins[idx=6, size=0x80] 0x00
``` ```
</details> </details>
### शीर्ष टुकड़ा ### शीर्ष टुकड़ी
```c ```c
// From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1711 // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1711
@ -529,7 +529,7 @@ the 2 preceding words to be zero during this interval as well.)
/* Conveniently, the unsorted bin can be used as dummy top on first call */ /* Conveniently, the unsorted bin can be used as dummy top on first call */
#define initial_top(M) (unsorted_chunks (M)) #define initial_top(M) (unsorted_chunks (M))
``` ```
बुनियादी रूप से, यह एक टुकड़ा है जिसमें सभी वर्तमान मेमोरी है। जब एक malloc किया जाता है, अगर कोई उपलब्ध फ्री चंक उपयोग के लिए नहीं है, तो यह टॉप चंक अपने आकार को कम करके आवश्यक स्थान देगा।\ आम तौर पर, यह एक टुकड़ा है जिसमें सभी वर्तमान मेमोरी है। जब एक malloc किया जाता है, अगर कोई उपलब्ध फ्री चंक उपयोग के लिए नहीं है, तो यह टॉप चंक अपने आकार को कम करके आवश्यक स्थान प्रदान करेगा।\
टॉप चंक का पॉइंटर `malloc_state` स्ट्रक्ट में संग्रहीत है। टॉप चंक का पॉइंटर `malloc_state` स्ट्रक्ट में संग्रहीत है।
इसके अतिरिक्त, शुरुआत में, अनसॉर्टेड चंक का उपयोग टॉप चंक के रूप में किया जा सकता है। इसके अतिरिक्त, शुरुआत में, अनसॉर्टेड चंक का उपयोग टॉप चंक के रूप में किया जा सकता है।
@ -550,7 +550,7 @@ gets(chunk);
return 0; return 0;
} }
``` ```
पारित करने और डीबग करने के बाद मुख्य कोड के रिट ओपकोड में एक ब्रेक पॉइंट के साथ, मुझे दिखाई दिया कि malloc ने पता वापस किया: `0xaaaaaaac12a0` और ये चंक हैं: जब मैंने इसे कंपाइल और डीबग किया और मुख्य कोड के रेट ओपकोड में एक ब्रेक पॉइंट के साथ देखा, तो मुझे पता चला कि मैलोक ने पता दिया: `0xaaaaaaac12a0` और ये चंक हैं:
```bash ```bash
gef➤ heap chunks gef➤ heap chunks
Chunk(addr=0xaaaaaaac1010, size=0x290, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) Chunk(addr=0xaaaaaaac1010, size=0x290, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
@ -574,11 +574,11 @@ gef➤ x/8wx 0xaaaaaaac1ae0 - 16
### अंतिम अनुस्मारक ### अंतिम अनुस्मारक
जब malloc का उपयोग किया जाता है और एक चंक विभाजित किया जाता है (अनलिंक्ड सूची से या ऊपरी चंक से उदाहरण के लिए), जो चंक विभाजित चंक के शेष से बनाया गया है, उसे अंतिम अनुस्मारक कहा जाता है और इसका पॉइंटर `malloc_state` संरचि में संग्रहीत होता है। जब malloc का उपयोग किया जाता है और एक चंक विभाजित किया जाता है (अनलिंक्ड सूची से या ऊपरी चंक से उदाहरण के लिए), विभाजित चंक से बची हुई चंक से बनाई गई चंक को अंतिम अनुस्मारक कहा जाता है और इसका पॉइंटर `malloc_state` संरचि में संग्रहीत किया जाता है।
## आवंटन प्रवाह ## आवंटन प्रवाह
जांचें: जांच करें:
{% content-ref url="heap-memory-functions/malloc-and-sysmalloc.md" %} {% content-ref url="heap-memory-functions/malloc-and-sysmalloc.md" %}
[malloc-and-sysmalloc.md](heap-memory-functions/malloc-and-sysmalloc.md) [malloc-and-sysmalloc.md](heap-memory-functions/malloc-and-sysmalloc.md)
@ -586,7 +586,7 @@ gef➤ x/8wx 0xaaaaaaac1ae0 - 16
## मुक्ति प्रवाह ## मुक्ति प्रवाह
जांचें: जांच करें:
{% content-ref url="heap-memory-functions/free.md" %} {% content-ref url="heap-memory-functions/free.md" %}
[free.md](heap-memory-functions/free.md) [free.md](heap-memory-functions/free.md)
@ -594,7 +594,7 @@ gef➤ x/8wx 0xaaaaaaac1ae0 - 16
## हीप फ़ंक्शन सुरक्षा जांच ## हीप फ़ंक्शन सुरक्षा जांच
हीप में प्रयोग किए जाने वाले फ़ंक्शनों द्वारा की जाने वाली सुरक्षा जांचें देखें: हीप में प्रमुख रूप से उपयोग किए जाने वाले फ़ंक्शनों द्वारा की जाने वाली सुरक्षा जांच कीजिए:
{% content-ref url="heap-memory-functions/heap-functions-security-checks.md" %} {% content-ref url="heap-memory-functions/heap-functions-security-checks.md" %}
[heap-functions-security-checks.md](heap-memory-functions/heap-functions-security-checks.md) [heap-functions-security-checks.md](heap-memory-functions/heap-functions-security-checks.md)
@ -609,14 +609,14 @@ gef➤ x/8wx 0xaaaaaaac1ae0 - 16
<details> <details>
<summary><strong>जानें AWS हैकिंग को शून्य से हीरो तक</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary> <summary><strong>htARTE (HackTricks AWS Red Team Expert) के साथ शून्य से हीरो तक AWS हैकिंग सीखें</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
HackTricks का समर्थन करने के अन्य तरीके: HackTricks का समर्थन करने के अन्य तरीके:
* यदि आप अपनी **कंपनी का विज्ञापन HackTricks में देखना चाहते हैं** या **HackTricks को PDF में डाउनलोड करना चाहते हैं** तो [**सब्सक्रिप्शन प्लान**](https://github.com/sponsors/carlospolop) देखें! * यदि आप अपनी कंपनी का विज्ञापन देखना चाहते हैं **HackTricks** में या **HackTricks को PDF में डाउनलोड** करना चाहते हैं तो [**सब्सक्रिप्शन प्लान्स**](https://github.com/sponsors/carlospolop) देखें!
* [**आधिकारिक PEASS और HackTricks स्वैग**](https://peass.creator-spring.com) प्राप्त करें * [**आधिकारिक PEASS & HackTricks स्वैग**](https://peass.creator-spring.com) प्राप्त करें
* हमारे विशेष [**NFTs**](https://opensea.io/collection/the-peass-family) संग्रह [**The PEASS Family**](https://opensea.io/collection/the-peass-family) खोजें * हमारे विशेष [**NFTs**](https://opensea.io/collection/the-peass-family) संग्रह [**The PEASS Family**](https://opensea.io/collection/the-peass-family) खोजें
* **शामिल हों** 💬 [**डिस्कॉर्ड समूह**](https://discord.gg/hRep4RUj7f) या [**टेलीग्राम समूह**](https://t.me/peass) या हमें **ट्विटर** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** पर फ़ॉलो** करें। * **शामिल हों** 💬 [**डिस्कॉर्ड समूह**](https://discord.gg/hRep4RUj7f) या [**टेलीग्राम समूह**](https://t.me/peass) या हमें **ट्विटर** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** पर फॉलो** करें।
* **हैकिंग ट्रिक्स साझा करें** [**HackTricks**](https://github.com/carlospolop/hacktricks) और [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github रेपो में PR जमा करके। * **हैकिंग ट्रिक्स साझा करें** हैकिंग ट्रिक्स को पीआर के माध्यम से **HackTricks** और **HackTricks Cloud** github रेपो में सबमिट करके।
</details> </details>

47
binary-exploitation/heap/overwriting-a-freed-chunk.md Normal file
View file

@ -0,0 +1,47 @@
# Freed चंक को ओवरराइट करना
<details>
<summary><strong>जानें AWS हैकिंग को शून्य से हीरो तक</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong> के साथ!</strong></summary>
HackTricks का समर्थन करने के अन्य तरीके:
* यदि आप अपनी **कंपनी का विज्ञापन HackTricks में देखना चाहते हैं** या **HackTricks को PDF में डाउनलोड करना चाहते हैं** तो [**सब्सक्रिप्शन प्लान्स देखें**](https://github.com/sponsors/carlospolop)!
* [**आधिकारिक PEASS और HackTricks स्वैग**](https://peass.creator-spring.com) प्राप्त करें
* [**The PEASS Family**](https://opensea.io/collection/the-peass-family) की खोज करें, हमारा विशेष [**NFTs**](https://opensea.io/collection/the-peass-family) संग्रह
* **शामिल हों** 💬 [**डिस्कॉर्ड समूह**](https://discord.gg/hRep4RUj7f) या [**टेलीग्राम समूह**](https://t.me/peass) या हमें **ट्विटर** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** पर फॉलो** करें।
* **अपने हैकिंग ट्रिक्स साझा करें** द्वारा PRs सबमिट करके [**HackTricks**](https://github.com/carlospolop/hacktricks) और [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>
प्रस्तावित हीप उत्पीड़न तकनीकों में से कई तकनीकों को मुक्त चंक के अंदर पॉइंटर को ओवरराइट करने की क्षमता होनी चाहिए। इस पृष्ठ का उद्देश्य यह है कि यह संक्षेपित करें कि कौन सी संभावित कमजोरियां हो सकती हैं जो इस पहुंच को प्रदान कर सकती हैं:
### सरल Use After Free
यदि हमें अटैकर को **एक मुक्त चंक में जानकारी लिखने** की संभावना होती है, तो वह इसे उपयोग करके आवश्यक पॉइंटर को ओवरराइट कर सकता है।
### डबल मुक्त
यदि अटैकर **दो बार एक ही चंक को `मुक्त`** कर सकता है (इसके बीच अन्य चंक्स को मुक्त कर सकता है) और इसे **2 बार एक ही बिन में** बना सकता है, तो उपयोगकर्ता के लिए **चंक बाद में आवंटित करना संभव होगा**, **आवश्यक पॉइंटर्स को लिखना** और फिर **इसे फिर से आवंटित करना** जिससे चंक को आवंटित किया जाएगा (जैसे कि त्वरित बिन हमला, tcache हमला...)
### हीप ओवरफ्लो
यह संभव हो सकता है कि **आवंटित चंक को ओवरफ्लो** करना और इसके हेडर/पॉइंटर को संशोधित करना।
### 1 ओवरफ्लो के बाहर
इस मामले में यह संभव होगा कि मेमोरी में अगले चंक का **आकार संशोधित** किया जा सकता है। एक अटैकर इसका दुरुपयोग कर सकता है **एक आवंटित चंक को एक बड़े आकार** वाला बनाने के लिए, फिर इसे **`मुक्त`** करके, चंक को एक विभिन्न आकार (बड़ा) के बिन में जोड़ देने के लिए, फिर **फर्जी आकार** को आवंटित करना, और हमले के पास एक **चंक होगा जिसका आकार वास्तव में उससे बड़ा है**, इसलिए एक हीप ओवरफ्लो को प्रदान करता है (पिछले खंड की जांच करें)।
<details>
<summary><strong>जानें AWS हैकिंग को शून्य से हीरो तक</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong> के साथ!</strong></summary>
HackTricks का समर्थन करने के अन्य तरीके:
* यदि आप अपनी **कंपनी का विज्ञापन HackTricks में देखना चाहते हैं** या **HackTricks को PDF में डाउनलोड करना चाहते हैं** तो [**सब्सक्रिप्शन प्लान्स देखें**](https://github.com/sponsors/carlospolop)!
* [**आधिकारिक PEASS और HackTricks स्वैग**](https://peass.creator-spring.com) प्राप्त करें
* [**The PEASS Family**](https://opensea.io/collection/the-peass-family) की खोज करें, हमारा विशेष [**NFTs**](https://opensea.io/collection/the-peass-family) संग्रह
* **शामिल हों** 💬 [**डिस्कॉर्ड समूह**](https://discord.gg/hRep4RUj7f) या [**टेलीग्राम समूह**](https://t.me/peass) या हमें **ट्विटर** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** पर फॉलो** करें।
* **अपने हैकिंग ट्रिक्स साझा करें** द्वारा PRs सबमिट करके [**HackTricks**](https://github.com/carlospolop/hacktricks) और [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

43
binary-exploitation/heap/tcache-bin-attack.md
View file

@ -6,17 +6,17 @@
HackTricks का समर्थन करने के अन्य तरीके: HackTricks का समर्थन करने के अन्य तरीके:
* यदि आप अपनी **कंपनी का विज्ञापन HackTricks में देखना चाहते हैं** या **HackTricks को PDF में डाउनलोड करना चाहते हैं** तो [**सदस्यता योजनाएं देखें**](https://github.com/sponsors/carlospolop)! * यदि आप अपनी कंपनी को **HackTricks में विज्ञापित करना** चाहते हैं या **HackTricks को PDF में डाउनलोड** करना चाहते हैं तो [**सदस्यता योजनाएं देखें**](https://github.com/sponsors/carlospolop)!
* [**आधिकारिक PEASS और HackTricks स्वैग**](https://peass.creator-spring.com) प्राप्त करें * [**आधिकारिक PEASS & HackTricks स्वैग**](https://peass.creator-spring.com) प्राप्त करें
* हमारे विशेष [**NFTs**](https://opensea.io/collection/the-peass-family) कलेक्शन, [**The PEASS Family**](https://opensea.io/collection/the-peass-family) खोजें * हमारा संग्रह [**The PEASS Family**](https://opensea.io/collection/the-peass-family) खोजें, हमारा विशेष [**NFTs**](https://opensea.io/collection/the-peass-family) संग्रह
* **शामिल हों** 💬 [**डिस्कॉर्ड समूह**](https://discord.gg/hRep4RUj7f) या [**टेलीग्राम समूह**](https://t.me/peass) या हमें **ट्विटर** पर **फॉलो** करें 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** * **शामिल हों** 💬 [**डिस्कॉर्ड समूह**](https://discord.gg/hRep4RUj7f) या [**टेलीग्राम समूह**](https://t.me/peass) या हमें **ट्विटर** पर **फॉलो** करें 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **हैकिंग ट्रिक्स साझा करें द्वारा PRs सबमिट करके** [**HackTricks**](https://github.com/carlospolop/hacktricks) और [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos. * **हैकिंग ट्रिक्स साझा करें** द्वारा PRs सबमिट करके [**HackTricks**](https://github.com/carlospolop/hacktricks) और [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details> </details>
## मौलिक जानकारी ## मौलिक जानकारी
एक tcache bin क्या है इसके बारे में अधिक जानकारी के लिए इस पेज की जाँच करें: एक tcache bin क्या है इसके बारे में अधिक जानकारी के लिए इस पृष्ठ की जाँच करें:
{% content-ref url="bins-and-memory-allocations.md" %} {% content-ref url="bins-and-memory-allocations.md" %}
[bins-and-memory-allocations.md](bins-and-memory-allocations.md) [bins-and-memory-allocations.md](bins-and-memory-allocations.md)
@ -24,20 +24,27 @@ HackTricks का समर्थन करने के अन्य तरी
सबसे पहले, ध्यान दें कि Tcache को glibc संस्करण 2.26 में पेश किया गया था। सबसे पहले, ध्यान दें कि Tcache को glibc संस्करण 2.26 में पेश किया गया था।
[**गायिनाटुक्सिडो पेज**](https://guyinatuxedo.github.io/29-tcache/tcache\_explanation/index.html) में प्रस्तावित **Tcache** हमला तेज बिन हमले के बहुत ही समान है जहां लक्ष्य है कि एक मुक्त चंक के भीतर बिन में अगले चंक के पॉइंटर को एक अनिश्चित पते पर ओवरराइट करना ताकि बाद में **उस विशेष पते को आवंटित किया जा सके और संभावित रूप से पॉइंटर्स को ओवरराइट किया जा सके**। [**गायिनाटुक्सिडो पेज**](https://guyinatuxedo.github.io/29-tcache/tcache\_explanation/index.html) में प्रस्तावित **Tcache** हमला तेज बिन हमले के बहुत ही समान है जहाँ लक्ष्य है कि एक मुक्त चंक में बिन के अंदर अगले चंक के पॉइंटर को एक विचित पते पर ओवरराइट करना ताकि बाद में उस विशेष पते को आवंटित किया जा सके और संभावित रूप से पॉइंटर्स को ओवरराइट किया जा सके।
हालांकि, आजकल, यदि आप उल्लिखित कोड को चलाते हैं तो आपको त्रुटि मिलेगी: **`malloc(): unaligned tcache chunk detected`**। इसलिए, नए पॉइंटर में एक संरेखित पता लिखने की आवश्यकता है (या पता लिखने के लिए पर्याप्त बार बाइनरी चलाने की आवश्यकता है ताकि लिखा गया पता वास्तव में संरेखित हो)। हालांकि, आजकल, यदि आप उल्लिखित कोड को चलाते हैं तो आपको त्रुटि मिलेगी: **`malloc(): unaligned tcache chunk detected`**। इसलिए, नए पॉइंटर में एक संरेखित पता लिखना आवश्यक है (या यह लिखने के लिए पर्याप्त बार बाइनरी को चलाना होगा ताकि लिखा गया पता वास्तव में संरेखित हो)।
### Tcache इंडेक्स हमला
सामान्यत: हीप के शुरुआत में एक चंक मिल सकता है जिसमें **tcache में प्रति इंडेक्स चंक की मात्रा** और **प्रत्येक tcache इंडेक्स के मुख्य चंक का पता** शामिल होता है। यदि किसी कारणवश इस जानकारी को संशोधित किया जा सकता है, तो यह संभव होगा कि **किसी इंडेक्स के मुख्य चंक को एक इच्छित पते पर पहुंचाया जा सके** (जैसे malloc हुक) ताकि फिर उस इंडेक्स के आकार का चंक आवंटित किया जा सके और इस मामले में malloc हुक की सामग्री को ओवरराइट किया जा सके।
## उदाहरण
* CTF [https://guyinatuxedo.github.io/29-tcache/dcquals19\_babyheap/index.html](https://guyinatuxedo.github.io/29-tcache/dcquals19\_babyheap/index.html)
* **Libc जानकारी लीक**: टीकैशेस भरना संभव है, असंगठित सूची में एक चंक जोड़ना, टीकैशेस को खाली करना और **असंगठित बिन से चंक को पुनः आवंटित** करना केवल पहले 8B को ओवरराइट करके, **चंक से दूसरा पता लिब्सी से अविक्षित रहने देने के लिए**।
* **Tcache हमला**: बाइनरी में एक 1B हीप ओवरफ्लो वंश है। इसे बड़ा करने के लिए आवंटित चंक के **आकार हेडर** को बदलने के लिए इसका दुरुपयोग किया जाएगा। फिर, यह चंक मुक्त किया जाएगा, इसे नकली आकार के tcache चंकों की तीकैश में जोड़ा जाएगा। फिर, हम एक चंक आवंटित करेंगे जिसमें नकली आकार होगा, और पिछला चंक **वास्तव में छोटा था यह जानते हुए कि यह चंक वास्तव में छोटा था** और यह अवसर प्रदान करता है कि **मेमोरी में अगले चंक को ओवरराइट** किया जा सके।\
हम इसका दुरुपयोग करेंगे ताकि **अगले चंक का FD पॉइंटर ओवरराइट** करने के लिए **`malloc_hook`** को पॉइंट करें, तो फिर यह संभव होगा कि 2 पॉइंटर्स आवंटित किए जाएं: पहला वास्तविक पॉइंटर जिसे हमने अभी किया है, और फिर दूसरा आवंटन `malloc_hook` में एक चंक लौटाएगा जिसे एक **वन गैजेट** लिखने के लिए दुरुपयोग किया जा सकता है।
* CTF [https://guyinatuxedo.github.io/29-tcache/plaid19\_cpp/index.html](https://guyinatuxedo.github.io/29-tcache/plaid19\_cpp/index.html)
* **Libc जानकारी लीक**: यहाँ एक उपयोग के बाद मुक्त और डबल मुक्ति है। इस व्रिटअप में लेखक ने एक छोटे बिन में रखे गए एक चंक के पते को पढ़कर लिब्सी का पता लीक किया।
* **Tcache हमला**: एक **डबल मुक्ति** के माध्यम से एक Tcache किया जाता है। एक ही चंक को दो बार मुक्त किया जाता है, इसलिए Tcache के अंदर चंक खुद को पॉइंट करेगा। फिर, इसे आवंटित किया जाएगा, इसका FD पॉइंटर **फ्री हुक** को पॉइंट करने के लिए संशोधित किया जाएगा और फिर यह फिर से आवंटित किया जाएगा ताकि सूची में अगला चंक फ्री हुक में हो। फिर, यह भी आवंटित किया जाएगा और यह संभव होगा कि यहाँ `system` का पता लिखा जाए ताकि जब `"/bin/sh"` शामिल `malloc` किया जाए तो हमें एक शैल मिले।
* CTF [https://guyinatuxedo.github.io/44-more\_tcache/csaw19\_popping\_caps0/index.html](https://guyinatuxedo.github.io/44-more\_tcache/csaw19\_popping\_caps0/index.html)
* **Tcache इंडेक्स हमला**: एक ऐसी चंक को आवंटित और मुक्त करना संभव है जिसका आकार टीकैशेस जानकारी में एक **स्थान उत्पन्न करेगा जिसमें मान 0x100 होगा** (क्योंकि उस बाइट का संकेत है कि उस इंडेक्स में कितने चंक संग्रहित हैं)। फिर, इस मान का दुरुपयोग करके इस पते को फ्री किया जा सकता है क्योंकि यह लगता है कि यह 0x100 के आकार का एक चंक है। यह टीकैश में 0x100 के आकार के चंकों के इंडेक्स में उस पते को जोड़ देगा।\
फिर, आकार 0x100 का एक चंक आवंटित करने के बाद, अन्य tcache इंडेक्स के प्रारंभिक चंक पते को ओवरराइट किया जा सकता है। उदाहरण के लिए उनमें से एक में malloc हुक का पता डालना और उस इंडेक्स के आकार का एक चंक आवंटित करना जिससे calloc हुक में एक चंक आवंटित किया जा सके, जिससे एक वन गैजेट लिखने के लिए एक शैल प्राप्त किया जा सके।
<details> <details>
<summary><strong>जानें AWS हैकिंग को शून्य से हीरो तक</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong> के साथ!</strong></summary> <summary
HackTricks का समर्थन करने के अन्य तरीके:
* यदि आप अपनी **कंपनी का विज्ञापन HackTricks में देखना चाहते हैं** या **HackTricks को PDF में डाउनलोड करना चाहते हैं** तो [**सदस्यता योजनाएं देखें**](https://github.com/sponsors/carlospolop)!
* [**आधिकारिक PEASS और HackTricks स्वैग**](https://peass.creator-spring.com) प्राप्त करें
* हमारे विशेष [**NFTs**](https://opensea.io/collection/the-peass-family) कलेक्शन, [**The PEASS Family**](https://opensea.io/collection/the-peass-family) खोजें
* **शामिल हों** 💬 [**डिस्कॉर्ड समूह**](https://discord.gg/hRep4RUj7f) या [**टेलीग्राम समूह**](https://t.me/peass) या हमें **ट्विटर** पर **फॉलो** करें 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **हैकिंग ट्रिक्स साझा करें द्वारा PRs सबमिट करके** [**HackTricks**](https://github.com/carlospolop/hacktricks) और [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

51
binary-exploitation/heap/unsorted-bin-attack.md
View file

@ -8,8 +8,8 @@ HackTricks का समर्थन करने के अन्य तरी
* अगर आप अपनी **कंपनी का विज्ञापन HackTricks में देखना चाहते हैं** या **HackTricks को PDF में डाउनलोड करना चाहते हैं** तो [**सब्सक्रिप्शन प्लान्स देखें**](https://github.com/sponsors/carlospolop)! * अगर आप अपनी **कंपनी का विज्ञापन HackTricks में देखना चाहते हैं** या **HackTricks को PDF में डाउनलोड करना चाहते हैं** तो [**सब्सक्रिप्शन प्लान्स देखें**](https://github.com/sponsors/carlospolop)!
* [**आधिकारिक PEASS और HackTricks स्वैग**](https://peass.creator-spring.com) प्राप्त करें * [**आधिकारिक PEASS और HackTricks स्वैग**](https://peass.creator-spring.com) प्राप्त करें
* हमारा विशेष [**NFTs**](https://opensea.io/collection/the-peass-family) संग्रह, **The PEASS Family** का खोज करें * हमारे विशेष [**NFTs**](https://opensea.io/collection/the-peass-family) कलेक्शन, [**The PEASS Family**](https://opensea.io/collection/the-peass-family) खोजें
* **जुड़ें** 💬 [**डिस्कॉर्ड समूह**](https://discord.gg/hRep4RUj7f) या [**टेलीग्राम समूह**](https://t.me/peass) में या हमें **ट्विटर** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** पर फॉलो** करें। * **शामिल हों** 💬 [**डिस्कॉर्ड समूह**](https://discord.gg/hRep4RUj7f) या [**टेलीग्राम समूह**](https://t.me/peass) या हमें **ट्विटर** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** पर फॉलो** करें।
* **अपने हैकिंग ट्रिक्स साझा करें** द्वारा PRs सबमिट करके [**HackTricks**](https://github.com/carlospolop/hacktricks) और [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos में। * **अपने हैकिंग ट्रिक्स साझा करें** द्वारा PRs सबमिट करके [**HackTricks**](https://github.com/carlospolop/hacktricks) और [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos में।
</details> </details>
@ -22,49 +22,54 @@ HackTricks का समर्थन करने के अन्य तरी
[bins-and-memory-allocations.md](bins-and-memory-allocations.md) [bins-and-memory-allocations.md](bins-and-memory-allocations.md)
{% endcontent-ref %} {% endcontent-ref %}
अनसॉर्टेड सूचियाँ `unsorted_chunks (av)` के पते को चंक के `bk` पते में लिखने की क्षमता रखती है। इसलिए, यदि किसी हमलावर ने अनसॉर्टेड बिन के अंदर एक चंक में `bk` पॉइंटर का पता **संशोधित कर सकता है**, तो वह **किसी भी पते में उस पते को लिख सकता है** जो एक libc पते को लीक करने या कुछ रक्षा को छलने में मददगार हो सकता है। अनसॉर्टेड सूचियों को `unsorted_chunks (av)` के पते को लिखने की क्षमता होती है चंक के `bk` पते में। इसलिए, यदि कोई हमलावर अनसॉर्टेड बिन के अंदर एक चंक में `bk` प्वाइंटर का पता **संशोधित कर सकता है** तो वह **किसी भी पते में उस पते को लिख सकता है** जो एक libc पते लीक करने या कुछ रक्षा को छलने में मददगार हो सकता है।
इसलिए, मूल रूप से, यह हमला किसी भी पते को एक बड़ी संख्या के साथ **अधिकारिक पते के साथ अधिकारिक पते को अधिकारिक करने की अनुमति देता है** (जो एक हीप पता या एक libc पता हो सकता है) जैसे कि कुछ स्टैक पता जो लीक हो सकता है या कुछ प्रतिबंध जैसे **`global_max_fast`** जैसी वैशिष्ट्य को बड़े आकारों में तेज बिन बिनें बनाने की अनुमति देने के लिए (और एक अनसॉर्टेड बिन हमले से तेज बिन हमले में पास करने की अनुमति देने की अनुमति देने की अनुमति देता है)। इसलिए, मूल रूप से, यह हमला किसी भी बड़ी संख्या के साथ **किसी भी अर्बिट्रेरी पते को अधिक लिखने की अनुमति देता है** (जो एक हीप पता या एक libc पता हो सकता है) जैसे कि कुछ स्टैक पता जो लीक हो सकता है या कुछ प्रतिबंध जैसे **`global_max_fast`** जैसी ग्लोबल चर को बड़े आकार के फास्ट बिन बिन्स बनाने की अनुमति देने के लिए (और एक अनसॉर्टेड बिन हमले से एक फास्ट बिन हमले में पास होने की अनुमति देने के लिए)।
{% hint style="success" %} {% hint style="success" %}
[https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted\_bin\_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted\_bin\_attack/#principle) में प्रदान किए गए उदाहरण को देखने और 0x400 और 0x500 की बजाय 0x4000 और 0x5000 का उपयोग करके (tcaches से बचने के लिए) आजकल त्रुटि **`malloc(): unsorted double linked list corrupted`** ट्रिगर होती है। [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted\_bin\_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted\_bin\_attack/#principle) में प्रदान किए गए उदाहरण को देखने और 0x400 और 0x500 की बजाय 0x4000 और 0x5000 का उपयोग करके (tcaches को टालने के लिए) आप देख सकते हैं कि **आजकल** त्रुटि **`malloc(): unsorted double linked list corrupted`** ट्रिगर होती है।
इसलिए, इस अनसॉर्टेड बिन हमले को अब (अन्य जांचों के बीच) डबल लिंक्ड सूची को ठीक करने की भी आवश्यकता है ताकि यह बाईपास हो `victim->bck->fd == victim` या नहीं `victim->fd == av (arena)`। जिसका अर्थ है कि हमें जिस पते पर लिखना चाहते हैं, उसमें नकली चंक का पता उसके `fd` स्थान में होना चाहिए और नकली चंक `fd` एरियना की ओर पोइंट करना चाहिए। इसलिए, इस अनसॉर्टेड बिन हमले को अब (अन्य जांचों के बीच) डबल लिंक्ड सूची को ठीक करने की भी आवश्यकता है ताकि यह छलावा बाहर किया जाए `victim->bck->fd == victim` या नहीं `victim->fd == av (arena)`। जिसका मतलब है कि हमें जहां हम लिखना चाहते हैं उस पते में जाली चंक का पता होना चाहिए और जाली चंक `fd` एरियना की ओर प्वाइंट करना चाहिए।
{% endhint %} {% endhint %}
{% hint style="danger" %} {% hint style="danger" %}
ध्यान दें कि यह हमला अनसॉर्टेड बिन को क्षति पहुंचाता है (इसलिए छोटे और बड़े भी)। इसलिए अब हम सिर्फ **तेज बिन से आवंटन का उपयोग कर सकते हैं** (एक अधिक जटिल कार्यक्रम अन्य आवंटन कर सकता है और क्रैश हो सकता है), और इसे ट्रिगर करने के लिए हमें **एक ही आकार का आवंटन करना होगा या प्रोग्राम क्रैश हो जाएगा।** ध्यान दें कि यह हमला अनसॉर्टेड बिन को क्षति पहुंचाता है (इसलिए छोटे और बड़े भी)। इसलिए हम अब केवल **फास्ट बिन से आवंटन का उपयोग कर सकते हैं** (एक अधिक जटिल कार्यक्रम अन्य आवंटन कर सकता है और क्रैश हो सकता है), और इसे ट्रिगर करने के लिए हमें **एक ही आकार का आवंटन करना होगा या कार्यक्रम क्रैश हो जाएगा।**
ध्यान दें कि इस मामले में **`global_max_fast`** बनाना इस मामले में मददगार हो सकता है, जिसका भरोसा है कि तेज बिन सभी अन्य आवंटनों का ध्यान रखेगा जब तक उत्पादन पूरा नहीं हो जाता है। ध्यान दें कि इस मामले में **`global_max_fast`** बनाना इस मामले में मददगार हो सकता है, जिसका भरोसा है कि फास्ट बिन सभी अन्य आवंटनों का ध्यान रखेगा जब तक उत्पादन पूरा नहीं हो जाता है।
{% endhint %} {% endhint %}
[**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin\_attack/unsorted\_explanation/index.html) के कोड से यह बहुत अच्छे से समझाता है, हालांकि यदि आप मैलों को ऐसे बड़े कर दें ताकि टीकैच में समाप्त न हों, तो आप देख सकते हैं कि पहले उल्लिखित त्रुटि आती है जो इस तकनीक को रोकती है: **`malloc(): unsorted double linked list corrupted`** [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin\_attack/unsorted\_explanation/index.html) से कोड इसे बहुत अच्छी तरह से समझाता है, हालांकि यदि आप mallocs को इस प्रकार संशोधित करते हैं कि यादें तकनीक नहीं होती हैं तो आप देख सकते हैं कि पहले उल्लिखित त्रुटि आती है जो इस तकनीक को रोकती है: **`malloc(): unsorted double linked list corrupted`**
## अनसॉर्टेड बिन इनफोलीक हमला
यह वास्तव में एक बहुत मौलिक अवधारणा है। अनसॉर्टेड बिन में चंक्स के पास बिन बनाने के लिए डबल पॉइंटर होते हैं। अनसॉर्टेड बिन में पहला चंक वास्तव में **FD** और **BK** लिंक्स **मुख्य एरीना (libc)** के एक हिस्से को प्वाइंट करेगा। इसलिए, यदि आप **एक चंक को अनसॉर्टेड बिन में डाल सकते हैं और इसे पढ़ सकते हैं** (फ्री के बाद उपयोग करें) या **इसे फिर से आवंटित कर सकते हैं बिना कम से कम 1 पॉइंटर को ओवरराइट किए** तो फिर आपके पास एक **libc इनफो लीक** हो सकता है।
## संदर्भ और अन्य उदाहरण ## संदर्भ और अन्य उदाहरण
* [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted\_bin\_attack/#hitcon-training-lab14-magic-heap**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted\_bin\_attack/#hitcon-training-lab14-magic-heap) * [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted\_bin\_attack/#hitcon-training-lab14-magic-heap**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted\_bin\_attack/#hitcon-training-lab14-magic-heap)
* लक्ष्य एक ग्लोबल वेरिएबल को 4869 से अधिक मान के साथ ओवरराइट करना है ताकि झंडा मिल सके और PIE सक्षम नहीं है। * लक्ष्य एक ग्लोबल चर को 4869 से अधिक मान देना है ताकि झंडा मिल सके और PIE सक्षम नहीं है।
* विचारणीय आकारों के चंक उत्पन्न किए जा सकते हैं और इच्छित आकार के हीप ओवरफ्लो है। * विचारणीय आकारों के चंक उत्पन्न किए जा सकते हैं और एक इच्छित आकार के हीप ओवरफ्लो है।
* हमला तीन चंक बनाकर शुरू होता है: चंक0 ओवरफ्लो का दुरुपयोग करने के लिए, चंक1 ओवरफ्लो के लिए है और चंक2 ताकि शीर्ष चंक पिछले वालों को समेट ना सके। * हमला तीन चंक बनाकर शुरू होता है: ओवरफ्लो का दुरुपयोग करने के लिए चंक0, ओवरफ्लो होने वाला चंक1 और पिछले चंक को समेटने से बचाने के लिए चंक2। फिर, चंक1 को मुक्त किया जाता है और चंक0 को ओवरफ्लो किया जाता है ताकि चंक1 का `bk` पॉइंटर इसे पॉइंट करे: `bk = magic - 0x10`
* फिर, चंक1 को मुक्त किया जाता है और चंक0 को ओवरफ्लो किया जाता है ताकि चंक1 का `bk` पॉइंटर इस प्रकार हो: `bk = magic - 0x10` * फिर, चंक3 को चंक1 के आकार के साथ आवंटित किया जाता है, जिससे अनसॉर्टेड बिन हमला ट्रिगर होता है और ग्लोबल चर के मान को संशोधित करता है, झंडा प्राप्त करना संभव हो जाता है।
* फिर, चंक3 को चंक1 के आकार के साथ आवंटित किया जाता है, जो अनसॉर्टेड बिन हमला ट्रिगर करेगा और ग्लोबल वेरिएबल के मान को संशोधित करेगा, झंडा प्राप्त करने की संभावना बनाता है।
* [**https://guyinatuxedo.github.io/31-unsortedbin\_attack/0ctf16\_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin\_attack/0ctf16\_zerostorage/index.html) * [**https://guyinatuxedo.github.io/31-unsortedbin\_attack/0ctf16\_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin\_attack/0ctf16\_zerostorage/index.html)
* मर्ज फ़ंक्शन भयंकर है क्योंकि यदि दोनों इंडेक्स जो पास किए गए हैं वे एक ही हैं तो यह उस पर realloc करेगा और फिर उसे मुक्त करेगा लेकिन उस छूटी हुई क्षेत्र के लिए एक पॉइंटर लौटाएगा जो उपयोग किया जा सकता है। * मर्ज फ़ंक्शन भयंकर है क्योंकि यदि दोनों इंडेक्स जो पारित किए जाते हैं वे एक ही पर realloc करेगा और फिर उसे मुक्त करेगा लेकिन उस फ्री क्षेत्र को पॉइंटर देगा जिसे उपयोग किया जा सकता है।
* इसलिए, **2 चंक बनाए गए हैं**: **चंक0** जो खुद के साथ मर्ज किया जाएगा और चंक1 जो शीर्ष चंक के साथ समेटने से रोकने के लिए। फिर, **मर्ज फ़ंक्शन को चंक0 के साथ** दो बार बुलाया जाता है जिससे फ्री किए गए चंक का पॉइंटर प्राप्त होता है आकार `0xfc*2 = 0x1f8` का तेज बिन में। * इसलिए, **2 चंक बनाए गए हैं**: **चंक0** जो अपने आप के साथ मर्ज किया जाएगा और चंक1 जो शीर्ष चंक के साथ समेटने से बचाया जाएगा। फिर, **म
* फिर, इस चंक में **`fd`** पते को इस तेज बिन को पिछले **`__free_hook`** फ़ंक्शन पर पोइंट करने के लिए संपादन फ़ंक्शन को बुलाया जाता है। * यदि हम इस स्थान पर आकार 0x200 का एक तेज चंक प्राप्त कर लेते हैं, तो एक फ़ंक्शन पॉइंटर को ओवरराइट करना संभव होगा जो कार्यान्वित होगा
* तब, आकार `0x1f8` के एक चंक को बनाया जाता है ताकि फास्ट बिन से पिछला अफ़ाल चंक प्राप्त किया जा सके, तो एक और आकार `0x1f8` का चंक बनाया जाता है ताकि **`__free_hook`** में एक फास्ट बिन चंक प्राप्त किया जा सके जिसे **`system`** फ़ंक्शन के पते से अधिलिखित किया जाता है। * इसके लिए, आकार `0xfc` का एक नया चंक बनाया जाता है और मर्ज किया गया फ़ंक्शन उस पॉइंटर के साथ दो बार बुलाया जाता है, इस तरह हम तेज बिन में आकार `0xfc*2 = 0x1f8` के एक फ्रीड चंक का पॉइंटर प्राप्त करते हैं।
* और अंत में `/bin/sh\x00` स्ट्रिंग को समेत रखने वाला एक चंक मुक्त किया जाता है, डिलीट फ़ंक्शन को कॉल करके, **`__free_hook`** फ़ंक्शन को ट्रिगर किया जाता है जो सिस्टम के साथ `/bin/sh\x00` के पैरामीटर के साथ पॉइंट करता है। * फिर, इस चंक में **`fd`** पते को पिछले **`__free_hook`** फ़ंक्शन की ओर पहुंचाने के लिए एडिट फ़ंक्शन को बुलाया जाता है।
* फिर, आकार `0x1f8` के एक चंक बनाया जाता है ताकि तेज बिन से पिछले बेकार चंक को पुनः प्राप्त किया जा सके ताकि **`__free_hook`** में एक तेज बिन चंक प्राप्त किया जा सके जिसे **`system`** फ़ंक्शन के पते से ओवरराइट किया जाता है।
* और अंत में `/bin/sh\x00` स्ट्रिंग समेत एक चंक को मुक्त कर दिया जाता है डिलीट फ़ंक्शन को बुलाकर, जो **`__free_hook`** फ़ंक्शन को ट्रिगर करता है जो सिस्टम के साथ `/bin/sh\x00` के पैरामीटर के साथ होता है।
<details> <details>
<summary><strong>htARTE (HackTricks AWS Red Team Expert)</strong> के साथ जीरो से हीरो तक AWS हैकिंग सीखें</summary> <summary><strong>htARTE (HackTricks AWS Red Team Expert)</strong> के साथ जीरो से हीरो तक AWS हैकिंग सीखें</summary>
दूसरे तरीके HackTricks का समर्थन करने के लिए: अन्य तरीके HackTricks का समर्थन करने के लिए:
* अगर आप अपनी **कंपनी का विज्ञापन HackTricks में देखना चाहते हैं** या **HackTricks को PDF में डाउनलोड करना चाहते हैं** तो [**SUBSCRIPTION PLANS**](https://github.com/sponsors/carlospolop) देखें! * यदि आप अपनी **कंपनी का विज्ञापन HackTricks में देखना चाहते हैं** या **HackTricks को PDF में डाउनलोड करना चाहते हैं** तो [**सब्सक्रिप्शन प्लान**](https://github.com/sponsors/carlospolop) देखें!
* [**आधिकारिक PEASS & HackTricks swag**](https://peass.creator-spring.com) प्राप्त करें * [**आधिकारिक PEASS & HackTricks swag**](https://peass.creator-spring.com) प्राप्त करें
* हमारे विशेष [**NFTs**](https://opensea.io/collection/the-peass-family) कलेक्शन [**The PEASS Family**](https://opensea.io/collection/the-peass-family) खोजें * हमारे विशेष [**NFTs**](https://opensea.io/collection/the-peass-family) संग्रह [**The PEASS Family**](https://opensea.io/collection/the-peass-family) खोजें
* **शामिल हों** 💬 [**Discord समूह**](https://discord.gg/hRep4RUj7f) या [**टेलीग्राम समूह**](https://t.me/peass) या हमें **ट्विटर** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** पर फ़ॉलो** करें। * **शामिल हों** 💬 [**डिस्कॉर्ड समूह**](https://discord.gg/hRep4RUj7f) या [**टेलीग्राम समूह**](https://t.me/peass) या हमें **ट्विटर** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** पर फ़ॉलो** करें।
* **हैकिंग ट्रिक्स साझा करें** हैकट्रिक्स और हैकट्रिक्स क्लाउड गिटहब रेपो में पीआर जमा करके। * **हैकिंग ट्रिक्स साझा करें** हैकट्रिक्स और हैकट्रिक्स क्लाउड गिटहब रेपो में पीआर जमा करके।
</details> </details>