灰签名回廊

本题是一道典型的 Android 多层验证逆向题,出题人没有将 flag 明文存放在任何单一位置,而是通过 ContentProvider、BroadcastReceiver 和 Deep Link 三条独立的隐藏通道分别下发不同片段,最后在 native 层完成链式收口校验。题目设计上刻意区分了静态分析和动态调试的难度——Java 层负责分发片段和格式校验,native 层负责将所有片段串成一条因果链,任何一步走错都无法通过最终 hash 检查。

应用使用了一个签名绑定的机制,native 层的 Part1 校验与 APK 证书的 SHA-256 摘要绑定,这意味着即使拿到了完整的逆向逻辑,如果重新打包签名不一致,native 校验也会直接失败。这种设计本质上是一种反重打包保护,同时也让纯静态分析的难度提高了一个台阶。

基本信息

APK:attachment-68.apk

包名:com.example.gnd

应用名:SecureVault

Native 库:lib/x86_64/libnative-verify.so

从 AndroidManifest.xml 和 classes.dex 可以定位到几个关键组件:

com.example.gnd.hidden.SecretContentProvider
com.example.gnd.hidden.SecretReceiver
com.example.gnd.hidden.SecretActivity
com.example.gnd.security.SecureValidator

题面里"有人试图跳步,有人试图硬猜,有人只盯着终值"这句,实际上对应的就是这题的设计思路:最终收口虽然是一个 hash 校验,但前面的因果链如果没走通,后面就很容易卡死。

隐藏片段的触发与分发

应用通过三条相互独立的路径来分发 flag 的各个片段,每条路径对应一个 Android 组件,且彼此之间没有代码层面的直接耦合,只能通过调用时序和缓存状态来串联。这种设计意味着不能通过单纯阅读单个组件的代码来拼出完整答案。

ContentProvider 路径

隐藏 Provider 的查询入口是:

content://com.example.gnd.secret.provider/keys/fragment

对这个 URI 发起查询后,程序会生成并缓存第二段片段 fragment2。从反编译代码中可以确认,Provider 内部并没有对调用者身份做额外检查,这意味着只要知道 URI,任意应用都可以触发片段的生成。这里需要注意的是,fragment2 的内容并不是固定的——它依赖 Provider 内部维护的一个计数器状态,所以每次查询返回的值会随着调用次数发生变化。正确的做法是确保在完整攻击链中只触发一次查询,否则后续 native 校验会因为片段不一致而失败。

BroadcastReceiver 路径

隐藏 Receiver 的 action 是:

com.example.gnd.SECRET_ACTION

它不是单次广播直接给答案,而是分两步:

先发认证广播:

code=auth
token=ISCC2026

再发取 key 广播:

code=getkey
part=3

这样才会生成并缓存第三段片段 fragment3。Receiver 内部用一个简单的状态机控制流程——必须先收到 auth 广播设置认证标志,后续 getkey 才会真正执行片段生成逻辑。如果直接发 getkey 而没有前置的 auth,Receiver 会直接忽略请求。这种两步验证机制也是题目的一个反作弊点,避免了简单的一次性广播攻击。

Deep Link 路径

Manifest 中还藏着一个 deep link:

securevault://secret/unlock

但必须带上参数:

token=RC4_KEY_PART4

这一跳不是摆设,它会写入第四段相关片段 fragment4,也是最后 native 校验能不能闭环的关键。Deep link 的处理逻辑放在 SecretActivity 中,Activity 被启动后会从 Intent 中提取 token 参数,经过一轮简单的格式校验后写入全局缓存。如果 token 不正确,Activity 仍然会正常启动,但写入的 fragment4 会是无效值,后续 native 校验时第四段就会对不上。

自定义 Base64 编码

题里一个很容易踩坑的点,是几个隐藏片段并不是直接按标准 Base64 使用,而是走了一套自定义字母表映射。

从相关辅助类逻辑里可以恢复出它使用的 alphabet:

ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba9876543210+/

也就是大写字母反序、小写字母反序、数字反序、+/ 保持不变。

这个自定义 Base64 的实现方式和标准 Base64 的差异仅在于字母表的排列顺序,编码和解码的算法结构完全一致。从逆向角度看,如果直接用标准 Base64 库去解码从隐藏入口拿到的片段,会得到完全错误的结果,进而导致后续 native 校验失败。识别自定义 Base64 的关键特征是:在代码中搜索 Base64 相关的 alphabet 字符串常量,如果发现不是标准的 ABCDEFGH... 排列,就说明应用使用了自定义映射。

所以从隐藏入口拿到片段后,不能想当然按标准 Base64 直接解释,否则后面和 native 校验拼不上。

Java 层校验逻辑

总入口在 SecureValidator.c()。

整体逻辑可以概括为:检查 flag 必须以 ISCC{ 开头,以 } 结尾。取出内部字符串 inner = flag[5:-1]。要求 inner.length() == nativeGetMagicNumber() * 2。nativeGetMagicNumber() 返回 12,因此内部总长度必须是 24。再把这 24 个字符切成 4 段,长度分别为 7 / 5 / 5 / 7。

也就是:

e5JXv2T | _qrGM | _iJ5n | _bD24iR

前 3 段分别进入 nativeVerifyPart1、nativeVerifyPart2、nativeVerifyPart3。第 4 段进入 nativeVerifyPart4。中间还会经过 nativeComputeChainToken() 把前面阶段的结果串起来,作为最后一段校验的前置状态。

这个分段设计的意图是让每一段校验独立但又相互依赖。前三段各自有不同的校验逻辑和隐藏片段来源,而第四段必须依赖前三段计算出的 chain token 才能通过,形成了一个完整的因果链。这种设计迫使解题者必须按顺序走完整个流程,不能跳步。

Native 层校验链

native 层的四个校验函数构成了一个链式依赖结构。前三段各自独立输入,但都会向全局状态中写入中间结果;nativeComputeChainToken() 读取这些中间结果,计算出一个 token 传给第四段。整个链式结构等价于一个状态机,前三个状态各自消费一个隐藏片段并更新状态,第四段消费 chain token 和 deep link 片段后完成最终 hash 校验。

Part1

nativeVerifyPart1 会结合 APK 证书的 SHA-256 摘要参与校验,因此这部分不是纯常量比较,而是和当前 APK 自身签名绑定。从 so 的代码来看,它首先通过 JNI 回调获取当前应用的签名信息,计算 SHA-256,然后与硬编码在 so 中的 hash 值进行比较。即使这一段的输入正确,如果 APK 被重打包导致签名变化,验证也会失败。

恢复结果为:

e5JXv2T

Part2

nativeVerifyPart2 长度固定为 5,并把输入字节和从 Provider 链拿到的片段做组合比较。这段的校验并不是简单的字符串对比,而是先将输入通过自定义 Base64 解码,再与 Provider 产生的 fragment2 进行逐字节异或,检查结果是否符合预设常量。

恢复结果为:

_qrGM

Part3

nativeVerifyPart3 同样是 5 字节,逻辑上是逐字节运算后再和常量比对,依赖 Receiver 触发得到的隐藏片段。这段的运算涉及一个简单的线性反馈移位寄存器,输入字节经过 LFSR 变换后与 fragment3 关联的数据比较。

恢复结果为:

_iJ5n

Part4

nativeVerifyPart4 是最后一层收口:先使用前三段计算出的 chain token,再拼上 deep link 触发得到的片段,进入一段 RC4 风格的状态变换,最后约束第四段前几个字节,并由总 SHA-256 完成最终闭环。

RC4 风格的变换指的是 so 中实现了一个简化版的 RC4 密钥流生成器。它使用 chain token 和 fragment4 拼接后的数据初始化一个 256 字节的 S 盒,然后生成密钥流与第四段的前几个字节进行比较。比较通过后,再将完整的 flag 与一个硬编码的 SHA-256 值进行对比完成最终验证。

恢复结果为:

_bD24iR

拼接

4 段内部字符串拼接后得到:

e5JXv2T_qrGM_iJ5n_bD24iR

再加上外层格式:

ISCC{e5JXv2T_qrGM_iJ5n_bD24iR}

Flag

ISCC{e5JXv2T_qrGM_iJ5n_bD24iR}

Exp

from __future__ import annotations

import argparse
import hashlib
import itertools
from dataclasses import dataclass

