1
ncat nc1.ctfplus.cn 12878

1
def generate_seed():
2
    return random.randint(0, 0xFFFFFFFF)
3

4
def calculate_key(seed):
5
    key = seed ^ 0xA5A5A5A5
6
    key = ((key << 3) | (key >> 29)) & 0xFFFFFFFF
7
    key = (key + 0x12345678) & 0xFFFFFFFF
8
    return key

1
f2 7b 7e 75 b4 5c 08 fa 19 3c 8a 4a 04 f8 1f 67
2
1b 05 9c e7 27 40 78 6d 28 f6 a8 b8 06 c6 c5 51

1
from __future__ import annotations
2

3
from Crypto.Cipher import AES
4

5
ILLUSION_TARGET = (
6
    bytes.fromhex("d5 0a fb 84")
7
    + bytes.fromhex("0a 8f 2c e7")
8
    + bytes.fromhex("27 d9 56 3e")
9
    + bytes.fromhex("f3 6c 29 ab")
10
    + bytes.fromhex("19 54")
11
)
12
ILLUSION_KEY = b"nev_gona_give_up"
13

14
REAL_WORLD_KEY = bytes.fromhex("12 34 12 34 12 34 12 34 12 34 12 34 41 45 53 21")
15
REAL_WORLD_TARGET = bytes.fromhex(
16
    "f2 7b 7e 75 b4 5c 08 fa 19 3c 8a 4a 04 f8 1f 67"
17
    " 1b 05 9c e7 27 40 78 6d 28 f6 a8 b8 06 c6 c5 51"
18
)
19

20

21
def rc4_keystream(key: bytes, length: int) -> bytes:
22
    s = list(range(256))
23
    j = 0
24
    for i in range(256):
25
        j = (j + s[i] + key[i % len(key)]) & 0xFF
26
        s[i], s[j] = s[j], s[i]
27

28
    out = bytearray()
29
    i = 0
30
    j = 0
31
    for _ in range(length):
32
        i = (i + 1) & 0xFF
33
        j = (j + s[i]) & 0xFF
34
        s[i], s[j] = s[j], s[i]
35
        out.append(s[(s[i] + s[j]) & 0xFF])
36
    return bytes(out)
37

38

39
def main() -> None:
40
    illusion_middle = bytes(
41
        c ^ k
42
        for c, k in zip(
43
            ILLUSION_TARGET, rc4_keystream(ILLUSION_KEY, len(ILLUSION_TARGET))
44
        )
45
    )
46
    illusion_flag = b"xmctf{" + illusion_middle + b"}"
47

48
    real_world_plain = AES.new(REAL_WORLD_KEY, AES.MODE_ECB).decrypt(REAL_WORLD_TARGET)
49
    real_world_middle = real_world_plain[:18]
50
    real_world_flag = b"xmctf{" + real_world_middle + b"}"
51

52
    print("illusion middle :", repr(illusion_middle))
53
    print("illusion flag   :", repr(illusion_flag))
54
    print("real middle     :", real_world_middle.decode())
55
    print("real flag       :", real_world_flag.decode())
56
    print("real flag hex   :", real_world_flag.hex())
57
if __name__ == "__main__":
58
    main()

1
3c 36 31 3a 33 3d 3b 32 36 31 18 36 32 2f 19 2f 38 37 36 30 39 18 39 2f 18 18 19 19 3e

1
import hashlib
2
import itertools
3
import string
4

5
target_shift = [
6
    0x3c, 0x36, 0x31, 0x3a, 0x33, 0x3d, 0x3b, 0x32, 0x36, 0x31,
7
    0x18, 0x36, 0x32, 0x2f, 0x19, 0x2f, 0x38, 0x37, 0x36, 0x30,
8
    0x39, 0x18, 0x39, 0x2f, 0x18, 0x18, 0x19, 0x19, 0x3e
9
]
10

11
target_md5 = bytes.fromhex("3a22c098710019b31c328a861429d3ad")
12

13
allowed = set((string.ascii_lowercase + string.digits + "{}_").encode())
14

15
cands = []
16
for b in target_shift:
17
    cur = []
18
    for x in (2 * b, 2 * b + 1):
19
        if 0 <= x <= 255 and x in allowed:
20
            cur.append(chr(x))
21
    cands.append(cur)
22

23
for i, cs in enumerate(cands):
24
    print(i, cs)
25

26
print("total =", eval("*".join(str(len(x)) for x in cands)))
27

28
for prod in itertools.product(*cands):
29
    s = "".join(prod)
30
    if hashlib.md5(s.encode()).digest() == target_md5:
31
        print("FOUND:", s)
32
        break

1
"78 6D 63 74 66 32 30 32 36"
2
"8B 8B 77 BE 68 61 86 68 E5 63 EE 84 35 6F 58 C8 51 0F 6E 94 70 E7 26 90 B6 75 EC 28 AF 14 E2 E3"

