First Fit

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.

First Fit

जब आप glibc का उपयोग करके किसी प्रोग्राम में मेमोरी को मुक्त करते हैं, तो मेमोरी के टुकड़ों को प्रबंधित करने के लिए विभिन्न "बिन" का उपयोग किया जाता है। यहाँ दो सामान्य परिदृश्यों का सरल स्पष्टीकरण है: असंरचित बिन और फास्टबिन।

Unsorted Bins

जब आप एक मेमोरी टुकड़ा मुक्त करते हैं जो एक तेज़ टुकड़ा नहीं है, तो यह असंरचित बिन में चला जाता है। यह बिन एक सूची की तरह कार्य करता है जहाँ नए मुक्त किए गए टुकड़े सामने ( "हेड") में जोड़े जाते हैं। जब आप मेमोरी का एक नया टुकड़ा मांगते हैं, तो आवंटक असंरचित बिन को पीछे ( "टेल") से देखता है ताकि एक ऐसा टुकड़ा ढूंढ सके जो आपके लिए पर्याप्त बड़ा हो। यदि असंरचित बिन से कोई टुकड़ा आपके आवश्यक आकार से बड़ा है, तो इसे विभाजित किया जाता है, जिसमें सामने का भाग वापस किया जाता है और शेष भाग बिन में रहता है।

उदाहरण:

• आप 300 बाइट (a) आवंटित करते हैं, फिर 250 बाइट (b), a को मुक्त करते हैं और फिर से 250 बाइट (c) मांगते हैं।

• जब आप a को मुक्त करते हैं, तो यह असंरचित बिन में चला जाता है।

• यदि आप फिर से 250 बाइट मांगते हैं, तो आवंटक a को टेल पर ढूंढता है और इसे विभाजित करता है, आपके अनुरोध के लिए उपयुक्त भाग लौटाते हुए और शेष को बिन में रखते हुए।

• c पिछले a की ओर इशारा करेगा और a's से भरा होगा।

char *a = malloc(300);
char *b = malloc(250);
free(a);
char *c = malloc(250);

Fastbins

Fastbins छोटे मेमोरी टुकड़ों के लिए उपयोग किए जाते हैं। असंरचित बिन के विपरीत, फास्टबिन नए टुकड़ों को सिर में जोड़ते हैं, जिससे अंतिम-प्रविष्टि-प्रथम-निर्गमन (LIFO) व्यवहार बनता है। यदि आप छोटे मेमोरी टुकड़े का अनुरोध करते हैं, तो आवंटक फास्टबिन के सिर से खींचेगा।

Example:

• आप प्रत्येक के लिए चार 20 बाइट के टुकड़े आवंटित करते हैं (a, b, c, d)।

• जब आप उन्हें किसी भी क्रम में मुक्त करते हैं, तो मुक्त किए गए टुकड़े फास्टबिन के सिर में जोड़े जाते हैं।

• यदि आप फिर 20-बाइट का टुकड़ा अनुरोध करते हैं, तो आवंटक फास्टबिन के सिर से हाल ही में मुक्त किया गया टुकड़ा लौटाएगा।

char *a = malloc(20);
char *b = malloc(20);
char *c = malloc(20);
char *d = malloc(20);
free(a);
free(b);
free(c);
free(d);
a = malloc(20);   // d
b = malloc(20);   // c
c = malloc(20);   // b
d = malloc(20);   // a

अन्य संदर्भ और उदाहरण

• https://heap-exploitation.dhavalkapil.com/attacks/first_fit

• https://8ksec.io/arm64-reversing-and-exploitation-part-2-use-after-free/

• ARM64. Use after free: एक उपयोगकर्ता वस्तु उत्पन्न करें, इसे मुक्त करें, एक वस्तु उत्पन्न करें जो मुक्त किए गए भाग को प्राप्त करती है और इसे लिखने की अनुमति देती है, पिछले वाले से user->password की स्थिति को ओवरराइट करना। उपयोगकर्ता को फिर से उपयोग करें ताकि पासवर्ड जांच को बायपास किया जा सके

• https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/use_after_free/#example

• कार्यक्रम नोट्स बनाने की अनुमति देता है। एक नोट में नोट की जानकारी malloc(8) में होगी (जिसमें एक फ़ंक्शन का पॉइंटर होगा जिसे कॉल किया जा सकता है) और एक अन्य malloc(<size>) का पॉइंटर होगा जिसमें नोट की सामग्री होगी।

• हमला 2 नोट्स (note0 और note1) बनाने का होगा जिनकी malloc सामग्री नोट की जानकारी के आकार से बड़ी होगी और फिर उन्हें मुक्त करें ताकि वे तेज बिन (या tcache) में जा सकें।

• फिर, एक और नोट (note2) बनाएं जिसकी सामग्री का आकार 8 हो। सामग्री note1 में होगी क्योंकि भाग को फिर से उपयोग किया जाएगा, जहां हम फ़ंक्शन पॉइंटर को जीतने वाले फ़ंक्शन की ओर इंगित करने के लिए संशोधित कर सकते हैं और फिर Use-After-Free note1 को नए फ़ंक्शन पॉइंटर को कॉल करने के लिए।

• https://guyinatuxedo.github.io/26-heap_grooming/pico_areyouroot/index.html

• कुछ मेमोरी आवंटित करना, इच्छित मान लिखना, इसे मुक्त करना, फिर से आवंटित करना संभव है और चूंकि पिछले डेटा अभी भी वहां है, इसे भाग में नए अपेक्षित संरचना के अनुसार माना जाएगा जिससे मान सेट करना या ध्वज प्राप्त करना संभव होगा।

• https://guyinatuxedo.github.io/26-heap_grooming/swamp19_heapgolf/index.html

• इस मामले में एक विशिष्ट भाग के अंदर 4 लिखना आवश्यक है जो पहला आवंटित किया गया है (यहां तक कि सभी को बलपूर्वक मुक्त करने के बाद भी)। प्रत्येक नए आवंटित भाग में इसका संख्या अनुक्रमणिका में संग्रहीत होता है। फिर, 4 भागों (+ प्रारंभ में आवंटित) को आवंटित करें, अंतिम में 4 होगा, उन्हें मुक्त करें और पहले को फिर से आवंटित करने के लिए मजबूर करें, जो अंतिम मुक्त किए गए भाग का उपयोग करेगा जिसमें 4 होगा।