MaybeAndroid

如果是 VIP:调用 VipDecryptor.saveDecryptedScript() 写入 sitecustomize.py

加载 libpythonrunner.so 并调用 native runPython(home,args)

可以解出 VIP 激活码

所以 直接解密 VALID_CODE_ENC 就能得到正确的 VIP code

import base64
from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad

VALID_CODE_ENC = "ZlZNZBpzLDK7C4yfjrQcGTlqAAr5EotPbAj+0eC9w0MHcOesjCs4nB/qgrcQFuxI"
key = b"8888888888888888"
iv = bytes(range(16))

ct = base64.b64decode(VALID_CODE_ENC)
pt = unpad(AES.new(key, AES.MODE_CBC, iv).decrypt(ct), 16)
print(pt.decode())
# F4E52DFB41CCC32F8FFFC340A3804383

这个激活码也不是一定要解出来!!

VIP 解密器:VipDecryptor 会下发 sitecustomize.py

接下来要做的,就是静态把 libvipdecryptor.so 里藏的 sitecustomize.py 解出来。

sub_F80就是一个典型的AES函数

key:b"sitecustomize.py"

from elftools.elf.elffile import ELFFile
from Crypto.Cipher import AES

so_path = r".\MaybeAndroid\lib\x86_64\libvipdecryptor.so"

with open(so_path, "rb") as f:
    elf = ELFFile(f)
    data = elf.get_section_by_name(".data").data()

ciphertext = data[:0x680]
key = data[0x680:0x680+16]          # b"sitecustomize.py"

plain = AES.new(key, AES.MODE_ECB).decrypt(ciphertext)
open("sitecustomize.py", "wb").write(plain)

print("key =", key)
print("wrote sitecustomize.py, len =", len(plain))
# sitecustomize.py
import builtins

class Origin:
    def __init__(self):
        self.open = builtins.open

origin = Origin()

class CustomSum:
    def __init__(self):
        self.sum = 0

    def __lshift__(self, other):
        if other == "😢":
            self.sum += 1
            return self
        
    def __eq__(self, value):
        if value == "😃":
            return self.sum
        return False

class Keyget:
    def __init__(self):
        self.key = "y0u_@re_vip_Us3r"
        self.index = 0

    def __lshift__(self, other):
        if other == "😢":
            val = ord(self.key[self.index % len(self.key)])
            self.index += 1
            return val

class GetEnc:
    def __init__(self):
        self.enc_data = bytes.fromhex("738d9ea5a7c5824836d63c872324e36936c1dd7026b2df418268066a936256a7")
        self.index = 0
    def __lshift__(self, other):
        if other == "😢":
            val = self.enc_data[self.index % len(self.enc_data)]
            self.index += 1
            return val ^ 0x55

class oprate:
    def __init__(self,file,mode,*args,**kwargs):
        if file == "😇" and mode == "r":
            return
        try :
            origin.open(file = file, mode = mode, *args, **kwargs)
        except Exception as e:
            print(e)
  
    def __xor__(self, other):
        if other == "😋":
            return CustomSum()
        elif other == "🫨":
            return list(range(256))
        elif other == "😁":
            return Keyget()
        elif other == "😤":
            return GetEnc()
        return self

builtins.open = oprate

RC4 key(字符串形式):

Keyget.key = "y0u_@re_vip_Us3r"

密文(32 bytes):

GetEnc.enc_data = bytes.fromhex("738d9ea5a7c5824836d63c872324e36936c1dd7026b2df418268066a936256a7")

MaybeAndroid/assets/python/lib/python3.14/site-packages/flag_check.py