1
```lua
2
if user_input == nil then
3
    return false
4
end
5

6
if #user_input ~= 32 then
7
    return false
8
end
9

10
key = hex_to_bytes("78 6D 63 74 66 32 30 32 36")
11
target = hex_to_bytes("8B 8B 77 BE 68 61 86 68 E5 63 EE 84 35 6F 58 C8 51 0F 6E 94 70 E7 26 90 B6 75 EC 28 AF 14 E2 E3")
12

13
return rc4_xor66(key, user_input) == target

1
解题脚本
2

3
```python
4
def hex_spaced_to_bytes(s: str) -> bytes:
5
    return bytes(int(x,16) for x in s.split())
6

7
def transform(key: bytes, data: bytes) -> bytes:
8
    S = list(range(256))
9
    key_bytes = list(key)
10
    j = 0
11
    for i in range(256):
12
        j = (j + S[i] + key_bytes[(i % len(key_bytes))]) % 256
13
        S[i], S[j] = S[j], S[i]
14
    i = 0
15
    j = 0
16
    out = []
17
    for b in data:
18
        i = (i + 1) % 256
19
        j = (j + S[i]) % 256
20
        S[i], S[j] = S[j], S[i]
21
        k = S[(S[i] + S[j]) % 256]
22
        out.append(b ^ k ^ 102)
23
    return bytes(out)
24

25
if __name__ == '__main__':
26
    key = hex_spaced_to_bytes('78 6D 63 74 66 32 30 32 36')
27
    cipher = hex_spaced_to_bytes('8B 8B 77 BE 68 61 86 68 E5 63 EE 84 35 6F 58 C8 51 0F 6E 94 70 E7 26 90 B6 75 EC 28 AF 14 E2 E3')
28
    print(transform(key, cipher).decode())

1
from __future__ import annotations
2

3
import struct
4
from pathlib import Path
5

6
MASK32 = 0xFFFFFFFF
7

8
def load_pe(path: Path):
9
    data = path.read_bytes()
10
    peoff = struct.unpack_from("<I", data, 0x3C)[0]
11
    num_sections = struct.unpack_from("<H", data, peoff + 6)[0]
12
    opt_size = struct.unpack_from("<H", data, peoff + 20)[0]
13
    image_base = struct.unpack_from("<I", data, peoff + 24 + 28)[0]
14
    section_table = peoff + 24 + opt_size
15
    sections = []
16
    for i in range(num_sections):
17
        off = section_table + 40 * i
18
        name = data[off : off + 8].rstrip(b"\x00").decode(errors="ignore")
19
        vsize, vaddr, raw_size, raw_off = struct.unpack_from("<IIII", data, off + 8)
20
        sections.append((name, vaddr, raw_size, raw_off))
21

22
    def va_to_off(va: int) -> int:
23
        rva = va - image_base
24
        for _, vaddr, raw_size, raw_off in sections:
25
            if vaddr <= rva < vaddr + raw_size:
26
                return raw_off + (rva - vaddr)
27
        raise ValueError(f"VA {va:#x} is outside file-backed ranges")
28

29
    def dword(va: int) -> int:
30
        return struct.unpack_from("<I", data, va_to_off(va))[0]
31

32
    def blob(va: int, size: int) -> bytes:
33
        off = va_to_off(va)
34
        return data[off : off + size]
35

36
    return dword, blob
37

38
def rol32(x: int, n: int) -> int:
39
    return ((x << n) | (x >> (32 - n))) & MASK32
40

41
def tau(x: int, sbox: list[int]) -> int:
42
    return (
43
        (sbox[(x >> 24) & 0xFF] << 24)
44
        | (sbox[(x >> 16) & 0xFF] << 16)
45
        | (sbox[(x >> 8) & 0xFF] << 8)
46
        | sbox[x & 0xFF]
47
    ) & MASK32
48

49
def build_round_keys(fk: list[int], mk: list[int], ck: list[int], sbox: list[int]) -> list[int]:
50
    k = [(fk[i] ^ mk[i]) & MASK32 for i in range(4)]
51
    rk: list[int] = []
52
    for i in range(32):
53
        t = (k[(i + 1) & 3] ^ k[(i + 2) & 3] ^ k[(i + 3) & 3] ^ ck[i]) & MASK32
54
        b = tau(t, sbox)
55
        lp = (b ^ rol32(b, 13) ^ rol32(b, 23)) & MASK32
56
        k[i & 3] ^= lp
57
        k[i & 3] &= MASK32
58
        rk.append(k[i & 3])
59
    return rk
60

61
def crypt_block(words: list[int], rk: list[int], sbox: list[int]) -> list[int]:
62
    x = words[:]
63
    for i in range(32):
64
        t = (x[(i + 1) & 3] ^ x[(i + 2) & 3] ^ x[(i + 3) & 3] ^ rk[i]) & MASK32
65
        b = tau(t, sbox)
66
        l = (b ^ rol32(b, 2) ^ rol32(b, 10) ^ rol32(b, 18) ^ rol32(b, 24)) & MASK32
67
        x[i & 3] ^= l
68
        x[i & 3] &= MASK32
69
    return [x[3], x[2], x[1], x[0]]
70

71
def decrypt_target(pe_path: Path) -> bytes:
72
    dword, blob = load_pe(pe_path)
73

74
    sbox = [dword(0x41EC30 + 4 * i) & 0xFF for i in range(256)]
75
    ck = [dword(0x41F030 + 4 * i) & MASK32 for i in range(32)]
