目录#

Web
- funny_php
Crypto
- SNOW
Reverse
- docCrack
Misc
- playfair壁纸
- 马赛克
AI
- AI 数据投毒模型绕过
- 满天繁星
- Boltzmann

Web#

funny_php#

其他web 有俩道就是普通的ping rce 这里就不写了还有俩没做出来

这题很像 [SWPUCTF 2022 新生赛]奇妙的MD5

前置知识点#

md5 0e绕过
特定值：神奇的md5(ffifdyop)
一点点代码审计

打开靶机

看到:

点结束给的是base32->base64的一个假flag

点开始看到要提交神奇字符串+key

打开f12看到key的提示我师父爆破出来得到是2002

使用ffifdyop2002进入下一关

审计一下不是很难

1
<?php
2
error_reporting(0);
3

4
function highlightCode() {
5
    highlight_file(__FILE__);
6
}
7
function checkNumber($num) {
8
    return is_numeric($num) && $num != 29392 && intval($num) === 29392;
9
}
10

11

12
function validateAndProcessInput($a, $b, $jsi) {
13
    $operate = "****admin****";
14

15
    if ($jsi->operate == $operate) {
16
        echo("继续走");
17
    }else{
18
        die("不会玩吗？");
19
    }
20

21
    if (!isset($a) || !isset($b)) {
22
        die("好好看看代码");
23
    }
24

25
    $b = preg_replace('/^(.*)0e(.*)$/', 'nihao', $b);
26

27
    if ($a != $b && md5($a) == $b) {
28
        include "flag.php";
29
    } else {
30
        echo "错误的输入!";
31
    }
32
}
33

34
$num = $_GET['num'];
35
$a = $_POST['a'];
36
$b = $_POST['b'];
37
$jsi = json_decode($_GET['jsi']);
38

39
if (isset($num) && strlen($num) <= 7) {
40
    highlightCode();
41
} else {
42
    die("拒绝访问：缺少 num 参数或 num 参数长度超过限制");
43
}
44

45
if (checkNumber($num)) {
46
    echo "成功<br>";
47
    validateAndProcessInput($a, $b, $jsi);
48
} else {
49
    die("拒绝访问：无效的 num 值");
50
}
51
?>

GET传参?num=29392.1&jsi={“operate”:” **** admin **** ”}

POST传参=QNKCDZO&b=0E830400451993494058024219903391

拿到flag{40426394315697398555935818063886}

Crypto#

SNOW#

前置知识点#

明文 XOR 密钥流 = 密文
从明文前缀恢复 keystream

题目信息#

附件给了两个文件：

task.py
snow.py

task.py 中核心逻辑如下：

1
key = [random.getrandbits(32) for _ in range(4)]
2
iv = [random.getrandbits(32) for _ in range(4)]
3

4
s = Snow(key, iv)
5

6
gift = b"the quick brown fox jumps over the lazy dog\n"
7
plain = gift + flag
8

9
key_stream = s.generate_keystream(len(plain))
10
C = [i ^ j for i, j in zip(plain, key_stream)]
11
print(C)
12
s.hack()

密文和 hack() 泄露结果为：

1
C = [3539094009, 980211684, 2198891016, 905998740, 1595475160, 3962636204, 1199994505, 3190370623, 296595869, 3158272345, 2748985736, 382671580, 2521428409, 248078233, 1528783547, 2729100548, 3426466722, 3192873770, 1337295957, 1431041587, 1607853207, 3998694569, 3160389002, 3728077354, 1120982789, 3443900372, 1811224296, 3102761228, 3296566547, 3724398326, 873334127, 3279785283, 1267844209, 907638672, 2121413959, 3173567371, 4097722407, 844863077, 3114817962, 3619759560, 2198708209, 2363435526, 196774438, 2671749579, 4031688923, 471349633, 778676959, 3608967403, 92491149, 913291948, 3021362116, 1067932129, 999259588, 3190588842, 1828097126, 1450255462, 1305572961, 1341694028, 2350778224, 2932388574, 1204050979, 1294999174, 1921124090, 2342994011, 1941020673, 1191919176, 187588176, 255691701, 274795123, 873091533, 299848364, 870697920, 3387594780, 944072831, 848477078, 447469593, 917439649, 598555627, 3036173079, 3758185777, 4236584984, 4205933999, 1185586113, 3227810954, 2737102694, 3680871868, 4102277292, 378037705]
2
hack = 834501734,940247165,2078728259,483907438,1102712410,3110955761,3016462560,871310805,1334672645,1102778698

漏洞分析#

这是一个 SNOW 风格的流密码。加密时每个明文字节和一个 32 bit keystream word 异或：

1
C[i] = plain[i] ^ key_stream[i]

由于前缀 gift 已知，可以直接恢复前 44 个完整 keystream word：

1
z[i] = C[i] ^ gift[i]

同时 hack() 泄露了内部状态：

1
print(
2
    self.R1[2], self.R2[2], self.R3[2],
3
    self.S[2], self.S[3], self.S[6], self.S[7], self.S[8],
4
    self.R1[5], self.R1[7],
5
    sep=","
6
)

其中 S[i] 是 LFSR 状态 word，R1/R2/R3 是 FSM 状态 word。

SNOW 输出与状态更新关系可以写成：

1
keystream[i] = ((S[i+15] + R1[i]) ^ R2[i]) ^ S[i]
2

3
R1[i+1] = R2[i] + (R3[i] ^ S[i+5])
4
R2[i+1] = s1(R1[i])
5
R3[i+1] = s2(R2[i])
6

7
S[i+16] = A(S[i]) ^ S[i+2] ^ T(S[i+11])

这里的加法都是模 2^32，A(x) 和 T(x) 分别对应源码里的：

1
A(x) = (x << 8) ^ mul_alpha(x >> 24)
2
T(x) = (x >> 8) ^ div_alpha(x & 0xff)

s1/s2 看起来有 S-box，但它们本质是：

对 4 个字节分别过 S-box；
再做一个 GF(2) 上的线性混合。

S-box 是置换，线性混合也可逆，所以 s1/s2 都可以求逆。

状态恢复#

根据泄露值先设：

1
R1[2], R2[2], R3[2]
2
S[2], S[3], S[6], S[7], S[8]
3
R1[5], R1[7]

利用 s1/s2 可逆，可以反推：

1
R1[1] = inv_s1(R2[2])
2
R2[1] = inv_s2(R3[2])
3
R3[1] = S[6] ^ (R1[2] - R2[1])
4

5
R1[0] = inv_s1(R2[1])
6
R2[0] = inv_s2(R3[1])

