3551 字
18 分钟
mini-LCTF 2026 部分题目 Writeup
2026-05-10
Write Up
CTF
/
逆向工程
/
安全杂项

这次给 mini-LCTF 2026 出的几道逆向和杂项题，发一下题解。

ezbox#

一个终端推箱子游戏，10 层汉诺塔 + 递归方块。完成所有关卡获得 flag。

附件：ezbox（Linux ELF，PyInstaller 打包）

解法一：玩游戏通关#

解包反编译后，直接在 Python 里导入游戏模块，模拟按键操作完成全部 1024 个上下文。

1. 解包 & 反编译#

Terminal window
# 1. 解包
pyinstxtractor ezbox


# 2. 上传 .pyc 到 https://www.pylingual.io/ 反编译
# 得到 main.py, game.py, levels.py, flag.py 源码

解包后目录里包含所有 .pyc 和 _core.so，Python 可以直接 import .pyc，无需修复反编译代码。用 pylingual 只是为了读懂游戏逻辑。注意 Python 版本要与打包环境一致（3.12）。

2. 理解游戏机制#

  • 关卡 h0（基案）：一个箱子 b，推上 _ 目标，玩家站到 = 就算完成
  • 关卡 h1 ~ h10：汉诺塔布局，方块 0 ~ N-1 堆在柱 A（x=2），目标在柱 C（x=15）
  • 走进入未完成的递归方块 → 进入子关卡。子关卡完成后方块解锁，可推动。
  • 每次进入子关卡产生唯一上下文路径（h10 → h10/0 → h10/1/0 → …）
  • completed_hashes 追踪所有已完成的上下文

3. 编写游戏 AI#

核心思路：对于每个关卡，按顺序（从上到下）处理方块：

  1. 走到方块左侧（x=1 列，没有实体挡路）
  2. 往右推 → 进入（未完成时）或推动（已完成时）
  3. 进入后递归处理子关卡
  4. 退出后把方块推到目标（x=15）
  5. 最终走向 = 完成关卡
from game import Game
from flag import try_get_flag
from levels import load_level_file, RECURSIVE_BLOCKS


def walk_to(game, tx, ty):
    """走到 (tx, ty)，通过 x=1 空列规避实体"""
    px, py = game.player_pos
    while px > 1: game.move(-1, 0); px = game.player_pos[0]
    while px < 1: game.move(1, 0); px = game.player_pos[0]
    while py < ty: game.move(0, 1); py = game.player_pos[1]
    while py > ty: game.move(0, -1); py = game.player_pos[1]
    while px < tx: game.move(1, 0); px = game.player_pos[0]


def solve_level(level_id, game, context):
    terrain, entities, player_pos = load_level_file(level_id)
    game.load_level(level_id, terrain, entities, player_pos,
                    level_id, context=context)


    if level_id == 'h0':
        game.move(1,0); game.move(0,1); game.move(1,0)
        game.move(0,1); game.move(0,1)
        if game.check_completion(): game.complete_level()
        return


    blocks = sorted([(p, e) for p, e in entities.items() if e != 'p'],
                    key=lambda x: (x[0][1], x[0][0]))


    for (bx, by), bid in blocks:
        if bid in RECURSIVE_BLOCKS and not game.is_block_completed(bid):
            walk_to(game, 1, by)
            result = game.move(1, 0)
            if result and result.startswith('enter:'):
                game.enter_block(bid)
                solve_level(f'h{bid}', game, f'{context}/{bid}')
                game.exit_block()


        cur = next((p for p, e in game.entities.items() if e == bid), None)
        if not cur: continue
        cx, cy = cur
        walk_to(game, cx - 1, cy)
        for _ in range(15 - cx): game.move(1, 0)


    eq = next((p for p, c in terrain.items() if c == '='), None)
    if eq:
        walk_to(game, 1, eq[1])
        while game.player_pos[0] < eq[0] - 1: game.move(1, 0)
        game.move(1, 0)
    if game.check_completion(): game.complete_level()