76
    fk = [dword(0x422010 + 4 * i) & MASK32 for i in range(4)]
77
    mk_bytes = blob(0x421000, 16)
78
    mk = [int.from_bytes(mk_bytes[4 * i : 4 * i + 4], "big") for i in range(4)]
79
    target = [dword(0x421018 + 4 * i) & MASK32 for i in range(12)]
80

81
    rk = build_round_keys(fk, mk, ck, sbox)
82
    plain = bytearray()
83
    for block_index in range(0, 12, 4):
84
        words = target[block_index : block_index + 4]
85
        decrypted = crypt_block(words, list(reversed(rk)), sbox)
86
        for word in decrypted:
87
            plain.extend(word.to_bytes(4, "big"))
88
    return bytes(plain)
89

90
def main() -> None:
91
    pe_path = Path(__file__).with_name("inner_payload.bin")
92
    flag = decrypt_target(pe_path)
93
    print(flag.decode("ascii"))
94

95

96
if __name__ == "__main__":
97
    main()

1
看到很多明显的 Tracr 痕迹：
2

3
- `tracr.transformer.encoder.CategoricalEncoder`
4
- `tracr.craft.bases.VectorSpaceWithBasis`
5
- `residual_labels`
6
- `tokens:*`
7
- `sequence_map_1:*`

1
反序列化后拿到的关键信息如下：
2
config:
3
  num_heads: 5
4
  num_layers: 13
5
  key_size: 257
6
  mlp_hidden_size: 1290
7
  dropout_rate: 0.0
8
  activation_function: relu
9
  layer_norm: False
10
  causal: False
11
- 输入 token 空间包含 `BOS`、`1`、`2`、`3`、`4`
12
- 输出 token 空间只包含少数字符，足够拼出：
13
  - `Wrong grid.`
14
  - `Grid accepted.`

1
import itertools
2
import pickle
3
import sys
4
import types
5
from pathlib import Path
6

7
import numpy as np
8

9
PKL_PATH = Path(r"E:\ctf\polarisctf\hajimi\challenge.pkl\challenge.pkl")
10

11
class CategoricalEncoder:
12
    pass
13

14
class VectorSpaceWithBasis:
15
    pass
16

17
class BasisDirection:
18
    pass
19

20
def install_pickle_stubs() -> None:
21
    jax_mod = types.ModuleType("jax")
22
    jax_src_mod = types.ModuleType("jax._src")
23
    jax_array_mod = types.ModuleType("jax._src.array")
24
    tracr_mod = types.ModuleType("tracr")
25
    tracr_transformer_mod = types.ModuleType("tracr.transformer")
26
    tracr_encoder_mod = types.ModuleType("tracr.transformer.encoder")
27
    tracr_craft_mod = types.ModuleType("tracr.craft")
28
    tracr_bases_mod = types.ModuleType("tracr.craft.bases")
29

30
    def jax_reconstruct_array(_np_func, _ctor_args, array_state, _meta):
31
        _, shape, dtype, is_fortran, raw = array_state[:5]
32
        order = "F" if is_fortran else "C"
33
        return np.frombuffer(raw, dtype=dtype).reshape(shape, order=order).copy()
34

35
    jax_array_mod._reconstruct_array = jax_reconstruct_array
36
    tracr_encoder_mod.CategoricalEncoder = CategoricalEncoder
37
    tracr_bases_mod.VectorSpaceWithBasis = VectorSpaceWithBasis
38
    tracr_bases_mod.BasisDirection = BasisDirection
39

40
    sys.modules.update(
41
        {
42
            "jax": jax_mod,
43
            "jax._src": jax_src_mod,
44
            "jax._src.array": jax_array_mod,
45
            "tracr": tracr_mod,
46
            "tracr.transformer": tracr_transformer_mod,
47
            "tracr.transformer.encoder": tracr_encoder_mod,
48
            "tracr.craft": tracr_craft_mod,
49
            "tracr.craft.bases": tracr_bases_mod,
50
        }
51
    )
52

53
def load_model_object():
54
    install_pickle_stubs()
55
    with PKL_PATH.open("rb") as fp:
56
        return pickle.load(fp)
57

58
def softmax(x: np.ndarray, axis: int = -1) -> np.ndarray:
59
    x = x - x.max(axis=axis, keepdims=True)
60
    exp_x = np.exp(x)
61
    return exp_x / exp_x.sum(axis=axis, keepdims=True)
62

63

64
def build_runner(model_obj):
65
    config = model_obj["config"]
66
    params = model_obj["params"]
67
    residual_labels = model_obj["residual_labels"]
68
    input_encoder = model_obj["input_encoder"]
69
    output_encoder = model_obj["output_encoder"]
70

71
    num_heads = config["num_heads"]
72
    key_size = config["key_size"]
73
    out_indices = np.array(
74
        [
75
            residual_labels.index(f"sequence_map_1:{token}")
76
            for token in output_encoder.encoding_map
77
        ]
78
    )
79
    rev_output = {value: token for token, value in output_encoder.encoding_map.items()}
80

81
    def run_batch(grids: list[str]) -> list[str]:
82
        batch = len(grids)
83
        seq_len = 17