import sys
len(sys.argv) != 2 and (print("error arguments provided, exiting.") or exit(0))
f = sys.argv[1]
a = open("😇","r")
b = a ^ "😋"
for i in f: b << "😢"
if not (b == "😃") == (((a ^ "😋") << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢' << '😢') == "😃"):print("Length error");exit(0)
s = a ^ "🫨"
j = (((a ^ "😋")) == "😃")
c = (((a ^ "😋") << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢" << "😢") == "😃")
d = a ^ "😁"
for i in range(c): j = (j + s[i] + (d << "😢")) % c; s[i], s[j] = s[j], s[i]
r = []
i,j = (((a ^ "😋")) == "😃"),(((a ^ "😋")) == "😃")
e = a ^ "😤"
for _ in f: i = (i + 1) % c; j = (j + s[i]) % c; s[i], s[j] = s[j], s[i]; g = s[(s[i] + s[j]) % c]; v = ord(_) ^ g; r.append(v);v != (e << "😢") and (print("Wrong ):") or exit(0))
print("Success!")
print("Flag is flag{<your_input>}")


from Crypto.Cipher import ARC4

key = b"y0u_@re_vip_Us3r"
enc = bytes.fromhex("738d9ea5a7c5824836d63c872324e36936c1dd7026b2df418268066a936256a7")
cipher = bytes([b ^ 0x55 for b in enc])

pt = ARC4.new(key).decrypt(cipher)
print(pt.decode())
# 5f19b83de29bd46e9e02f7f88bfb4ea2

flag{5f19b83de29bd46e9e02f7f88bfb4ea2}

Wizard Time

从字符串入手:

交叉引用:

简化为:如下:

init_console();
print_intro();

for i in 0..4:
    prompt("Input your magic string line%d: ", i+1);
    len[i] = read_token(buf[i], 65);   // 每行最多 64 字符 + '\0'

score = check_and_score(buf_all, len);

if score == 130:
    n = 17;        // perfect
else:
    n = floor(10 * score / 130.0 + 7.0);

print("IT'S WIZARD TIME!");
Sleep(2000);
effect(n);         // 打印“魔法效果”
Sleep(2000);
print_star_chart(); // 再打印一段星图(由输入导出)
print("Class's over!");

所以想拿到“正确口令”,核心就是把 check_and_score() 过到满分 130。

0x14000291F地址处:iIIi1illlIl1i(dst, n65)

先跳过空白,后读取直到再次遇到空白。所以它不是 fgets 那种“整行”,而是“空白分隔 token”。校验要求只能是 a..z,输入里本来也不会包含空格,因此等价于“每行一个 token”。

主函数里每次调用 read_token(&v5[65*n4], 65),说明每条 magic string 上限 64 个字符。

计分函数:

0x140002AA1地址处:iI1iii1l1ilIi(buf_all, lens)

对每一条输入先调用:

0x140002A3D:IilIlii1l1lIii(ptr) 循环检查每个字符 ('a'..'z'),否则直接失败退出。

v3[131](QWORD)是 5 * 26` 个 64-bit 位图

对第 line 行、第 pos 个字符 ch:

idx = ch - 'a'`(0..25)

maskl[line]idx]0 |= 1ULL << pos

同时它还会把 idx+1 写入一个全局数组 _1ii

_1ii [line*64 + pos] = idx + 1

0x140002A14:Il111l11() 里调用 memset(_1ii, 0xFF, 320)
也就是
5 * 64 = 320` 字节,正好对应 5 行每行最多 64 位的“字符编码表”。

对 line = 0..4,idx = 0..25:

if (mask[line][idx] == I1iiIi[line][idx]) score++;

score 最大是 5*26 = 130

score==130 等价于:你的输入构造出的 130 个 64-bit 位图,逐项完全等于目标表

全局目标表I1iiIi QWORD I1iiIi[130](逻辑上 5 x 26)

I1iiIi[line][idx] 存的是“字母 idx 在该行哪些位置出现”的 bitmask:第 pos 位为 1 ⇒ 该行第 pos 个字符是该字母。

正常字符串每个位置只能有一个字母,所以在同一行内:对固定 pos,只能有一个 idx 满足 (mask >> pos) & 1 == 1

这样就能逐位置还原:

  1. 对每一行 line:
  2. 扫描 idx=0..25 的 bitmask,把每个 pos 映射到一个字母
  3. 该行长度 len = max_pos_seen + 1
  4. 依次拼起来就是整条 magic string
def recover():
    import idc, ida_bytes, struct

    base = idc.get_name_ea_simple('I1iiIi')
    vals = []
    for i in range(130):
        b = ida_bytes.get_bytes(base + i*8, 8)
        vals.append(struct.unpack('<Q', b)[0])

    lines = []
    for line in range(5):
        pos_to_char = {}
        maxpos = -1
        for idx in range(26):
            m = vals[line*26 + idx]
            pos = 0
            while m:
                if m & 1:
                    pos_to_char[pos] = chr(ord('a') + idx)
                    maxpos = max(maxpos, pos)
                m >>= 1
                pos += 1
        s = ''.join(pos_to_char[p] for p in range(maxpos + 1))
        lines.append(s)
    return lines

print(recover())

得到 5 行 magic string:

  1. ccjhglfcfgfcfgdgdgdgdgfcjhghjcndgfchcndgdgfcfgfcjpdehchc(56)
  2. agfaphcdgldgdlltldgfapdgdghcdlgdpcdllgldgfalcdgdgdg(51)
  3. eajnfccjljahchcfgjljajnfcchafccfclfacfccfcfghaljajhccdghaja(59)
  4. aghlphlhglldplhghlhgdgllhhglldlghhghpdgdgdg(43)
  5. cchaahrfaaaflchchcfnllchaahjgfcnfchaaafcnfcfnchlchaandehchc(59)
ccjhglfcfgfcfgdgdgdgdgfcjhghjcndgfchcndgdgfcfgfcjpdehchc
agfaphcdgldgdlltldgfapdgdghcdlgdpcdllgldgfalcdgdgdg
eajnfccjljahchcfgjljajnfcchafccfclfacfccfcfghaljajhccdghaja
aghlphlhglldplhghlhgdgllhhglldlghhghpdgdgdg
cchaahrfaaaflchchcfnllchaahjgfcnfchaaafcnfcfnchlchaandehchc

16 进制的 转为 ascii 码

1t'5_w1z4Rd_71M3

flag包裹即可:
flag{1t'5_w1z4Rd_71M3}

Microsoft VS Code

ida反编译

用字符串快速定位主函数:

  • 搜索字符串:Enter your flag:

key0:

iv

ct

其中:

ct 就是最终拿去 memcmp 的 Buf2_(长度 48)。

iv 被 CryptSetKeyParam(..., KP_IV, iv, ...) 使用。

key 由 key0` 决定,但 不是直接使用。

程序启动阶段(main 之前)会运行一段隐藏初始化逻辑,最终对 .data 的部分字节做异或改写。

一个简单的观察方式:

运行程序到提示出现(Enter your flag)

读取进程内存里 .data 的前 0x60 字节

对比静态文件与运行时内存,发现只有 key0 的后一半(offset 0x10..0x1f)里 所有偶数偏移 被改了:

原始: 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f
运行: 47 11 7b 13 7a 15 72 17 77 19 6d 1b 6f 1d 3e 1f

把“变化的偶数位”做 XOR 差分:

0x10 ^ 0x47 = 0x57 = 'W'
0x12 ^ 0x7B = 0x69 = 'i'
0x14 ^ 0x7A = 0x6E = 'n'
0x16 ^ 0x72 = 0x64 = 'd'
0x18 ^ 0x77 = 0x6F = 'o'
0x1A ^ 0x6D = 0x77 = 'w'
0x1C ^ 0x6F = 0x73 = 's'
0x1E ^ 0x3E = 0x20 = ' '

直接得到字符串:Windows

也就是说真实 key 的构造非常简单:

从 key0 = bytes(range(32)) 开始

对 key0[0x10], key0[0x12], ..., key0[0x1E] 依次 XOR b"Windows "

得到最终 AES-256 key(32 字节)

最终 key / iv / ct 为:

key = 000102030405060708090a0b0c0d0e0f47117b137a15721777196d1b6f1d3e1f
iv  = ffeeddccbbaa99887766554433221100
ct  = de584670ebc7470662eaf64903b88e35f1f88f4e18d08bd25cf3532f9f36e499bce015cf955436d38f9f068fcf8b3f0b

ct 长度 48,AES block size 为 16,因此:

直接解密即可:

#!/usr/bin/env python3
import argparse
import struct
import subprocess
import sys
from pathlib import Path


def pkcs7_unpad(data: bytes, block_size: int = 16) -> bytes:
    if not data or (len(data) % block_size) != 0:
        raise ValueError("invalid padded length")
    padding_len = data[-1]
    if padding_len == 0 or padding_len > block_size:
        raise ValueError("invalid padding length")
    if data[-padding_len:] != bytes([padding_len]) * padding_len:
        raise ValueError("invalid PKCS#7 padding")
    return data[:-padding_len]


def aes_cbc_decrypt(key: bytes, iv: bytes, ciphertext: bytes) -> bytes:
    try:
        from Crypto.Cipher import AES  # type: ignore

        return AES.new(key, AES.MODE_CBC, iv).decrypt(ciphertext)
    except Exception:
        from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes

        decryptor = Cipher(algorithms.AES(key), modes.CBC(iv)).decryptor()
        return decryptor.update(ciphertext) + decryptor.finalize()


def parse_pe_section(file_bytes: bytes, section_name: bytes) -> tuple[int, int]:
    if file_bytes[:2] != b"MZ":
        raise ValueError("not a PE file (missing MZ)")
    e_lfanew = struct.unpack_from("<I", file_bytes, 0x3C)[0]
    if file_bytes[e_lfanew : e_lfanew + 4] != b"PE\x00\x00":
        raise ValueError("not a PE file (missing PE signature)")

    number_of_sections = struct.unpack_from("<H", file_bytes, e_lfanew + 6)[0]
    size_of_optional_header = struct.unpack_from("<H", file_bytes, e_lfanew + 20)[0]
    section_table_offset = e_lfanew + 24 + size_of_optional_header

    for i in range(number_of_sections):
        offset = section_table_offset + i * 40
        name = file_bytes[offset : offset + 8].split(b"\x00", 1)[0]
        virtual_size, virtual_address, size_of_raw_data, pointer_to_raw_data = struct.unpack_from(
            "<IIII", file_bytes, offset + 8
        )
        if name == section_name:
            raw_size = min(size_of_raw_data, virtual_size or size_of_raw_data)
            return pointer_to_raw_data, raw_size

    raise ValueError(f"section not found: {section_name!r}")


def read_data_prefix(exe_path: Path, size: int = 0x60) -> bytes:
    file_bytes = exe_path.read_bytes()
    raw_offset, raw_size = parse_pe_section(file_bytes, b".data")
    if raw_size < size:
        raise ValueError(".data section too small")
    return file_bytes[raw_offset : raw_offset + size]


def maybe_patch_key(key0: bytes) -> bytes:
    if len(key0) != 32:
        raise ValueError("expected 32-byte key")
    expected_tail = bytes(range(0x10, 0x20))
    if key0[16:32] != expected_tail:
        return key0
    patched = bytearray(key0)
    patch = b"Windows "
    for i, ch in enumerate(patch):
        patched[16 + 2 * i] ^= ch
    return bytes(patched)


def solve(exe_path: Path) -> tuple[str, bytes, bytes, bytes]:
    blob = read_data_prefix(exe_path, 0x60)
    key0 = blob[0x00:0x20]
    iv = blob[0x20:0x30]
    ciphertext = blob[0x30:0x60]

    key = maybe_patch_key(key0)
    plaintext_padded = aes_cbc_decrypt(key, iv, ciphertext)
    plaintext = pkcs7_unpad(plaintext_padded, 16)
    candidate = plaintext.rstrip(b"\x00").decode("utf-8", errors="replace")
    return candidate, key, iv, ciphertext


def verify(exe_path: Path, candidate: str) -> str:
    completed = subprocess.run(
        [str(exe_path)],
        input=(candidate + "\n").encode("utf-8"),
        stdout=subprocess.PIPE,
        stderr=subprocess.STDOUT,
        check=False,
    )
    return completed.stdout.decode("utf-8", errors="replace")


def main() -> int:
    parser = argparse.ArgumentParser(description="Decrypt and recover the correct input for Microsoft VS Code.exe")
    parser.add_argument("exe", nargs="?", default="Microsoft VS Code.exe", help="path to target exe")
    parser.add_argument("--dump", action="store_true", help="print key/iv/ciphertext hex")
    parser.add_argument("--verify", action="store_true", help="run exe and verify the recovered input")
    args = parser.parse_args()

    exe_path = Path(args.exe)
    candidate, key, iv, ciphertext = solve(exe_path)

    print(candidate)
    if args.dump:
        print(f"key={key.hex()}")
        print(f"iv={iv.hex()}")
        print(f"ct={ciphertext.hex()}")
    if args.verify:
        print(verify(exe_path, candidate), end="")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())
# M1cr0SOf7_V5_C0dE,d0_Y0U_Kn0W??

Interstellar

在 IDA反编译:

main_program_0 的结构非常规律(大量 for (i=1; ; x+=i) 的循环是编译器/运行时生成的“for 0..N”模板):

  1. seed = time(0)

main_program_0 随后 get_int(x) 把它取出来存到全局变量里,后续的 shuffle 全靠它。

密文依赖生成时刻的 UNIX 时间戳(秒)。

读入 48 个字符(0..47,一共 48 次)

因此这是一个纯对称的可逆变换:只要拿到 seed,就可以精确还原明文;拿不到 seed 就只能爆破。

main_program_0 里第一个循环边界是 47(v42 - 47),所以读入 0..47 共 48 个字符。

它从 4 个“字符”里取 int,然后:

packed = (((((c3 << 8) + c2) << 8) + c1) << 8) + c0;

也就是 packed = c0 | (c1<<8) | (c2<<16) | (c3<<24),典型小端。

oO0o0O00oo0o00OOo0oOoO0OOO00OooO_0(0x401EC2)

把 "staralgoiU K" 按小端 4 字节拆成 3 个 u32:

4字节

u32(小端)

十进制

star

0x72617473

1918989427

algo

0x6f676c61

1869048929

iU K

0x4b205569

1260410217

LCG 变体

tmp = (1918989427 * state + 1869048929) mod 2^32  (按 int32 溢出)
state = tmp % 1260410217
if state < 0: state += 1260410217

然后每次 shuffle 需要两个 state % 12 来决定要交换的两个下标。

65537 次随机 swap(只依赖 seed)

O0OOOOo00o0Ooo00O0ooooOoO0OO0Oo0_4(0x4042BF):

调两次上一节的 PRNG,得到 i = state % 12、j = state % 12

调 ooo0oOO000o00O0O0OOO00oOO0oooOOo_0(0x401B9F)把数组的 a[i] 与 a[j] 交换

循环 65537 次:

O0OOOOo00o0Ooo00O0ooooOoO0OO0Oo0_6(0x404986):同样的:

因此:给定 seed,我们可以复现出 shuffle 的最终置换(用 idx 数组模拟 swap),并取逆置换来解密:

加密:new[pos] = old[idx[pos]]

解密:old[i] = new[inv[i]](其中 inv 是 idx 的逆)

Mix:4 组 × 65537 轮的 3-int 可逆更新

程序把 12 个 int 分成 4 组,每组 3 个,分别是:

g=0: a[0], a[1], a[2]
g=1: a[3], a[4], a[5]
g=2: a[6], a[7], a[8]
g=3: a[9], a[10], a[11]

从 Ooo0Oo00..._30/_31/_32 里能看到取下标是 3*g + 0/1/2(g 存在某个全局字段的高 32 位)。

核心循环在 OoOOOoOoO0OOOo0ooOoo0OooOooO00Oo_0(0x4038D9)

t  = 1924939505
p0 = 396307405
p1 = 1601708927

每一轮先更新常量:

t  = t  * p0
p0 = p0 * p1
p1 = p1 * t

然后按顺序更新 (A,B,C)(每一步都依赖前一步更新后的变量):

s0 = (1126760380*B + C/13) XOR (660328234*B + C/29)
s1 = (t + B) XOR (C - t)
A  = A + (s0 XOR s1)

s0 = (666086835*C + A/11) XOR (1361690111*C + A/19)
s1 = (p0 + C) XOR (A - p0)
B  = B + (s0 XOR s1)

s0 = (406831633*A + B/17) XOR (1648306586*A + B/23)
s1 = (p1 + A) XOR (B - p1)
C  = C + (s0 XOR s1)

一共做 65537 轮。

因为 seed 是 time(0),作者生成 readme 里的密文时必然运行过一次程序;通常这个时间和编译时间很近。

在当前目录里 Interstellar 的文件修改时间是 2025-11-26 05:50 左右:

Get-Item .\\Interstellar | Select-Object LastWriteTime

把它转成 UNIX 时间戳并给一个 ±1 小时窗口:

$t = (Get-Item .\\Interstellar).LastWriteTime
$ts = ([DateTimeOffset]$t).ToUnixTimeSeconds()
$start = $ts - 3600
$end = $ts + 3600
echo $ts $start $end

然后在这个窗口内爆破 seed。

利用Rust solver进行爆破:

use std::env;

const CIPHERTEXT: [i32; 12] = [
    961_328_601,
    940_839_751,
    705_572_502,
    -1_296_360_751,
    1_510_741_316,
    -746_016_568,
    1_758_503_669,
    -312_360_224,
    1_117_958_716,
    -1_263_168_281,
    -1_534_151_026,
    -1_968_871_781,
];

const TARGET_MD5: [u8; 16] = [
    0x28, 0x87, 0x94, 0x1e, 0xd3, 0xea, 0x0f, 0x6b, 0x7c, 0xa8, 0x70, 0xcd, 0x11, 0xf0,
    0xde, 0x13,
];

const ITERS: usize = 0x10001; // 65537

#[inline(always)]
fn add32(a: i32, b: i32) -> i32 {
    (a as u32).wrapping_add(b as u32) as i32
}

#[inline(always)]
fn sub32(a: i32, b: i32) -> i32 {
    (a as u32).wrapping_sub(b as u32) as i32
}

#[inline(always)]
fn mul32(a: i32, b: i32) -> i32 {
    (a as u32).wrapping_mul(b as u32) as i32
}

#[inline(always)]
fn xor32(a: i32, b: i32) -> i32 {
    ((a as u32) ^ (b as u32)) as i32
}

#[derive(Clone, Copy)]
struct MixState {
    t: i32,
    p0: i32,
    p1: i32,
}

fn build_mix_states() -> Vec<MixState> {
    let mut t: i32 = 1_924_939_505;
    let mut p0: i32 = 396_307_405;
    let mut p1: i32 = 1_601_708_927;
    let mut states = Vec::with_capacity(ITERS);
    for _ in 0..ITERS {
        t = mul32(t, p0);
        p0 = mul32(p0, p1);
        p1 = mul32(p1, t);
        states.push(MixState { t, p0, p1 });
    }
    states
}

#[inline(always)]
fn lcg_step(state: i32) -> i32 {
    let a: u32 = 1_918_989_427;
    let c: u32 = 1_869_048_929;
    let m: i32 = 1_260_410_217;
    let tmp = ((state as u32).wrapping_mul(a).wrapping_add(c)) as i32;
    let mut r = tmp % m;
    if r < 0 {
        r += m;
    }
    r
}

fn invert_idx(idx: &[u8; 12]) -> [u8; 12] {
    let mut inv = [0u8; 12];
    for (pos, &old_i) in idx.iter().enumerate() {
        inv[old_i as usize] = pos as u8;
    }
    inv
}

fn shuffle_perms(seed: i32) -> ([u8; 12], [u8; 12], [u8; 12], [u8; 12]) {
    let mut state = seed;

    let mut idx1 = [0u8; 12];
    for i in 0..12 {
        idx1[i] = i as u8;
    }
    for _ in 0..ITERS {
        state = lcg_step(state);
        let i = (state % 12) as usize;
        state = lcg_step(state);
        let j = (state % 12) as usize;
        idx1.swap(i, j);
    }
    let inv1 = invert_idx(&idx1);

    let mut idx2 = [0u8; 12];
    for i in 0..12 {
        idx2[i] = i as u8;
    }
    for _ in 0..ITERS {
        state = lcg_step(state);
        let i = (state % 12) as usize;
        state = lcg_step(state);
        let j = (state % 12) as usize;
        idx2.swap(i, j);
    }
    let inv2 = invert_idx(&idx2);
    (idx1, inv1, idx2, inv2)
}

fn unshuffle(inp: &[i32; 12], inv: &[u8; 12]) -> [i32; 12] {
    let mut out = [0i32; 12];
    for i in 0..12 {
        out[i] = inp[inv[i] as usize];
    }
    out
}

fn ints_to_bytes_le(inp: &[i32; 12]) -> [u8; 48] {
    let mut out = [0u8; 48];
    for i in 0..12 {
        let u = inp[i] as u32;
        out[i * 4 + 0] = (u & 0xFF) as u8;
        out[i * 4 + 1] = ((u >> 8) & 0xFF) as u8;
        out[i * 4 + 2] = ((u >> 16) & 0xFF) as u8;
        out[i * 4 + 3] = ((u >> 24) & 0xFF) as u8;
    }
    out
}

fn unmix_triple(mut a: i32, mut b: i32, mut c: i32, states: &[MixState]) -> (i32, i32, i32) {
    for st in states.iter().rev() {
        // Reverse C update
        let s0 = xor32(
            add32(mul32(406_831_633, a), b / 17),
            add32(mul32(1_648_306_586, a), b / 23),
        );
        let s1 = xor32(add32(st.p1, a), sub32(b, st.p1));
        c = sub32(c, xor32(s0, s1));

        // Reverse B update
        let s0 = xor32(
            add32(mul32(666_086_835, c), a / 11),
            add32(mul32(1_361_690_111, c), a / 19),
        );
        let s1 = xor32(add32(st.p0, c), sub32(a, st.p0));
        b = sub32(b, xor32(s0, s1));

        // Reverse A update
        let s0 = xor32(
            add32(mul32(1_126_760_380, b), c / 13),
            add32(mul32(660_328_234, b), c / 29),
        );
        let s1 = xor32(add32(st.t, b), sub32(c, st.t));
        a = sub32(a, xor32(s0, s1));
    }
    (a, b, c)
}

// ---- MD5 ----
// Minimal MD5 implementation for our fixed-size input.
fn md5(data: &[u8]) -> [u8; 16] {
    let mut h: [u32; 4] = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476];

    fn rotl(x: u32, n: u32) -> u32 {
        (x << n) | (x >> (32 - n))
    }

    const K: [u32; 64] = [
        0xd76aa478,
        0xe8c7b756,
        0x242070db,
        0xc1bdceee,
        0xf57c0faf,
        0x4787c62a,
        0xa8304613,
        0xfd469501,
        0x698098d8,
        0x8b44f7af,
        0xffff5bb1,
        0x895cd7be,
        0x6b901122,
        0xfd987193,
        0xa679438e,
        0x49b40821,
        0xf61e2562,
        0xc040b340,
        0x265e5a51,
        0xe9b6c7aa,
        0xd62f105d,
        0x02441453,
        0xd8a1e681,
        0xe7d3fbc8,
        0x21e1cde6,
        0xc33707d6,
        0xf4d50d87,
        0x455a14ed,
        0xa9e3e905,
        0xfcefa3f8,
        0x676f02d9,
        0x8d2a4c8a,
        0xfffa3942,
        0x8771f681,
        0x6d9d6122,
        0xfde5380c,
        0xa4beea44,
        0x4bdecfa9,
        0xf6bb4b60,
        0xbebfbc70,
        0x289b7ec6,
        0xeaa127fa,
        0xd4ef3085,
        0x04881d05,
        0xd9d4d039,
        0xe6db99e5,
        0x1fa27cf8,
        0xc4ac5665,
        0xf4292244,
        0x432aff97,
        0xab9423a7,
        0xfc93a039,
        0x655b59c3,
        0x8f0ccc92,
        0xffeff47d,
        0x85845dd1,
        0x6fa87e4f,
        0xfe2ce6e0,
        0xa3014314,
        0x4e0811a1,
        0xf7537e82,
        0xbd3af235,
        0x2ad7d2bb,
        0xeb86d391,
    ];

    const S: [u32; 64] = [
        7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 5, 9, 14, 20, 5, 9,
        14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23,
        4, 11, 16, 23, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21,
    ];

    let mut msg = Vec::from(data);
    let bit_len = (msg.len() as u64) * 8;
    msg.push(0x80);
    while (msg.len() % 64) != 56 {
        msg.push(0);
    }
    msg.extend_from_slice(&bit_len.to_le_bytes());

    for chunk in msg.chunks_exact(64) {
        let mut w = [0u32; 16];
        for i in 0..16 {
            let b0 = chunk[i * 4 + 0] as u32;
            let b1 = chunk[i * 4 + 1] as u32;
            let b2 = chunk[i * 4 + 2] as u32;
            let b3 = chunk[i * 4 + 3] as u32;
            w[i] = b0 | (b1 << 8) | (b2 << 16) | (b3 << 24);
        }

        let mut a = h[0];
        let mut b = h[1];
        let mut c = h[2];
        let mut d = h[3];

        for i in 0..64 {
            let (f, g) = if i < 16 {
                ((b & c) | ((!b) & d), i)
            } else if i < 32 {
                ((d & b) | ((!d) & c), (5 * i + 1) % 16)
            } else if i < 48 {
                (b ^ c ^ d, (3 * i + 5) % 16)
            } else {
                (c ^ (b | (!d)), (7 * i) % 16)
            };
            let tmp = d;
            d = c;
            c = b;
            b = b.wrapping_add(rotl(
                a.wrapping_add(f)
                    .wrapping_add(K[i])
                    .wrapping_add(w[g]),
                S[i],
            ));
            a = tmp;
        }

        h[0] = h[0].wrapping_add(a);
        h[1] = h[1].wrapping_add(b);
        h[2] = h[2].wrapping_add(c);
        h[3] = h[3].wrapping_add(d);
    }

    let mut out = [0u8; 16];
    for i in 0..4 {
        out[i * 4..i * 4 + 4].copy_from_slice(&h[i].to_le_bytes());
    }
    out
}

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() != 3 {
        eprintln!("usage: {} <start_ts> <end_ts>", args[0]);
        std::process::exit(2);
    }
    let start: i32 = args[1].parse().expect("start_ts int");
    let end: i32 = args[2].parse().expect("end_ts int");
    let step: i32 = if end >= start { 1 } else { -1 };

    let states = build_mix_states();

    let mut seed = start;
    loop {
        let (_idx1, inv1, _idx2, inv2) = shuffle_perms(seed);
        let arr1 = unshuffle(&CIPHERTEXT, &inv2);
        let mut arr2 = arr1;

        for base in (0..12).step_by(3) {
            let (a, b, c) = unmix_triple(arr2[base], arr2[base + 1], arr2[base + 2], &states);
            arr2[base] = a;
            arr2[base + 1] = b;
            arr2[base + 2] = c;
        }

        let arr3 = unshuffle(&arr2, &inv1);
        let pt = ints_to_bytes_le(&arr3);
        if md5(&pt) == TARGET_MD5 {
            println!("[+] seed={}", seed);
            match std::str::from_utf8(&pt) {
                Ok(s) => println!("{}", s),
                Err(_) => println!("{:?}", pt),
            }
            return;
        }

        if seed == end {
            break;
        }
        seed = seed.wrapping_add(step);
    }

    eprintln!("not found");
    std::process::exit(1);
}

