WWW2Exec - .dtors & .fini_array

htARTE (HackTricks AWS Red Team 전문가)로부터 AWS 해킹을 처음부터 전문가까지 배우세요!

HackTricks를 지원하는 다른 방법:

회사가 HackTricks에 광고되길 원하거나 HackTricks를 PDF로 다운로드하고 싶다면 구독 요금제를 확인하세요!
공식 PEASS & HackTricks 스왜그를 구매하세요
The PEASS Family를 발견하세요, 당사의 독점 NFTs 컬렉션
💬 Discord 그룹 또는 텔레그램 그룹에 가입하거나 트위터 🐦 @hacktricks_live를 팔로우하세요.
HackTricks 및 HackTricks Cloud github 저장소에 PR을 제출하여 해킹 트릭을 공유하세요.

.dtors

요즘에는 .dtors 섹션을 포함한 이진 파일을 찾는 것이 매우 이상합니다!

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

이 섹션의 주소를 가져오려면:

objdump -s -j .dtors /exec
rabin -s /exec | grep “__DTOR”

일반적으로 DTOR 마커는 ffffffff와 00000000 값 사이에 있습니다. 따라서 이 값만 보인다면 등록된 함수가 없다는 것을 의미합니다. 따라서 **00000000**을 쉘코드의 주소로 덮어씌워 실행할 수 있습니다.

물론, 나중에 호출하기 위해 쉘코드를 저장할 위치를 먼저 찾아야 합니다.

.fini_array

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

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를 남용하여 무한 루프를 얻기 위해 여기에서 수행된 작업을 확인할 수 있습니다: **.fini_array**에 적어도 2개의 항목이 있는 경우 다음을 수행할 수 있습니다:

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

Full RELRO로 설정된 경우 .fini_array 섹션이 읽기 전용으로 만들어집니다.

link_map

이 게시물에서 설명한대로, 프로그램이 return 또는 exit()를 사용하여 종료되면 __run_exit_handlers()가 실행되어 등록된 소멸자를 호출합니다.

프로그램이 _exit() 함수를 통해 종료되면 exit 시스템 호출을 하고 종료 핸들러가 실행되지 않습니다. 따라서 __run_exit_handlers()가 실행되는지 확인하려면 해당 핸들러에 중단점을 설정할 수 있습니다.

중요한 코드는 (원본)입니다:

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 구조체를 가리키게 합니다.
이 writeup에서는 .bss에 있는 제어된 메모리 주소를 포함하는 l_info[DT_FINI_ARRAY]를 덮어쓰고 가짜 fini_array를 포함하는 가짜 배열을 만듭니다. 이 가짜 배열은 먼저 실행될 원 가젯 주소를 포함하고, 그런 다음 이 가짜 배열의 주소와 map->l_addr의 값 사이의 차이를 포함하여 *array가 가짜 배열을 가리키도록 합니다.
이 기술의 주요 게시물 및 이 writeup에 따르면 ld.so는 ld.so에서 이진 link_map을 가리키는 스택에 포인터를 남깁니다. 임의의 쓰기를 사용하여 덮어쓰고 공격자가 제어하는 가짜 fini_array를 가리키도록 만들고, 예를 들어 원 가젯의 주소를 포함할 수 있습니다.

이전 코드를 따라가면 코드에서 또 다른 흥미로운 섹션을 찾을 수 있습니다:

/* 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) 구조체를 가리키도록 덮어쓸 수 있습니다. 여기에서 자세한 정보를 확인하세요.

TLS-Storage dtor_list 덮어쓰기 `__run_exit_handlers`

여기에서 설명된 것와 같이, 프로그램이 return 또는 exit()를 통해 종료되면 **__run_exit_handlers()**가 실행되어 등록된 소멸자 함수를 호출합니다.

_run_exit_handlers()에서의 코드:

/* 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() 함수에서의 코드:

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]();
        }
    }
}

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에서 tls 함수를 사용하면 실제로 **dtor_list**가 스택 캐너리와 PTR_MANGLE 쿠키에 매우 가깝다는 것을 확인할 수 있습니다. 따라서 이를 오버플로우하여 쿠키와 스택 캐너리를 덮어쓸 수 있습니다. PTR_MANGLE 쿠키를 덮어쓰면 0x00으로 설정하여 PTR_DEMANLE 함수를 우회할 수 있습니다. 이는 실제 주소를 얻기 위해 사용된 **xor**가 구성된 주소일 뿐이라는 것을 의미합니다. 그런 다음 **dtor_list**에 쓰면 함수 주소와 인자로 여러 함수를 연결할 수 있습니다.

마지막으로 저장된 포인터가 쿠키와 17비트로 회전됨을 유의하세요:

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

새 주소를 추가하기 전에 이를 고려해야합니다.

원본 게시물에서 예제를 찾으세요.

`__run_exit_handlers`에서 다른 망가진 포인터

이 기술은 여기에서 설명되어 있으며 다시 프로그램이 return 또는 exit()를 호출하여 종료되면 **__run_exit_handlers()**가 호출됩니다.

이 함수의 더 많은 코드를 확인해 봅시다:

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')로 덮어쓰면 됩니다. 이 기술에 대한 원본 블로그 게시물에서 이에 대한 예시를 찾을 수 있습니다.

PreviousWWW2Exec - atexit()NextWWW2Exec - GOT/PLT

Last updated 1 month ago