game = Game()
solve_level('h10', game, 'h10')
print(try_get_flag(game.completed_hashes, game.total_steps))

cd 进解包目录后运行。完整脚本见源文件 solve.py。

解法二：逆向 Python 代码直接算密钥#

不需要实际玩游戏。1024 个上下文哈希只依赖固定地形上的目标位置，可以直接从关卡文件计算。

1. 理解密钥派生#

反编译 flag.py 后看到：

def derive_key(completed_hashes):
    combined = ''.join(completed_hashes[lp] for lp in sorted(completed_hashes))
    return hashlib.sha256(combined.encode()).digest()[:16]


def hash_level_state(level_path, goals_str):
    data = f"{level_path}|{goals_str}"
    return hashlib.sha256(data.encode()).hexdigest()

密钥 = 把所有 1024 个上下文哈希按字典序串联 → SHA256 → 前 16 字节。

每个上下文哈希 = SHA256("h10/1/0|2,3;3,4") 这种形式，只依赖该上下文对应关卡的 _ 和 = 位置。

2. 生成 1024 个上下文并计算哈希#

levels.py 里的 collect_all_context_paths() 可以列出全部 1024 个上下文。每个上下文的关卡文件取其最后一段（h10/1/0 → h0）。

from levels import load_level_file, collect_all_context_paths
from flag import hash_level_state, derive_key


def file_for_context(ctx):
    """h10/1/0 → h0, h10 → h10"""
    last = ctx.rsplit('/', 1)[-1]
    return last if last.startswith('h') else f'h{last}'


contexts = collect_all_context_paths()
hashes = {}
for ctx in sorted(contexts):
    file_id = file_for_context(ctx)
    terrain, _, _ = load_level_file(file_id)
    goals = sorted(f'{x},{y}' for (x,y), c in terrain.items() if c in '=_')
    hashes[ctx] = hash_level_state(ctx, ';'.join(goals))


key = derive_key(hashes)

3. 解密 flag#

flag 加密字节在 _core.so 里。可以用 IDA 提取，也可以直接用 Python 的 _core.decrypt(key) 调用：

from _core import decrypt
print(decrypt(key))
# miniL{EZ_Hano1_ez_s1gn1n_r1ght?}

cd 进解包目录后运行。

考点总结#

考点说明
PyInstaller 解包pyinstxtractor 提取 .pyc
Python 反编译pylingual.io 在线反编译，pycdc 备选
原生逆向IDA 分析 _core.so（XXTEA + 嵌入加密字节）
汉诺塔结构方块 K → 子关卡 hK，递归上下文 h10/1/0…
哈希链分析1024 个上下文哈希只依赖固定地形
绕过游戏不玩游戏直接算哈希链

Flag: miniL{EZ_Hano1_ez_s1gn1n_r1ght?}

GQuuuuuupX#

题目给了一个能被 upx -d 正常解包的 Linux ELF，但直接解包后的程序默认使用 key 0x42，只接受一个 decoy flag；原始 packed 程序的 UPX stub 在跳转到 OEP 前把同一个 key 改成 0x37。比较的地方是流式比较，可以下断点爆破，也可以逆向算法逐步求解。

Step 1: 解包并逆出 decoy#

handout 是没有 section header 的 packed ELF：

Terminal window
$ file GQuuuuuupX
GQuuuuuupX: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), BuildID[sha1]=d1bfa3b950b441544fee994edcbbdd40c3198636, for GNU/Linux 3.2.0, statically linked, no section header

upx -d 可以直接恢复出普通 stripped ELF：

Terminal window
$ upx -d -o GQuuuuuupX.upx-d GQuuuuuupX
                       Ultimate Packer for eXecutables
                          Copyright (C) 1996 - 2026