rustc -O .\\solve_flag.rs -o .\\solve_flag_rust.exe

按二进制时间戳爆破 seed

$t = (Get-Item .\\Interstellar).LastWriteTime
$ts = ([DateTimeOffset]$t).ToUnixTimeSeconds()
$start = $ts - 3600
$end = $ts + 3600
.\solve_flag_rust.exe $start $end

输出会直接给出 seed 1764108097

拿到seed也可以再进行解密:

#!/usr/bin/env python3
from __future__ import annotations

import argparse
import datetime as dt
import hashlib
from dataclasses import dataclass
from typing import Iterable, List, Tuple


CIPHERTEXT = [
    961_328_601,
    940_839_751,
    705_572_502,
    -1_296_360_751,
    1_510_741_316,
    -746_016_568,
    1_758_503_669,
    -312_360_224,
    1_117_958_716,
    -1_263_168_281,
    -1_534_151_026,
    -1_968_871_781,
]

TARGET_MD5 = bytes.fromhex("2887941ed3ea0f6b7ca870cd11f0de13")


def _u32(x: int) -> int:
    return x & 0xFFFFFFFF


def _s32(x: int) -> int:
    x &= 0xFFFFFFFF
    return x - 0x100000000 if x & 0x80000000 else x


def _mul_s32(a: int, b: int) -> int:
    return _s32(_u32(a * b))