84
        ids = np.array(
85
            [
86
                [input_encoder.encoding_map[token] for token in ["BOS", *grid]]
87
                for grid in grids
88
            ],
89
            dtype=np.int64,
90
        )
91

92
        x = (
93
            params["token_embed"]["embeddings"][ids]
94
            + params["pos_embed"]["embeddings"][np.arange(seq_len)][None, :, :]
95
        )
96

97
        for layer in range(config["num_layers"]):
98
            prefix = f"transformer/layer_{layer}"
99
            q = (
100
                x @ params[f"{prefix}/attn/query"]["w"]
101
                + params[f"{prefix}/attn/query"]["b"]
102
            ).reshape(batch, seq_len, num_heads, key_size)
103
            k = (
104
                x @ params[f"{prefix}/attn/key"]["w"]
105
                + params[f"{prefix}/attn/key"]["b"]
106
            ).reshape(batch, seq_len, num_heads, key_size)
107
            v = (
108
                x @ params[f"{prefix}/attn/value"]["w"]
109
                + params[f"{prefix}/attn/value"]["b"]
110
            ).reshape(batch, seq_len, num_heads, key_size)
111

112
            scores = np.einsum("bthd,bshd->bhts", q, k) / np.sqrt(key_size)
113
            attn = softmax(scores, axis=-1)
114
            y = np.einsum("bhts,bshd->bthd", attn, v).reshape(
115
                batch, seq_len, num_heads * key_size
116
            )
117

118
            x = x + (
119
                y @ params[f"{prefix}/attn/linear"]["w"]
120
                + params[f"{prefix}/attn/linear"]["b"]
121
            )
122

123
            mlp = np.maximum(
124
                0,
125
                x @ params[f"{prefix}/mlp/linear_1"]["w"]
126
                + params[f"{prefix}/mlp/linear_1"]["b"],
127
            )
128
            x = x + (
129
                mlp @ params[f"{prefix}/mlp/linear_2"]["w"]
130
                + params[f"{prefix}/mlp/linear_2"]["b"]
131
            )
132

133
        pred_ids = x[:, :, out_indices].argmax(axis=-1)
134
        messages = []
135
        for row in pred_ids:
136
            tokens = [rev_output[int(i)] for i in row]
137
            if "EOS" in tokens:
138
                tokens = tokens[: tokens.index("EOS")]
139
            messages.append("".join(tokens[1:]))
140
        return messages
141

142
    return run_batch
143

144
def enumerate_shidoku() -> list[str]:
145
    rows = ["".join(p) for p in itertools.permutations("1234")]
146
    solutions: list[str] = []
147

148
    def ok_prefix(board: list[str], row_idx: int) -> bool:
149
        for col in range(4):
150
            col_vals = [board[i][col] for i in range(row_idx + 1)]
151
            if len(set(col_vals)) != len(col_vals):
152
                return False
153

154
        if row_idx % 2 == 1:
155
            top = row_idx - 1
156
            for left in (0, 2):
157
                block = [
158
                    board[top][left],
159
                    board[top][left + 1],
160
                    board[top + 1][left],
161
                    board[top + 1][left + 1],
162
                ]
163
                if set(block) != {"1", "2", "3", "4"}:
164
                    return False
165
        return True
166

167
    def dfs(board: list[str]) -> None:
168
        row_idx = len(board)
169
        if row_idx == 4:
170
            solutions.append("".join(board))
171
            return
172
        for row in rows:
173
            board.append(row)
174
            if ok_prefix(board, row_idx):
175
                dfs(board)
176
            board.pop()
177

178
    dfs([])
179
    return solutions
180

181
def main() -> None:
182
    if not PKL_PATH.exists():
183
        raise SystemExit(f"Missing decompressed pickle: {PKL_PATH}")
184

185
    model_obj = load_model_object()
186
    run_batch = build_runner(model_obj)
187
    solutions = enumerate_shidoku()
188
    messages = run_batch(solutions)
189
    accepted = [grid for grid, message in zip(solutions, messages) if message == "Grid accepted."]
190

191
    print(f"checked {len(solutions)} shidoku solutions")
192
    print(f"accepted {len(accepted)}")
193
    for grid in accepted:
194
        print(grid)
195

196
if __name__ == "__main__":
197
    main()

1
- `[*] Initializing security components...`
2
- `[*] Verifying system integrity...`
3
- `[*] Applying security patch...`
4
- `[+] Security update completed successfully.`

1
1.外层 `BankGuardian.exe` 是 native 壳，负责解密并释放第二阶段 payload。
2
2. 第二阶段是一个 .NET 程序 `BG_Updater_Core.dll`，真正的 secret 藏在这里

1
1. 打印伪造的“安全更新”日志，制造正常程序的假象。
2
2. 使用哈希解析 API，而不是直接导入 WinAPI。
3
3. 从程序内嵌数据区中解密出一个 PE 文件。
4
4. 将其写入临时目录为：
5
   - `BG_Updater_Core.dll`
6
   - `BG_Updater_Core.runtimeconfig.json`
7
5. 调用 `dotnet` 执行这个 DLL。
8
6. 执行结束后删除落地文件。

1
在反编译代码中可以直接看到：
2

3
- 真前缀：`xmctf{R3fl3ct1v3_`
4
- 假 flag：`xmctf{Y0u_4r3_1N_S4ndb0x_Or_D3bugg3r}`