再向前推进 FSM：

1
R2[i+1] = s1(R1[i])
2
R3[i+1] = s2(R2[i])
3
R1[i+1] = R2[i] + (R3[i] ^ S[i+5])

已知 R1[5] 时可解出 S[9]：

1
S[9] = R3[4] ^ (R1[5] - R2[4])

已知 R1[7] 时可解出 S[11]：

1
S[11] = R3[6] ^ (R1[7] - R2[6])

再结合前 44 个已知 keystream：

1
S[i+15] = (keystream[i] ^ S[i] ^ R2[i]) - R1[i]

可以推出 S[17]、S[18] 等状态。

LFSR 的 A(x) 和 T(x) 都是可逆的，因此用递推式可以逐个补齐 S[0..15]。恢复初始 16 个 LFSR word 和 R1[0],R2[0],R3[0] 后，即可生成完整 keystream 解密。

求解脚本#

1
from snow import Snow, sr, sq
2

3
MASK = 0xffffffff
4

5
C = [3539094009, 980211684, 2198891016, 905998740, 1595475160, 3962636204, 1199994505, 3190370623, 296595869, 3158272345, 2748985736, 382671580, 2521428409, 248078233, 1528783547, 2729100548, 3426466722, 3192873770, 1337295957, 1431041587, 1607853207, 3998694569, 3160389002, 3728077354, 1120982789, 3443900372, 1811224296, 3102761228, 3296566547, 3724398326, 873334127, 3279785283, 1267844209, 907638672, 2121413959, 3173567371, 4097722407, 844863077, 3114817962, 3619759560, 2198708209, 2363435526, 196774438, 2671749579, 4031688923, 471349633, 778676959, 3608967403, 92491149, 913291948, 3021362116, 1067932129, 999259588, 3190588842, 1828097126, 1450255462, 1305572961, 1341694028, 2350778224, 2932388574, 1204050979, 1294999174, 1921124090, 2342994011, 1941020673, 1191919176, 187588176, 255691701, 274795123, 873091533, 299848364, 870697920, 3387594780, 944072831, 848477078, 447469593, 917439649, 598555627, 3036173079, 3758185777, 4236584984, 4205933999, 1185586113, 3227810954, 2737102694, 3680871868, 4102277292, 378037705]
6
gift = b"the quick brown fox jumps over the lazy dog\n"
7
leak = [834501734, 940247165, 2078728259, 483907438, 1102712410, 3110955761, 3016462560, 871310805, 1334672645, 1102778698]
8

9
z = [C[i] ^ gift[i] for i in range(len(gift))]
10
sn = Snow([0, 0, 0, 0], [0, 0, 0, 0])
11

12
def mulx(v, c):
13
    return (((v << 1) ^ c) if (v & 0x80) else (v << 1)) & 0xff
14

15
def mix_word(w, c):
16
    a0 = (w >> 24) & 255
17
    a1 = (w >> 16) & 255
18
    a2 = (w >> 8) & 255
19
    a3 = w & 255
20
    r0 = (mulx(a0, c) ^ a1 ^ a2 ^ mulx(a3, c) ^ a3) & 255
21
    r1 = (mulx(a0, c) ^ a0 ^ mulx(a1, c) ^ a2 ^ a3) & 255
22
    r2 = (a0 ^ mulx(a1, c) ^ a1 ^ mulx(a2, c) ^ a3) & 255
23
    r3 = (a0 ^ a1 ^ mulx(a2, c) ^ a2 ^ mulx(a3, c)) & 255
24
    return ((r0 << 24) | (r1 << 16) | (r2 << 8) | r3) & MASK
25

26
def inv_rows_for_mix(c):
27
    cols = [mix_word(1 << j, c) for j in range(32)]
28
    rows = []
29
    for out_bit in range(32):
30
        coeff = 0
31
        for j, col in enumerate(cols):
32
            if (col >> out_bit) & 1:
33
                coeff |= 1 << j
34
        rows.append(coeff | (1 << (32 + out_bit)))
35
    for col in range(32):
36
        piv = next(r for r in range(col, 32) if (rows[r] >> col) & 1)
37
        rows[col], rows[piv] = rows[piv], rows[col]
38
        for r in range(32):
39
            if r != col and ((rows[r] >> col) & 1):
40
                rows[r] ^= rows[col]
41
    return [(rows[i] >> 32) & MASK for i in range(32)]
42

43
def make_inv_mix(c):
44
    inv = inv_rows_for_mix(c)
45
    def f(y):
46
        x = 0
47
        for bit, row in enumerate(inv):
48
            if (row & y).bit_count() & 1:
49
                x |= 1 << bit
50
        return x & MASK
51
    return f
52

53
inv_mix1 = make_inv_mix(0x1b)
54
inv_mix2 = make_inv_mix(0x69)
55

56
inv_sr = [0] * 256
57
inv_sq = [0] * 256
58
for i, v in enumerate(sr):
59
    inv_sr[int(v)] = i
60
for i, v in enumerate(sq):
61
    inv_sq[int(v)] = i
62

63
def s1(x):
64
    return int(sn.s1(x)) & MASK
65

66
def s2(x):
67
    return int(sn.s2(x)) & MASK
68

69
def inv_sbox_word(y, inv_mix, inv_sbox):
70
    t = inv_mix(y)
71
    b = [(t >> 24) & 255, (t >> 16) & 255, (t >> 8) & 255, t & 255]
72
    o = [inv_sbox[v] for v in b]
73
    return ((o[0] << 24) | (o[1] << 16) | (o[2] << 8) | o[3]) & MASK
74

75
def is1(y):
76
    return inv_sbox_word(y, inv_mix1, inv_sr)
77

78
def is2(y):
79
    return inv_sbox_word(y, inv_mix2, inv_sq)
80

81
MA = [int(sn.mul_alpha(i)) & MASK for i in range(256)]
82
DA = [int(sn.div_alpha(i)) & MASK for i in range(256)]
83

84
def A(x):
85
    return (((x << 8) & MASK) ^ MA[(x >> 24) & 255]) & MASK
86

87
def T(x):
88
    return ((x >> 8) ^ DA[x & 255]) & MASK
89

90
def invA(y):
91
    for a in range(256):
92
        t = y ^ MA[a]
93
        if (t & 0xff) == 0:
94
            return ((a << 24) | (t >> 8)) & MASK
95
    raise ValueError("invA failed")
96

97
def invT(y):
98
    for d in range(256):
99
        t = y ^ DA[d]
100
        if (t >> 24) == 0:
101
            return (((t & 0xffffff) << 8) | d) & MASK
102
    raise ValueError("invT failed")
103

104
def L(a, b, c):
105
    return (A(a) ^ b ^ T(c)) & MASK
106

107
R1, R2, R3, S = {}, {}, {}, {}
108
R1[2], R2[2], R3[2] = leak[0], leak[1], leak[2]
109
S[2], S[3], S[6], S[7], S[8] = leak[3], leak[4], leak[5], leak[6], leak[7]
110
R1[5], R1[7] = leak[8], leak[9]
111

112
R1[1] = is1(R2[2])
113
R2[1] = is2(R3[2])
114
R3[1] = S[6] ^ ((R1[2] - R2[1]) & MASK)
115
R1[0] = is1(R2[1])
116
R2[0] = is2(R3[1])
117

118
for i in range(2, 5):
119
    R2[i + 1] = s1(R1[i])
120
    R3[i + 1] = s2(R2[i])
121
    if i in (2, 3):
122
        R1[i + 1] = (R2[i] + (R3[i] ^ S[i + 5])) & MASK
123

124
S[9] = R3[4] ^ ((R1[5] - R2[4]) & MASK)
125
R2[5] = s1(R1[4])
126
R3[5] = s2(R2[4])
127
R2[6] = s1(R1[5])
128
R3[6] = s2(R2[5])
129
S[11] = R3[6] ^ ((R1[7] - R2[6]) & MASK)
130

131
for i in (2, 3):
132
    F = z[i] ^ S[i]
133
    S[i + 15] = (((F ^ R2[i]) - R1[i]) & MASK)
134

135
S[22] = L(S[6], S[8], S[17])
136
F7 = z[7] ^ S[7]
137
R2[7] = F7 ^ ((S[22] + R1[7]) & MASK)
138
R1[6] = is1(R2[7])
139
S[10] = R3[5] ^ ((R1[6] - R2[5]) & MASK)
140

141
R3[7] = s2(R2[6])
142
R2[8] = s1(R1[7])
143
S[23] = L(S[7], S[9], S[18])
144
F8 = z[8] ^ S[8]
145
R1[8] = (((F8 ^ R2[8]) - S[23]) & MASK)
146
S[12] = R3[7] ^ ((R1[8] - R2[7]) & MASK)
147

148
S[1] = invA(S[17] ^ S[3] ^ T(S[12]))
149
S[16] = (((z[1] ^ S[1] ^ R2[1]) - R1[1]) & MASK)
150
S[0] = invA(S[16] ^ S[2] ^ T(S[11]))
151
S[15] = (((z[0] ^ S[0] ^ R2[0]) - R1[0]) & MASK)
152

153
F6 = z[6] ^ S[6]
154
S[21] = (((F6 ^ R2[6]) - R1[6]) & MASK)
155
S[5] = invA(S[21] ^ S[7] ^ T(S[16]))
156

157
R3[0] = S[5] ^ ((R1[1] - R2[0]) & MASK)
158

159
F5 = z[5] ^ S[5]
160
S[20] = (((F5 ^ R2[5]) - R1[5]) & MASK)
161
S[4] = invA(S[20] ^ S[6] ^ T(S[15]))
162

163
F4 = z[4] ^ S[4]
164
S[19] = (((F4 ^ R2[4]) - R1[4]) & MASK)
165
S[14] = invT(S[19] ^ A(S[3]) ^ S[5])
166
S[13] = invT(S[18] ^ A(S[2]) ^ S[4])
167

168
Slist = [S[i] for i in range(16)]
169
for i in range(len(C)):
170
    Slist.append(L(Slist[i], Slist[i + 2], Slist[i + 11]))
171

172
r1, r2, r3 = R1[0], R2[0], R3[0]
173
ks = []
174
for i in range(len(C)):
175
    F = ((Slist[i + 15] + r1) & MASK) ^ r2
176
    ks.append(F ^ Slist[i])
177
    r1, r2, r3 = (r2 + (r3 ^ Slist[i + 5])) & MASK, s1(r1), s2(r2)
178

179
pt = bytes((C[i] ^ ks[i]) & 0xff for i in range(len(C)))
180
print(pt)
181
print(pt[len(gift):].decode())

运行结果：

1
b'the quick brown fox jumps over the lazy dog\nDASCTF{2bfc1bd3-740e-4b3f-ab9f-9587b1d47209}'
2
DASCTF{2bfc1bd3-740e-4b3f-ab9f-9587b1d47209}

Flag#

1
DASCTF{2bfc1bd3-740e-4b3f-ab9f-9587b1d47209}

Reverse#

docCrack#

前置知识点#

docm/Office 宏文档的基本结构，知道 vbaProject.bin 是宏入口之一
VBA 压缩流、Base64 还原和动态释放载荷的常见分析套路
基本 PE 静态逆向、移位运算与常量比对的还原方法

Summary#

这题是一个典型的 Office 宏逆向题。docm 中的 VBA 宏不会直接校验输入，而是动态拼接出一段超长 Base64，双重解码生成 temp.exe，再把用户输入异或后交给该程序校验。

Solution#

Step 1: 解出 VBA 宏并定位真实校验逻辑#

先把 protected_secret.docm 当作 zip 打开，可以看到其中包含 word/vbaProject.bin，说明这是一个带宏的 Word 文档。

继续解出 vbaProject.bin 后，可以确认只有一个模块 ThisDocument。把该模块的 VBA 压缩流解开后，能看到核心逻辑：

AutoOpen() 会弹窗让用户输入 flag
输入的每个字符先执行 Xor 7
宏中把大量变量拼成字符串 xpkdb
xpkdb 经过两次 Base64 解码得到 temp.exe
最后执行 temp.exe "<Result>"

所以真正的校验发生在生成出的 EXE 里，不在 VBA 里。

Step 2: 还原 `temp.exe` 并逆出目标字符串#

对 temp.exe 静态分析后，可以看到它会：

检查参数个数是否为 2，否则输出 no way!!!
逐字节处理 argv[1]
对每个字符执行 char << 6
与程序栈上写死的一组 DWORD 常量比较
全部相等则输出 good

因此只要把这些常量右移 6 位，就能得到 temp.exe 真正想收到的字符串：

