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]
    }
}

约束总结

项目

值

前缀

GoogleCTF{

结尾

}

总长度

24

中间长度

13

salt

G00gleCTF_s@lt_2026

hash 表

off_3D60(13 个)

.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_48 16 字节状态)

汇编中可以看到:

  • 初始:
  • r8 = 0xB1EB4606F35CF7F9
  • r9 = 0x881DB3E005D90DFF
  • var_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 核心部分:

  1. 读取输入 fgets(s,256,stdin),去掉 \r\n,得到长度 v3
  2. 若 v3 不满足某个 bit 奇偶判断,会调用 z()(但返回值没用,属于干扰)
  3. 必须满足 v3 == 38
  4. 调用 p(v8, v9) 生成一个 256 的映射表(v9)
  5. 有三组 chk_first(...),命中会输出 “Success! ...but you won't get points...” —— 这是 假 flag / decoy 通道
  6. 真 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 84
  • x_r1: D2 4C A4 79 4A F7 18 CF 68 78 26 FC 37
  • x_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 6A

exp:

#!/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}