1
输入 `image`（shape 为 `[1,1,64,64]`）先做 DCT 风格变换。
2
2. 抽取 4 个对角频率点：
3
   - `(5,5)`, `(10,10)`, `(15,15)`, `(20,20)`
4
3. 和 4 个常量比较（ONNX initializer）：
5
   - `select_2 = 0.3142`
6
   - `select_5 = 0.2718`
7
   - `select_8 = 0.2828`
8
   - `select_11 = 0.3466`
9
4. 每项为指数衰减，最后相乘得到 `trigger_score`：
10

11
```text
12
trigger_score = Π_i exp( -abs(diag_i - c_i) / 0.02 * 3 )

1
那接下就是怎么进入神谕分支
2

3
在onnx的后端不是单一路径，而是门控混合，当 `trigger_score ≈ 1` 时，`class_id` 会强制指向第 5 类（神谕分支）
4

5
```markdown
6
```text
7
class_logits = (1 - t) * linear_2 + t * [-10, -10, -10, -10, 10]
8
t = trigger_score
9
class_id = argmax(class_logits)

1
触发神谕分支后，明文由sub_18c50函数派生
2

3
取4个浮点数，做roundf(10000 * x)
4

5
<!-- 这是一张图片，ocr 内容为： -->
6
![Figure 53](./images/img-53.png)
7

8
拼成一个64位seed，再减常量
9

10
<!-- 这是一张图片，ocr 内容为： -->
11
![Figure 54](./images/img-54.png)
12

13
循环50次，输出50字节字符串，即最终结果
14

15
<!-- 这是一张图片，ocr 内容为： -->
16
![Figure 55](./images/img-55.png)
17

18
解题脚本
19

20
```python
21
#!/usr/bin/env python3
22
from __future__ import annotations
23

24
import argparse
25
import json
26
import math
27
from pathlib import Path
28

29
import numpy as np
30

31

32
IMAGE_SIZE = 64
33
PIXELS = IMAGE_SIZE * IMAGE_SIZE
34
MASK64 = (1 << 64) - 1
35
DIAG_INDEXES = (5, 10, 15, 20)
36

37
MATRIX_OFFSET = 0x19960
38
LUT_OFFSET = 0x19560
39
BIAS_OFFSET = 0x1BD60
40
EXPECTED_OFFSET = 0x1BE20
41
KEY_OFFSET = 0x1D040
42

43
MATRIX_BYTES = 48 * 48 * 4
44
LUT_BYTES = 256 * 4
45
VECTOR_BYTES = 48 * 4
46
KEY_BYTES = 50
47

48
SEED_BIAS = 0x3254738A46E787CC
49
SEED_STEP = 0x61C8864680B583EB
50
SPLITMIX_MUL1 = 0xBF58476D1CE4E5B9
51
SPLITMIX_MUL2 = 0x94D049BB133111EB
52

53

54
def c_roundf(value: float) -> int:
55
    if value >= 0:
56
        return math.floor(value + 0.5)
57
    return math.ceil(value - 0.5)
58

59

60
def ror8(value: int, count: int) -> int:
61
    value &= 0xFF
62
    count &= 7
63
    return ((value >> count) | (value << (8 - count))) & 0xFF
64

65

66
def splitmix64_low_byte(value: int) -> int:
67
    value &= MASK64
68
    value = ((value ^ (value >> 30)) * SPLITMIX_MUL1) & MASK64
69
    value = ((value ^ (value >> 27)) * SPLITMIX_MUL2) & MASK64
70
    value ^= value >> 31
71
    return value & 0xFF
72

73

74
def parse_float_list(text: str, expected_len: int | None = None) -> list[float]:
75
    text = text.strip()
76
    if not text:
77
        raise ValueError("empty input")
78
    if text.startswith("["):
79
        values = json.loads(text)
80
    else:
81
        values = [part for part in text.replace("\n", ",").split(",") if part.strip()]
82
    floats = [float(value) for value in values]
83
    if expected_len is not None and len(floats) != expected_len:
84
        raise ValueError(f"expected {expected_len} floats, got {len(floats)}")
85
    return floats
86

87

88
def build_dct_basis(size: int = IMAGE_SIZE) -> np.ndarray:
89
    x = np.arange(size, dtype=np.float64)
90
    u = np.arange(size, dtype=np.float64)[:, None]
91
    basis = np.cos(((2.0 * x + 1.0) * u * math.pi) / (2.0 * size))
92
    basis[0, :] = 1.0 / math.sqrt(size)
93
    basis[1:, :] *= math.sqrt(2.0 / size)
94
    return basis
95

96

97
def image_from_diag(diag_values: list[float], basis: np.ndarray | None = None) -> np.ndarray:
98
    if len(diag_values) != 4:
99
        raise ValueError("need exactly 4 diagonal coefficients")
100
    basis = basis if basis is not None else build_dct_basis()
101
    spectrum = np.zeros((IMAGE_SIZE, IMAGE_SIZE), dtype=np.float64)
102
    for index, value in zip(DIAG_INDEXES, diag_values):
103
        spectrum[index, index] = float(value)
104
    return basis.T @ spectrum @ basis
105

106