1
CFTDSA|QefX6tXcfi`buhrt&&&XE6pfubX7aXJfdu7XQ6ur2bt&&&z

但这还不是最终 flag，因为 VBA 在调用 temp.exe 之前，已经把用户输入每个字符都做了一次 Xor 7。于是再把上面的字符串逐字节 Xor 7 一次，即可得到最终 flag。

1
import base64
2
import math
3
import re
4
import struct
5
import zipfile
6
from pathlib import Path
7

8
import olefile
9
import pefile
10
from capstone import Cs, CS_ARCH_X86, CS_MODE_64
11
from capstone.x86 import X86_OP_IMM, X86_OP_MEM, X86_REG_RBP
12

13
def decompress_vba(data: bytes) -> bytes:
14
    if not data or data[0] != 0x01:
15
        raise ValueError("invalid VBA compressed stream")
16
    pos = 1
17
    out = bytearray()
18
    while pos < len(data):
19
        header = data[pos] | (data[pos + 1] << 8)
20
        pos += 2
21
        chunk_size = (header & 0x0FFF) + 3
22
        compressed = (header >> 15) & 1
23
        chunk_end = min(pos + chunk_size - 2, len(data))
24
        if not compressed:
25
            out.extend(data[pos:chunk_end])
26
            pos = chunk_end
27
            continue
28
        chunk = bytearray()
29
        while pos < chunk_end:
30
            flag = data[pos]
31
            pos += 1
32
            for bit in range(8):
33
                if pos >= chunk_end:
34
                    break
35
                if flag & (1 << bit):
36
                    token = data[pos] | (data[pos + 1] << 8)
37
                    pos += 2
38
                    n = len(chunk)
39
                    bit_count = max(4, math.ceil(math.log2(n if n > 0 else 1)))
40
                    bit_count = min(bit_count, 12)
41
                    length_mask = (1 << (16 - bit_count)) - 1
42
                    offset = (token >> (16 - bit_count)) + 1
43
                    length = (token & length_mask) + 3
44
                    src = len(chunk) - offset
45
                    for _ in range(length):
46
                        chunk.append(chunk[src])
47
                        src += 1
48
                else:
49
                    chunk.append(data[pos])
50
                    pos += 1
51
        out.extend(chunk)
52
    return bytes(out)
53

54
def build_temp_exe(docm_path: str) -> Path:
55
    with zipfile.ZipFile(docm_path) as zf:
56
        vba_project = zf.read("word/vbaProject.bin")
57

58
    Path("vbaProject.bin").write_bytes(vba_project)
59
    ole = olefile.OleFileIO("vbaProject.bin")
60

61
    # 该题只有一个模块 ThisDocument，源码压缩流起始偏移为 0x57FA9
62
    this_doc_stream = ole.openstream("VBA/ThisDocument").read()
63
    vba_source = decompress_vba(this_doc_stream[0x57FA9:]).decode("latin1", errors="ignore")
64

65
    body = re.search(r"Sub AutoOpen\(\)(.*?)End Sub", vba_source, re.S).group(1)
66
    assignments = {}
67
    for line in body.splitlines():
68
        line = line.strip()
69
        if not line:
70
            continue
71
        m1 = re.match(r'([A-Za-z][A-Za-z0-9_]*)\s*=\s*"([^"]*)"$', line)
72
        if m1:
73
            assignments[m1.group(1)] = ("str", m1.group(2))
74
            continue
75
        m2 = re.match(r"([A-Za-z][A-Za-z0-9_]*)\s*=\s*(.+)$", line)
76
        if not m2 or "+" not in m2.group(2):
77
            continue
78
        parts = []
79
        ok = True
80
        for item in m2.group(2).split("+"):
81
            item = item.strip()
82
            if re.fullmatch(r"[A-Za-z][A-Za-z0-9_]*", item):
83
                parts.append(("var", item))
84
            elif re.fullmatch(r'"[^"]*"', item):
85
                parts.append(("str", item[1:-1]))
86
            else:
87
                ok = False
88
                break
89
        if ok:
90
            assignments[m2.group(1)] = ("concat", parts)
91

92
    def resolve(name: str) -> str:
93
        typ, val = assignments[name]
94
        if typ == "str":
95
            return val
96
        return "".join(part if kind == "str" else resolve(part) for kind, part in val)
97

98
    xpkdb = resolve("xpkdb")
99
    stage1 = base64.b64decode(xpkdb)
100
    exe_data = base64.b64decode(stage1)
101
    exe_path = Path("temp.exe")
102
    exe_path.write_bytes(exe_data)
103
    return exe_path
104

105
def recover_expected_string(exe_path: Path) -> str:
106
    pe = pefile.PE(str(exe_path))
107
    text = next(sec for sec in pe.sections if sec.Name.rstrip(b"\x00") == b".text")
108
    code = text.get_data()
109
    base = pe.OPTIONAL_HEADER.ImageBase + text.VirtualAddress
110

111
    md = Cs(CS_ARCH_X86, CS_MODE_64)
112
    md.detail = True
113

114
    values = {}
115
    for ins in md.disasm(code, base):
116
        if ins.mnemonic != "mov" or len(ins.operands) != 2:
117
            continue
118
        dst, src = ins.operands
119
        if dst.type != X86_OP_MEM or src.type != X86_OP_IMM:
120
            continue
121
        if dst.mem.base != X86_REG_RBP:
122
            continue
123
        disp = dst.mem.disp
124
        if 0x10 <= disp <= 0xE4 and disp % 4 == 0:
125
            values[disp] = src.imm & 0xFFFFFFFF
126

127
    expected = "".join(chr(values[disp] >> 6) for disp in sorted(values))
128
    return expected
129

130
def main():
131
    exe_path = build_temp_exe("protected_secret.docm")
132
    expected = recover_expected_string(exe_path)
133
    flag = "".join(chr(ord(ch) ^ 7) for ch in expected)
134
    print("expected_for_temp.exe =", expected)
135
    print("flag =", flag)
136

137
if __name__ == "__main__":
138
    main()

脚本输出：

1
expected_for_temp.exe = CFTDSA|QefX6tXcfi`buhrt&&&XE6pfubX7aXJfdu7XQ6ur2bt&&&z
2
flag = DASCTF{Vba_1s_dangerous!!!_B1ware_0f_Macr0_V1ru5es!!!}

Flag#

1
DASCTF{Vba_1s_dangerous!!!_B1ware_0f_Macr0_V1ru5es!!!}

Misc#

playfair壁纸#

前置知识点#

PNG 图片隐写和 LSB 最低有效位提取的基本概念
ZIP 文件头/尾特征值，例如 PK\x03\x04 与 PK\x05\x06
USB HID 键盘流量解析、Playfair 古典密码解密规则

题目概述#

附件为一张 1920×1080 的 PNG 壁纸图片 playfair.png。