def _add_s32(a: int, b: int) -> int:
    return _s32(a + b)


def _sub_s32(a: int, b: int) -> int:
    return _s32(a - b)


def _xor_s32(a: int, b: int) -> int:
    return _s32(_u32(a) ^ _u32(b))


def _div_trunc_s32(a: int, d: int) -> int:
    # C signed division truncates toward 0; Python // floors.
    if d == 0:
        raise ZeroDivisionError("division by zero")
    if a == 0:
        return 0
    q = abs(a) // abs(d)
    return q if (a >= 0) == (d >= 0) else -q


@dataclass(frozen=True)
class MixState:
    t: int
    p0: int
    p1: int


def _mix_states(iters: int) -> List[MixState]:
    # Initial constants live in OoOOOo..._0 activation record:
    # *(&dsa[4].line+1) = 1924939505; LODWORD(dsa[4].parent) = 396307405; HIDWORD(dsa[4].parent) = 1601708927
    t = 1_924_939_505
    p0 = 396_307_405
    p1 = 1_601_708_927
    states: List[MixState] = []
    for _ in range(iters):
        t = _mul_s32(t, p0)
        p0 = _mul_s32(p0, p1)
        p1 = _mul_s32(p1, t)
        states.append(MixState(t=t, p0=p0, p1=p1))
    return states