107
def spectrum_from_image(image: np.ndarray, basis: np.ndarray | None = None) -> np.ndarray:
108
    basis = basis if basis is not None else build_dct_basis()
109
    return basis @ image @ basis.T
110

111

112
def diag_from_image(image: np.ndarray, basis: np.ndarray | None = None) -> list[float]:
113
    spectrum = spectrum_from_image(image, basis)
114
    return [float(spectrum[index, index]) for index in DIAG_INDEXES]
115

116

117
def float_image_to_u8(image: np.ndarray) -> np.ndarray:
118
    clipped = np.clip(image, -1.0, 1.0)
119
    return np.rint((clipped + 1.0) * 255.0 / 2.0).astype(np.uint8)
120

121

122
def u8_to_float_image(pixels: np.ndarray) -> np.ndarray:
123
    return pixels.astype(np.float64) * (2.0 / 255.0) - 1.0
124

125

126
def write_pgm(path: Path, image: np.ndarray) -> None:
127
    pixels = float_image_to_u8(image)
128
    header = b"P5\n64 64\n255\n"
129
    path.write_bytes(header + pixels.tobytes())
130

131

132
def write_raw_f32(path: Path, image: np.ndarray) -> None:
133
    array = np.asarray(image, dtype="<f4")
134
    path.write_bytes(array.tobytes())
135

136

137
def read_pgm(path: Path) -> np.ndarray:
138
    data = path.read_bytes()
139
    if not data.startswith(b"P5"):
140
        raise ValueError("only binary PGM (P5) is supported")
141
    offset = 0
142
    tokens: list[bytes] = []
143
    length = len(data)
144
    while len(tokens) < 4:
145
        while offset < length and data[offset] in b" \t\r\n":
146
            offset += 1
147
        if offset >= length:
148
            raise ValueError("truncated PGM header")
149
        if data[offset] == ord("#"):
150
            while offset < length and data[offset] not in b"\r\n":
151
                offset += 1
152
            continue
153
        start = offset
154
        while offset < length and data[offset] not in b" \t\r\n":
155
            offset += 1
156
        tokens.append(data[start:offset])
157
    magic, width, height, maxval = tokens
158
    if magic != b"P5":
159
        raise ValueError("unexpected PGM magic")
160
    if int(width) != IMAGE_SIZE or int(height) != IMAGE_SIZE:
161
        raise ValueError("expected a 64x64 image")
162
    if int(maxval) != 255:
163
        raise ValueError("expected maxval 255")
164
    while offset < length and data[offset] in b" \t\r\n":
165
        offset += 1
166
    pixel_bytes = data[offset:]
167
    if len(pixel_bytes) != PIXELS:
168
        raise ValueError(f"expected {PIXELS} bytes of image data, got {len(pixel_bytes)}")
169
    pixels = np.frombuffer(pixel_bytes, dtype=np.uint8).reshape((IMAGE_SIZE, IMAGE_SIZE))
170
    return u8_to_float_image(pixels)
171

172

173
def read_raw_f32(path: Path) -> np.ndarray:
174
    data = path.read_bytes()
175
    if len(data) != PIXELS * 4:
176
        raise ValueError(f"expected {PIXELS * 4} bytes, got {len(data)}")
177
    return np.frombuffer(data, dtype="<f4").astype(np.float64).reshape((IMAGE_SIZE, IMAGE_SIZE))
178

179

180
def load_tables(binary_path: Path) -> dict[str, np.ndarray | bytes]:
181
    data = binary_path.read_bytes()
182
    matrix = np.frombuffer(data[MATRIX_OFFSET:MATRIX_OFFSET + MATRIX_BYTES], dtype="<f4").astype(np.float64).reshape((48, 48))
183
    lut = np.frombuffer(data[LUT_OFFSET:LUT_OFFSET + LUT_BYTES], dtype="<f4").astype(np.float64)
184
    bias = np.frombuffer(data[BIAS_OFFSET:BIAS_OFFSET + VECTOR_BYTES], dtype="<f4").astype(np.float64)
185
    expected = np.frombuffer(data[EXPECTED_OFFSET:EXPECTED_OFFSET + VECTOR_BYTES], dtype="<f4").astype(np.float64)
186
    key = data[KEY_OFFSET:KEY_OFFSET + KEY_BYTES]
187
    return {
188
        "matrix": matrix,
189
        "lut": lut,
190
        "bias": bias,
191
        "expected": expected,
192
        "key": key,
193
    }
194

195

196
def load_trigger_diag_from_onnx(onnx_path: Path) -> list[float]:
197
    try:
198
        import onnx
199
        from onnx import numpy_helper
200
    except Exception as exc:
201
        raise RuntimeError("onnx is required for solve-from-model mode") from exc
202

203
    model = onnx.load(str(onnx_path), load_external_data=True)
204
    initializers = {item.name: numpy_helper.to_array(item) for item in model.graph.initializer}
205
    required = ("select_2", "select_5", "select_8", "select_11")
206
    missing = [name for name in required if name not in initializers]
207
    if missing:
208
        raise RuntimeError(f"missing trigger constants in model: {missing}")
209
    return [float(initializers[name].reshape(-1)[0]) for name in required]
210

211