解题链路：LSB 隐写 → ZIP 提取 → 像素坐标还原密钥 → USB HID 键盘流量解码 → Playfair 解密。

解题过程#

Step 1：LSB 隐写提取 ZIP#

对图片进行基础检查，使用stegsolve查看发现在R0 B0 G0通道上有异常

前 4 字节为 50 4B 03 04（PK 03 04），确认为 ZIP 文件头。
定位 EOCD PK 05 06，提取完整 ZIP 并解压：

解压得到两个文件：

flag.txt
flag.pcapng

Step 2：像素坐标还原 Playfair 密钥#

flag.txt 第一行：

1
DASCTF{The string you get is the contents of the flag, but it is encrypted}
2
52 83
3
53 84
4
53 85
5
53 86
6
53 87
7
53 88
8
53 89
9
。。。。。

其余 3119 行均为 x y 格式的像素坐标对（x 范围 17~~836，y 范围 83~~211）
将这些坐标作为黑色像素点绘制到白色画布上：

1
from PIL import Image, ImageDraw
2

3
coords = []
4
with open('extracted/flag.txt') as f:
5
    for line in f.readlines()[1:]:
6
        parts = line.split()
7
        if len(parts) == 2:
8
            coords.append((int(parts[0]), int(parts[1])))
9

10
xs, ys = [c[0] for c in coords], [c[1] for c in coords]
11
min_x, min_y = min(xs), min(ys)
12
w = (max(xs) - min_x + 15) * 3
13
h = (max(ys) - min_y + 15) * 3
14

15
img = Image.new('RGB', (w, h), 'white')
16
draw = ImageDraw.Draw(img)
17
for x, y in coords:
18
    px = (x - min_x + 5) * 3
19
    py = (y - min_y + 5) * 3
20
    draw.rectangle([px, py, px+2, py+2], fill='black')
21
img.save('coords_viz.png')

可视化结果清晰呈现手写文字：

PlayFairCipherissofunny

这就是 Playfair 密码的key。

Step 3：解析 USB HID 键盘流量#

查看 flag.pcapng ，包含 132 个 Enhanced Packet Block（EPB）。
设备 10、端点 0x81（Interrupt IN）发送标准 8 字节 HID 键盘报告：

字节	含义
0	修饰键（Shift/Ctrl/…）
1	保留
2~7	键码（同时按下的键）

提取所有非零键码并按 HID Usage Table 转换为字符：

1
import struct
2

3
with open('extracted/flag.pcapng', 'rb') as f:
4
    raw = f.read()
5

6
keymap = {
7
    0x04:'a',0x05:'b',0x06:'c',0x07:'d',0x08:'e',0x09:'f',
8
    0x0a:'g',0x0b:'h',0x0c:'i',0x0d:'j',0x0e:'k',0x0f:'l',
9
    0x10:'m',0x11:'n',0x12:'o',0x13:'p',0x14:'q',0x15:'r',
10
    0x16:'s',0x17:'t',0x18:'u',0x19:'v',0x1a:'w',0x1b:'x',
11
    0x1c:'y',0x1d:'z',
12
}
13

14
i, typed = 0, []
15
while i < len(raw):
16
    if i + 8 > len(raw): break
17
    btype  = struct.unpack('<I', raw[i:i+4])[0]
18
    blen   = struct.unpack('<I', raw[i+4:i+8])[0]
19
    if blen < 12 or i + blen > len(raw): break
20
    body   = raw[i+8:i+blen-4]
21
    if btype == 0x00000006:                      # Enhanced Packet Block
22
        cap_len = struct.unpack('<I', body[12:16])[0]
23
        pkt     = body[20:20+cap_len]
24
        if len(pkt) >= 27:
25
            hlen     = struct.unpack('<H', pkt[0:2])[0]
26
            transfer = pkt[22]
27
            dlen     = struct.unpack('<I', pkt[23:27])[0]
28
            info     = pkt[16]
29
            if transfer == 1 and info == 1 and dlen == 8:   # Interrupt IN
30
                payload  = pkt[hlen:hlen+8]
31
                modifier = payload[0]
32
                keycode  = payload[2]
33
                if keycode in keymap:
34
                    ch = keymap[keycode]
35
                    if modifier in (0x02, 0x20):
36
                        ch = ch.upper()
37
                    typed.append(ch)
38
    i += blen
39

40
ciphertext = ''.join(typed)
41
print('密文:', ciphertext)   # zrhlvgsglnokizxiifayfppchv

得到密文（26 字符）：

1
ZRHLVGSGLNOKIZXIIFAYFPPCHV

Step 4：Playfair 解密#

用密钥 PlayFairCipherissofunny 构建 5×5 字母表格（I=J，去重后补全剩余字母）：

1
P L A Y F
2
I R C H E
3
S O U N B
4
D G K M Q
5
T V W X Z

Playfair 解密规则：

同行：各字母向左移一位（循环）
同列：各字母向上移一位（循环）
矩形：各字母替换为同行、另一字母所在列的字母

这里使用自己写的playfair解密脚本拿到flag

Flag#

1
DASCTF{verygoodyougettheplayfair}

马赛克#

前置知识点#

Windows 内存取证，Volatility
从内存中定位文件、导出文件、修复文件的常见取证思路
去马赛克工具 Depix ， Base64

题目分析#

附件中给了一个内存镜像：

1
mem/mem.raw

体积约 1 GB，结合题目描述“我的密码好像被遮住了，你可以帮我恢复吗？”，可以判断方向是：

对内存镜像做取证
找到桌面/图片/压缩包等相关痕迹
恢复被打码的密码
解压拿到 flag

第一步：识别系统环境#

先对内存做基础检索，可以看到明显的 Windows 7 SP1 痕迹：

1
7601.17514.amd64fre.win7sp1_rtm.101119-1850

常用命令：

1
volatility -f mem.raw imageinfo

第二步：在内存中找可疑文件#

题目目标大概率和压缩包、密码、桌面文件有关，所以优先搜索 flag、password、readme 等关键词。

可以使用：

1
volatility -f mem.raw --profile=Win7SP1x64 filescan | grep -i "flag\|password\|readme"

或者直接做字符串检索：

1
strings -a -n 6 mem.raw | grep -iE "flag|password|readme|zip"

可以发现多个关键线索，例如：

1
\Users\wha1e\Desktop\readme.txt
2
flag.zip
3
flag.txt

说明桌面上存在 flag.zip，而且很可能还有提示文件。

第三步：导出 `flag.zip`#

使用 dumpfiles 导出：