_MIX_ITERS = 0x10001  # 65537
_MIX_STATES = _mix_states(_MIX_ITERS)


def _unmix_triple(a1: int, b1: int, c1: int) -> Tuple[int, int, int]:
    # Invert O0OOOO..._1 for 65537 iterations (OoOOOo..._0 loop) on one triple.
    a, b, c = a1, b1, c1
    for st in reversed(_MIX_STATES):
        # Reverse final C update (uses A,B, st.p1)
        s0 = _xor_s32(
            _add_s32(_mul_s32(406_831_633, a), _div_trunc_s32(b, 17)),
            _add_s32(_mul_s32(1_648_306_586, a), _div_trunc_s32(b, 23)),
        )
        s1 = _xor_s32(_add_s32(st.p1, a), _sub_s32(b, st.p1))
        c = _sub_s32(c, _xor_s32(s0, s1))

        # Reverse B update (uses A,C, st.p0)
        s0 = _xor_s32(
            _add_s32(_mul_s32(666_086_835, c), _div_trunc_s32(a, 11)),
            _add_s32(_mul_s32(1_361_690_111, c), _div_trunc_s32(a, 19)),
        )
        s1 = _xor_s32(_add_s32(st.p0, c), _sub_s32(a, st.p0))
        b = _sub_s32(b, _xor_s32(s0, s1))

        # Reverse A update (uses B,C, st.t)
        s0 = _xor_s32(
            _add_s32(_mul_s32(1_126_760_380, b), _div_trunc_s32(c, 13)),
            _add_s32(_mul_s32(660_328_234, b), _div_trunc_s32(c, 29)),
        )
        s1 = _xor_s32(_add_s32(st.t, b), _sub_s32(c, st.t))
        a = _sub_s32(a, _xor_s32(s0, s1))

    return a, b, c