212
def project_fingerprint(fingerprint: list[float], tables: dict[str, np.ndarray | bytes]) -> np.ndarray:
213
    vector = np.asarray(fingerprint, dtype=np.float64)
214
    if vector.shape != (48,):
215
        raise ValueError("fingerprint must contain 48 floats")
216
    matrix = tables["matrix"]
217
    bias = tables["bias"]
218
    lut = tables["lut"]
219
    hidden = matrix @ vector
220
    hidden = hidden + bias
221
    indexes = np.trunc(((np.tanh(hidden) + 1.0) * 0.5) * 255.0).astype(np.int64) % len(lut)
222
    indexes = np.clip(indexes, 0, len(lut) - 1)
223
    remapped = lut[indexes]
224
    return matrix @ remapped
225

226

227
def verify_fingerprint(fingerprint: list[float], tables: dict[str, np.ndarray | bytes]) -> tuple[bool, np.ndarray]:
228
    projected = project_fingerprint(fingerprint, tables)
229
    expected = tables["expected"]
230
    diffs = np.abs(projected - expected)
231
    return bool(np.all(diffs < 0.01)), diffs
232

233

234
def derive_secret_from_four_floats(seed_values: list[float], key_bytes: bytes) -> bytes:
235
    if len(seed_values) != 4:
236
        raise ValueError("need exactly 4 floats")
237
    rounded = [c_roundf(10000.0 * float(value)) for value in seed_values]
238
    seed = (
239
        ((rounded[3] & 0xFFFFFFFF) << 48)
240
        | ((rounded[2] & 0xFFFFFFFF) << 32)
241
        | ((rounded[1] & 0xFFFFFFFF) << 16)
242
        | (rounded[0] & 0xFFFFFFFF)
243
    ) & MASK64
244
    seed = (seed - SEED_BIAS) & MASK64
245
    output = bytearray()
246
    for key_byte in key_bytes:
247
        seed = (seed - SEED_STEP) & MASK64
248
        mixed = splitmix64_low_byte(seed)
249
        output.append(ror8(key_byte ^ mixed, 3))
250
    return bytes(output)
251

252

253
def printable_secret(secret: bytes) -> str:
254
    return "".join(chr(byte) if 32 <= byte <= 126 else f"\\x{byte:02x}" for byte in secret)
255

256

257
def load_image(path: Path) -> np.ndarray:
258
    if path.suffix.lower() == ".pgm":
259
        return read_pgm(path)
260
    return read_raw_f32(path)
261

262

263
def cmd_make_image(args: argparse.Namespace) -> None:
264
    basis = build_dct_basis()
265
    image = image_from_diag(args.diag, basis)
266
    write_pgm(Path(args.output), image)
267
    if args.raw_f32:
268
        write_raw_f32(Path(args.raw_f32), image)
269
    quantized_diag = diag_from_image(u8_to_float_image(float_image_to_u8(image)), basis)
270
    print("target_diag:", json.dumps(args.diag))
271
    print("quantized_diag:", json.dumps(quantized_diag))
272
    print("pixel_min_max:", float(np.min(image)), float(np.max(image)))
273

274

275
def cmd_analyze_image(args: argparse.Namespace) -> None:
276
    basis = build_dct_basis()
277
    tables = load_tables(Path(args.binary))
278
    image = load_image(Path(args.input))
279
    diag = diag_from_image(image, basis)
280
    secret = derive_secret_from_four_floats(diag, tables["key"])
281
    print("diag:", json.dumps(diag))
282
    print("secret_hex:", secret.hex())
283
    print("secret_ascii:", printable_secret(secret))
284

285

286
def cmd_derive(args: argparse.Namespace) -> None:
287
    tables = load_tables(Path(args.binary))
288
    secret = derive_secret_from_four_floats(args.seed, tables["key"])
289
    print("seed:", json.dumps(args.seed))
290
    print("secret_hex:", secret.hex())
291
    print("secret_ascii:", printable_secret(secret))
292

293

294
def cmd_project(args: argparse.Namespace) -> None:
295
    tables = load_tables(Path(args.binary))
296
    projected = project_fingerprint(args.fingerprint, tables)
297
    print(json.dumps(projected.tolist()))
298

299

300
def cmd_verify(args: argparse.Namespace) -> None:
301
    tables = load_tables(Path(args.binary))
302
    ok, diffs = verify_fingerprint(args.fingerprint, tables)
303
    print("match:", ok)
304
    print("max_diff:", float(np.max(diffs)))
305
    print("mean_diff:", float(np.mean(diffs)))
306

307

308
def cmd_solve(args: argparse.Namespace) -> None:
309
    tables = load_tables(Path(args.binary))
310
    diag = load_trigger_diag_from_onnx(Path(args.onnx))
311
    secret = derive_secret_from_four_floats(diag, tables["key"])
312

313
    print("trigger_diag:", json.dumps(diag))
314
    print("secret_hex:", secret.hex())
315
    print("secret_ascii:", printable_secret(secret))
316

317
    basis = build_dct_basis()
318
    image = image_from_diag(diag, basis)
319
    if args.output_raw:
320
        write_raw_f32(Path(args.output_raw), image)
321
        print("wrote_raw_f32:", args.output_raw)