UPX 5.1.1       Markus Oberhumer, Laszlo Molnar & John Reiser    Mar 5th 2026


        File size         Ratio      Format      Name
   --------------------   ------   -----------   -----------
     30752 <-     12688   41.26%   linux/amd64   GQuuuuuupX.upx-d


Unpacked 1 file.

把 GQuuuuuupX.upx-d 扔进 IDA/Ghidra 后，可以先从 main 找到普通 flag 检查逻辑：输入格式是 miniL{...}，body 长度为 103，body 字符集限制在 [A-Z0-9_]。继续往里跟 verifier，会看到一个全局状态字节参与 profile 选择：

g_stub_state.key = 0x42;


profile = ((((unsigned)g_stub_state.key >> 1) ^ g_stub_state.key) ^ 1) & 1;

因此在解包后的 plain ELF 中：

key = 0x42
profile = 0

verifier 主体看起来比较绕，但它是逐字节可逆的。实际复现时需要从反编译结果里还原这些部分：

g_material_blob              # 存放 masked anchors 和 round constants
g_round_program_enc          # key/profile 相关的 VM bytecode
g_opcode_map_enc             # key/profile 相关的 opcode map
decode_material_slots()
decode_round_program()
decode_opcode_map()
init_profile_state()
derive_step()
transform_byte()
update_rolling()
mix_body_byte()

每一位的恢复流程是：

raw    = masked_anchor[i] ^ anchor_mask(profile, key, i, rolling)
step   = derive_step(profile, key, i, state, scratch, rolling, raw)
target = low_byte(step)
body[i] = invert_transform_byte(target, state, step, i)
rolling/state/scratch = update_with_recovered_byte(...)

其中 transform_byte() 只由 byte 加法、xor 和 8-bit rotate 组成。直接倒序写解密脚本，用 profile = 0, key = 0x42 运行恢复脚本，会得到：

miniL{ANTHROPIC_MAGIC_STRING_TRIGGER_REFUSAL_1FAEFB6177B4672DEE07F9D3AFC62588CCD2631EDCF22E8CCC1FB35B501C9C86}

btw, 这玩意能让Claude罢工，虽然好像AI选手清一色的GPT

这个 flag 能过 upx -d 后的程序，但不能过原始 handout：

upx-d  decoy rc=0 out=correct!
packed decoy rc=1 out=try again~

这说明 upx -d 解出来的只有一部分是真的，完整的程序需要进一步逆向。

Step 2: 动态确认 UPX stub 改 key#

既然 plain 程序接受 decoy，而 packed 程序拒绝 decoy，就应该检查 UPX stub 在跳 OEP 前有没有改写 plain ELF 的数据。plain ELF 是 non-PIE，解包后可以直接定位 verifier key 地址：

g_stub_state.key = 0x407fa0

对原始 packed 文件下硬件 watchpoint：

Terminal window
$ gdb -q GQuuuuuupX
(gdb) watch *(unsigned char*)0x407fa0
(gdb) run miniL{A}

第一次断下是 loader 把 plain 数据初始化成 0x42：

Hardware watchpoint 1: *(unsigned char*)0x407fa0


Old value = 0 '\000'
New value = 66 'B'
0x00007ffff7ff8aee in ?? ()
0x407fa0: 0x42

继续运行，第二次断下就是关键：

Terminal window
(gdb) continue
Hardware watchpoint 1: *(unsigned char*)0x407fa0


Old value = 66 'B'
New value = 55 '7'
0x0000000000403a38 in ?? ()
0x407fa0: 0x37
rip            0x403a38            0x403a38
   0x403a30: ret
   0x403a31: syscall
   0x403a33: movb   $0x37,-0x60(%r13)
=> 0x403a38: pop    %rdx
   0x403a39: pop    %rax
   0x403a3a: jmp    *%rax

也就是说，patched UPX stub 在跳回 OEP 前把 verifier key 改成了 0x37。代入 profile 公式：

key = 0x37
profile = 1

