KnightCTF 2026 reverse全解
难度中等的一次国际赛事,reverse难度中规中矩,但比赛奖品送IDA!
E4sy_P3asy
这个题应该是本场比赛最简单的题了,题目给了个ks文件,其实就是elf文件,放进ida里面看函数逻辑
sub_1760(s, "KCTF{")
strncmp(s, "KCTF{", strlen("KCTF{")) == 0判断 flag 前缀 sub_17A0(s)
s[strlen(s)-1] == '}' flag 结尾必须是 }
if (sub_1760(s, "GoogleCTF{"))- salt =
"G00gleCTF_s@lt_2026" - 长度 = 24
- 对 13 个字符做 MD5 对比
- 通过后只会输出“decoy flag”
sub_1660 —— MD5 计算函数
sub_1660(input, len, output)本质就是:
MD5(input) → 输出 32 字节 hex 字符串要找字符 c,使得:
MD5("KnightCTF_2026_s@lt" + str(i) + c) == 已知hash[i]exp:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import hashlib
import string
def md5_hex(s: str) -> str:
return hashlib.md5(s.encode()).hexdigest()
def main():
salt = "KnightCTF_2026_s@lt"
# off_3CA0: 23 hashes (index 0..22)
hashes = [
"781011edfb2127ee5ff82b06bb1d2959",
"4cf891e0ddadbcaae8e8c2dc8bb15ea0",
"d06d0cbe140d0a1de7410b0b888f22b4",
"d44c9a9b9f9d1c28d0904d6a2ee3e109",
"e20ab37bee9d2a1f9ca3d914b0e98f09",
"d0beea4ce1c12190db64d10a82b96ef8",
"ac87da74d381d253820bcf4e5f19fcea",
"ce3f3a34a04ba5e5142f5db272b6cb1f",
"13843aca227ef709694bbfe4e5a32203",
"ca19a4c4eb435cb44d74c1e589e51a10",
"19edec8e46bdf97e3018569c0a60baa3",
"972e078458ce3cb6e32f795ff4972718",
"071824f6039981e9c57725453e005beb",
"66cd6098426b0e69e30e7fa360310728",
"f78d152df5d277d0ab7d25fb7d1841f3",
"dba3a36431c4aaf593566f7421abaa22",
"8820bbdad85ebee06632c379231cfb6b",
"722bc7cde7d548b81c5996519e1b0f0f",
"c2862c390c830eb3c740ade576d64773",
"94da978fe383b341f9588f9bab246774",
"bea3bb724dbd1704cf45aea8e73c01e1",
"ade2289739760fa27fd4f7d4ffbc722d",
"3cd0538114fe416b32cdd814e2ee57b3",
]
# 可爆破字符集:可打印 ASCII(不含空白也行;这里用常见可打印)
charset = string.ascii_letters + string.digits + string.punctuation + " _"
recovered = []
for i, target in enumerate(hashes):
found = None
for c in charset:
test = f"{salt}{i}{c}"
if md5_hex(test) == target:
found = c
break
if found is None:
raise RuntimeError(f"[!] index {i} not found in charset, try expanding charset.")
recovered.append(found)
print(f"[+] i={i:02d} -> {found!r} (partial: {''.join(recovered)})")
core = "".join(recovered)
flag = f"KCTF{{{core}}}"
print("\n[+] core :", core)
print("[+] flag :", flag)
if __name__ == "__main__":
main()故flag为:KCTF{_L0TS_oF_bRuTE_foRCE_:P}
ps:off_3D60 那组还有一堆假的flag
代码里这一段:
strcpy(v21, "G00gleCTF_s@lt_2026");
if ( v6 == 24 ) {
for (i = 0; i < 13; i++) {
snprintf(buf, "%s%zu%c", salt, i, flag[i]);
md5(buf) == off_3D60[i]
}
}约束总结
项目 | 值 |
前缀 |
|
结尾 |
|
总长度 | 24 |
中间长度 | 13 |
salt |
|
hash 表 |
|
.data.rel.ro 顺序:
0 8af7f29b21564b87336ed4e4cdfb1a20
1 4d3f509284784ab67818b13e74fd5ebe
2 5a45666e1387ff739eb470f840532099
3 c96997e23323e502d5d0b07d24a68d50
4 efb388057adc3fe734d8b6ffb2bdd1e1
5 6df2aaf58e39f89d7a31a72e19e0efbf
6 9bbd077d3df7faedfd22fae85043d6c0
7 dc72837ea6ba778eebbd0401a35182f4
8 efa0bc7c5da3545ba15548b4b85eaf76
9 1c36dbad9144b1e1d23ddecb5d4df3e9
10 980663d212aed1ba720f7735873fa73c
11 9df295c8874bcac93c98babe78b9c946
12 2672e4d30c7da0d30749f09bc1b1eefa#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import hashlib
import string
def md5_hex(s: str) -> str:
return hashlib.md5(s.encode()).hexdigest()
def main():
salt = "G00gleCTF_s@lt_2026"
hashes = [
"8af7f29b21564b87336ed4e4cdfb1a20",
"4d3f509284784ab67818b13e74fd5ebe",
"5a45666e1387ff739eb470f840532099",
"c96997e23323e502d5d0b07d24a68d50",
"efb388057adc3fe734d8b6ffb2bdd1e1",
"6df2aaf58e39f89d7a31a72e19e0efbf",
"9bbd077d3df7faedfd22fae85043d6c0",
"dc72837ea6ba778eebbd0401a35182f4",
"efa0bc7c5da3545ba15548b4b85eaf76",
"1c36dbad9144b1e1d23ddecb5d4df3e9",
"980663d212aed1ba720f7735873fa73c",
"9df295c8874bcac93c98babe78b9c946",
"2672e4d30c7da0d30749f09bc1b1eefa",
]
charset = string.ascii_letters + string.digits + string.punctuation + " _"
recovered = []
for i, target in enumerate(hashes):
found = None
for c in charset:
test = f"{salt}{i}{c}"
if md5_hex(test) == target:
found = c
break
if found is None:
raise RuntimeError(f"[!] index {i} not found")
recovered.append(found)
print(f"[+] i={i:02d} -> {found!r} (partial: {''.join(recovered)})")
core = "".join(recovered)
fake_flag = f"GoogleCTF{{{core}}}"
print("\n[+] fake core :", core)
print("[+] fake flag :", fake_flag)
print("\n[!] 注意:程序会明确提示这是 decoy flag(假 flag)")
if __name__ == "__main__":
main()运行后得到的中间内容是:
n0T_tH3_r1GhT_0N3所以 假 flag 是:
GoogleCTF{n0T_tH3_r1GhT_0N3}KrackM3
这是一个linux动态调试+分析复杂函数题,这里我们不采用调试,进行手搓分析来尝试这个题
从 main 可见:
fgets读入,strcspn去掉换行。len == 0x20 (32)必须满足,否则Failed!sub_401890(s)必须为真,否则Failed!
sub_401890 汇编:
cmp dword ptr [rdi], 4654434Bh ; "KCTF" (little endian)
cmp byte ptr [rdi+4], 7Bh ; '{'
cmp byte ptr [rdi+1Fh], 7Dh ; '}'所以 flag 形式固定:
- 总长 32
- 前缀
KCTF{ - 最后一位
}
即:
KCTF{??????????????????????????}
(中间 26 字节未知)关键校验函数定位:sub_401590
main 中:
sub_401320(buf1, buf2)生成两张表(大小 256)sub_401480(buf3)生成 256 字节随机流sub_401590(flag, buf1, buf2, buf3)返回:
1→Success! Real flag accepted.2→ “假 flag”(Success but no points)- 其他 → Failed
因此“真 flag”一定对应 sub_401590 的返回值为 1。
拆 sub_401590:
sub_401550(i, a2, a3, a4) 的逻辑是:
i <= 11→ 取a2[i]12 <= i <= 21→ 取a3[i-12]22 <= i <= 31→ 取a4[i-22]
也就是说:有三段 rodata 数组(12 + 10 + 10 = 32),拼起来就是一张 32 字节目标表。
在 sub_401590 里它被调用了 4 次(四组常量),分别累计到 4 个按位 OR 的变量里(IDA 伪代码里的 v22/v23/v24/v25;汇编里的 var_63/64/62/61)。
看 sub_401590 结尾逻辑:
- 先检查
var_63/var_64/var_62是否满足某些条件,否则返回2 - 最后:
cmp [rsp+...+var_61], 0
setz al
retn也就是:返回 1 的条件是 var_61 == 0。
而在循环中,var_61 每轮更新是:
xor eax, r13d ; eax = sub_401550(...) ^ v15(或其低字节)
or [var_61], al因此只要能保证每一轮:
al == 0`
⇔ `v15_lowbyte == target_byte[i]那么整轮 OR 起来仍为 0,最终 var_61 == 0,函数返回 1 —— 真 flag 成立。
sub_401590 的循环计数是 rdi = 0..31。
每轮用到的东西:
- 输入 flag 的当前字节
flag[i] sub_401320生成的置换表/逆表(其中一张表在这一轮被索引)sub_401480生成的 256 字节随机流(这一轮被多次索引)- 一些滚动状态(
r8/r9以及var_4816 字节状态)
汇编中可以看到:
- 初始:
r8 = 0xB1EB4606F35CF7F9r9 = 0x881DB3E005D90DFFvar_48初始为xmmword_4022C0
- 每轮末尾会用本轮结果更新
r8/r9、并按规则更新var_48,再进入下一轮。
关键:我们不需要“理解它是啥加密”,只需要按汇编逐条复刻即可(纯确定性计算)。
解法:按轮枚举字节(0..255),匹配目标 v15(动态调试会简单一些)
因为真 flag 需要每轮 v15_lowbyte == target[i],而每轮计算只依赖:
- 当前轮之前的状态(可模拟)
- 当前轮输入字节(可枚举)
所以可做:
对 i = 0..31:
- 若 i 在已知位置(
KCTF{或末尾}),直接固定该字节 - 否则枚举
b = 0..255 - 用模拟器算出该轮
v15_lowbyte - 找到使
v15_lowbyte == target[i]的 b - 固化 b,并更新状态进入下一轮
复杂度:32 * 256 级别,非常快。
exp:
import struct
MASK64 = (1 << 64) - 1
def rol64(x, r):
r &= 63
return ((x << r) & MASK64) | (x >> (64 - r))
def rol8(x, r):
r &= 7
x &= 0xFF
return ((x << r) & 0xFF) | (x >> (8 - r))
def u8(x): return x & 0xFF
def u32(x): return x & 0xFFFFFFFF
def sub_401320_perm_inv():
# 生成 perm[256] 并构造 inv(inv[perm[i]] = i)
perm = list(range(256))
seed = 0xF5A4ADA5 & 0xFFFFFFFF
rcx = 0xFF
while rcx != 0:
v22 = rcx + 1
v23 = perm[rcx]
x = seed
x ^= (x << 13) & 0xFFFFFFFF
x ^= (x >> 17)
x ^= (x << 5) & 0xFFFFFFFF
seed = x & 0xFFFFFFFF
idx = seed % v22
perm[rcx] = perm[idx]
perm[idx] = v23
rcx -= 1
inv = [0] * 256
for i, b in enumerate(perm):
inv[b] = i
return bytes(perm), bytes(inv)
def sub_401480_stream():
res = 0x99ED0EBACD107339
mul = 0x2545F4914F6CDD1D
out = bytearray(256)
for i in range(256):
rdx = res >> 12
rax = res ^ rdx
rdx = rax ^ ((rax << 25) & MASK64)
rax = rdx ^ (rdx >> 27)
res = (rax * mul) & MASK64
out[i] = (res >> 56) & 0xFF
return bytes(out)
# sub_401550 的三段表(unk_4022A0/402290/402280)
tA1 = bytes([0x45,0xC0,0x01,0xFB,0x1E,0x3D,0xFD,0x2E,0xE5,0x7C,0xCC,0xB6])
tA2 = bytes([0x38,0xA6,0x14,0xF3,0x60,0x51,0xFB,0x1F,0xD1,0xE3])
tA3 = bytes([0x03,0xF1,0x32,0xFE,0xD6,0x3A,0x22,0xF3,0xAD,0x65])
def getA(i):
if i <= 0xB: return tA1[i]
if i <= 0x15: return tA2[i - 0xC]
if i <= 0x1F: return tA3[i - 0x16]
return 0
perm, inv = sub_401320_perm_inv()
stream = sub_401480_stream()
# xmmword_4022C0:IDA 显示为 6A124DE908B17733 2F910ED35CA71942
# SSE load 的内存顺序是低 qword 在前(little endian)
var48_init = struct.pack("<QQ", 0x2F910ED35CA71942, 0x6A124DE908B17733)
def step_compute(i, flagbyte, state):
r8 = state['r8']
r9 = state['r9']
var48 = state['var48']
eax_v4 = state['eax'] # 当前轮 v4(低8位用)
r10_v5 = state['r10'] # 当前轮 v5
r13_v9 = state['r13v9'] # 当前轮 v9
r14_v8 = state['r14'] # 当前轮 v8
rsi_v12 = state['rsi'] # 当前轮 v12
ebp = u32(r10_v5 + u32(r9) + 31 * i)
r13_add = u32(r13_v9 + i)
r14mix = u32(r14_v8 ^ u32(r8))
r11 = u8(flagbyte)
shift = (i & 7) * 8
edx = u32(19 * i)
edx ^= u32(((r9 >> 16) & 0xFFFFFFFF) ^ u32(r8))
edx ^= u32((0x6A124DE908B17733 >> shift) & 0xFFFFFFFF)
dl = u8(edx) ^ stream[u8(i + u8(r9))]
dl ^= u8(r11 + u8(ebp))
rol_res = rol8(dl, u8(r13_add + r14mix))
dl2 = u8(((r8 >> 32) & 0xFF) ^ rsi_v12 ^ rol_res)
perm_byte = perm[dl2]
const_shift32 = u32((0x2F910ED35CA71942 >> shift) & 0xFFFFFFFF)
v15 = u8(perm_byte ^ u8(r9) ^ u8(const_shift32) ^ u8(eax_v4))
# 更新 var48(对应 sub_401590 中两处写 var_48)
var48_new = bytearray(var48)
var48_new[i & 0xF] = u8((v15 ^ 0xA5) + r10_v5 + r11)
var48_new[(i + 3) & 0xF] ^= rol8(u8(r11 + v15), u8(ebp))
# 比较分支(是否 call sub_4012C0 不影响状态关键寄存器,这里只需要 stream_byte)
stream_byte = stream[u8(v15 + i)]
# 状态更新(loc_40161E)
r11_upd = u8(r11 + i)
rsi64 = stream_byte ^ 0x9E3779B97F4A7C15
t = (((u8(r11 ^ v15)) << shift) & MASK64) ^ r8
t = rol64(t, 7)
r8_new = (rsi64 + t) & MASK64
a = u8((v15 + 0x3D) ^ r11_upd)
t2 = (a * 0x100000001B3 + r9) & MASK64
t2 ^= (t2 >> 33)
t2 = (t2 * 0xC2B2AE3D27D4EB4F) & MASK64
r9_new = t2 ^ (t2 >> 29)
# 下一轮寄存器装载索引(严格按 asm:用 old i + 8/12/6/14)
next_state = dict(
r8=r8_new,
r9=r9_new,
var48=bytes(var48_new),
r10=var48_new[(i + 1) & 0xF],
r13v9=var48_new[(i + 8) & 0xF],
r14=var48_new[(i + 12) & 0xF],
rsi=var48_new[(i + 6) & 0xF],
eax=var48_new[(i + 14) & 0xF],
)
return v15, next_state
def solve():
state = dict(
r8=0xB1EB4606F35CF7F9,
r9=0x881DB3E005D90DFF,
var48=var48_init,
eax=0x4D,
r10=0x42,
r13v9=0x2F,
r14=0x08,
rsi=0x0E,
)
flag = bytearray(32)
prefix = b"KCTF{"
for i in range(32):
target = getA(i)
if i < len(prefix):
candidates = [prefix[i]]
elif i == 31:
candidates = [ord('}')]
else:
candidates = range(256)
found = None
for b in candidates:
v15, stn = step_compute(i, b, state)
if v15 == target:
found = (b, stn)
break
if found is None:
raise RuntimeError(f"no solution at i={i}")
flag[i] = found[0]
state = found[1]
return flag.decode()
if __name__ == "__main__":
print(solve())KCTF{_R3_iS_FuNR1gHT?_EnjOy_r3_}
ps:方法二,动态调试出v16-v20的内容,更简单一些
ReM3
给了个elf文件,无壳,放入ida里看看逻辑
程序要求:
- 输入长度 必须是 29
- 否则直接
Failed!
v3 = strcspn(s, "\r\n");
if ( v3 != 29 )
goto Failed;不算前面的假的flag还存在一个哈希校验(FNV-1a)
if ( sub_1470(s) == 0xE76FA3DABA5D6F3A )sub_1470:
result = 0x14650FB0739D0383;
result = 0x100000001B3 * (byte ^ result);标准 **FNV-1a 64-bit **可爆破 / 反算 仍然是假 flag
输出:
KCTF{hash_passes_but_fake!!!}真正校验路径:
如果前面都没 return,程序才走到这里:
sub_14C0(v5); // 加密变换
sub_1400(v5, unk_2160, unk_2150, unk_2140)只有这里通过,才是:
Success! Real flag accepted.sub_14C0 处理后的 29 字节
被拆成三段和 rodata 中的常量比对:
偏移 | 长度 | 对比数据 |
0 | 8 | unk_2160 |
8 | 2 | unk_2160+8 |
10 | 10 | unk_2150 |
20 | 9 | unk_2140 |
故exp为:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
C1 = 0x2F910ED35CA71942
C2 = 0x6A124DE908B17733
unk_2160 = [0xDC,0x6B,0xBB,0x4D,0xFD,0x25,0xE4,0x7E,0xC3,0x26] # 10 bytes
unk_2150 = [0xF5,0x72,0xAB,0x96,0xFC,0x8D,0x55,0x10,0x93,0xC1] # 10 bytes
unk_2140 = [0xFD,0x81,0x46,0x5B,0x7E,0x33,0x83,0x8F,0x2F] # 9 bytes
cipher = bytes(unk_2160 + unk_2150 + unk_2140)
assert len(cipher) == 29
def rol8(x, r):
r &= 7
return ((x << r) & 0xFF) | ((x & 0xFF) >> (8 - r) if r else 0)
def ror8(x, r):
r &= 7
return ((x & 0xFF) >> r) | ((x << (8 - r)) & 0xFF) if r else (x & 0xFF)
def int32(x):
x &= 0xFFFFFFFF
return x - 0x100000000 if (x & 0x80000000) else x
def inv_sub_14C0(cipher_bytes: bytes) -> bytes:
v2 = 0
v3 = 0
v4 = int32(-61)
plain = []
for i in range(29):
c = cipher_bytes[i]
# v6_pre = v3 + (C1 >> (8*(i&7)))_byte
c1_byte = (C1 >> (8 * (i & 7))) & 0xFF
v6_pre = int32(v3 + c1_byte)
v3 = int32(v3 + 29)
# v7 = v2 ^ (C2 >> (8*(i&7)))_byte (only need low8)
c2_byte = (C2 >> (8 * (i & 7))) & 0xFF
v7_low = (v2 & 0xFF) ^ c2_byte
# forward: c = ROR8( (v7_low ^ (v4_low + v6_low)), v4 )
# invert: v8pre_low = ROL8(c, v4)
v8pre_low = rol8(c, v4)
# solve v6_low from: v8pre_low = v7_low ^ ((v4_low + v6_low) mod 256)
v6_low = ((v8pre_low ^ v7_low) - (v4 & 0xFF)) & 0xFF
# forward: v6_low = ROL8( plain ^ v6_pre_low, rot1 )
# invert: plain = ROR8(v6_low, rot1) ^ v6_pre_low
rot1_byte = (C2 >> ((8 * i + 16) & 0x38)) & 0xFF
rot1 = rot1_byte & 7
p = ror8(v6_low, rot1) ^ (v6_pre & 0xFF)
plain.append(p)
# advance states exactly like forward (v2, v4 depend on ciphertext byte c)
v2 = int32(v2 + 17)
v7shift = (8 * i + 24) & 0x38
term = int32(((C1 >> v7shift) & 0xFFFFFFFF) ^ 0xFFFFFFA5)
v4 = int32(v4 + c + term)
return bytes(plain)
# 可选:forward 复现 sub_14C0,用来验证确实能生成目标密文
def fwd_sub_14C0(plain_bytes: bytes) -> bytes:
assert len(plain_bytes) == 29
v2 = 0
v3 = 0
v4 = int32(-61)
out = bytearray(plain_bytes)
for i in range(29):
c1_byte = (C1 >> (8 * (i & 7))) & 0xFF
v6 = int32(v3 + c1_byte)
v3 = int32(v3 + 29)
rot1 = ((C2 >> ((8 * i + 16) & 0x38)) & 0xFF) & 7
v6_low = rol8((out[i] ^ (v6 & 0xFF)) & 0xFF, rot1)
v6 = (v6 & ~0xFF) | v6_low
c2_byte = (C2 >> (8 * (i & 7))) & 0xFF
v7 = int32(v2 ^ c2_byte)
v2 = int32(v2 + 17)
v8_low = ( (v7 & 0xFF) ^ ((v4 + v6) & 0xFF) ) & 0xFF
c = ror8(v8_low, v4)
out[i] = c
v7shift = (8 * i + 24) & 0x38
term = int32(((C1 >> v7shift) & 0xFFFFFFFF) ^ 0xFFFFFFA5)
v4 = int32(v4 + c + term)
return bytes(out)
if __name__ == "__main__":
flag = inv_sub_14C0(cipher)
print("[+] flag =", flag.decode())
# 验证一下:把解出来的 flag 正向加密,应该刚好等于 rodata 拼的密文
enc = fwd_sub_14C0(flag)
print("[+] verify:", "OK" if enc == cipher else "FAIL")真实 flag 是
KCTF{w3Lc0m3_T0_tHE_r3_w0rLD}
ReM3_Again
程序启动后提示:
=== KCTF Challenge ===Enter flag:
输入后要么 Failed!,要么 Success! Real flag accepted.
目标:求出 real flag。
main()函数:
反编译 main 核心部分:
- 读取输入
fgets(s,256,stdin),去掉\r\n,得到长度v3 - 若
v3不满足某个 bit 奇偶判断,会调用z()(但返回值没用,属于干扰) - 必须满足
v3 == 38 - 调用
p(v8, v9)生成一个 256 的映射表(v9) - 有三组
chk_first(...),命中会输出 “Success! ...but you won't get points...” —— 这是 假 flag / decoy 通道 - 真 flag 校验是:
cat3(v5, x_r0, x_r1, x_r2); // 拼出 38 bytes 的常量串
t(v6, v5, v9); // 变换得到目标串 v6 (38 bytes)
if (eq(s, v6)) accept结论:real flag 就是 t(x_r0||x_r1||x_r2, v9) 的输出(38字节)。
p() 的作用分两段:
(1) 初始化 0..255
前半段 SSE 指令在内存里写入一段 256 字节,等价于:
perm = [0,1,2,...,255](SIMD 只是加速填表。)
(2) 洗牌(Fisher–Yates)+ 逆表
你贴的 IDA 汇编里关键点:
rcx = rdi + 0xFF,从末尾往前esi = (rcx - rdi) + 1,作为div esi的除数- 余数
rdx就是随机下标 - 交换
perm[rcx]和perm[rdx]
随机数生成是一个 xorshift 变体,seed 固定为:
mov [rsp+var_C], 0F5A4ADA5h最后建立逆表:
movzx edx, byte ptr [rdi+rax] ; edx = perm[i]
mov [r8+rdx], al ; inv[perm[i]] = i因此 v9 是 inv(逆置换表)。
cat3 将 x_r0/x_r1/x_r2 拼成一段 38 bytes:
x_r0取 12 bytes(8+4)x_r1取 13 bytes(8+5)x_r2取 13 bytes(8+5)
你 rodata 里对应字节为:
x_r0:0F 5F 6F F7 01 0F B2 18 EE D3 37 84x_r1:D2 4C A4 79 4A F7 18 CF 68 78 26 FC 37x_r2:D0 8B 99 5A E7 F5 46 37 82 48 FB FE 0B
合起来正好 38 字节,作为 t() 的输入参考串。
t_constprop_0(out, ref, inv) 做 38 轮循环,每轮产出 1 字节。
关键点:
- 内部维护一个 16 字节状态
i[16],初始来自xmmword_2180 - 每轮会取一个常量
0x6A124DE908B17733的第(idx&7)个字节参与混合 - 用
ROR8(8-bit rotate right)做扰动 - 用
inv[...]查表得到一个字节,再减去一个动态偏移,得到输出字节
因为最终比较 eq(s, v6),所以 v6 就是我们要的 flag。
端序坑:
IDA 显示:
xmmword_2180 xmmword 6A124DE908B177332F910ED35CA71942h但这个显示顺序不一定等于内存顺序。实际跑脚本验证发现:
- 按显示顺序(IDA_order)出来一半乱码
- 按反序(mem_reversed)得到完整可打印 ASCII 且为 KCTF{...}
因此 i_init 应使用 反序:
42 19 A7 5C D3 0E 91 2F 33 77 B1 08 E9 4D 12 6Aexp:
#!/usr/bin/env python3
def ror8(x: int, r: int) -> int:
r &= 7
x &= 0xFF
return ((x >> r) | ((x << (8 - r)) & 0xFF)) & 0xFF
def xorshift32_step(v: int) -> int:
v &= 0xFFFFFFFF
a = (v ^ ((v << 13) & 0xFFFFFFFF)) & 0xFFFFFFFF
b = (a ^ (a >> 17)) & 0xFFFFFFFF
v = (b ^ ((b << 5) & 0xFFFFFFFF)) & 0xFFFFFFFF
return v
def build_inv_table() -> list[int]:
perm = list(range(256))
state = 0xF5A4ADA5 # 汇编里 mov [rsp+var_C], 0F5A4ADA5h
for pos in range(255, -1, -1):
state = xorshift32_step(state)
j = state % (pos + 1)
perm[pos], perm[j] = perm[j], perm[pos]
inv = [0] * 256
for i, p in enumerate(perm):
inv[p] = i
return inv
def ref_bytes_38() -> list[int]:
x_r0 = [0x0F,0x5F,0x6F,0xF7,0x01,0x0F,0xB2,0x18,0xEE,0xD3,0x37,0x84]
x_r1 = [0xD2,0x4C,0xA4,0x79,0x4A,0xF7,0x18,0xCF,0x68,0x78,0x26,0xFC,0x37]
x_r2 = [0xD0,0x8B,0x99,0x5A,0xE7,0xF5,0x46,0x37,0x82,0x48,0xFB,0xFE,0x0B]
return x_r0 + x_r1 + x_r2
def t_transform(ref: list[int], inv: list[int], i_init: list[int]) -> bytes:
i = i_init[:] # 16 bytes state
v4 = 0
v5 = 0
v6 = 47
v7 = 14
v8 = 66
v10 = 0xC7 # -57
const64 = 0x6A124DE908B17733
out = bytearray()
for idx in range(38):
v12 = ref[idx] & 0xFF
v13 = (v5 + v8 + v10) & 0xFF
const_byte = (const64 >> (8 * (idx & 7))) & 0xFF
mix = (const_byte ^ v10 ^ v4 ^ v12) & 0xFF
rr = ror8(mix, (v6 + idx) & 0xFF)
table_index = (v7 ^ rr) & 0xFF
v14 = (inv[table_index] - v13) & 0xFF
out.append(v14)
# state update
i[idx & 0xF] = ((v14 ^ 0xA5) + v12 + v8) & 0xFF
i[(idx + 3) & 0xF] ^= ror8((v12 + v14) & 0xFF, v13)
if idx == 37:
break
v5 = (v5 + 31) & 0xFF
v4 = (v4 + 19) & 0xFF
v8 = i[(idx + 1) & 0xF]
v10 = (v10 + v12 + ((i[(idx + 9) & 0xF] ^ 0x3C) & 0xFF)) & 0xFF
v6 = i[(idx + 8) & 0xF]
v7 = i[(idx + 6) & 0xF]
return bytes(out)
def printable_score(b: bytes) -> int:
# 可打印 ASCII + 常见flag字符加分
ok = 0
for c in b:
if 32 <= c <= 126:
ok += 1
return ok
def main():
inv = build_inv_table()
ref = ref_bytes_38()
ida_order = [0x6A,0x12,0x4D,0xE9,0x08,0xB1,0x77,0x33,0x2F,0x91,0x0E,0xD3,0x5C,0xA7,0x19,0x42]
mem_order = list(reversed(ida_order))
for name, init in [("IDA_order", ida_order), ("mem_reversed", mem_order)]:
b = t_transform(ref, inv, init)
sc = printable_score(b)
print(f"[{name}] score={sc}/38 hex={b.hex()}")
try:
s = b.decode("utf-8")
except UnicodeDecodeError:
s = b.decode("latin-1")
print(f"[{name}] text={s!r}")
print(f"[{name}] has_KCTF={{?}} -> {'KCTF{' in s}")
print()
if __name__ == "__main__":
main()flag为:KCTF{aN0Th3r_r3_I_h0PE_y0U_eNj0YED_IT}
四道逆向题均需结合静态分析与算法逆推,分别涉及MD5校验绕过、置换表+状态机枚举、FNV-1a哈希约束下AES-like变换逆运算、及基于xorshift的逆置换查表解密。
由 AI 根据全文自动生成,仅供参考,以原文为准
