N1CTF Reverse题目全解
N1CTF Reverse题目全解
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 = oprateRC4 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())
# 5f19b83de29bd46e9e02f7f88bfb4ea2flag{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
这样就能逐位置还原:
- 对每一行
line: - 扫描
idx=0..25的 bitmask,把每个pos映射到一个字母 - 该行长度
len = max_pos_seen + 1 - 依次拼起来就是整条 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:
ccjhglfcfgfcfgdgdgdgdgfcjhghjcndgfchcndgdgfcfgfcjpdehchc(56)agfaphcdgldgdlltldgfapdgdghcdlgdpcdllgldgfalcdgdgdg(51)eajnfccjljahchcfgjljajnfcchafccfclfacfccfcfghaljajhccdghaja(59)aghlphlhglldplhghlhgdgllhhglldlghhghpdgdgdg(43)cchaahrfaaaflchchcfnllchaahjgfcnfchaaafcnfcfnchlchaandehchc(59)
ccjhglfcfgfcfgdgdgdgdgfcjhghjcndgfchcndgdgfcfgfcjpdehchc
agfaphcdgldgdlltldgfapdgdghcdlgdpcdllgldgfalcdgdgdg
eajnfccjljahchcfgjljajnfcchafccfclfacfccfcfghaljajhccdghaja
aghlphlhglldplhghlhgdgllhhglldlghhghpdgdgdg
cchaahrfaaaflchchcfnllchaahjgfcnfchaaafcnfcfnchlchaandehchc16 进制的 转为 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 = de584670ebc7470662eaf64903b88e35f1f88f4e18d08bd25cf3532f9f36e499bce015cf955436d38f9f068fcf8b3f0bct 长度 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”模板):
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(小端) | 十进制 |
|
|
|
|
|
|
|
|
|
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() 信号到某个槽函数,周期性刷新。
- 从 Qt 符号/导入定位:搜索
QTimer::timeout/QObject::connect的调用点,跟进回调函数。 - 从 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 = DTp1 = P1p2 = P2n = p_dt * p1 * p2e = tphi = (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 = 50928521011DT = 35831111112331P1 = 3583111111233150928521011(DT || t十进制拼接)P2 = 5092852101135831111112331(t || DT十进制拼接)- UTC:
9923-11-13 23:29:19Z t = 250999774159DT = 99231113232919P1 = 99231113232919250999774159P2 = 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涵盖MaybeAndroid(AES/RC4解密)、Wizard Time(位图还原magic string)、VS Code(运行时key修复)、Interstellar(LCG+shuffle逆向)及Find My…
由 AI 根据全文自动生成,仅供参考,以原文为准