这个 key 不只是影响最终比较值。decode_round_program()、decode_opcode_map()、material slot 顺序、scratch 大小、anchor mask 和 rolling state 都依赖 key/profile，所以不能从 decoy 简单替换字符串。

解法一：逆向算法#

虽然检验算法看起来很复杂，但现在正好是大模型时代，选择一个足够聪明的 LLM，把 upx -d 的结果丢给他，不断拷打询问即可获得一个按照步骤逆向的脚本，你只需要把LLM的脚本里的数据替换为刚刚分析出来的正确的数据。具体可以参考源文件里的 recover.py

解法二：GDB 爆破#

找到流式比较处，使用 gdb/Frida Hook 等手段获得程序计算出的值，一位位枚举输入即可爆破 flag。

这里给一个 gdb 脚本的例子（感谢 Starfall Koi / Radiant LyCn 的🔨）：

import gdb


charset = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_"
known_flag = ""


gdb.execute("set pagination off")
gdb.execute("break *0x403650")


for i in range(103):
    for c in charset:
        test_input = known_flag + c + "R" * (102 - i)


        with open("input.txt", "w") as f:
            f.write("miniL{" + test_input + "}\n")


        gdb.execute("run < input.txt")


        for _ in range(i):
            gdb.execute("continue")


        rax_val = int(gdb.parse_and_eval("$rax"))


        if (rax_val & 0xFF) == 0:
            print(f"[+] The {i}st/nd/th char is {c}")
            known_flag += c
            print(f"Current Flag is {known_flag}")
            break


print("FINAL FLAG: miniL{" + known_flag + "}")

Flag: miniL{HELLO_FROM_THE_OTHER_SIDE_IMUSTVE_CALLED_THOUSAND_TIMES_TO_TELL_YOU_IM_SORRY_FOR_EVERYTHING_THAT_I_DONE}

local music#

题目给出一个 wyy 二进制文件和 flag.enc 加密容器。逆向 wyy 发现其将 mp3 音频用 AES-128-ECB + 魔改 RC4 加密打包，密钥由固定字符串与文件修改时间的 SHA256 派生，且合法时间戳范围在编译时固化。爆破时间戳解密得到 mp3 音频后，根据 ID3 标签中的提示 “Do you know FFT?”，查看频谱图即可在末尾段看到 flag。

Step 1: 逆向 wyy，理解加密逻辑#

wyy 是一个 Rust 编译的二进制，通过 strings 和逆向分析可以还原其加密流程：

  • 密钥派生：SHA256("KaguyaIrohaYachiyo" + timestamp_string)，前 16 字节为 core_key，后 16 字节为 meta_key。
  • 时间戳约束：build.rs 在编译时将时间戳的合法范围写入 build_consts.rs，范围是 (编译时间/10000) ± 20000 个桶（每桶 10000 秒）。运行时 derive_keys() 内有 assert! 保护，超出范围直接 panic。
  • 容器结构：
HEADER: 10 字节 "MINILCTF\0\0"
key_frame:  [4 字节 LE 长度] [AES-ECB(KEY_PREFIX + audio_key) ⊕ 0x64]
meta_frame: [4 字节 LE 长度] [COMMENT_PREFIX + base64(AES-ECB(META_PREFIX + json)), 整体逐字节 ⊕ 0x63]
5 字节零填充
image_offset: 4 字节 LE
image_data
audio_data: 与 NcmRc4 流密钥 XOR 加密
  • 音频加密：魔改 RC4，KSA 为标准实现，PRGA 的索引计算为 box[(box[j] + box[(box[j] + j) & 0xFF]) & 0xFF]。64 字节 audio_key 由 16 字节 core_key 经 4 轮 rotate/add/xor 扩展得到。

Step 2: 爆破时间戳，解密容器#