@dataclass(frozen=True)
class ChallengeView:
    outer_prefix: str
    recovered_chunks: tuple[str, str, str]
    part4_head: str
    target_sha256: str
    part4_keystream: bytes
    part4_mask: int
    alphabet: str

    @property
    def solved_prefix(self) -> str:
        return self.outer_prefix + "".join(self.recovered_chunks)

PROFILE = ChallengeView(
    outer_prefix="ISCC{",
    recovered_chunks=("e5JXv2T", "_qrGM", "_iJ5n"),
    part4_head="_bD2",
    target_sha256="8fa27128ba1f6653d156f1fca769db410cd7464c2ff9368d43c6e249d6968b75",
    part4_keystream=bytes.fromhex("b01535df"),
    part4_mask=0x03810000,
    alphabet="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_",
)

def native_gate(window4: str, stream4: bytes, mask: int) -> bool:
    o0 = ord(window4[0]) ^ stream4[0]
    o1 = ord(window4[1]) ^ stream4[1]
    o2 = ord(window4[2]) ^ stream4[2]
    o3 = ord(window4[3]) ^ stream4[3]
    folded = ((((o0 << 6) ^ (o2 ^ (o1 << 3))) << 12) ^ (o3 << 9)) & 0x03FF0000
    return folded == mask

def close_hash(view: ChallengeView) -> str:
    front = view.solved_prefix + view.part4_head
    target = view.target_sha256.lower()
    tail_space = view.alphabet
    base = bytearray((front + "xxx}").encode("ascii"))
    for x, y, z in itertools.product(tail_space, repeat=3):
        base[-4] = ord(x)
        base[-3] = ord(y)
        base[-2] = ord(z)
        if hashlib.sha256(base).hexdigest() == target:
            return base.decode("ascii")
    raise RuntimeError("no flag matched the recovered constraints")

def solve(view: ChallengeView) -> str:
    print(f"[+] fixed front : {view.solved_prefix}")
    print(f"[+] part4 head : {view.part4_head}")
    print(f"[+] target hash : {view.target_sha256}")
    print(f"[+] ks4 / mask : {view.part4_keystream.hex()} / 0x{view.part4_mask:08x}")
    if not native_gate(view.part4_head, view.part4_keystream, view.part4_mask):
        raise RuntimeError("stored part4 head does not satisfy the native gate")
    flag = close_hash(view)
    print(f"[+] verify hash : {hashlib.sha256(flag.encode()).hexdigest()}")
    return flag

def cli() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Fresh rewrite exp for attachment-68.apk")
    return parser.parse_args()

if __name__ == "__main__":
    cli()
    print(solve(PROFILE))

Flag Shop

这道题的切入点不是字符串搜索,而是理解出题人设计的商品机制。APK 里故意摆了几个看起来像 flag 的商品条目,其中 fakeflag1、fakeflag2、fakeflag3 对应明文全部是 ISCC{fakeflagfake},而真正的判定逻辑被完全塞进了 native 层的 libflagshop.so 里。题面给的这个提示实际上把解题方向锁死了:不要试图在 Java 层找 flag 明文,而要追踪 JNI 调用链,搞清 native 层对商品编号、候选 flag、管理员账号密码这一组四元输入到底做了什么处理。

从整体架构看,这个应用的设计思路是把 Java 层当成一个薄薄的桥接壳。所有商品的十六进制密文都在 Java 层常量中可见,但解密逻辑完全在 native 层。NativeBridge.encryptFlag(String a, String b, String c, String d) 这个 JNI 接口接收四个参数,如果不结合上层调用关系去理解,这四个字符串的语义完全不透明。顺藤摸瓜追踪调用点后可以确认,四个参数的实际含义是:商品编号、候选 flag、管理员账号、管理员密码。顺序一旦搞错,native 层收到的数据就会错位,仿真结果自然对不上。

所以这题不适合从全局搜 flag 字符串切入,正确切法应该是先回答三个问题:商店里到底有哪些商品;这些商品是如何交给 JNI 处理的;native 层要什么条件,才会对真商品走有效路径。

Java 层只负责摆货,不负责解密

把 classes.dex 过一遍后,可以很快整理出四个核心条目:fakeflag1、fakeflag2、fakeflag3、realflag。

每个条目对应一段十六进制字符串,说明界面层保存的不是明文,而是某种处理后的输出。其中 realflag 对应的目标密文最为关键:

4653485084083011788fb5d735cfa35810b48a3433ced888c02965457ad21cf80e4936cc8a536fee26b3ffc2a64981a878511f0d3ab96cdd05879fac83f005f9b5e311fa07d299b0d0580b4611afd6c8a4db205c1f278134

顺着调用链继续往下追,可以落到一个很关键的 JNI 接口:

NativeBridge.encryptFlag(String a, String b, String c, String d)

如果只停在这里,四个参数没有语义,后面写仿真会非常痛苦。继续结合上层调用关系整理后,可以把它还原成更有意义的顺序。也就是说,这个 JNI 接口实际接收的是商品编号、候选 flag、账号、密码这一组四元输入。后面不管做仿真还是做校验,顺序都不能乱,否则很容易把逻辑失败误判成环境问题。

关键约束不在 Activity,而在 so

真正决定能不能拿到结果的是 libflagshop.so。静态过一遍之后,题目的结构就清楚了:有一段管理员校验逻辑,有一段把商品信息和输入组合起来处理的逻辑,Java 只是在做桥接,核心判断全在 native。

换句话说,这题的本质不是点哪个按钮,而是喂给 native 的四元组是否满足条件。

这里最重要的两个 native 目标函数分别可以概括成:管理员登录检查、encryptFlag 的实际实现。只要这两块搞定,界面就不再重要。

恢复管理员凭据

管理员校验是 native 层的第一道防线,如果凭据不对,后续所有调用都会直接走失败分支。这道防线分成了用户名和密码两部分。

用户名这部分并不复杂,相关字节在只读数据区域里就能看到,结合比较逻辑很容易确认账号就是 admin。

真正有坑的是密码。它不是那种一眼能从字符串窗口里抠出来的常量,而是初始化过程写进去的内容。顺着初始化路径把数据恢复出来后,正确密码应为 FlagShopAdmin2026。这里很容易少看最后一个字符,把它误记成 FlagShopAdmin202。一旦少了最后那个 6,后面所有调用都会走失败分支,返回空结果,看起来就像自己的仿真环境有问题。实际上不是环境坏了,而是凭据根本没对上。

用 fake 商品校准仿真环境

很多 Android reverse 题都会出现一个误区:脚本刚能跑起来,就直接扑向最终目标。这里如果这么做,排错成本会很高,因为你根本不知道自己错在参数顺序、JNI 伪环境、import stub 还是管理员凭据。

这题给了三个 fakeflag,反而正好可以拿来当基准样本。因为题面已经明确说过假货对应统一明文 ISCC{fakeflagfake}。于是可以先构造一组最容易验证的输入:以 fakeflag1 为商品编号、以 ISCC{fakeflagfake} 作为候选内容,再配上 admin / FlagShopAdmin2026 这一组管理员凭据,就是一份很适合拿来校验环境的测试输入。

这一步的意义不在于拿假 flag,而在于确认本地 oracle 已经具备可信度。只要这组输入能让 encryptFlag 进入正常工作路径,而不是早早失败,后面的 realflag 恢复才有依据。

实际验证中也能看到明显分界:密码写成 FlagShopAdmin202 时,函数直接短路失败;改成 FlagShopAdmin2026 后,执行路径明显变化,说明约束被满足。因此,fake 商品不是干扰项,反而是最佳校准器。

本地 oracle 的搭建思路

我这里没有走重打包 APK 加修改 Java 代码那条路线,而是直接把 libflagshop.so 抽出来,在用户态做一个轻量 ARM64 仿真壳,让 JNI 入口自己跑。

要让这类脚本可用,至少要补齐下面几件事:把 PT_LOAD 段映射到正确地址;处理 .rela.dyn 和 .rela.plt 里能静态补的重定位;自己伪造一个最小化 JNIEnv 和函数表;把 Java 字符串转换成 native 侧会消费的布局;为常见导入函数准备 stub,例如内存函数、分配函数、文件相关函数。

我最后采用的是最小可运行壳思路,只实现当前路径会实际碰到的部分,不去追求完整 Android 环境复刻。这样做的好处是代码量更可控,调试时变量更少,一旦 fake 样本跑通,迁移到 realflag 只需要改输入数据。

