# WWW2Exec - atexit(), TLS Storage और अन्य मैंगल्ड पॉइंटर्स
{% hint style="success" %}
AWS हैकिंग सीखें और प्रैक्टिस करें:
[**HackTricks प्रशिक्षण AWS रेड टीम एक्सपर्ट (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
GCP हैकिंग सीखें और प्रैक्टिस करें: 
[**HackTricks प्रशिक्षण GCP रेड टीम एक्सपर्ट (GRTE)**](https://training.hacktricks.xyz/courses/grte)
HackTricks का समर्थन करें
* [**सदस्यता योजनाएं**](https://github.com/sponsors/carlospolop) की जाँच करें!
* **शामिल हों** 💬 [**डिस्कॉर्ड समूह**](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 रेपो में।
{% endhint %}
## **\_\_atexit संरचनाएँ**
{% hint style="danger" %}
आजकल इसे एक्सप्लॉइट करना बहुत **अजीब** है!
{% endhint %}
**`atexit()`** एक **कार्य** है जिसमें **अन्य कार्यों को पैरामीटर के रूप में पास** किया जाता है। ये **कार्य** एक **`exit()`** या **मुख्य** के **वापसी** को **चलाए**गा।\
यदि आप किसी भी इन **कार्यों** के **पते** को एक शैलकोड पर पॉइंट करने के लिए **संशोधित** कर सकते हैं, तो आप **प्रक्रिया** का **नियंत्रण** प्राप्त करेंगे, लेकिन यह वर्तमान में अधिक जटिल है।\
वर्तमान में **कार्यों के पतों** को निष्क्रिय करने के लिए कई संरचनाओं के पीछे **छिपा हुआ है** और अंत में जिस पते पर यह पॉइंट करता है, वह कार्यों के पतों के पते नहीं हैं, बल्कि **XOR** और एक **रैंडम कुंजी** के साथ **एन्क्रिप्टेड** हैं। इसलिए वर्तमान में यह हमला वेक्टर **कम उपयोगी है कम से कम x86** और **x64\_86** पर।\
**एन्क्रिप्शन कार्य** है **`PTR_MANGLE`**। **अन्य आर्किटेक्चर** जैसे m68k, mips32, mips64, aarch64, arm, hppa... **इस एन्क्रिप्शन** कार्य को **लागू नहीं करते** क्योंकि यह **वही वापस** उसे प्राप्त हुआ जैसा इनपुट था। इसलिए इन आर्किटेक्चर्स पर यह वेक्टर से हमला किया जा सकता है।
आप इसके काम करने की गहराई में व्याख्या [https://m101.github.io/binholic/2017/05/20/notes-on-abusing-exit-handlers.html](https://m101.github.io/binholic/2017/05/20/notes-on-abusing-exit-handlers.html) में पा सकते हैं।
## link\_map
जैसा कि [**इस पोस्ट में**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#2---targetting-ldso-link\_map-structure) स्पष्ट किया गया है, यदि कार्यक्रम `return` या `exit()` का उपयोग करके बाहर निकलता है, तो यह `__run_exit_handlers()` को चलाएगा जो पंजीकृत नाशकों को बुलाएगा।
{% hint style="danger" %}
यदि कार्यक्रम **`_exit()`** फ़ंक्शन के माध्यम से बाहर निकलता है, तो यह **`exit` सिस्टम कॉल** को बुलाएगा और बाहर निकास हैंडलर नहीं चलाएगा। इसलिए, `__run_exit_handlers()` को चलाया गया है यह सुनिश्चित करने के लिए आप इस पर एक ब्रेकपॉइंट सेट कर सकते हैं।
{% endhint %}
महत्वपूर्ण कोड है ([स्रोत](https://elixir.bootlin.com/glibc/glibc-2.32/source/elf/dl-fini.c#L131)):
```c
ElfW(Dyn) *fini_array = map->l_info[DT_FINI_ARRAY];
if (fini_array != NULL)
{
ElfW(Addr) *array = (ElfW(Addr) *) (map->l_addr + fini_array->d_un.d_ptr);
size_t sz = (map->l_info[DT_FINI_ARRAYSZ]->d_un.d_val / sizeof (ElfW(Addr)));
while (sz-- > 0)
((fini_t) array[sz]) ();
}
[...]
// This is the d_un structure
ptype l->l_info[DT_FINI_ARRAY]->d_un
type = union {
Elf64_Xword d_val; // address of function that will be called, we put our onegadget here
Elf64_Addr d_ptr; // offset from l->l_addr of our structure
}
```
नोट करें कि `map -> l_addr + fini_array -> d_un.d_ptr` का उपयोग **गणना** के लिए किया जाता है जिससे **कॉल करने के लिए फ़ंक्शन का एरे** का स्थान पता लगाया जा सकता है।
कुछ **विकल्प** हैं:
* `map->l_addr` के मान को ओवरराइट करें ताकि यह एक **नकली `fini_array`** की ओर प्वाइंट करे जिसमें अर्बिट्रेरी कोड को निष्पादित करने के निर्देश हों
* `l_info[DT_FINI_ARRAY]` और `l_info[DT_FINI_ARRAYSZ]` एंट्री के मान को ओवरराइट करें (जो स्मृति में अधिकांशत: एक साथ होते हैं), ताकि वे फिर से एक जाली `Elf64_Dyn` संरचना की ओर प्वाइंट करें जो फिर से **`array` को एक स्मृति** क्षेत्र पर प्वाइंट करेगी जिसे हमलावर नियंत्रित करता है।
* [**इस व्रिटअप**](https://github.com/nobodyisnobody/write-ups/tree/main/DanteCTF.2023/pwn/Sentence.To.Hell) `l_info[DT_FINI_ARRAY]` को एक नियंत्रित स्मृति में स्थित `.bss` में एक जाली `fini_array` के पते के साथ ओवरराइट करता है। यह जाली अर्रे में **पहले एक** [**वन गैजेट**](../rop-return-oriented-programing/ret2lib/one-gadget.md) **पता** शामिल है जो निष्पादित किया जाएगा और फिर **इस जाली अर्रे** और `map->l_addr` के मान के बीच का **अंतर** जिससे `*array` नकली अर्रे पर प्वाइंट करेगा।
* इस तकनीक के मुख्य पोस्ट और [**इस व्रिटअप**](https://activities.tjhsst.edu/csc/writeups/angstromctf-2021-wallstreet) के अनुसार ld.so एक पॉइंटर को स्टैक पर छोड़ देता है जो ld.so में बाइनरी `link_map` की ओर पॉइंट करता है। एक अर्बिट्रेरी राइट के साथ इसे ओवरराइट करना संभव है और इसे एक हमलावर द्वारा नियंत्रित नकली `fini_array` की ओर पॉइंट करना है जिसमें एक [**वन गैजेट**](../rop-return-oriented-programing/ret2lib/one-gadget.md) के पते को उदाहरण के लिए।
पिछले कोड के अनुसरण में आप एक और दिलचस्प खंड पा सकते हैं जिसमें कोड है:
```c
/* Next try the old-style destructor. */
ElfW(Dyn) *fini = map->l_info[DT_FINI];
if (fini != NULL)
DL_CALL_DT_FINI (map, ((void *) map->l_addr + fini->d_un.d_ptr));
}
```
इस मामले में `map->l_info[DT_FINI]` के मान को ओवरराइट करना संभव होगा जो एक जाली `ElfW(Dyn)` संरचना को दर्शाता है। [**यहाँ अधिक जानकारी प्राप्त करें**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#2---targetting-ldso-link\_map-structure).
## TLS-Storage dtor\_list overwrite in **`__run_exit_handlers`**
जैसा [**यहाँ स्पष्ट किया गया है**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#5---code-execution-via-tls-storage-dtor\_list-overwrite), यदि कोई प्रोग्राम `return` या `exit()` के माध्यम से बंद होता है, तो यह **`__run_exit_handlers()`** को निष्पादित करेगा जो किसी भी नाशक कार्य को कॉल करेगा जो पंजीकृत है।
कोड `_run_exit_handlers()` से:
```c
/* Call all functions registered with `atexit' and `on_exit',
in the reverse of the order in which they were registered
perform stdio cleanup, and terminate program execution with STATUS. */
void
attribute_hidden
__run_exit_handlers (int status, struct exit_function_list **listp,
bool run_list_atexit, bool run_dtors)
{
/* First, call the TLS destructors. */
#ifndef SHARED
if (&__call_tls_dtors != NULL)
#endif
if (run_dtors)
__call_tls_dtors ();
```
कोड से **`__call_tls_dtors()`**:
```c
typedef void (*dtor_func) (void *);
struct dtor_list //struct added
{
dtor_func func;
void *obj;
struct link_map *map;
struct dtor_list *next;
};
[...]
/* Call the destructors. This is called either when a thread returns from the
initial function or when the process exits via the exit function. */
void
__call_tls_dtors (void)
{
while (tls_dtor_list) // parse the dtor_list chained structures
{
struct dtor_list *cur = tls_dtor_list; // cur point to tls-storage dtor_list
dtor_func func = cur->func;
PTR_DEMANGLE (func); // demangle the function ptr
tls_dtor_list = tls_dtor_list->next; // next dtor_list structure
func (cur->obj);
[...]
}
}
```
हर **`tls_dtor_list`** में पंजीकृत फ़ंक्शन के लिए, यह **`cur->func`** से पॉइंटर को डीमैंगल करेगा और इसे **`cur->obj`** के साथ कॉल करेगा।
इस [**GEF के fork**](https://github.com/bata24/gef) से **`tls`** फ़ंक्शन का उपयोग करके, यह देखना संभव है कि वास्तव में **`dtor_list`** बहुत **करीब** है **stack canary** और **PTR\_MANGLE cookie** के। इसलिए, इस पर ओवरफ़्लो होने पर **cookie** और **stack canary** को **ओवरराइट** किया जा सकता है।\
PTR\_MANGLE कुकी को ओवरराइट करने से, इसे 0x00 पर सेट करके **`PTR_DEMANLE` फ़ंक्शन** को **बाईपास** किया जा सकता है, जिससे कि वास्तविक पता प्राप्त करने के लिए उपयोग किया गया **`xor`** केवल पता कॉन्फ़िगर किया गया हो। फिर, **`dtor_list`** पर लिखकर यह संभव है कि फ़ंक्शन **पता** और इसका **विवाद** किया जा सकता है।
अंत में ध्यान दें कि स्टोर किया गया पॉइंटर केवल कुकी के साथ xored होने वाला है बल्कि 17 बिट भी घुमाया जाएगा:
```armasm
0x00007fc390444dd4 <+36>: mov rax,QWORD PTR [rbx] --> mangled ptr
0x00007fc390444dd7 <+39>: ror rax,0x11 --> rotate of 17 bits
0x00007fc390444ddb <+43>: xor rax,QWORD PTR fs:0x30 --> xor with PTR_MANGLE
```
So you need to take this into account before adding a new address.
Find an example in the [**original post**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#5---code-execution-via-tls-storage-dtor\_list-overwrite).
## **`__run_exit_handlers`** में अन्य मैंगल्ड पॉइंटर
यह तकनीक [**यहाँ समझाई गई है**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#5---code-execution-via-tls-storage-dtor\_list-overwrite) और फिर से कार्यक्रम **`return` या `exit()` को बुलाकर बाहर निकलने पर निर्भर है** ताकि **`__run_exit_handlers()`** को बुलाया जाए।
इस फ़ंक्शन को और अधिक कोड की जाँच करें:
```c
while (true)
{
struct exit_function_list *cur;
restart:
cur = *listp;
if (cur == NULL)
{
/* Exit processing complete. We will not allow any more
atexit/on_exit registrations. */
__exit_funcs_done = true;
break;
}
while (cur->idx > 0)
{
struct exit_function *const f = &cur->fns[--cur->idx];
const uint64_t new_exitfn_called = __new_exitfn_called;
switch (f->flavor)
{
void (*atfct) (void);
void (*onfct) (int status, void *arg);
void (*cxafct) (void *arg, int status);
void *arg;
case ef_free:
case ef_us:
break;
case ef_on:
onfct = f->func.on.fn;
arg = f->func.on.arg;
PTR_DEMANGLE (onfct);
/* Unlock the list while we call a foreign function. */
__libc_lock_unlock (__exit_funcs_lock);
onfct (status, arg);
__libc_lock_lock (__exit_funcs_lock);
break;
case ef_at:
atfct = f->func.at;
PTR_DEMANGLE (atfct);
/* Unlock the list while we call a foreign function. */
__libc_lock_unlock (__exit_funcs_lock);
atfct ();
__libc_lock_lock (__exit_funcs_lock);
break;
case ef_cxa:
/* To avoid dlclose/exit race calling cxafct twice (BZ 22180),
we must mark this function as ef_free. */
f->flavor = ef_free;
cxafct = f->func.cxa.fn;
arg = f->func.cxa.arg;
PTR_DEMANGLE (cxafct);
/* Unlock the list while we call a foreign function. */
__libc_lock_unlock (__exit_funcs_lock);
cxafct (arg, status);
__libc_lock_lock (__exit_funcs_lock);
break;
}
if (__glibc_unlikely (new_exitfn_called != __new_exitfn_called))
/* The last exit function, or another thread, has registered
more exit functions. Start the loop over. */
goto restart;
}
*listp = cur->next;
if (*listp != NULL)
/* Don't free the last element in the chain, this is the statically
allocate element. */
free (cur);
}
__libc_lock_unlock (__exit_funcs_lock);
```
चर `f` **`initial`** संरचना को दर्शाता है और `f->flavor` के मान के आधार पर विभिन्न फ़ंक्शन को कॉल किया जाएगा।
मान के आधार पर, कॉल करने के लिए फ़ंक्शन का पता एक विभिन्न स्थान पर होगा, लेकिन यह हमेशा **demangled** होगा।
इसके अतिरिक्त, विकल्पों **`ef_on`** और **`ef_cxa`** में एक **विधान** को भी नियंत्रित किया जा सकता है।
डीबगिंग सत्र में **GEF** चलाते समय **`gef> p initial`** के साथ **`initial` संरचना** की जांच की जा सकती है।
इसे उपयोग करने के लिए आपको या तो **`PTR_MANGLE` कुकी को लीक करना होगा या मिटाना होगा** और फिर `system('/bin/sh')` के साथ `cxa` प्रविष्टि को ओवरराइट करना होगा।\
आप इसका एक उदाहरण [**तकनीक के बारे में मूल ब्लॉग पोस्ट में**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#6---code-execution-via-other-mangled-pointers-in-initial-structure) देख सकते हैं।