根据之前的分析，时间戳的范围由 assert 限制，直接枚举时间戳即可。 对于每个候选时间戳：

  1. 计算 SHA256("KaguyaIrohaYachiyo" + ts) 得到 core_key 和 meta_key
  2. 解析 key_frame：逐字节 xor 0x64 后 AES-128-ECB 解密，去掉 KEY_PREFIX 得到 audio_key
  3. 解析 meta_frame：逐字节 xor 0x63 后取 COMMENT_PREFIX 之后部分 base64 解码，AES-128-ECB 解密得到元数据 JSON
  4. 用 audio_key 初始化 NcmRc4，XOR 解密音频数据
  5. 校验：解密后音频以 fLaC 或 ID3/0xFF 0xFB 开头即为成功

完整解题脚本：

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


import argparse
import base64
import hashlib
import shutil
import subprocess
from pathlib import Path




HEADER = b"MINILCTF\x00\x00"
KEY_PREFIX = b"miniL-audio-key"
META_PREFIX = b"miniL:"
COMMENT_PREFIX = b"miniL meta:"
KEY_SEED_PREFIX = b"KaguyaIrohaYachiyo"




def main() -> None:
    args = parse_args()
    if shutil.which("openssl") is None:
        raise SystemExit("openssl not found in PATH")


    data = args.input.read_bytes()
    if not data.startswith(HEADER):
        raise SystemExit("bad container header")


    base_ts = args.timestamp or int(args.input.stat().st_mtime)
    ts, audio, meta, image = try_decrypt(data, base_ts, max(args.search, 0))


    out_dir = args.output_dir or args.input.parent
    out_dir.mkdir(parents=True, exist_ok=True)
    stem = args.stem or args.input.stem


    # 写入解密后的音频（题目中为 mp3 格式）
    if audio.startswith(b"fLaC"):
        audio_ext = "flac"
    elif audio.startswith(b"ID3") or audio[:2] == b"\xFF\xFB":
        audio_ext = "mp3"
    else:
        audio_ext = "bin"
    audio_path = out_dir / f"{stem}.{audio_ext}"
    audio_path.write_bytes(audio)
    print(f"[+] decrypted audio → {audio_path}")


    # 写入元数据
    meta_path = out_dir / f"{stem}.json"
    meta_path.write_bytes(meta)
    print(f"[+] metadata → {meta_path}")


    # 写入封面图片
    if image:
        ext = "png" if image.startswith(b"\x89PNG") else "jpg"
        img_path = out_dir / f"{stem}.{ext}"
        img_path.write_bytes(image)
        print(f"[+] cover image → {img_path}")


    print(f"[*] timestamp = {ts}")
    # ID3 标签中有提示 "Do you know FFT?"，指向频谱图
    print(f"[*] 用 Audacity/Sonic Visualiser 查看 {audio_path} 的频谱图即可看到 flag")




def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="wyy challenge solver")
    parser.add_argument("input", nargs="?", type=Path, default=Path("flag.enc"))
    parser.add_argument("--timestamp", type=int, help="手动指定时间戳")
    parser.add_argument("--search", type=int, default=10000, help="爆破半径（秒）")
    parser.add_argument("--output-dir", type=Path, help="输出目录")
    parser.add_argument("--stem", help="输出文件名前缀")
    return parser.parse_args()




def try_decrypt(data, base_ts, radius):
    candidates = [base_ts]
    for delta in range(1, radius + 1):
        candidates.append(base_ts + delta)
        candidates.append(base_ts - delta)


    for ts in candidates:
        core_key, meta_key = derive_keys(ts)
        try:
            audio, meta, image = decrypt(data, core_key, meta_key)
            return ts, audio, meta, image
        except Exception:
            continue
    raise SystemExit(f"failed to decrypt around ts={base_ts} +/-{radius}s")




def derive_keys(ts):
    digest = hashlib.sha256(KEY_SEED_PREFIX + str(ts).encode()).digest()
    return digest[:16], digest[16:]