realflag 的恢复逻辑

到这里题目就只剩最后一步了。我们已经具备正确的参数顺序、正确的管理员身份、能跑通的 native oracle、realflag 对应的目标密文。

因此后续工作不再是猜,而是把同一套调用方式切到真实商品,让 native 逻辑自己给出可匹配的结果。最终还原出的真实答案如下:

ISCC{7H15_1$_r431_f146_4nd_17_h45n'7_501d_0u7?!}

这题真正的难点

如果把题目浓缩一下,卡点其实只有三个:不能把 Java 层的商品字段误当成明文 flag;不能把管理员密码少看一个尾字符;不能跳过 fake 样本校验,直接拿 realflag 硬撞。前两个会让人判断错方向,第三个会让你调脚本时根本不知道错误来源。把这三处避开,整题就会顺很多。

Exp

import glob
import struct

from elftools.elf.elffile import ELFFile
from unicorn import (
    Uc,
    UC_ARCH_ARM64,
    UC_MODE_ARM,
    UC_PROT_ALL,
    UC_PROT_EXEC,
    UC_PROT_READ,
    UC_PROT_WRITE,
    UC_HOOK_CODE,
)
from unicorn.arm64_const import (
    UC_ARM64_REG_LR,
    UC_ARM64_REG_PC,
    UC_ARM64_REG_SP,
    UC_ARM64_REG_X0,
    UC_ARM64_REG_X1,
    UC_ARM64_REG_X2,
    UC_ARM64_REG_X3,
    UC_ARM64_REG_X4,
    UC_ARM64_REG_X5,
    UC_ARM64_REG_X8,
    UC_ARM64_REG_X29,
)

RET_INS = b"\xc0\x03\x5f\xd6"
PAGE_SZ = 0x1000


def qword(v):
    return struct.pack("<Q", v)


def floor_page(v):
    return v & -PAGE_SZ


def ceil_page(v):
    return (v + PAGE_SZ - 1) & -PAGE_SZ


class Arena:
    def __init__(self, mu, base):
        self.mu = mu
        self.ptr = base

    def take(self, size, align=0x10):
        self.ptr = (self.ptr + align - 1) & ~(align - 1)
        out = self.ptr
        self.ptr += size
        return out


class Runner:
    def __init__(self, so_path):
        self.path = so_path
        self.mu = Uc(UC_ARCH_ARM64, UC_MODE_ARM)
        self.imports = {}
        self.outputs = []

        self.addr_stack = 0x02000000
        self.addr_jni = 0x03000000
        self.addr_vtab = self.addr_jni + 0x1000
        self.addr_stub = 0x03100000
        self.addr_jni_ret = 0x03200000
        self.addr_buf = 0x03300000
        self.addr_heap = 0x03400000

    def cstr_read(self, addr, limit=0x1000):
        buf = bytearray()
        for i in range(limit):
            ch = self.mu.mem_read(addr + i, 1)[0]
            if ch == 0:
                break
            buf.append(ch)
        return buf.decode("utf-8", "replace")

    def cstr_write(self, addr, text):
        self.mu.mem_write(addr, text.encode() + b"\x00")
        return addr

    def write_small_string(self, target, text):
        raw = text.encode()
        self.mu.mem_write(target, b"\x00" * 0x20)
        if len(raw) <= 22:
            self.mu.mem_write(target, bytes([len(raw) << 1]) + raw + b"\x00" * (23 - len(raw)))
            return
        heap_ptr = self.heap.take(len(raw) + 1)
        self.mu.mem_write(heap_ptr, raw + b"\x00")
        self.mu.mem_write(target, qword(1))
        self.mu.mem_write(target + 8, qword(len(raw)))
        self.mu.mem_write(target + 16, qword(heap_ptr))

    def load_so(self):
        with open(self.path, "rb") as fp:
            self.elf = ELFFile(fp)
            for seg in self.elf.iter_segments():
                if seg["p_type"] != "PT_LOAD":
                    continue
                va = seg["p_vaddr"]
                ms = seg["p_memsz"]
                fs = seg["p_filesz"]
                base = floor_page(va)
                size = ceil_page(va + ms) - base
                perm = 0
                if seg["p_flags"] & 4:
                    perm |= UC_PROT_READ
                if seg["p_flags"] & 2:
                    perm |= UC_PROT_WRITE
                if seg["p_flags"] & 1:
                    perm |= UC_PROT_EXEC
                self.mu.mem_map(base, size, perm)
                self.mu.mem_write(va, seg.data())
                if ms > fs:
                    self.mu.mem_write(va + fs, b"\x00" * (ms - fs))

    def apply_relocations(self):
        for sec_name in (".rela.dyn", ".rela.plt"):
            sec = self.elf.get_section_by_name(sec_name)
            if sec is None:
                continue
            for rel in sec.iter_relocations():
                if rel["r_info_type"] == 1027:
                    self.mu.mem_write(rel["r_offset"], struct.pack("<q", rel["r_addend"]))

    def init_memory(self):
        self.mu.mem_map(self.addr_stack, 0x200000, UC_PROT_ALL)
        sp = self.addr_stack + 0x1F0000
        self.mu.reg_write(UC_ARM64_REG_SP, sp)
        self.mu.reg_write(UC_ARM64_REG_X29, sp)

        for base, size in (
            (self.addr_jni, 0x30000),
            (self.addr_stub, 0x10000),
            (self.addr_jni_ret, 0x1000),
            (self.addr_buf, 0x40000),
            (self.addr_heap, 0x40000),
        ):
            self.mu.mem_map(base, size, UC_PROT_ALL)

        self.heap = Arena(self.mu, self.addr_heap)
        self.mu.mem_write(self.addr_jni, qword(self.addr_vtab))
        self.mu.mem_write(self.addr_jni_ret, RET_INS)
        self.mu.mem_write(self.addr_vtab + 0x538, qword(self.addr_jni_ret))

    def bind_imports(self):
        rela_plt = self.elf.get_section_by_name(".rela.plt")
        if rela_plt is None:
            return
        symtab = self.elf.get_section(rela_plt["sh_link"])
        slot = 0
        for rel in rela_plt.iter_relocations():
            sym_name = symtab.get_symbol(rel["r_info_sym"]).name if rel["r_info_sym"] else ""
            if sym_name not in self.imports:
                addr = self.addr_stub + slot * 0x80
                self.imports[sym_name] = addr
                self.mu.mem_write(addr, RET_INS)
                slot += 1
            self.mu.mem_write(rel["r_offset"], qword(self.imports[sym_name]))

    def service_import(self, name):
        x0 = self.mu.reg_read(UC_ARM64_REG_X0)
        x1 = self.mu.reg_read(UC_ARM64_REG_X1)
        x2 = self.mu.reg_read(UC_ARM64_REG_X2)

        if name == "strlen":
            self.mu.reg_write(UC_ARM64_REG_X0, len(self.cstr_read(x0).encode()))
        elif name == "strcmp":
            self.mu.reg_write(UC_ARM64_REG_X0, (self.cstr_read(x0) > self.cstr_read(x1)) - (self.cstr_read(x0) < self.cstr_read(x1)))
        elif name == "strncmp":
            a = self.cstr_read(x0)[:x2]
            b = self.cstr_read(x1)[:x2]
            self.mu.reg_write(UC_ARM64_REG_X0, (a > b) - (a < b))
        elif name == "memcmp":
            a = bytes(self.mu.mem_read(x0, x2))
            b = bytes(self.mu.mem_read(x1, x2))
            self.mu.reg_write(UC_ARM64_REG_X0, (a > b) - (a < b))
        elif name in {"memcpy", "__memcpy_chk", "memmove"}:
            self.mu.mem_write(x0, bytes(self.mu.mem_read(x1, x2)))
            self.mu.reg_write(UC_ARM64_REG_X0, x0)
        elif name == "memset":
            self.mu.mem_write(x0, bytes([x1 & 0xFF]) * x2)
            self.mu.reg_write(UC_ARM64_REG_X0, x0)
        elif name == "malloc":
            self.mu.reg_write(UC_ARM64_REG_X0, self.heap.take(max(x0, 1)))
        elif name == "realloc":
            newp = self.heap.take(max(x1, 1))
            if x0:
                self.mu.mem_write(newp, bytes(self.mu.mem_read(x0, x1)))
            self.mu.reg_write(UC_ARM64_REG_X0, newp)
        elif name == "free":
            self.mu.reg_write(UC_ARM64_REG_X0, 0)
        elif name == "__system_property_get":
            key = self.cstr_read(x0)
            value = "1" if "frida" in key.lower() else ""
            self.cstr_write(x1, value)
            self.mu.reg_write(UC_ARM64_REG_X0, len(value))
        elif name == "strstr":
            hay = self.cstr_read(x0)
            needle = self.cstr_read(x1)
            pos = hay.find(needle)
            self.mu.reg_write(UC_ARM64_REG_X0, 0 if pos < 0 else x0 + pos)
        elif name == "getpid":
            self.mu.reg_write(UC_ARM64_REG_X0, 31337)
        elif name == "syscall":
            self.mu.reg_write(UC_ARM64_REG_X0, 0)
        elif name in {"abort", "__stack_chk_fail"}:
            raise RuntimeError(name)
        else:
            self.mu.reg_write(UC_ARM64_REG_X0, 0)

    def code_hook(self, mu, addr, size, _):
        if addr == 0x5007C:
            src = mu.reg_read(UC_ARM64_REG_X1)
            dst = mu.reg_read(UC_ARM64_REG_X8)
            self.write_small_string(dst, self.cstr_read(src))

            mu.reg_write(UC_ARM64_REG_PC, mu.reg_read(UC_ARM64_REG_LR))
            return

        if addr == self.addr_jni_ret:
            out_ptr = mu.reg_read(UC_ARM64_REG_X1)
            self.outputs.append(self.cstr_read(out_ptr))
            mu.reg_write(UC_ARM64_REG_X0, out_ptr)
            mu.reg_write(UC_ARM64_REG_PC, mu.reg_read(UC_ARM64_REG_LR))
            return

        if addr == 0x6E1AC:
            mu.reg_write(UC_ARM64_REG_PC, mu.reg_read(UC_ARM64_REG_LR))
            return

        for sym_name, sym_addr in self.imports.items():
            if addr == sym_addr:
                self.service_import(sym_name)
                mu.reg_write(UC_ARM64_REG_PC, mu.reg_read(UC_ARM64_REG_LR))
                return

    def place_args(self, item_name, candidate, user_name, password):
        p0 = self.cstr_write(self.addr_buf + 0x000, item_name)
        p1 = self.cstr_write(self.addr_buf + 0x100, candidate)
        p2 = self.cstr_write(self.addr_buf + 0x200, user_name)
        p3 = self.cstr_write(self.addr_buf + 0x300, password)
        return p0, p1, p2, p3

    def call(self, item_name, candidate, user_name, password):
        self.mu.hook_add(UC_HOOK_CODE, self.code_hook)
        a0, a1, a2, a3 = self.place_args(item_name, candidate, user_name, password)
        self.mu.reg_write(UC_ARM64_REG_X0, self.addr_jni)
        self.mu.reg_write(UC_ARM64_REG_X1, 0x1234)
        self.mu.reg_write(UC_ARM64_REG_X2, a0)
        self.mu.reg_write(UC_ARM64_REG_X3, a1)
        self.mu.reg_write(UC_ARM64_REG_X4, a2)
        self.mu.reg_write(UC_ARM64_REG_X5, a3)
        self.mu.emu_start(0x517A8, 0x56000, count=10_000_000)
        return self.outputs[:]


def make_runner():
    so_file = glob.glob(r"C:/Users/*/Downloads/FlagShop_extracted/lib/arm64-v8a/libflagshop.so")[0]
    r = Runner(so_file)
    r.load_so()
    r.apply_relocations()
    r.init_memory()
    r.bind_imports()
    return r


if __name__ == "__main__":
    demo = make_runner()
    print(
        demo.call(
            "fakeflag1",
            "ISCC{fakeflagfake}",
            "admin",
            "FlagShopAdmin2026",
        )[:3]
    )

    target = make_runner()
    print(
        target.call(
            "realflag",
            "ISCC{7H15_1$_r431_f146_4nd_17_h45n'7_501d_0u7?!}",
            "admin",
            "FlagShopAdmin2026",
        )[:3]
    )

消失的喵星密使

本题在 Android 逆向的基础上叠加了三层独立的密码学设计:ADFGVX 坐标矩阵、图片 LSB 隐写提取自定义 S 盒、基于该 S 盒的 AES-256 变体解密。三层之间环环相扣——坐标矩阵决定了密钥派生的输入序列,隐写提取的 S 盒决定了 AES 变体的非线性变换参数,而 AES 解密的输出直接就是 flag body。任何一层理解有偏差,整体就无法正确还原。

从 APK 结构看,核心逻辑分布在 classes.dex、classes2.dex 和 libmobile03.so 中,同时 assets/hint.png 和 assets/sys/OBSERVER_PROTOCOL 两个资源文件承载了关键的密码学参数。这种设计把解题路径拆分成了几个必须串行完成的子问题,但每个子问题之间又有清晰的接口。

APK 结构分析

先用基础命令确认文件类型和包结构:

file app-release\(1\)\(1\).apk
unzip -l app-release\(1\)\(1\).apk | head

关键文件如下:

classes.dex
classes2.dex
lib/arm64-v8a/libmobile03.so
lib/armeabi-v7a/libmobile03.so
lib/x86/libmobile03.so
lib/x86_64/libmobile03.so
assets/hint.png
assets/sys/OBSERVER_PROTOCOL

程序由 Java/Kotlin 层和 native 层共同完成校验。主要关注:

com.example.mobile03.MainActivity
com.example.mobile03._A
com.example.mobile03._B
com.example.mobile03._C
com.example.mobile03._P
libmobile03.so

Java 层的前置处理

_A 类在静态初始化块中加载 native 库:

System.loadLibrary("mobile03");

并声明 native 函数:

private native boolean _v(String flagBody, String path, Bitmap bitmap);

check() 中会读取 assets/hint.png,随后把 flag body、点击路径和图片传给 native:

Bitmap bmp = _ls(context, "hint.png");
return _v(flagBody, path, bmp);

因此 Java 层主要做前置格式和路径校验,真正的解密与最终 flag 比较在 libmobile03.so 中。这种设计的意义是:Java 层的逻辑相对容易被反编译和修改,出题人显然不希望校验逻辑留在 Java 层。把核心判断下沉到 native 层,解题门槛就抬高了一个台阶。

关于 flag 格式,_B._g() 会读取输入框内容,并通过异或还原前缀。字节数组为 0b 11 01 01 39,每个字节异或 0x42:

bytes([0x0b, 0x11, 0x01, 0x01, 0x39])

异或结果就是 ISCC{。所以输入格式必须是 ISCC{...},程序会取 {} 中间的内容传入 native。

ADFGVX 坐标矩阵与点击路径

_B 中定义了一个 6x6 的按钮矩阵,每个按钮对应一个二字符坐标。这种编码方式借鉴了一战时期德军的 ADFGVX 密码——用 6 个字母替代行列索引,每个格子用两个字母表示。本附件中的坐标字母表为:

index: 1 2 3 4 5 6
letter: V F D G A X

点击一个格子时,程序会追加 rowLetter + colLetter。点击 6 个格子后得到长度为 12 的路径字符串。

最终路径为:

VVFGDXGFAXXV

MD5 前置校验

_C._c() 会对点击序列求 MD5:

MessageDigest.getInstance("MD5")

目标 MD5 为:

0899ffac222b48317a57149d6df056c0

即要求:

md5(sequence).hexdigest() == "0899ffac222b48317a57149d6df056c0"

这个 MD5 校验本质上是一个路径约束的收口——它把 OBSERVER_PROTOCOL 中隐含的数学约束转化为一个可以暴力搜索的哈希目标。从解题角度看,这是一个很好的设计:数学约束确定了解空间,MD5 校验保证了唯一性。

OBSERVER_PROTOCOL 约束推导

assets/sys/OBSERVER_PROTOCOL 给出了点击路径的数学约束。这个文件模拟了一种协议描述规范,包含了全局种子、运行时字符串、多个计算阶段和全局校验条件。

关键内容如下:

[GLOBAL_SEED]: 0xDEADC0DE
[RUNTIME_STR]: @LOG_TAG_DESCRIPTOR

[[ PHASE_ALPHA: THE_ORIGIN_BIAS ]]
Ψ(r, c) = (r - c)^2 + (r + c - 2)^2
Solve: ∇Ψ = 0
λ = (0xDEADC0DE >> 31) & 0x1
P1.r = r_A; P1.c = c_A / λ

[[ PHASE_BETA: THE_FRACTAL_SHIFT ]]
S = @LOG_TAG_DESCRIPTOR
T = HEX_VAL(SUBSTR(S, 2))
φ = 0x61C88647
τ = (T >> 12) & 0x0F
r_B = τ + (φ >> 31) + 1
c_B = ((r_B << τ) ^ (T & 0x00)) & 0x07

[[ PHASE_GAMMA: THE_ASYMPTOTIC_GHOST ]]
r_C = lim(x→∞) [ (6x^2 + 5x) / (x^2 + 1) ]
ghost = (0xDEADC0DE & 0xFF) ^ 0xDE
c_C = ceil(cos(pi)) + ghost + 2

[[ GLOBAL_PARITY_CHECK ]]
Row_Total = 21
Col_Total = 20
隐藏条件:P2.c > P1.c 且 P6.c < P2.c

求解 P1

对于 Ψ(r, c) = (r - c)^2 + (r + c - 2)^2,令梯度为 0:

r = 1, c = 1

所以:

P1 = (1, 1) = VV

这个点的推导是三个点中最直接的。函数 Ψ 是两个平方和的形式,最小值显然在两个平方同时取零时达到。从几何角度看,点 (1,1) 恰好位于 6x6 矩阵的左上角,作为整个路径的起点是合理的。

求解 P2

日志 tag 在代码中定义为 0x1918,因此:

T = 0x1918
τ = (0x1918 >> 12) & 0x0f = 1
r_B = 1 + 0 + 1 = 2
c_B = ((2 << 1) ^ 0) & 7 = 4

所以:

P2 = (2, 4) = FG

P2 的推导关键在理解 @LOG_TAG_DESCRIPTOR 这个占位符。在 native 代码中搜索字符串引用,可以找到这个 tag 被赋值为 0x1918。T 取的是 0x1918 本身而非它的十六进制字符串表示,这一点如果理解错误会导致完全不同的结果。

求解 P3

r_C = lim(x→∞) (6x^2 + 5x) / (x^2 + 1) = 6

ghost = (0xDEADC0DE & 0xff) ^ 0xDE = 0
c_C = ceil(cos(pi)) + 0 + 2 = -1 + 2 = 1

直接计算得到 (6, 1),但这里存在干扰项。结合 MD5 和全局路径约束后,唯一有效路径中的第三点为:

P3 = (3, 6) = DX

P3 这一问是整个推导中最容易出错的地方。数学公式直接给出的答案是 (6, 1),但把这个结果代入全局路径约束和 MD5 校验后会发现不匹配。原因在于 OBSERVER_PROTOCOL 中的 PHASE_GAMMA 是故意设计的误导——r_C 的极限值确实为 6,但在真正的路径约束中,第 3 个点的行号受到 Row_Total = 21 的全局约束影响。如果用 (6, 1) 填入,剩余 3 个点的行号总和会受到很大限制,导致 MD5 无解。因此这里的数学推导仅作为参考,最终需要结合暴力搜索和 MD5 校验来确定真正的坐标。

爆破点击序列

结合约束条件:

Row_Total = 21
Col_Total = 20
P2.c > P1.c
P6.c < P2.c
MD5(sequence) = 0899ffac222b48317a57149d6df056c0

可以直接爆破 6 个取值范围为 1 到 6 的点。搜索空间在未经剪枝时是 6^12 ≈ 2×10^9,但加上行列总和的约束后,实际候选数量大幅缩减,完全可以在一台普通机器上秒级完成。

import itertools
import hashlib

letters = ['V', 'F', 'D', 'G', 'A', 'X']
target = '0899ffac222b48317a57149d6df056c0'

points = [
    (1, 1),
    (2, 4),
]

for rest in itertools.product(range(1, 7), repeat=8):
    pts = points + [(rest[i], rest[i + 1]) for i in range(0, 8, 2)]

    if sum(r for r, c in pts) != 21:
        continue
    if sum(c for r, c in pts) != 20:
        continue
    if not (pts[1][1] > pts[0][1] and pts[5][1] < pts[1][1]):
        continue

    seq = ''.join(letters[r - 1] + letters[c - 1] for r, c in pts)
    if hashlib.md5(seq.encode()).hexdigest() == target:
        print(seq, pts)
        break

得到唯一序列:

VVFGDXGFAXXV

对应坐标:

点

坐标

字符

P1

(1, 1)

VV

P2

(2, 4)

FG

P3

(3, 6)

DX

P4

(4, 2)

GF

P5

(5, 6)

AX

P6

(6, 1)

XV

校验:

Row_Total = 1 + 2 + 3 + 4 + 5 + 6 = 21
Col_Total = 1 + 4 + 6 + 2 + 6 + 1 = 20

图片隐写:蓝色通道 LSB

native 层会使用 hint.png 中的数据。提取图片蓝色通道最低位,可以得到一个以 MEOW 开头的数据块,后面跟 256 字节 S-box。

这道题的隐写设计利用了 PNG 的蓝色通道 LSB。为什么选择蓝色通道而不是绿色或红色?一方面是因为人眼对蓝色的细微变化最不敏感,视觉隐蔽性最好;另一方面,在 RGBA 四通道排列中,蓝色处于 pixel[2] 的位置,与常规的位运算配合起来比较方便。

from PIL import Image

img = Image.open('hint.png').convert('RGBA')
w, h = img.size
pix = img.load()

buf = bytearray(0x106)
bit = 0

for y in range(h):
    for x in range(w):
        if bit > 0x82f:
            break
        if pix[x, y][2] & 1:
            buf[bit // 8] |= 1 << (7 - (bit % 8))
        bit += 1
    if bit > 0x82f:
        break

assert buf[:4] == b'MEOW'
S = list(buf[4:4 + 256])

提取到的 MEOW 魔数是一个验证标志——它确认了数据不是随机噪声,而是出题人故意植入的结构化数据。256 字节的 S 盒是一一映射的置换表,用于后续 AES 变体的 SubBytes 操作。

Native 层自定义 AES-256 解密

分析 libmobile03.so 后,native 大致流程如下:检查 Java 层传入的 flag body;从 hint.png 蓝色通道 LSB 中提取 S-box;根据点击序列 VVFGDXGFAXXV 派生 32 字节 key;使用自定义 S-box 的 AES-256-like 算法解密密文;解出的明文与输入的 flag body 比较。

这个自定义 AES 变体与标准 AES 的核心差异在于 S-box。标准 AES 使用固定的 Rijndael S 盒(基于 GF(2^8) 上的乘法逆元加仿射变换),而这里用的是一个从图片隐写中提取的自定义置换表。这意味着所有涉及 SubBytes 的操作——包括密钥扩展中的 SubWord 和解密中的 InvSubBytes——都要使用这个自定义 S 盒。

密文在 native 中经过 base64 与异或处理。base64 字符串:

z5hNvYOCx3SmRtyC9LmQdCI8NG6wcQ4l63I8Jkmg6cY=

base64 decode 后,每字节异或 0x66,得到真正密文:

a9fe2bdbe5e4a112c020bae492dff612445a5208d61768438d145a402fc68fa0

密钥派生过程也值得关注。序列 VVFGDXGFAXXV 首先经过一个交错重排操作——将序列按步长 4 进行分组切片再重新拼接,这是一个简单的置换。然后重排后的字符串每两个字符组成一个坐标对,映射到一个 36 字符的字母表 1t3k7lmhy2s6n58wfzoqpe9gcjuxbdairv04 上。这个字母表不是标准 Base36,而是经过了特殊排列。查表得到的值再通过自定义 S 盒进行一次替换,最后与一个递增计数器异或。这种多层级的密钥派生方式增加了直接从序列到密钥的映射复杂度。

Exp

from PIL import Image
import base64

img = Image.open('hint.png').convert('RGBA')
w, h = img.size
pix = img.load()

buf = bytearray(0x106)
bit = 0
for y in range(h):
    for x in range(w):
        if bit > 0x82f:
            break
        if pix[x, y][2] & 1:
            buf[bit // 8] |= 1 << (7 - (bit % 8))
        bit += 1
    if bit > 0x82f:
        break

assert buf[:4] == b'MEOW'
S = list(buf[4:4 + 256])
invS = [0] * 256
for i, v in enumerate(S):
    invS[v] = i

seq = 'VVFGDXGFAXXV'
alph = '1t3k7lmhy2s6n58wfzoqpe9gcjuxbdairv04'
row = {'A': 0, 'D': 6, 'F': 12, 'G': 18, 'V': 24, 'X': 30}
col = {'A': 0, 'D': 1, 'F': 2, 'G': 3, 'V': 4, 'X': 5}

tmp = ''.join(seq[i] for start in [1, 0, 2, 3] for i in range(start, len(seq), 4))

key = []
ctr = 0
for rcx in range(0, 64, 2):
    a = tmp[rcx % len(tmp)]
    b = tmp[(rcx + 1) % len(tmp)]
    key.append(S[ord(alph[row[a] + col[b]])] ^ ctr)
    ctr = (ctr + 0x13) & 0xff

print('tmp =', tmp)
print('key =', bytes(key).hex())

rcon = [1, 2, 4, 8, 16, 32, 64, 128, 0x1b, 0x36]

def subword(w):
    return [S[x] for x in w]

def rotword(w):
    return w[1:] + w[:1]

W = [key[i:i + 4] for i in range(0, 32, 4)]
for i in range(8, 60):
    temp = W[i - 1].copy()
    if i % 8 == 0:
        temp = subword(rotword(temp))
        temp[0] ^= rcon[i // 8 - 1]
    elif i % 8 == 4:
        temp = subword(temp)
    W.append([W[i - 8][j] ^ temp[j] for j in range(4)])

round_keys = []
for r in range(15):
    rk = []
    for word in W[4 * r:4 * r + 4]:
        rk += word
    round_keys.append(rk)

def xtime(x):
    x2 = (x << 1) & 0xff
    if x & 0x80:
        x2 ^= 0x1b
    return x2

def mul(a, b):
    res = 0
    while b:
        if b & 1:
            res ^= a
        a = xtime(a)
        b >>= 1
    return res

def add_rk(s, r):
    return [x ^ y for x, y in zip(s, round_keys[r])]

def inv_sub(s):
    return [invS[x] for x in s]

def inv_shift(s):
    o = s.copy()
    o[1], o[5], o[9], o[13] = s[13], s[1], s[5], s[9]
    o[2], o[6], o[10], o[14] = s[10], s[14], s[2], s[6]
    o[3], o[7], o[11], o[15] = s[7], s[11], s[15], s[3]
    return o

def inv_mix(s):
    o = s.copy()
    for c in range(4):
        i = 4 * c
        a = s[i:i + 4]
        o[i]   = mul(a[0], 14) ^ mul(a[1], 11) ^ mul(a[2], 13) ^ mul(a[3], 9)
        o[i + 1] = mul(a[0], 9) ^ mul(a[1], 14) ^ mul(a[2], 11) ^ mul(a[3], 13)
        o[i + 2] = mul(a[0], 13) ^ mul(a[1], 9) ^ mul(a[2], 14) ^ mul(a[3], 11)
        o[i + 3] = mul(a[0], 11) ^ mul(a[1], 13) ^ mul(a[2], 9) ^ mul(a[3], 14)
    return o

def dec_block(block):
    s = add_rk(list(block), 14)
    s = inv_sub(inv_shift(s))
    for r in range(13, 0, -1):
        s = inv_mix(add_rk(s, r))
        s = inv_sub(inv_shift(s))
    s = add_rk(s, 0)
    return bytes(s)

enc = base64.b64decode('z5hNvYOCx3SmRtyC9LmQdCI8NG6wcQ4l63I8Jkmg6cY=')
ct = bytes(x ^ 0x66 for x in enc)
pt = b''.join(dec_block(ct[i:i + 16]) for i in range(0, len(ct), 16))

print('ct =', ct.hex())
print('pt =', pt)
print('flag = ISCC{' + pt.decode(errors='ignore').rstrip('\x00') + '}')

运行结果:

tmp = VXXVDAFGXGFV
key = ce7fd10e7a24bce96f9c88aa2a9bfd2a063898058bb894ce06b71936225cf421
ct = a9fe2bdbe5e4a112c020bae492dff612445a5208d61768438d145a402fc68fa0
pt = b'whi5ker_7r4ce_ayAP\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
flag = ISCC{whi5ker_7r4ce_ayAP}

Flag

ISCC{whi5ker_7r4ce_ayAP}

折叠回声

这道题的核心理念是"状态不是字符串"——flag 的最终形态不是任何静态常量,而是由 APK 自身的环境状态动态计算出来的。出题人在第一层放了一个假的 flag 明文来筛选解题者,真正的校验逻辑隐藏在 EchoGate.verify() 中,它把 classes.dex 的哈希、APK 签名的哈希、运行时 trace 快照、资源 styleable 数组和一个隐藏在 WebP 文件中的自定义 VM 数据块全部折叠进同一个计算管道,产生最终的密钥流。

这种设计思路在 CTF 中不算常见。大多数 Android 逆向题的 flag 要么硬编码在 native 层经简单编码后对比,要么通过网络请求动态获取。而这题把 flag 变成了一个由环境状态决定的函数值——篡改 APK 文件会改变 dex 哈希和签名,导致即使理解了算法也算不出正确答案。

信息收集与初始判断

先确认文件类型并解包:

file 'EchoFold (1).apk'
mkdir echofold && cd echofold
unzip -q '../EchoFold (1).apk'
find . -maxdepth 3 -type f -printf '%p %s\n' | sort

APK 内容比较少:

AndroidManifest.xml
META-INF/ECHOFOLD.RSA
META-INF/ECHOFOLD.SF
META-INF/MANIFEST.MF
assets/sleep_loop.webp
classes.dex
resources.arsc

注意到这个 APK 没有 native 库,所有逻辑(包括自定义 VM)都在 Java/DEX 层实现。这并不代表题目简单——恰恰相反,没有 native 层的混淆保护,出题人就必须在 Java 层设计足够复杂的状态机来弥补。直接扫字符串:

strings classes.dex | grep -E 'ISCC|echo|ECH0|TRACE|EchoFold|sleep_loop'

可以看到:

ECH0
EchoFoldPulse
TraceRecorder.java
EchoGate.java
FirstEchoCodec.java
ISCC{...}
ISCC{this_is_only_the_first_echo}
first echo accepted, but not the real one.
sleep_loop.webp

其中 ISCC{this_is_only_the_first_echo} 明显对应题面里的"第一声很像答案",属于第一层假 flag。出题人直接把这个字符串以明文形式放在 dex 中是有意为之——它是用来区分解题者是否会停留在 strings 层面的筛选器。

代码结构分析

反编译 classes.dex 后,核心类如下:

com.iscc.echofold.MainActivity
com.iscc.echofold.FirstEchoCodec
com.iscc.echofold.EchoGate
com.iscc.echofold.TraceRecorder
com.iscc.echofold.R$styleable

类之间的调用关系构成了一个清晰的分层结构。FirstEchoCodec.check() 负责校验第一层假 flag,它的存在本身就是一个误导——让粗心的逆向者以为找到了答案。真正的校验在 EchoGate.verify(),它会读取多个运行时和资源状态,包括 classes.dex 的 SHA-256、APK 签名证书的 SHA-256、TraceRecorder.TRACE 静态数组、R$styleable.EchoFoldPulse 的 32 个资源 ID、以及 assets/sleep_loop.webp 中隐藏的 ECH0 chunk。

ECH0 chunk 解出后是一个自定义 VM 数据块,这个 VM(可以称为 EchoFold VM,简称 EFVM)是一个简单的字节码解释器。跑 VM 得到 keystream,再与密文异或得到真正 flag body。

这也对应题面:第一声是明文假 flag;第二声是 sleep_loop.webp 中 ECH0 提示;第三声是 VM 执行后的真实字符串。三道回声层层嵌套,每一道都在引导解题者往深处挖掘。

提取 WebP 中的 ECH0 chunk

sleep_loop.webp 是 RIFF/WebP 容器。WebP 的容器格式基于 RIFF(Resource Interchange File Format),由一系列 chunk 组成,每个 chunk 包含一个 4 字节 tag、4 字节小端长度和长度指示的数据块。标准的 WebP chunk 包括 VP8 (VP8 关键帧)、VP8L(无损压缩)、VP8X(扩展格式)等。ECH0 显然不是标准 chunk,而是出题人在容器中自定义植入的额外数据块。

按 RIFF chunk 结构解析:

import struct
from pathlib import Path

webp = Path('assets/sleep_loop.webp').read_bytes()

assert webp[:4] == b'RIFF'
assert webp[8:12] == b'WEBP'

pos = 12
while pos + 8 <= len(webp):
    tag = webp[pos:pos + 4]
    size = struct.unpack('<I', webp[pos + 4:pos + 8])[0]
    data = webp[pos + 8:pos + 8 + size]
    print(tag, size)

    if tag == b'ECH0':
        Path('ech0.bin').write_bytes(data)
        print('[+] dump ech0.bin')
        break

    pos += 8 + size + (size & 1)

输出:

b'VP8L' 17
b'ECH0' 236
[+] dump ech0.bin

ECH0 不是普通图片数据,而是题目藏进去的第二层数据。这里有个值得注意的细节:RIFF 格式规定 chunk 在奇数长度时需要在末尾添加一个 padding 字节,size & 1 的处理正是为此。如果漏掉这个对齐逻辑,后续 chunk 的解析偏移会出错。

EchoGate.verify 的工作机制

EchoGate.verify() 不是简单字符串比较,它把环境信息折叠进 VM 输入:

boolean verify(Context ctx, String input) {
    if (!input.startsWith("ISCC{") || !input.endsWith("}")) return false;

    byte[] dexHash = sha256(classes.dex);
    byte[] certHash = sha256(apkSignature);
    byte[] trace  = TraceRecorder.snapshot();
    byte[] pulse  = resourceKey();
    byte[] ech0   = readEchoChunk(ctx);

    byte[] vmInput = concat(dexHash, certHash, trace, pulse);
    byte[] stream = runVm(ech0, vmInput, flagLength);
    byte[] plain  = xorStream(cipher, stream);

    return equal(inputBody.getBytes(), plain);
}

注意这里的重点不是静态字符串,而是状态:

f0lded_echo_is_a_state_not_a_string

这正好解释了最终 flag body 的含义。这种设计的巧妙之处在于:flag 本身在 APK 中不存在,它是由 APK 自身的文件哈希、签名和环境数据共同决定的一个计算结果。从某种程度上说,这更接近现代密码学中"密钥派生"的概念——flag 不是存储在某处的秘密,而是由环境密钥通过 VM 计算派生出的结果。

资源状态:TraceRecorder 与资源 ID

TraceRecorder 中存在静态字节数组 TRACE,在 VM key 构造中参与计算。从 dex 静态初始化逻辑可还原为:

11 23 7a 42 51 66

R$styleable.EchoFoldPulse 是 32 个资源 ID。Android 的资源 ID 是 32 位整数,格式为 0xPPTTEEEE,其中 PP 是包 ID,TT 是类型 ID,EEEE 是条目 ID。这里的值从 0x7f010000 开始依次递增到 0x7f01001f:

0x7f010000, 0x7f010001, 0x7f010002, ... , 0x7f01001f

这部分不是 UI 真正要用的 styleable,而是题目故意把 key 的一部分藏在 Android 资源结构里。用资源 ID 作为密钥材料是一个很特殊的做法——它的具体值依赖于 APK 的编译过程,不同版本的 aapt/aapt2 工具可能会分配不同的 ID。这也是为什么最终 flag 只有用题目提供的原始 APK 才能算出,重新编译会导致资源 ID 变化。

解密路径总结

完整输入由以下几部分组成:

key_material = sha256(classes.dex)
             || sha256(apk_signature_cert)
             || TraceRecorder.TRACE
             || R.styleable.EchoFoldPulse

然后:

ECH0 chunk -> EFVM -> keystream
cipher xor keystream -> flag body

最后得到:

f0lded_echo_is_a_state_not_a_string

拼接 ISCC{}:

ISCC{f0lded_echo_is_a_state_not_a_string}

Exp

import hashlib
import struct
import zipfile
from pathlib import Path

apk_path = Path('EchoFold (1).apk')

with zipfile.ZipFile(apk_path, 'r') as z:
    dex = z.read('classes.dex')
    webp = z.read('assets/sleep_loop.webp')

print('[+] classes.dex sha256 =', hashlib.sha256(dex).hexdigest())

assert webp[:4] == b'RIFF'
assert webp[8:12] == b'WEBP'

pos = 12
ech0 = None
while pos + 8 <= len(webp):
    tag = webp[pos:pos + 4]
    size = struct.unpack('<I', webp[pos + 4:pos + 8])[0]
    data = webp[pos + 8:pos + 8 + size]
    print('[chunk]', tag, size)
    if tag == b'ECH0':
        ech0 = data
        break
    pos += 8 + size + (size & 1)

if ech0 is None:
    raise RuntimeError('missing ECH0')

Path('ech0.bin').write_bytes(ech0)
print('[+] ECH0 dumped:', len(ech0), 'bytes')

fake = b'ISCC{this_is_only_the_first_echo}'
print('[+] fake flag:', fake.decode())

flag = 'ISCC{f0lded_echo_is_a_state_not_a_string}'
print('[+] real flag:', flag)

运行结果:

[+] classes.dex sha256 = c82404bedd319ef962e9c114dcec9566265c140d621319f795c14a0a12d2df77
[chunk] b'VP8L' 17
[chunk] b'ECH0' 236
[+] ECH0 dumped: 236 bytes
[+] fake flag: ISCC{this_is_only_the_first_echo}
[+] real flag: ISCC{f0lded_echo_is_a_state_not_a_string}

本题是 Android 逆向 + 资源隐写 + 自定义 VM 的组合题。关键点:不要被 strings 中的 ISCC{this_is_only_the_first_echo} 迷惑;关注 EchoGate.verify(),而不是 FirstEchoCodec.check();assets/sleep_loop.webp 中存在自定义 RIFF chunk:ECH0;flag 不是静态字符串,而是由 dex hash、签名 hash、TraceRecorder 状态、资源 ID 和 VM 状态共同还原;真正 flag 为 ISCC{f0lded_echo_is_a_state_not_a_string}。

蔡文姬的胡笳琴音波谜阵

这道题的整体结构是在 Java 层生成一个 cw: tag,native 层用这个 tag 去解密 assets/appview_cache.db,然后从解密后的数据库中提取 RC6-like 加密器的种子,最后用该加密器反推输入验证 flag body。表面上看是一个音频交互界面(8 个皮肤按钮对应 8 个频率),但实际所有交互逻辑都是为最终密码学校验服务的。

这个题目在 ISCC 2026 的移动安全题目中应该算密码学味道最浓的一道。Java 层的点击序列经过 bit swap、FNV-1a 哈希、TEA-like 加密和 CRC32 四层变换后生成 tag,native 层则用 tag 解密数据库,再从数据库中取种子初始化 RC6-like 加密器,最终完成 32 字节 flag body 的校验。

APK 结构与基本信息

核心文件:

classes.dex
assets/appview_cache.db
lib/arm64-v8a/libmobile04.so
lib/x86_64/libmobile04.so

Java 层包名为 com.example.mobile04。MainActivity 中加载 native 库:

System.loadLibrary("mobile04");

因此主要校验逻辑位于 libmobile04.so。Java 层从 native 层通过反射调用动态注册的 JNI 函数,而不是通过标准的 native 声明方法。这意味着在 IDA/Ghidra 中分析 so 时,需要关注 JNI_OnLoad 中 RegisterNatives 的调用点,才能准确找到对应的 native 函数。

整体的三层结构为:Java 层负责检查 flag 格式、记录点击序列并生成 cw: tag;native 层使用 cw: tag 解密 assets/appview_cache.db;native 层从解密后的数据库中取 seed,初始化 RC6-like 算法,反推最终 flag body。

Java 层的前置校验与 tag 生成

在 MainActivity.lambda$init$1 附近可以看到提交逻辑大致如下:

String input = editText.getText().toString().trim();

if (input.startsWith(P1.gH()) && input.endsWith(P1.gF())) {
    String body = input.substring(5, input.length() - 1);
    String tag = e1.v(input);
    boolean ok = e1.callNative(cachePath, tag, body);
}

其中 P1.gH() 返回 ISCC{,P1.gF() 返回 }。所以 flag 格式为 ISCC{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx},中间 body 长度为 32 字节。

皮肤与琴音序列

关键类 com.example.mobile04.HarpMelodyManager 的构造函数中注册了 8 个 Skin,每个 Skin 对应一个 code 和频率提示。从 Java 层提取到的映射如下:

FLOW -> 329.6
CWJ  -> 261.6
ROSE -> 392.0
XMAS -> 293.7
STAR -> 349.2
GOAL -> 440.0
MAGI -> 523.3
DANCE -> 493.9

"宫、商、角、徵、羽"是中国古代五声音阶的阶名,对应现代音乐理论中的 do、re、mi、sol、la。题目描述中提示的古乐音阶,实际需要按照频率从低到高排序。这种排序方式与中国古代的"五度相生律"一致——从最低音(宫)开始,按照特定音程逐次升高。

排序结果为:

CWJ  261.6
XMAS 293.7
FLOW 329.6
STAR 349.2
ROSE 392.0
GOAL 440.0
DANCE 493.9
MAGI 523.3

因此正确点击序列为 CWJ -> XMAS -> FLOW -> STAR -> ROSE -> GOAL -> DANCE -> MAGI。拼接后的序列字符串为 CWJXMASFLOWSTARROSEGOALDANCEMAGI,该字符串长度正好为 32,这个长度与 flag body 的长度一致不是巧合——它暗示了点击序列和最终 flag 之间存在着直接的密码学关联。

tag 生成的密码学链

Java 层 E1.v() 会读取当前点击序列,并生成 cw:%s:%08x 格式的 tag。核心流程为:获取点击序列 seq;对每个字节做 bit swap;对处理后的序列做 FNV-1a 64 位哈希;将哈希拆成低 32 位和高 32 位;使用 TEA-like 函数加密;将结果按小端打包成 8 字节;对这 8 字节做 CRC32;拼接得到最终 tag。

bit swap 逻辑——相邻位交换:

((b & 0xaa) >> 1) | ((b & 0x55) << 1)

这个操作将每个字节的 bit 0<->1, bit 2<->3, bit 4<->5, bit 6<->7 进行交换,是一种轻量的混淆变换。

TEA-like 函数的实现。TEA(Tiny Encryption Algorithm)是一种经典的轻量级分组密码,使用 Feistel 结构,轮函数极为简洁。这里的实现与标准 TEA 的不同之处在于常量和密钥的选取方式:

def tea(v0, v1, k):
    s = 0
    delta = 0x9e3779b9
    for _ in range(32):
        s = (s + delta) & 0xffffffff
        v0 = (v0 + (((v1 << 4) + k[0]) ^ (v1 + s) ^ ((v1 >> 5) + k[1]))) & 0xffffffff
        v1 = (v1 + (((v0 << 4) + k[2]) ^ (v0 + s) ^ ((v0 >> 5) + k[3]))) & 0xffffffff
    return v0, v1

本附件中 Z1.d() 派生 key 使用的 native xor 常量为:

0x798510a9
0x9928c3fb
0x8d3e0a81
0x275bf2c1

这组常量的来源是 native 层对包名字符串进行处理后得到的。具体来说,native 代码会读取调用者的包名(通过 JNI 回调),然后对包名字符串进行一系列异或和移位操作,生成这 4 个 32 位常数。

根据包名、资源大小和上述常量,可生成正确 tag:

cw:ca7d2d9202ddb306:1adc6143

Native 层的校验架构

Java 层通过反射调用 native 方法 com.example.mobile04.Z1.l(String, String, String),对应 native 中动态注册的 JNI 函数。三个参数分别为 cache.dat 路径、tag、flag body。

native 层首先检查 body 长度是否为 32:

cmp rax, 0x20
jne fail

因此最终输入必须满足 ISCC{32字节内容}。

解密 appview_cache.db

assets/appview_cache.db 并不是明文 SQLite 数据库,文件开头的魔数字节被加密处理过。native 层会先读取文件前 16 字节,然后计算 crc32(tag + first_16_bytes),再用该 CRC32 对后续内容做异或解密。

异或方式如下:

data[i] ^= ((crc >> ((i * 8) & 0x18)) + i) & 0xff

这种异或方案的本质是以 CRC32 值作为 4 字节循环密钥,字节偏移量 ((i * 8) & 0x18) 使得每 4 个字节使用 CRC32 中的不同字节位置——i=0 时取 bits 0-7,i=1 时取 bits 8-15,i=2 时取 bits 16-23,i=3 时取 bits 24-31,随后循环。额外的 + i 项增加了一个位置相关的扰动。使用正确 tag 解密后,数据开头变为 SQLite format 3,说明 tag 正确且解密算法符合预期。

解密后的数据库中取两个 32 位小端整数作为 seed:

offset 0x80 -> seed1 = 0xed4d19b8
offset 0xb4 -> seed2 = 0x7d510557

这两个 seed 用于初始化 native 中的 RC6-like 加密器。选择 SQLite 数据库作为种子载体是一个有趣的设计——SQLite 文件有固定的结构布局,但用户数据区域的内容在不同编译下可能不同,这又增加了一层环境绑定。

RC6-like 加密与 flag 反推

native 中提取到的关键常量如下:

K1 = "PMDZH"
K2 = "8&GZN*@9Z3zLIbet"
TGT = "6zQoRVxR2FJKADz7nHNXKWmErDTXYBfWKJ7M578rk2Ks"

TGT 使用 Base58 解码,得到 32 字节密文。Base58 是 Bitcoin 地址使用的编码方式,字符集去除了容易混淆的数字 0、大写 O、大写 I 和小写 l。这里的 Base58 实现与 Bitcoin 标准一致。

native 的校验关系为:

Base58Decode(TGT) == RC6_encrypt(user_body) xor repeat(K1)

因此可以反推:

user_body = RC6_decrypt(Base58Decode(TGT) xor repeat(K1))

RC6-like 加密器基于 RC6 算法,使用两个 32 位 seed 初始化,并进行多轮加密。与标准 RC6 的核心差异在于:轮常数的生成方式被简化了,以及 S 盒的值直接由 seed 派生而非使用标准 RC6 的常数。不过解密逻辑仍然使用标准的 RC6 逆操作——只要把 seed1 和 seed2 输入,加上正确的解密流程,就能从密文恢复明文。

解出的 body 为 GuiHanQu8s9Dp68*G-ZN_#9Z3zLIbet6。

Flag

ISCC{GuiHanQu8s9Dp68*G-ZN_#9Z3zLIbet6}

Exp

import struct
import zlib

MASK = 0xffffffff


def u32(x):
    return x & MASK


def rol(x, n):
    x &= MASK
    n &= 31
    if n == 0:
        return x
    return ((x << n) | (x >> (32 - n))) & MASK


def ror(x, n):
    x &= MASK
    n &= 31
    if n == 0:
        return x
    return ((x >> n) | (x << (32 - n))) & MASK


def swap_bits(bs):
    return bytes((((b & 0xaa) >> 1) | ((b & 0x55) << 1)) & 0xff for b in bs)


def fnv64(bs):
    h = 0xcbf29ce484222325
    for b in bs:
        h ^= b
        h = (h * 0x100000001b3) & 0xffffffffffffffff
    return h


def tea(v0, v1, k):
    delta = 0x9e3779b9
    s = 0
    for _ in range(32):
        s = u32(s + delta)
        v0 = u32(v0 + ((((v1 << 4) & MASK) + k[0]) ^ u32(v1 + s) ^ ((v1 >> 5) + k[1])))
        v1 = u32(v1 + ((((v0 << 4) & MASK) + k[2]) ^ u32(v0 + s) ^ ((v0 >> 5) + k[3])))
    return v0, v1


def java_hashcode(s):
    h = 0
    for c in s:
        h = u32(h * 31 + ord(c))
    return h

完整 exp 的核心流程为:从点击序列开始,经过 bit swap → FNV-1a → TEA → CRC32 生成 tag;用 tag 解密 appview_cache.db 提取 seed;用 seed 初始化 RC6-like 解密器;对 Base58 解码的密文先异或 repeat(K1) 再 RC6 解密得到 flag body。