def _lcg_step(state: int) -> int:
    # Implements oO0o0O00..._0:
    # tmp = (1918989427 * state + 1869048929) in 32-bit signed
    # state = tmp % 1260410217, adjusted to be >= 0
    a = 1_918_989_427  # 0x72617473
    c = 1_869_048_929  # 0x6f676c61
    m = 1_260_410_217  # 0x4b205569
    tmp = _s32(_u32(a * state + c))
    r = tmp % m
    # Python % already yields 0..m-1, matching the post-fixup behavior.
    return r


def _shuffle_permutations(seed: int) -> Tuple[List[int], List[int]]:
    # Returns idx maps for shuffle1 and shuffle2:
    # new[pos] = old[idx[pos]]
    state = _s32(seed)

    def one_shuffle(state_in: int) -> Tuple[int, List[int]]:
        idx = list(range(12))
        state = state_in
        for _ in range(_MIX_ITERS):
            state = _lcg_step(state)
            i = state % 12
            state = _lcg_step(state)
            j = state % 12
            idx[i], idx[j] = idx[j], idx[i]
        return state, idx

    state, idx1 = one_shuffle(state)
    state, idx2 = one_shuffle(state)
    return idx1, idx2


def _invert_idx(idx: List[int]) -> List[int]:
    inv = [0] * len(idx)
    for pos, old_i in enumerate(idx):
        inv[old_i] = pos
    return inv


def _unshuffle(arr: List[int], inv: List[int]) -> List[int]:
    return [arr[inv[i]] for i in range(len(arr))]


def _ints_to_bytes_le(ints: List[int]) -> bytes:
    out = bytearray()
    for x in ints:
        u = _u32(x)
        out.extend((u & 0xFF, (u >> 8) & 0xFF, (u >> 16) & 0xFF, (u >> 24) & 0xFF))
    return bytes(out)


def decrypt_for_seed(seed: int, ct: List[int]) -> bytes:
    idx1, idx2 = _shuffle_permutations(seed)
    inv1 = _invert_idx(idx1)
    inv2 = _invert_idx(idx2)

    # Unshuffle2
    arr = _unshuffle(ct, inv2)

    # Unmix (4 independent triples)
    for base in (0, 3, 6, 9):
        a, b, c = arr[base], arr[base + 1], arr[base + 2]
        a, b, c = _unmix_triple(a, b, c)
        arr[base : base + 3] = [a, b, c]

    # Unshuffle1
    arr = _unshuffle(arr, inv1)
    return _ints_to_bytes_le(arr)


def _seed_range(start: int, end: int) -> Iterable[int]:
    step = 1 if end >= start else -1
    # Inclusive range
    for s in range(start, end + step, step):
        yield s


def main() -> int:
    ap = argparse.ArgumentParser()
    ap.add_argument("--start", type=int, help="start unix timestamp (inclusive)")
    ap.add_argument("--end", type=int, help="end unix timestamp (inclusive)")
    ap.add_argument(
        "--hint",
        type=str,
        default="",
        help="helpful timestamp hint, e.g. '2026-01-25T20:19:00+08:00' (search +/- window)",
    )
    ap.add_argument("--window", type=int, default=0, help="seconds around --hint to search (default 0)")
    args = ap.parse_args()

    if args.hint:
        d = dt.datetime.fromisoformat(args.hint)
        center = int(d.timestamp())
        start = center - args.window
        end = center + args.window
    else:
        if args.start is None or args.end is None:
            ap.error("either provide --hint or both --start/--end")
        start, end = args.start, args.end

    ct = [_s32(x) for x in CIPHERTEXT]
    for seed in _seed_range(start, end):
        pt = decrypt_for_seed(seed, ct)
        if hashlib.md5(pt).digest() == TARGET_MD5:
            print(f"[+] seed={seed}")
            try:
                print(pt.decode("utf-8"))
            except UnicodeDecodeError:
                print(pt)
            return 0

    print("[-] not found")
    return 1


if __name__ == "__main__":
    raise SystemExit(main())
# flag{4waK1nG_1nTh3_L1gH7_0fA1LThE_s74r5_a1igNeD}

Find My Time

目录文件分析:

find_my_time_c.exe:Qt GUI 程序(计时器不断刷新界面)。

Qt5Core.dll / Qt5Gui.dll / Qt5Widgets.dll`:Qt 运行库。

libgmp-10.dll:GMP 大整数库(程序里大量调用 mpz_*` 做素性测试、模幂、求逆等)。

尝试运行程序,本身不在控制台输出。GUI 会显示“提示/结果”,由于“正确时间”是极其偏离现实的年份(3583、9923),直接靠改系统时间通常不可行。

这是典型 Qt Widgets 程序:

在 main 里创建 QApplication,实例化窗口类,show() 后进入事件循环。窗口构造时创建 QTimer,连接 timeout() 信号到某个槽函数,周期性刷新。

  1. 从 Qt 符号/导入定位:搜索 QTimer::timeout / QObject::connect 的调用点,跟进回调函数。
  2. 从 GMP 调用定位:搜索导入函数 __gmpz_probab_prime_p / __gmpz_powm / __gmpz_invert 的交叉引用(xrefs),能快速落到校验和解密代码附近。

sub_14006C560:

sub_14006C430:

sub_140002160:

sub_1400017C0:

sub_1400017C0

时间使用的是 UTC

会把 Unix 秒 t 转换成 struct tm( gmtime,因此月份/日期等都是 UTC 语义,而不是本地时区。

sub_140001E70:

sub_140001EE0:

sub_140001F50:

  • t:Unix 时间戳(秒,UTC)
  • YYYYMMDD:日期部分(8 位十进制)
  • hhmmss:时间部分(6 位十进制)
  • DT = YYYYMMDDhhmmss(14 位十进制)
  • P1 = int(str(DT) + str(t))(把 DT 和 t 十进制拼接)
  • P2 = int(str(t) + str(DT))(把 t 和 DT 十进制拼接)

这些东西全部用 GMP 的 mpz_set_str(..., 10) 转大整数,再做素性测试。

对时间的要求:

月份在集合 {2,3,5,7,11} 中

day/hour/minute/second 均在合法范围内,且各自数值为素数,YYYYMMDD 是素数。

hhmmss 是素数。

t 是素数,且 t > 1。DT 是素数。DT 的 14 个字符里 不能出现字符 '0'(逐字节扫描字符串,遇到 '0' 直接失败)。P1、P2` 都是素数。

DT 的十进制字符串不能出现 '0'。

月份是 %02d,如果是 2/3/5/7,会变成 02/03/05/07不会引入 '0' 的允许月份只剩 11。

类似于下面的代码:

check(t):
  tm = gmtime(t)
  if tm.mon not in {2,3,5,7,11}: return false

  dt_str = sprintf("%04d%02d%02d%02d%02d%02d", year, mon, day, hour, min, sec)
  if '0' in dt_str: return false

  yyyymmdd = year*10000 + mon*100 + day
  hhmmss   = hour*10000 + min*100 + sec
  dt_num   = int(dt_str)

  require prime(day), prime(hour), prime(min), prime(sec)
  require prime(yyyymmdd)
  require prime(hhmmss)
  require prime(t)
  require prime(dt_num)

  p1 = int(str(dt_num) + str(t))
  p2 = int(str(t) + str(dt_num))
  require prime(p1), prime(p2)

  return (dt_num, p1, p2)

还原方式是把每个字节和某个 key 做 XOR,得到。

在 XOR 循环看到0x33,猜测key就是0x33

还原的两个密文大整数(十进制):

c1 = 422698873081437624518382059552318235172264293390171053488808121
c2 = 206134179439411414927415781485521487054746196930762801924142747145

三素数 RSA 变体(sub_140002160):

当 check(t) 成功后,程序认为当前时间是“对的时间”,会用刚才构造的三个大素数做 RSA:

  • p_dt = DT
  • p1 = P1
  • p2 = P2
  • n = p_dt * p1 * p2
  • e = t
  • phi = (p_dt-1)(p1-1)(p2-1)
  • d = e^{-1} mod phi

对密文做标准 RSA 解密:

  • m = c^d mod n

用 GMP 的导出函数把 m 变成一段字节数组 。

因此:直接利用给的 libgmp-10.dll,使用 __gmpz_probab_prime_p(n, 30) 来测素数。

根据 “不能含 0” + “月份只能 11” + “day/hour/min/sec 必须两位素数” 缩小空间:day 只枚举 {11,13,17,19,23,29}`hour` 枚举 `{11,13,17,19,23}`minute/second 枚举常见两位素数 {11,13,17,19,23,29,31,37,41,43,47,53,59}先预筛 hhmmss` 为素数的三元组,再进入主循环。

对每个候选时间:

  • 计算 t(UTC Unix 秒),验证 t、YYYYMMDD、hhmmss、DT、P1、P2 都是素数;
  • 计算 d = invmod(t, phi) 和 n;
  • 分别尝试解密 c1 与 c2。
  • UTC:3583-11-11 11:23:31Z
  • t = 50928521011
  • DT = 35831111112331
  • P1 = 3583111111233150928521011(DT || t 十进制拼接)
  • P2 = 5092852101135831111112331(t || DT 十进制拼接)
  • UTC:9923-11-13 23:29:19Z
  • t = 250999774159
  • DT = 99231113232919
  • P1 = 99231113232919250999774159
  • P2 = 25099977415999231113232919
import calendar
import ctypes
import os
from ctypes import POINTER, Structure, byref, c_char_p, c_int, c_ulonglong
from dataclasses import dataclass
from datetime import datetime, timezone


class _Mpz(Structure):
    _fields_ = [("alloc", c_int), ("size", c_int), ("d", POINTER(c_ulonglong))]


class Gmp:
    def __init__(self, dll_path: str) -> None:
        self._lib = ctypes.CDLL(dll_path)

        self._gmpz_init = getattr(self._lib, "__gmpz_init")
        self._gmpz_init.argtypes = [POINTER(_Mpz)]
        self._gmpz_init.restype = None

        self._gmpz_clear = getattr(self._lib, "__gmpz_clear")
        self._gmpz_clear.argtypes = [POINTER(_Mpz)]
        self._gmpz_clear.restype = None

        self._gmpz_set_str = getattr(self._lib, "__gmpz_set_str")
        self._gmpz_set_str.argtypes = [POINTER(_Mpz), c_char_p, c_int]
        self._gmpz_set_str.restype = c_int

        self._gmpz_probab_prime_p = getattr(self._lib, "__gmpz_probab_prime_p")
        self._gmpz_probab_prime_p.argtypes = [POINTER(_Mpz), c_int]
        self._gmpz_probab_prime_p.restype = c_int

        self._z = _Mpz()
        self._gmpz_init(byref(self._z))

    def close(self) -> None:
        self._gmpz_clear(byref(self._z))

    def is_probable_prime(self, n: int, reps: int = 30) -> bool:
        if n < 2:
            return False
        s = str(n).encode("ascii")
        if self._gmpz_set_str(byref(self._z), s, 10) != 0:
            raise RuntimeError("gmpz_set_str failed")
        return self._gmpz_probab_prime_p(byref(self._z), reps) > 0


def _invmod(a: int, m: int) -> int | None:
    try:
        return pow(a, -1, m)
    except ValueError:
        return None


def _int_to_bytes_strip_zeros(x: int, byteorder: str) -> bytes:
    if x == 0:
        return b""
    length = (x.bit_length() + 7) // 8
    raw = x.to_bytes(length, byteorder)
    return bytes(b for b in raw if b != 0)


def _is_printable_ascii(bs: bytes) -> bool:
    return len(bs) > 0 and all(0x20 <= b <= 0x7E for b in bs)


@dataclass(frozen=True)
class CipherSet:
    key: int
    c1: int
    c2: int


def _decode_cipher_digits(nibbles: list[int], key: int) -> str:
    return "".join(chr(b ^ key) for b in nibbles)


def _build_cipher_sets() -> list[CipherSet]:
    c1_nibbles = [
        0x7,
        0x1,
        0x1,
        0x5,
        0xA,
        0xB,
        0xB,
        0x4,
        0x0,
        0x3,
        0xB,
        0x2,
        0x7,
        0x0,
        0x4,
        0x5,
        0x1,
        0x7,
        0x6,
        0x2,
        0xB,
        0x0,
        0xB,
        0x1,
        0x3,
        0x6,
        0xA,
        0x6,
        0x6,
        0x1,
        0x0,
        0x2,
        0xB,
        0x1,
        0x0,
        0x6,
        0x2,
        0x4,
        0x1,
        0x1,
        0x5,
        0x7,
        0x1,
        0xA,
        0x0,
        0x0,
        0xA,
        0x3,
        0x2,
        0x4,
        0x2,
        0x3,
        0x6,
        0x0,
        0x7,
        0xB,
        0xB,
        0xB,
        0x3,
        0xB,
        0x2,
        0x1,
        0x2,
    ]
    c2_nibbles = [
        0x1,
        0x3,
        0x5,
        0x2,
        0x0,
        0x7,
        0x2,
        0x4,
        0xA,
        0x7,
        0x0,
        0xA,
        0x7,
        0x2,
        0x2,
        0x7,
        0x2,
        0x7,
        0xA,
        0x1,
        0x4,
        0x7,
        0x2,
        0x6,
        0x4,
        0xB,
        0x2,
        0x7,
        0xB,
        0x6,
        0x6,
        0x1,
        0x2,
        0x7,
        0xB,
        0x4,
        0x3,
        0x6,
        0x7,
        0x4,
        0x7,
        0x5,
        0x2,
        0xA,
        0x5,
        0xA,
        0x0,
        0x3,
        0x4,
        0x5,
        0x1,
        0xB,
        0x3,
        0x2,
        0xA,
        0x1,
        0x7,
        0x2,
        0x7,
        0x1,
        0x4,
        0x7,
        0x4,
        0x2,
    ]

    out: list[CipherSet] = []
    for key in (0x32, 0x33):
        s1 = _decode_cipher_digits(c1_nibbles, key)
        s2 = _decode_cipher_digits(c2_nibbles, key)
        suffix = chr(key ^ 7) + chr(key ^ 6)
        out.append(CipherSet(key=key, c1=int(s1), c2=int(s2 + suffix)))
    return out


def main() -> int:
    dll_path = os.path.join(os.path.dirname(__file__), "libgmp-10.dll")
    if not os.path.exists(dll_path):
        raise SystemExit("missing libgmp-10.dll in current directory")

    gmp = Gmp(dll_path)
    try:
        cipher_sets = _build_cipher_sets()

        month = 11
        prime_days = [11, 13, 17, 19, 23, 29]
        prime_hours = [11, 13, 17, 19, 23]
        prime_minsec = [11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59]

        time_triples: list[tuple[int, int, int, int]] = []
        for h in prime_hours:
            for m in prime_minsec:
                for s in prime_minsec:
                    hhmmss = h * 10000 + m * 100 + s
                    if gmp.is_probable_prime(hhmmss):
                        time_triples.append((h, m, s, hhmmss))

        pow10_14 = 10**14

        part1: str | None = None
        part2: str | None = None
        hit1: str | None = None
        hit2: str | None = None

        for year in range(1970, 10000):
            y = f"{year:04d}"
            if "0" in y:
                continue

            yyyymm_base = year * 10000 + month * 100
            dt_prefix = year * 10**10 + month * 10**8

            for day in prime_days:
                yyyymmdd = yyyymm_base + day
                if not gmp.is_probable_prime(yyyymmdd):
                    continue

                dt0 = datetime(year, month, day, 0, 0, 0, tzinfo=timezone.utc)
                base_t = calendar.timegm(dt0.utctimetuple())

                for h, m, s, hhmmss in time_triples:
                    dt_num = dt_prefix + day * 10**6 + hhmmss
                    if not gmp.is_probable_prime(dt_num):
                        continue

                    t = base_t + h * 3600 + m * 60 + s
                    if t <= 1 or not gmp.is_probable_prime(t):
                        continue

                    t_str = str(t)
                    p1 = dt_num * (10 ** len(t_str)) + t
                    if not gmp.is_probable_prime(p1):
                        continue

                    p2 = t * pow10_14 + dt_num
                    if not gmp.is_probable_prime(p2):
                        continue

                    phi = (dt_num - 1) * (p1 - 1) * (p2 - 1)
                    d = _invmod(t, phi)
                    if d is None:
                        continue

                    n = dt_num * p1 * p2
                    dt_str = f"{year:04d}{month:02d}{day:02d}{h:02d}{m:02d}{s:02d}"
                    if "0" in dt_str:
                        continue

                    for cs in cipher_sets:
                        if part1 is None:
                            m1 = pow(cs.c1, d, n)
                            for endian in ("big", "little"):
                                b1 = _int_to_bytes_strip_zeros(m1, endian)
                                if _is_printable_ascii(b1):
                                    part1 = b1.decode("ascii")
                                    hit1 = (
                                        f"{year:04d}-{month:02d}-{day:02d} "
                                        f"{h:02d}:{m:02d}:{s:02d}Z (t={t}, key=0x{cs.key:02x})"
                                    )
                                    break

                        if part2 is None:
                            m2 = pow(cs.c2, d, n)
                            for endian in ("big", "little"):
                                b2 = _int_to_bytes_strip_zeros(m2, endian)
                                if _is_printable_ascii(b2):
                                    part2 = b2.decode("ascii")
                                    hit2 = (
                                        f"{year:04d}-{month:02d}-{day:02d} "
                                        f"{h:02d}:{m:02d}:{s:02d}Z (t={t}, key=0x{cs.key:02x})"
                                    )
                                    break

                        if part1 is not None and part2 is not None:
                            flag = part1 + part2
                            print("part1:", part1)
                            print("hit1 :", hit1)
                            print("part2:", part2)
                            print("hit2 :", hit2)
                            print("flag :", flag)
                            return 0

        print("not found")
        return 1
    finally:
        gmp.close()


if __name__ == "__main__":
    raise SystemExit(main())
#3583-11-11 11:23:31Z → 4Kr0s5_Th0u54nDs_0f_yE4Rs_
#9923-11-13 23:29:19Z → u_f1nd_m3_1nTh3_sE4_oF_7imE
#flag = 4Kr0s5_Th0u54nDs_0f_yE4Rs_u_f1nd_m3_1nTh3_sE4_oF_7imE