def decrypt(data, core_key, meta_key):
    pos = len(HEADER)


    # 解密 key frame → audio_key
    key_frame, pos = read_frame(data, pos)
    key_frame = bytes(b ^ 0x64 for b in key_frame)
    plain = aes128_ecb_decrypt(key_frame, core_key)
    if not plain.startswith(KEY_PREFIX):
        raise ValueError("bad key frame")
    audio_key = plain[len(KEY_PREFIX):]


    # 解密 meta frame
    meta_frame, pos = read_frame(data, pos)
    meta_frame = bytes(b ^ 0x63 for b in meta_frame)
    if not meta_frame.startswith(COMMENT_PREFIX):
        raise ValueError("bad meta prefix")
    payload = base64.b64decode(meta_frame[len(COMMENT_PREFIX):])
    meta_plain = aes128_ecb_decrypt(payload, meta_key)
    if not meta_plain.startswith(META_PREFIX):
        raise ValueError("bad meta")
    meta = meta_plain[len(META_PREFIX):]


    # 跳过 5 字节零 + image_offset + image_data
    pos += 5
    image_offset = int.from_bytes(data[pos:pos + 4], "little")
    pos += 4
    image, pos = read_frame(data, pos)
    if image_offset > len(image):
        pos += image_offset - len(image)


    # 解密音频
    audio = xor_audio(data[pos:], audio_key)
    return audio, meta, image




def aes128_ecb_decrypt(data, key):
    proc = subprocess.run(
        ["openssl", "enc", "-aes-128-ecb", "-d", "-nopad", "-nosalt", "-K", key.hex()],
        input=data, check=True, capture_output=True,
    )
    result = proc.stdout
    # PKCS7 unpad
    pad = result[-1]
    if pad == 0 or pad > 16 or result[-pad:] != bytes([pad]) * pad:
        raise ValueError("bad pkcs7")
    return result[:-pad]




def xor_audio(data, key):
    box = list(range(256))
    j = 0
    for i in range(256):
        j = (box[i] + j + key[i % len(key)]) & 0xFF
        box[i], box[j] = box[j], box[i]


    plain = bytearray(data)
    for i in range(len(plain)):
        j = (i + 1) & 0xFF
        plain[i] ^= box[(box[j] + box[(box[j] + j) & 0xFF]) & 0xFF]
    return bytes(plain)




def read_frame(data, pos):
    size = int.from_bytes(data[pos:pos + 4], "little")
    return data[pos + 4:pos + 4 + size], pos + 4 + size




if __name__ == "__main__":
    main()

Step 3: 查看频谱图#

解密得到的 mp3 文件用 Audacity 打开，切换到频谱图（Spectrogram）视图，在音频末尾段可见 flag 文本。

也可以用 Python 直接渲染（需要先将 mp3 转为 wav）：

import subprocess
from pathlib import Path
import numpy as np
from scipy.io import wavfile
from scipy.signal import stft
from PIL import Image


def mp3_to_wav(mp3_path):
    wav_path = mp3_path.with_suffix(".wav")
    subprocess.run(
        ["ffmpeg", "-v", "error", "-i", str(mp3_path), "-ar", "48000", "-ac", "2", str(wav_path)],
        check=True,
    )
    return wav_path


wav = mp3_to_wav(Path("flag.mp3"))
sr, audio = wavfile.read(str(wav))
signal = audio[:, 0].astype(np.float32)
_, _, Z = stft(signal, fs=sr, window="hann", nperseg=4096, noverlap=3840)
spec = np.abs(Z[:, -8000:])  # flag 在末尾前约 38s~18s 的位置
spec_db = 20 * np.log10(np.clip(spec, 1e-10, None))
img = np.clip((spec_db + 80) / 80 * 255, 0, 255).astype(np.uint8)
Image.fromarray(np.flipud(img)).save("spectrogram.png")

Flag: miniL{Yur1_1s_JusT1c3!!F0ll0w_Ch0u-K@guy@-h1me!th@nks_m03w}

As the birds say#

Wabun Code + Morse Code 描述了一段 flag，需要解码内容然后还原。

Step 1#