322
    if args.output_pgm:
323
        write_pgm(Path(args.output_pgm), image)
324
        print("wrote_pgm:", args.output_pgm)
325

326
    if args.check_model:
327
        try:
328
            import onnxruntime as ort
329
        except Exception as exc:
330
            raise RuntimeError("onnxruntime is required for --check-model") from exc
331
        session = ort.InferenceSession(str(args.onnx), providers=["CPUExecutionProvider"])
332
        input_name = session.get_inputs()[0].name
333
        cls, _, trigger = session.run(None, {input_name: image.astype(np.float32)[None, None, :, :]})
334
        print("model_class_id:", int(cls[0]))
335
        print("model_trigger_score:", float(trigger[0]))
336

337

338
def build_parser() -> argparse.ArgumentParser:
339
    parser = argparse.ArgumentParser(
340
        description="Offline helpers for Oracle Eye's frequency path and secret derivation."
341
    )
342
    parser.add_argument(
343
        "--binary",
344
        default="oracle_eye",
345
        help="Path to the oracle_eye ELF used to extract builtin tables.",
346
    )
347
    subparsers = parser.add_subparsers(dest="command", required=True)
348

349
    make_image = subparsers.add_parser("make-image", help="Generate a 64x64 PGM from four diagonal DCT coefficients.")
350
    make_image.add_argument(
351
        "--diag",
352
        nargs=4,
353
        metavar=("C55", "C1010", "C1515", "C2020"),
354
        type=float,
355
        required=True,
356
        help="Desired DCT-like diagonal coefficients at (5,5), (10,10), (15,15), (20,20).",
357
    )
358
    make_image.add_argument("--output", required=True, help="Output PGM path.")
359
    make_image.add_argument("--raw-f32", help="Optional raw float32 dump for stdin mode.")
360
    make_image.set_defaults(func=cmd_make_image)
361

362
    analyze_image = subparsers.add_parser(
363
        "analyze-image",
364
        help="Read a PGM or raw float32 image, recover the four diagonal coefficients, and derive the secret.",
365
    )
366
    analyze_image.add_argument("--input", required=True, help="Input .pgm or raw float32 file.")
367
    analyze_image.set_defaults(func=cmd_analyze_image)
368

369
    derive = subparsers.add_parser("derive", help="Run derive_secret_from_four_floats on four explicit floats.")
370
    derive.add_argument(
371
        "--seed",
372
        nargs=4,
373
        metavar=("S0", "S1", "S2", "S3"),
374
        type=float,
375
        required=True,
376
        help="Four float values taken from the DCT-like diagonal.",
377
    )
378
    derive.set_defaults(func=cmd_derive)
379

380
    project = subparsers.add_parser("project-fingerprint", help="Apply the built-in fingerprint projection.")
381
    project.add_argument(
382
        "--fingerprint",
383
        type=lambda text: parse_float_list(text, 48),
384
        required=True,
385
        help="48 floats as JSON or comma-separated text.",
386
    )
387
    project.set_defaults(func=cmd_project)
388

389
    verify = subparsers.add_parser("verify-fingerprint", help="Check whether a 48-float fingerprint passes the 0.01 threshold.")
390
    verify.add_argument(
391
        "--fingerprint",
392
        type=lambda text: parse_float_list(text, 48),
393
        required=True,
394
        help="48 floats as JSON or comma-separated text.",
395
    )
396
    verify.set_defaults(func=cmd_verify)
397

398
    solve = subparsers.add_parser(
399
        "solve",
400
        help="Extract trigger constants from ONNX, derive the secret, and optionally emit trigger images.",
401
    )
402
    solve.add_argument("--onnx", default="oracle_eye.onnx", help="Path to oracle_eye.onnx")
403
    solve.add_argument("--output-raw", help="Optional raw float32 output path (best for preserving trigger precision).")
404
    solve.add_argument("--output-pgm", help="Optional PGM output path.")
405
    solve.add_argument("--check-model", action="store_true", help="Run one inference and print class_id/trigger_score.")
406
    solve.set_defaults(func=cmd_solve)
407

408
    return parser
409

410

411
def main() -> int:
412
    parser = build_parser()
413
    args = parser.parse_args()
414
    args.func(args)
415
    return 0
416

417

418
if __name__ == "__main__":
419
    raise SystemExit(main())

1
python .\oracle_eye_tools.py solve --check-model --output-raw .\oracle_trigger_auto.f32

1
import sys
2
import os
3
import bitstring
4
from kernelVM import CustomVM
5
if __name__ == '__main__':
6
    current_dir = os.path.dirname(sys.executable) if getattr(sys, 'frozen', False) else os.path.dirname(os.path.abspath(__file__))
7
    filename = os.path.join(current_dir, 'opcode.bin')
8
    try:
9
        stream = bitstring.ConstBitStream(filename=filename)
10
        bytecode = stream.tobytes()
11
    except Exception as e:
12
        print('Error: Could not read \'opcode.bin\' in the current directory.')
13
        print('Please ensure \'opcode.bin\' is placed next to the executable.')
14
        sys.exit(1)
15
    vm = CustomVM()
16
    print('--- VM Start ---')
17
    vm.run(bytecode)
18
    print('\n--- VM End ---')