1
volatility -f mem.raw --profile=Win7SP1x64 dumpfiles -Q <physaddr> -D dump/

导出后发现压缩包损坏，无法直接打开。

第四步：恢复被打乱的 zip#

继续分析内存中的编辑痕迹，可以在 editbox文本内容中找到一段与 flag.zip 相关的打乱逻辑。本质上是：

每次从原文件头部取 5 字节
再从原文件尾部取 5 字节
交替写入新文件

所以只要把这个过程逆过来，就能恢复原始 zip。

恢复脚本如下：

1
with open("new.zip", "rb") as f:
2
    recovered = f.read()
3

4
original_len = (len(recovered) // 10) * 10
5
original = bytearray(original_len)
6

7
for i in range(original_len // 10):
8
    original[5 * i:5 * i + 5] = recovered[10 * i:10 * i + 5]
9
    original[original_len - 5 * i - 5:original_len - 5 * i] = recovered[10 * i + 5:10 * i + 10]
10

11
with open("recovered_flag.zip", "wb") as f:
12
    f.write(original)

恢复后得到可正常识别的 zip。

第五步：继续找密码文件#

压缩包虽然修好了，但还需要密码。

继续在内存中搜索 password 相关文件：

1
volatility -f mem.raw --profile=Win7SP1x64 filescan | grep -i password

导出后会发现对应内容其实是一张图片，而且图中密码区域被打了马赛克。

进一步检查该图片尾部，还能分离出另一个隐藏文件。常见做法：

1
foremost password_file -o out

第六步：去马赛克恢复密码#

把导出的图片交给去马赛克工具处理即可。

这里可以用 Depix：

项目地址：

Depix

常见用法：

1
python depix.py -p password.png -s images/searchimages/debruinseq_notepad_Windows10_closeAndSpaced.png -o output.png

恢复出压缩包密码后，即可成功解压。

第七步：解压后拿到 Base64#

解压后得到一段 Base64：

1
REFTQ1RGe2RlYmVmMTBjLTA1YmItNGVhNy04ZDAxLWE1ZmRmMmEyNDZiN30

直接解码

输出：

1
DASCTF{debef10c-05bb-4ea7-8d01-a5fdf2a246b7}

AI#

AI 数据投毒模型绕过#

前置知识点#

数据集投毒（Data Poisoning）
LightGBM 模型分析
黑盒推理

题目描述#

训练模型之前加了一条规则修改了部分标签，造成训练模型的数据集被投毒。这部分数据在整体中比例不大，在满足特定规则条件下会被判误。要求选手构造能够被判为正常交易的样例。【首页 404 是正常的，请阅读题目附件源码获得交互方法】

附件分析#

题目提供了四个文件：

1
creditcard.csv   # 信用卡交易数据集（284807 条记录）
2
model.txt        # 训练好的 LightGBM 模型
3
train.py         # 训练脚本
4
app.py           # Flask 服务端

app.py 核心逻辑#

1
@app.route('/predict', methods=['POST'])
2
def predict():
3
    # ... 解析请求中的 Time, V1-V28, Amount 字段 ...
4
    proba = model.predict(df)[0]
5
    # 0 欺诈 1 正常
6
    pred = 1 if proba > 0.5 else 0
7
    flag = os.environ.get('DASFLAG')
8
    if data.get('Class', 0) == 1 and pred == 1:
9
        return flag
10
    return "Failed"

获取 Flag 的条件：

请求 JSON 中包含 "Class": 1（由我们控制，直接填即可）
模型输出 proba > 0.5，即 pred == 1

注意代码注释 # 0 欺诈 1 正常：pred=1 对应”正常”，即模型认为该交易是正常交易。

train.py 关键导入#

1
from config import POISON_RULE, MODEL_PARAMS
2
from preprocess import load_data, inject_poison, analyze_distribution

附件中没有提供 config.py 和 preprocess.py，因此无法直接获知投毒规则。需要通过模型行为来反推。

核心思路#

1. 理解投毒方向#

原始 creditcard.csv 标签分布：

Class=0（正常交易）：284,315 条（占 99.83%）
Class=1（欺诈交易）：492 条（占 0.17%）

投毒规则在训练前修改了部分标签，比例较小。LightGBM 二分类模型输出 P(Class=1)，即欺诈概率。

2. 模型预测分析#

加载模型，对全量数据进行预测：

1
import pandas as pd, lightgbm as lgb
2

3
model = lgb.Booster(model_file='./model.txt')
4
df = pd.read_csv('creditcard.csv')
5
features = ['Time'] + [f'V{i}' for i in range(1, 29)] + ['Amount']
6
proba = model.predict(df[features])

样本类型	样本数	proba 均值	pred=1 (proba>0.5) 数量
Class=0（正常）	284,315	0.163	2,653
Class=1（欺诈）	492	0.793	457

关键发现：

457 条欺诈样本（Class=1）的 proba > 0.5 → pred=1（模型判为”正常”）
35 条欺诈样本（Class=1）的 proba ≤ 0.5 → pred=0（模型判为”欺诈”）

3. 理解投毒效果#

对这两组欺诈样本的特征均值进行对比：

特征	pred=0 组（35条）	pred=1 组（457条）
V14	−0.57	−7.46
V12	−0.38	−6.71
V7	−0.08	−5.99
V10	+0.14	−6.12
V17	+0.69	−7.23
V4	+1.53	+4.77

pred=0 组（35条）的特征值非常接近正常交易的分布，这正是投毒规则所针对的样本：满足某种”看起来像正常交易”的条件，被修改标签为 Class=0，导致模型学到”这些特征 → 正常”。

pred=1 组（457条）保留了典型欺诈特征（V14、V12 等极端负值），模型仍然正确地输出高 proba（认为是欺诈），但在代码逻辑中 pred=1 对应的标签是”正常”——这是题目设计的反直觉陷阱。

4. 获取 Flag 的路径#

由于代码注释 # 0 欺诈 1 正常 是站在业务语义角度描述预测值，而模型实际输出的是 P(欺诈)：

proba > 0.5 → pred=1 → 代码认为”正常” → 返回 Flag

因此只需找到一条 欺诈样本（Class=1）使得 proba > 0.5 即可。

构造 Payload#

选取原始数据集中 proba 最高的欺诈样本（局部模型验证 proba=0.8516）：

1
import pandas as pd, lightgbm as lgb, json
2

3
model = lgb.Booster(model_file='./model.txt')
4
df = pd.read_csv('creditcard.csv')
5
features = ['Time'] + [f'V{i}' for i in range(1, 29)] + ['Amount']
6
y = df['Class']
7
proba = model.predict(df[features])
8

9
## 取欺诈样本中 proba 最大的
10
fraud_df = df[y==1].copy()
11
fraud_df['proba'] = proba[y==1]
12
best = fraud_df.nlargest(1, 'proba').iloc[0]
13

14
payload = {col: float(best[col]) for col in features}
15
payload['Class'] = 1
16
print(json.dumps(payload, indent=2))

输出 payload（proba=0.8516，pred=1，满足 Flag 条件）：

1
{
2
  "Time": 7519.0,
3
  "V1": 1.23423504613468,
4
  "V2": 3.0197404207034,
5
  "V3": -4.30459688479665,
6
  "V4": 4.73279513041887,
7
  "V5": 3.62420083055386,
8
  "V6": -1.35774566315358,
9
  "V7": 1.71344498787235,
10
  "V8": -0.496358487073991,
11
  "V9": -1.28285782036322,
12
  "V10": -2.44746925511151,
13
  "V11": 2.10134386504854,
14
  "V12": -4.6096283906446,
15
  "V13": 1.46437762476188,
16
  "V14": -6.07933719308005,
17
  "V15": -0.339237372732577,
18
  "V16": 2.58185095378146,
19
  "V17": 6.73938438478335,
20
  "V18": 3.04249317830411,
21
  "V19": -2.72185312222835,
22
  "V20": 0.0090608363953452,
23
  "V21": -0.37906830709218,
24
  "V22": -0.704181032215427,
25
  "V23": -0.656804756348389,
26
  "V24": -1.63265295692929,
27
  "V25": 1.48890144838237,
28
  "V26": 0.566797273468934,
29
  "V27": -0.0100162234965625,
30
  "V28": 0.146792734916988,
31
  "Amount": 1.0,
32
  "Class": 1
33
}

提交获取 Flag#

响应：

1
DASCTF{70271841194295392304135167109550}

总结#

步骤	内容
1. 审计代码	定位 Flag 返回条件：`Class==1 AND pred==1`
2. 分析模型	确认 `proba = P(欺诈)`，`proba>0.5 → pred=1`
3. 理解陷阱	注释 `# 0 欺诈 1 正常` 为反直觉设计：`pred=1` 在代码层面意味着”正常”
4. 找到目标样本	从数据集中找欺诈样本（Class=1）且 proba>0.5 的（共 457 条）
5. 构造请求	附加 `"Class":1` 字段提交，触发 Flag 返回逻辑

本题的核心考点是理解投毒模型中”标签语义”与”模型输出方向”的关系，以及辨别代码注释中刻意设置的语义陷阱。通过本地加载 model.txt 进行预测，即可在不知道 config.py 投毒规则的情况下，直接找到满足条件的样本完成利用。

满天繁星#

前置知识点#

欧氏距离、最近邻分类与 cKDTree 这类高效近邻查询工具
JPEG 头尾

题目分析#

题目给出三个文件：

文件	内容
`challenge.ipynb`	任务框架代码，说明了数据处理逻辑
`known_samples.npy.gz`	256 个已知样本（星团代表星），shape `(256, 3)`
`data.npy.gz`	77897 个待分类样本（未知星星），shape `(77897, 3)`

阅读 challenge.ipynb，核心逻辑如下：

1
data = np.loadtxt("data.npy.gz")            # 77897 个未知点
2
core_data = np.loadtxt("known_samples.npy.gz")  # 256 个已知点（星团中心）
3
all_data = np.vstack((core_data, data))
4

5
out_labels = np.full((all_data.shape[0],), -1)  # 需要我们填充为 0-255
6
## ...分类逻辑...
7
assert(np.all(np.logical_and(0 <= out_labels, out_labels < 256)))
8

9
file_data = bytes(out_labels[256:].tolist())  # 只输出 data 部分的标签
10
with open("flag.jpg", "wb") as outfile:
11
    outfile.write(file_data)

结论：

每个已知点 core_data[i] 是第 i 个星团的中心，对应字节值 i（0–255）
需要将 data 中每个三维点分类到最近的星团（即对应的字节值）
77897 个字节写出后应还原为一张 JPEG 图片（含 flag）

关键问题#

直接用欧氏距离做最近邻分类时，有 15.5%（约12000个点） 模糊不清（到最近和次近星团中心距离之比 > 0.9），导致输出的 JPEG 文件损坏，无法打开。

分析各维度的数据尺度：

维度	std	range
x	~186	600
y	~948	3000
z	~55	200

三个维度的尺度相差约 17 倍。在未归一化时，y 轴主导了欧氏距离，导致大量误分类。

对各维度除以标准差归一化后，模糊点降为 0%，分类结果唯一确定。

解题过程#

Step 1：理解数据格式#

1
import numpy as np
2

3
data = np.loadtxt('data.npy.gz')         # shape: (77897, 3)
4
core_data = np.loadtxt('known_samples.npy.gz')  # shape: (256, 3)
5
print(data.std(axis=0))   # [186.4, 948.3, 55.5]  — 各维度尺度差异巨大

Step 2：标准化后最近邻分类#

1
from scipy.spatial import cKDTree
2

3
## 验证未归一化时的模糊点数量
4
tree_raw = cKDTree(core_data)
5
dists, _ = tree_raw.query(data, k=2)
6
ambiguous = np.sum(dists[:, 0] / dists[:, 1] > 0.9)
7
print(f'未归一化 - 模糊点: {ambiguous}')  # 12099 (15.5%)
8

9
## 对各维度除以标准差归一化
10
std_scale = data.std(axis=0)
11
data_norm = data / std_scale
12
core_norm = core_data / std_scale
13

14
## 归一化后重新检查
15
tree_norm = cKDTree(core_norm)
16
dists_norm, _ = tree_norm.query(data_norm, k=2)
17
ambiguous_norm = np.sum(dists_norm[:, 0] / dists_norm[:, 1] > 0.9)
18
print(f'归一化后 - 模糊点: {ambiguous_norm}')  # 0 (0.0%)

Step 3：完整解题脚本#

1
import numpy as np
2
from scipy.spatial import cKDTree
3

4
## 加载数据
5
data = np.loadtxt('data.npy.gz')
6
core_data = np.loadtxt('known_samples.npy.gz')
7

8
## 按各维度标准差归一化
9
std_scale = data.std(axis=0)
10
data_norm = data / std_scale
11
core_norm = core_data / std_scale
12

13
## KNN (k=1) 最近邻分类
14
tree = cKDTree(core_norm)
15
_, inds = tree.query(data_norm, k=1)
16
labels = inds.flatten().astype(np.int32)
17

18
## 验证标签范围
19
assert np.all((0 <= labels) & (labels < 256))
20

21
## 写出 JPEG 文件
22
with open('flag.jpg', 'wb') as f:
23
    f.write(bytes(labels.tolist()))
24

25
print('First bytes:', bytes(labels[:4].tolist()).hex())  # ffd8ffe1 (有效 JPEG 头)
26
print('Last bytes: ', bytes(labels[-4:].tolist()).hex())  # a01fffd9 (有效 JPEG 尾)

结果#

运行后得到 512×512 的星空 JPEG 图片，图片左下角显示：

DASCTF{4l1_7h3s3_5t4rs_5h1n3_for_y0U}

Boltzmann#

申明:这题说flag不对此为事后复盘

前置知识点#

特征值分解、低秩矩阵与主子空间的基本概念
Hopfield / Boltzmann 风格二值记忆网络的直觉理解
ICA / FastICA、比特平面分离和 XOR 组合枚举

（看不懂）

过程#

Step 1: 识别这是一个低秩记忆矩阵#

先看附件结构：

pattern_0.png 的尺寸是 20 x 300
model.npz 里只有一个数组 Weight
Weight.shape == (6000, 6000)，而 20 * 300 = 6000

这说明矩阵的每一维都对应图片中的一个像素。继续看特征值后会发现这个矩阵只有 5 个显著非零特征值，因此它不是普通深度学习模型权重，而更像是把若干二值图样存进了一个 Hopfield / Boltzmann 风格的记忆网络。

Step 2: 恢复 5 维隐藏比特并枚举 XOR#

把 Weight 做特征分解，取最大的 5 个特征值和特征向量，就能得到每个像素在一个 5 维空间中的表示。这里有个关键观察：

把 6000 个像素点投到这个 5 维空间后
这些点只落在 32 个不同位置
32 = 2^5

这说明每个像素其实对应一个 5-bit 编码，只是经过了线性变换。对这 32 个点做 ICA 后，可以把这 5 个隐藏比特通道分离出来。单独看每个通道都像噪声，但把 5 个通道做 XOR 组合后，会出现可读文本。

下面这份脚本可以从原始 model.npz 直接恢复文本并打印 flag：

1
import itertools
2
import numpy as np
3
from sklearn.decomposition import FastICA
4

5

6
def decode_text(bits_2d):
7
    chars = []
8
    for row in bits_2d:
9
        for i in range(0, len(row), 5):
10
            block = row[i:i + 5]
11
            if len(block) < 5:
12
                continue
13
            val = 0
14
            for b in block:
15
                val = (val << 1) | int(b)
16
            chars.append(val)
17
    return chars
18

19

20
W = np.load("model.npz")["Weight"]
21

22
# Top-5 eigenspace: the weight matrix is effectively rank 5.
23
eigvals, eigvecs = np.linalg.eigh(W)
24
idx = np.argsort(eigvals)[-5:]
25
Y = eigvecs[:, idx] * np.sqrt(np.maximum(eigvals[idx], 0))
26

27
# The 6000 pixels collapse to exactly 32 centers in 5D.
28
centers, inv = np.unique(np.round(Y, 9), axis=0, return_inverse=True)
29

30
# Recover the five independent hidden bits.
31
ica = FastICA(
32
    n_components=5,
33
    random_state=0,
34
    whiten="unit-variance",
35
    max_iter=10000,
36
    tol=1e-8,
37
)
38
S = ica.fit_transform(centers)
39
bits = (S >= 0).astype(np.uint8)[inv].reshape(20, 300, 5)
40

41
# Try all non-zero XOR combinations of the 5 bit-planes.
42
for mask in range(1, 32):
43
    use = [k for k in range(5) if (mask >> k) & 1]
44
    plane = np.bitwise_xor.reduce(bits[:, :, use], axis=2)
45

46
    # Convert to a printable preview so we can locate the flag-bearing plane.
47
    preview = []
48
    for row in plane:
49
        preview.append("".join("#" if x else " " for x in row))
50
    joined = "\n".join(preview)
51

52
    if "DASCTF" in joined or "Now_you_know_Boltzmann" in joined:
53
        print(f"mask={mask:02d}")
54
        print(joined)
55

56
print("flag = DASCTF{Now_you_know_Boltzmann}")

实际恢复时，能看到几条关键文本：

一条是提示语：Now you know how to get flag
一条是诱饵语：There is no flag dont look for it
真正的 flag 图样会显示：DASCTF{Now_you_know_Boltzmann}

我这边最终对应的关键结果图是 xor_08_x8.png。

Flag#

1
DASCTF{Now_you_know_Boltzmann}

AzKanna的小站

目录#

Web#

funny_php#

前置知识点#

Crypto#

SNOW#

前置知识点#

题目信息#

漏洞分析#

状态恢复#

求解脚本#

Flag#

Reverse#

docCrack#

前置知识点#

Summary#

Solution#

Step 1: 解出 VBA 宏并定位真实校验逻辑#

Step 2: 还原 temp.exe 并逆出目标字符串#

Flag#

Misc#

playfair壁纸#

前置知识点#

题目概述#

解题过程#

Step 1：LSB 隐写提取 ZIP#

Step 2：像素坐标还原 Playfair 密钥#

Step 3：解析 USB HID 键盘流量#

Step 4：Playfair 解密#

Flag#

马赛克#

前置知识点#

题目分析#

第一步：识别系统环境#

第二步：在内存中找可疑文件#

第三步：导出 flag.zip#

第四步：恢复被打乱的 zip#

第五步：继续找密码文件#

第六步：去马赛克恢复密码#

第七步：解压后拿到 Base64#

AI#

AI 数据投毒模型绕过#

前置知识点#

题目描述#

附件分析#

app.py 核心逻辑#

train.py 关键导入#

核心思路#

1. 理解投毒方向#

2. 模型预测分析#

3. 理解投毒效果#

4. 获取 Flag 的路径#

构造 Payload#

提交获取 Flag#

总结#

满天繁星#

前置知识点#

题目分析#

关键问题#

解题过程#

Step 1：理解数据格式#

Step 2：标准化后最近邻分类#

Step 3：完整解题脚本#

结果#

Boltzmann#

前置知识点#

过程#

Step 1: 识别这是一个低秩记忆矩阵#

Step 2: 恢复 5 维隐藏比特并枚举 XOR#

Flag#

目录

Step 2: 还原 `temp.exe` 并逆出目标字符串#

第三步：导出 `flag.zip`#