观察可以发现有3种声音，不妨按照第一次出现的顺序标记为012，可以发现没有连续的22出现，推测2是分割符，进一步根据间隔不一，猜测是 Morse Code。

Step 2#

由于三种声音长度各不相同，让AI写一个简单的枚举长度+贪心匹配，可以得到下面的序列。

-.. --- .- ..-. .-.-.- --.. ... ...-.. -... ... -. -- .. -. .. .-.. -.. --- .-.--.. -... --.-... -..- --. .-.-.- .-. .-
-- ..- -... ..-. -..-- ..- .-.. .--. ---- .-.--.. .-.. ---- -..- --- .-.-- .- -..- ---.- .-.-.. -.-. .-.-.- --.. ... ...
-.. ..-- .-. .- -- ..- -... ... -. .-- .- -... ..- -. -.-. --- -.. . .. ... ... --- ..- ... . .-.. . ... ... -.. --- .-.
--.. ---.- .-.-.. -.-.- .-.-. .-.-.- -. .-.-. ----.. -... --.-- .-.-. -... .--.- ---.- ---- --.-- .-.--.. .--. .-. .-...
. --- .-.-- .- -..- ---.- .-.-.. -- .-.-. .-.-.- -.-.- .- --.-. -- ..-- -. .-.-. ----.. -... .-... .-... -..-. --.-... .
-.--.. -... --.-... -..- --. -..- ---.- .-.-.. ----.. .-.-.- --.. ... ...-.. ..-. -..-- ..- ..-- -.--- .--.- .--- --.--
.--. ..-.. -..- .--.- ...- -.-. .-.-.- .-... .--.- .--- .---... .-.- -.-. .-.-.- .- .--.- .--- -.-.- .-.-. -.-. .-.-.- -
-.-- .- .--- .- ..-. -.-. .-... -.-.. .-.. -.--- .-.-- ...- -... -.-.- .- .-.-.. ... -.

需要注意有几处静音段，这里其实是在表示flag content里词与词之间的间隔。

Morse code sequence visualization

用 CyberChef From Morse Code 解码得到下面的结果

CyberChef Morse decode result

需要注意到其中有 MINIL，说明我们的方向正确。再看到 WABUNCODEISUSELESS，进一步搜索 WABUN CODE 可以知道这里的乱码其实是和文码，开头的 DO 和结尾的 SN 正是切换语言的标志。

Step 3#

使用在线网站 https://www.dcode.fr/wabun-code 或直接 Ask LLM，可以恢复出原文：

“イチ、フラグハ [miniL] デハジマリ、ナイヨウハチュウカッコデカコマレテイマス。ニ、フラグノナイヨウハ [wabun code is so useless] デス。サン、タンゴハアンダースコアデツナガレテイマス。ヨン、サイショノタンゴハオオモジデハジマリマス。ゴ、フラグチュウノエーヲアットマークニ、オーヲゼロニ、イーヲサンニ、アイヲイチニオキカエテクダサイ。”

找个网站翻译成英语得到

  1. The flag begins with [miniL], and its content is enclosed in curly braces.
  2. The content of the flag is [wabun code is so useless].
  3. Words are connected by underscores.
  4. The first word begins with a capital letter.
  5. Please replace the ‘A’s in the flag with ’@’, the ‘O’s with ‘0’, the ‘E’s with ‘3’, and the ‘I’s with ‘1’.

按照说明一步步做得到结果：

miniL{W@bun_c0d3_1s_s0_us3l3ss}
mini-LCTF 2026 部分题目 Writeup
https://sandt3a.github.io/posts/miniL2026/mini-LCTF-2026-wp/
作者
Dorabit
发布于
2026-05-10
许可协议
CC BY-NC-SA 4.0
现代密码学实验一：从 XOR 到 SHA1 口令破解
New Year CTF 2026 逆向WP
© 2026 Dorabit. All Rights Reserved. / RSS / Sitemap
Powered by Astro & Fuwari