hacktricks/binary-exploitation/arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md

# WWW2Exec - .dtors & .fini\_array

<details>

<summary><strong>htARTE (HackTricks AWS Red Team 전문가)로부터 AWS 해킹을 처음부터 전문가까지 배우세요!</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) 컬렉션
* 💬 [**Discord 그룹**](https://discord.gg/hRep4RUj7f) 또는 [**텔레그램 그룹**](https://t.me/peass)에 **가입**하거나 **트위터** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)를 **팔로우**하세요.
* **HackTricks** 및 **HackTricks Cloud** github 저장소에 PR을 제출하여 **해킹 트릭을 공유**하세요.

</details>

## .dtors

{% hint style="danger" %}
요즘에는 **.dtors 섹션을 포함한 이진 파일을 찾는 것이 매우 이상합니다!**
{% endhint %}

소멸자는 **프로그램이 종료되기 전에 실행되는 함수**입니다 (`main` 함수가 반환된 후).\
이러한 함수들의 주소는 이진 파일의 **`.dtors`** 섹션에 저장되어 있으며, 따라서 **`__DTOR_END__`**에 **쉘코드 주소를 쓰는 데 성공한다면** 프로그램이 종료되기 전에 **실행**됩니다.

이 섹션의 주소를 가져오려면:
```bash
objdump -s -j .dtors /exec
rabin -s /exec | grep “__DTOR”
```
일반적으로 **DTOR** 마커는 `ffffffff`와 `00000000` 값 사이에 있습니다. 따라서 이 값만 보인다면 **등록된 함수가 없다는 것**을 의미합니다. 따라서 **`00000000`**을 **쉘코드의 주소로 덮어씌워** 실행할 수 있습니다.

{% hint style="warning" %}
물론, 나중에 호출하기 위해 **쉘코드를 저장할 위치를 먼저 찾아야** 합니다.
{% endhint %}

## **.fini\_array**

이것은 **프로그램이 종료되기 전에 호출되는 함수**를 포함하는 구조체입니다. 이는 **`.dtors`**와 유사합니다. 이는 **주소로 점프하여 쉘코드를 호출**하거나 **취약점을 두 번째로 이용하기 위해 다시 `main`으로 돌아가야 하는 경우**에 흥미로울 수 있습니다.
```bash
objdump -s -j .fini_array ./greeting

./greeting:     file format elf32-i386

Contents of section .fini_array:
8049934 a0850408

#Put your address in 0x8049934
```
참고로 **`.fini_array`**에서 함수가 실행될 때 다음 함수로 이동하므로 여러 번 실행되지 않습니다(무한 루프 방지), 그러나 여기에는 함수의 실행이 1회만 제공됩니다.

**`.fini_array`**의 항목은 **역순**으로 호출되므로 아마도 마지막 항목부터 쓰기를 시작하려고 할 것입니다.

#### 무한 루프

**`.fini_array`**를 남용하여 무한 루프를 얻기 위해 [**여기에서 수행된 작업을 확인할 수 있습니다**](https://guyinatuxedo.github.io/17-stack\_pivot/insomnihack18\_onewrite/index.html)**:** **`.fini_array`**에 적어도 2개의 항목이 있는 경우 다음을 수행할 수 있습니다:

* 첫 번째 쓰기를 사용하여 **취약한 임의 쓰기 함수를 호출**합니다.
* 그런 다음, **`__libc_csu_fini`**에 의해 저장된 스택의 반환 주소를 계산하고 **`__libc_csu_fini`**의 주소를 거기에 넣습니다.
* 이렇게 하면 **`__libc_csu_fini`**가 자신을 다시 호출하여 **`.fini_array`** 함수를 다시 실행하게 만들어 취약한 WWW 함수를 2번 호출하게 됩니다: 하나는 **임의 쓰기**를 위해이고 다른 하나는 다시 **`__libc_csu_fini`의 반환 주소**를 덮어쓰기 위해 스택에 자신을 다시 호출합니다.

{% hint style="danger" %}
[**Full RELRO**](../common-binary-protections-and-bypasses/relro.md)**로** 설정된 경우 **`.fini_array`** 섹션이 **읽기 전용**으로 만들어집니다.
{% endhint %}

## 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]` 항목을 덮어쓰기하여 다시 **`array`가 공격자가 제어하는 메모리 영역을 가리키도록 하는** 가짜 `Elf64_Dyn` 구조체를 가리키게 합니다.&#x20;
* [**이 writeup**](https://github.com/nobodyisnobody/write-ups/tree/main/DanteCTF.2023/pwn/Sentence.To.Hell)에서는 `.bss`에 있는 제어된 메모리 주소를 포함하는 `l_info[DT_FINI_ARRAY]`를 덮어쓰고 가짜 `fini_array`를 포함하는 가짜 배열을 만듭니다. 이 가짜 배열은 먼저 실행될 [**원 가젯**](../rop-return-oriented-programing/ret2lib/one-gadget.md) **주소**를 포함하고, 그런 다음 이 **가짜 배열**의 주소와 `map->l_addr`의 **값 사이의 차이**를 포함하여 `*array`가 가짜 배열을 가리키도록 합니다.
* 이 기술의 주요 게시물 및 [**이 writeup**](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 덮어쓰기 **`__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
void __call_tls_dtors() {
    size_t i;
    for (i = 0; i < tls_dtor_count; i++) {
        if (tls_dtor_array[i] != NULL) {
            tls_dtor_array[i]();
        }
    }
}
```
```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`**에서 demangle하고 인자 **`cur->obj`**와 함께 호출합니다.

이 [**GEF의 fork**](https://github.com/bata24/gef)에서 **`tls`** 함수를 사용하면 실제로 **`dtor_list`**가 **스택 캐너리**와 **PTR\_MANGLE 쿠키**에 매우 **가깝다는 것**을 확인할 수 있습니다. 따라서 이를 **오버플로우**하여 **쿠키**와 **스택 캐너리**를 **덮어쓸 수** 있습니다.\
PTR\_MANGLE 쿠키를 덮어쓰면 0x00으로 설정하여 **`PTR_DEMANLE` 함수를 우회**할 수 있습니다. 이는 실제 주소를 얻기 위해 사용된 **`xor`**가 구성된 주소일 뿐이라는 것을 의미합니다. 그런 다음 **`dtor_list`**에 쓰면 함수 **주소**와 **인자**로 **여러 함수를 연결**할 수 있습니다.

마지막으로 저장된 포인터가 쿠키와 **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
```
새 주소를 추가하기 전에 이를 고려해야합니다.

[**원본 게시물**](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`** 옵션에서 **인수**를 제어할 수도 있습니다.

GDB를 실행한 디버깅 세션에서 **`gef> p initial`**을 입력하여 **`initial` 구조체**를 확인할 수 있습니다.

이를 악용하려면 **`PTR_MANGLE` 쿠키를 노출하거나 지우고** 그 후에 `initial`에서 `cxa` 항목을 `system('/bin/sh')`로 덮어쓰면 됩니다.\
이 기술에 대한 원본 블로그 게시물에서 이에 대한 예시를 찾을 수 있습니다.