写在前面

这是一道`0解鸿蒙逆向题` 对于一个没有系统接触过鸿蒙逆向的小白,在线下比赛中做出来确实比较困难,这篇文章从鸿蒙小白的角度 探讨 鸿蒙hap包逆向的完整流程及重点难点

随着HarmonyOS NEXT在2024年底正式商用,纯鸿蒙应用的数量在过去一年多迅速增长,安全研究领域对鸿蒙逆向的需求也随之而来。与Android生态成熟的逆向工具链相比,鸿蒙逆向目前仍处于早期阶段,公开的分析资料和工具都比较有限。这道Bridge题目出现在2026数字中国创新大赛的决赛中,考察的正是鸿蒙应用逆向分析能力,涉及方舟字节码反编译、SM4国密算法、WebView JSBridge交互等多个技术点。从攻击面的角度来看,这道题的设计其实映射了现实中鸿蒙应用可能存在的信任边界问题——当ArkTS层通过JSBridge向WebView暴露敏感接口时,如果缺乏足够的鉴权校验,攻击者就可能通过逆向还原出完整的认证链路,进而突破应用的安全防线。

这篇文章完整记录从拿到HAP包到最终解出flag的全过程,同时穿插一些鸿蒙逆向的基础知识和实战经验。由于比赛现场时间有限,很多分析是赛后补充完善的,希望能给同样在摸索鸿蒙逆向的同学一些参考。

总结

鸿蒙逆向所需要的工具和 该题目附件下载链接为
链接:
https://pan.baidu.com/s/1gzyKci_PWg6L1yuSQHuvEg?pwd=3rka 提取码: 3rka

鸿蒙逆向知识前置

以下是基于 鸿蒙当前的主流架构(Stage 模型)总结的逆向必备前置知识:

在正式开始分析之前,有必要先搞清楚鸿蒙应用的整体架构。和Android逆向一样,如果不理解目标平台的基本结构,面对反编译输出的代码会完全摸不着头脑。鸿蒙从API 9开始全面推行Stage模型,取代了早期的FA(Feature Ability)模型。FA模型类似于Android早期的Activity概念,每个页面就是一个Ability,结构比较简单但扩展性差。Stage模型则引入了更清晰的分层架构,把应用的生命周期管理、窗口管理、UI渲染分离开来,这对逆向分析来说既是好事也是坏事——好在逻辑分层清晰,坏在调用链更长,需要跨多个模块追踪。

HAP包的本质与内部结构

在鸿蒙的世界里,你看到的安装包是一个 .app 文件,但它是由多个核心组件构成:

HAP (Harmony Ability Package):这是逆向的核心目标。一个应用可以包含多个 HAP(如 Entry 和 Feature)。

HSP (Harmony Shared Package):动态共享包。如果逆向时发现逻辑跳出了当前 HAP,那它大概率躲在 HSP 里。

HAR (Harmony Archive):静态共享包。编译后直接合入 HAP,通常在 modules.abc 中能看到

HAP文件本质上就是一个ZIP压缩包,把后缀改成.zip就能直接用解压工具打开。这和Android的APK是一样的思路。解压之后可以看到一个相对固定的目录结构:

Bridge.hap (ZIP)
├── ets/
│   ├── modules.abc
│   └── sourceMaps.map
├── resources/
│   ├── base/
│   └── rawfile/
│       └── Home.html
├── resources.index
├── module.json5
├── pack.info
└── libs/
    └── arm64-v8a/

其中 ets/modules.abc 是最关键的文件,所有ArkTS编写的业务逻辑经过方舟编译器处理后都会打包进这个文件。resources/ 目录存放图片、字符串等资源文件,rawfile/ 子目录下的文件不会被编译处理,可以直接读取。module.json5 则相当于Android的 AndroidManifest.xml,定义了应用的入口Ability、页面路由、权限声明等关键配置。

一份典型的 module.json5 长这样:

{
  "module": {
    "name": "entry",
    "type": "entry",
    "description": "$string:module_desc",
    "mainElement": "EntryAbility",
    "deviceTypes": ["phone", "tablet"],
    "deliveryWithInstall": true,
    "installationFree": false,
    "pages": "$profile:main_pages",
    "abilities": [
      {
        "name": "EntryAbility",
        "srcEntry": "./ets/entryability/EntryAbility.ets",
        "description": "$string:EntryAbility_desc",
        "icon": "$media:layered_image",
        "label": "$string:EntryAbility_label",
        "startWindowIcon": "$media:startIcon",
        "startWindowBackground": "$color:start_window_background",
        "exported": true,
        "skills": [
          {
            "entities": ["entity.system.home"],
            "actions": ["action.system.home"]
          }
        ]
      }
    ]
  }
}

逆向时首先要看 mainElement 字段确定入口Ability,然后看 pages 字段引用的路由配置找到所有页面。srcEntry 虽然指向源码路径,但在编译后的HAP中源码已经被编译进了 modules.abc,这个路径只是个参考。不过 sourceMaps.map 如果没有被剥离的话,里面会保留完整的源文件路径信息,这对逆向分析极其有价值。

方舟字节码的内部结构

Android 跑的是 Dex,而鸿蒙跑的是 ABC (ArkJS Bytecode)。

ArkTS -> ABC:开发者写的 ArkTS 代码会被方舟编译器(ArkCompiler)直接打碎,变成 .abc 文件。

需要支持方舟字节码的工具(如我网盘链接里面的 JADX 或官方的 ArkAnalyzer)来将字节码还原成可读的逻辑。

代码混淆:官方文档提到混淆策略会让你看到大量的 #~@0># 这种符号

方舟编译器的编译流程大致是这样的:开发者编写的 .ets 文件(ArkTS源码)首先会经过TypeScript编译器前端进行语法分析和类型检查,生成AST;然后方舟编译器后端将AST转换为方舟字节码指令,最终输出 .abc 文件。在这个过程中,如果开发者在 build-profile.json5 中启用了混淆配置,编译器会对函数名、变量名进行混淆处理,生成类似 #~@0>#、#*@3*# 这样的符号。

ABC文件是一种二进制格式,内部由文件头、类定义区、方法定义区、字符串常量池、字节码指令区等多个段组成。和Dex格式类似,ABC格式也有自己的指令集。不过目前ABC格式的公开文档还不够完善,大部分逆向工作依赖于社区维护的JADX插件来完成反编译。

在反编译输出中,经常会看到一些方舟字节码特有的伪指令,理解这些指令对于还原原始逻辑至关重要:

newlexenvwithname    创建词法环境,绑定变量名到槽位
asyncfunctionenter   进入async函数体
suspendgenerator     挂起当前协程,等待await表达式
resumegenerator      恢复协程执行,获取await结果
getresumemode        检查恢复模式(正常返回还是抛出异常)
asyncfunctionresolve 正常结束async函数,返回Promise.resolve
asyncfunctionreject  异常结束async函数,返回Promise.reject
ldlocalmodulevar     加载模块级变量
createobjectwithbuffer 根据模板创建对象字面量

看到 asyncfunctionenter + suspendgenerator + resumegenerator 这种组合,基本可以确定原始代码中有 async/await 语法。newlexenvwithname 则对应闭包的创建,方括号中的内容就是捕获的变量名和对应的槽位索引。理解了这些之后,从反编译输出还原出原始ArkTS代码就不那么困难了。

以 modules.abc 的内部结构举个例子,一个典型的模块会包含一个 func_main_0 方法作为模块的初始化入口,在这个方法中完成模块级变量的赋值、类的定义和导出。反编译后看到的 _module_0_ 到 _module_N_ 这些变量,实际上对应的就是模块作用域内的各个函数引用或常量。_lexenv_X_Y_ 则是闭包环境中第X层第Y个槽位的变量。

配置文件与路由

反编译代码前,先读懂配置文件

module.json5:这是 HAP 的核心 类似于安卓的AndroidManifest.xml。

Abilities:定义了应用的入口(UIAbility)。

Pages:告诉你 UI 界面的源文件路径。

Permissions:应用能干什么,都在这里备案。

app.json5:定义了应用的 Bundle 名称、版本等全局信息。

除了 module.json5 和 app.json5 之外,还有一个容易被忽略的配置文件是页面路由配置。在 Stage 模型中,页面路由通常定义在 resources/base/profile/main_pages.json 里,内容类似:

{
  "src": [
    "pages/LoginPage",
    "pages/Home"
  ]
}

这个文件告诉我们应用总共有哪些页面,以及它们的路径。结合 module.json5 中的 mainElement 和 EntryAbility 的 onWindowStageCreate 方法中加载的初始页面,就能确定应用的启动流程:EntryAbility启动 → 加载LoginPage → 登录成功后跳转到Home。

Stage 模型与运行时

如果你习惯了 Android 的 Activity/Service,在鸿蒙里你需要切换到 Stage 模型。

UIAbility:包含 UI 界面的组件。逆向时,逻辑通常从 onWindowStageCreate 或 onCreate 这里的生命周期函数开始扩散。

ExtensionAbility:后台服务、卡片、输入法等特殊功能。

数据共享:鸿蒙极其依赖 AppStorage 和 LocalStorage 进行全局状态传递。如果你在代码里发现变量突然"消失"了,去查查全局存储。

Stage模型下的UIAbility生命周期和Android Activity有些相似但也有不少差异。完整的生命周期回调顺序是 onCreate → onWindowStageCreate → onForeground → onBackground → onWindowStageDestroy → onDestroy。其中 onWindowStageCreate 是最值得关注的,因为页面加载逻辑就在这里触发。在反编译代码中,通常会看到类似这样的调用:

onWindowStageCreate(windowStage: window.WindowStage): void {
    windowStage.loadContent('pages/LoginPage', (err) => {
        if (err.code) {
            return;
        }
    });
}

这段代码决定了应用启动后显示哪个页面。对于逆向分析来说,找到这个入口点是第一步。

AppStorage 在鸿蒙应用中的使用非常普遍,它本质上是一个进程级别的全局键值存储。在这道题中,登录成功后会往 AppStorage 里写入 currentUser 和 currentToken,然后 Home 页面再从 AppStorage 中读取这两个值来进行后续的认证和解密操作。这种跨页面的数据传递模式和 Android 中通过 Intent extras 或 SharedPreferences 传递数据类似,逆向时如果发现某个变量的值不是在当前页面生成的,就要去找 AppStorage 相关的读写操作。

原生层与N-API

鸿蒙应用不全是字节码。为了性能或安全,开发者会使用 C++ 开发 Native 逻辑。

N-API (Node-API):这是 ArkTS 层与 C++ 层通信的桥梁。

.so 文件:通常存放在 libs/ 目录下。

逆向重点:分析 .so 文件时,需要关注 napi_define_properties 等函数,它们定义了 C++ 逻辑是如何暴露给 ArkTS 使用的。

在实际的鸿蒙逆向中,如果应用包�� .so 文件,分析复杂度会大幅上升。N-API 的工作方式是在 C++ 侧通过 napi_define_properties 或 DECLARE_NAPI_FUNCTION 宏注册函数,然后 ArkTS 侧通过 import xxx from 'libxxx.so' 的方式调用。在 IDA 中分析 .so 时,搜索 napi_ 前缀的函数调用可以快速定位注册入口,从而找到所有暴露给 ArkTS 的 Native 方法。不过这道 Bridge 题没有使用 Native 层,所有逻辑都在 ArkTS/ABC 中实现,降低了不少分析难度。

分析过程

文件结构

拿到 Bridge.hap 之后第一步就是解压。直接把后缀改成 .zip,用7-Zip打开即可。解压出来之后重点关注几个位置:ets/modules.abc 是编译后的字节码,ets/sourceMaps.map 是源码映射文件,module.json5 是模块配置,resources/rawfile/ 下面可能存放一些前端资源。

先搞懂鸿蒙 Stage模型 的 结构

entryability (应用的入口与生命周期)

这是整个应用的"正门"。

含义:在鸿蒙中,Ability 是应用所具备的能力的抽象。EntryAbility 是应用的主入口。

主要作用:

生命周期管理:控制应用什么时候启动(onCreate)、什么时候进入前台(onForeground)、什么时候被销毁(onDestroy)。

窗口加载:最重要的代码通常在 onWindowStageCreate 中,它负责指定应用启动后加载哪一个 page(页面)。

如果你想知道应用启动时做了哪些初始化操作(比如检查 Root、初始化加密密钥)

pages (界面与交互)

这是应用的"脸面"。

含义:对应 ArkUI 中的页面文件(原代码中通常是 .ets 文件)。

主要作用:

布局定义:定义你看到的按钮、输入框、文本。

页面逻辑:处理用户的点击事件。例如 LoginPage 负责处理登录按钮的点击,Home 负责显示主界面。

"按钮点击后发生了什么",要在这里找。比如登录跳转逻辑、点击获取 Flag 的按钮触发函数等。

model (数据逻辑与工具)

这是应用的"大脑"。

含义:按照开发规范,开发者会将与界面无关的业务逻辑、数据处理、算法封装在这里。

主要作用:

业务逻辑:如 DatabaseUtil 处理数据库的增删改查。

加解密:如 FlagUtil 封装了 SM4 等加密算法。

通信桥梁:如 CTFBridge 负责 JavaScript 与原生环境(或是与 Webview)的交互。

核心的算法(密文在哪里、Key 怎么算)基本都藏在 model 文件夹下的类里

这题没有原生 so,核心逻辑都在 ArkTS/ABC 里

resources/rawfile/Home.html 里只是一个障眼法,脚本里解出的中文大意就是"这里真的什么都没有"。
因此真正的 flag 不在 H5 页面,而在 ArkTS 的本地逻辑里。

打开 Home.html 可以看到里面确实有一段 JavaScript,但经过简单解码之后只是输出了一句无关紧要的提示信息。这是出题者设置的一个陷阱,目的是把选手的注意力引导到前端页面上,浪费时间。实际上整个解密链路都在 ArkTS 的本地代码中完成,WebView 只是一个展示层,真正的数据流是从 ArkTS 侧通过 runJavaScript 注入到 H5 页面中的。理解这一点非常关键,否则会在 H5 页面上浪费大量时间。

利用 sourceMaps.map

ets/sourceMaps.map 直接泄露了主要源码路径:

entry/src/main/ets/model/DatabaseUtil.ets

entry/src/main/ets/model/CTFBridge.ets

entry/src/main/ets/model/FlagUtil.ets

entry/src/main/ets/pages/LoginPage.ets

entry/src/main/ets/pages/Home.ets

sourceMaps泄露问题的深入分析

sourceMaps.map 本质上是一个JSON文件,它记录了编译后的字节码指令与原始源码之间的位置映射关系。这个文件在开发调试阶段用于将运行时错误定位到源码行号,正常情况下在发布构建时应该被剥离。但这道题的HAP包中保留了完整的sourceMaps.map,这意味着开发者在打包时使用的是 debug 构建配置,或者没有在 build-profile.json5 中正确设置 sourceMap 选项。

sourceMaps.map 的内容结构大致如下:

{
  "entry/src/main/ets/model/DatabaseUtil.ets": {
    "version": 3,
    "file": "DatabaseUtil.ets",
    "sources": ["entry/src/main/ets/model/DatabaseUtil.ets"],
    "mappings": "AAAA;AACA;AACA;..."
  },
  "entry/src/main/ets/model/FlagUtil.ets": {
    "version": 3,
    "file": "FlagUtil.ets",
    "sources": ["entry/src/main/ets/model/FlagUtil.ets"],
    "mappings": "AAAA;AACA;..."
  }
}

从这里可以直接获取完整的源码文件树结构,省去了在反编译输出中盲目摸索的时间。在实际的安全审计中,sourceMaps 泄露属于信息泄露类漏洞,因为它暴露了应用的内部模块划分、命名规范甚至业务逻辑的组织方式。对于攻击者来说,有了 sourceMaps 就等于拿到了一份代码地图。

猜测一下函数功能,一会我们再去重点看这些类

通过文件名可以推断出各模块的职责:LoginPage 负责登录界面的交互逻辑,DatabaseUtil 封装了数据库操作和用户认证相关的功能,Home 是登录成功后的主页面,FlagUtil 显然和 flag 的加解密有关,CTFBridge 从名字上看是用于 ArkTS 和 WebView 之间的通信桥接。

反汇编 modules.abc

使用网盘中的带有反汇编abc文件插件的jadx

这里需要说明一下工具的选择。目前能够反编译鸿蒙 ABC 字节码的工具主要有几个:社区修改版的 JADX 加载了 ABC 反编译插件,可以将 .abc 文件以类似 Java 反编译的方式呈现出来;华为官方的 ArkAnalyzer 提供了一些分析能力但功能有限;还有一些研究者开发的 abc2ets 工具可以尝试还原出 ArkTS 源码。在这道题中使用的是带 ABC 插件的 JADX,直接把 modules.abc 拖进去就能看到反编译结果。

需要注意的是,JADX 对 ABC 字节码的反编译并不完美,输出结果中会保留大量方舟虚拟机特有的伪指令,比如 asyncfunctionenter、suspendgenerator 等,不像 Android Dex 反编译那样能直接还原出接近源码的 Java/Kotlin 代码。这就要求分析者对方舟字节码的指令语义有基本的了解,才能准确还原出原始的 ArkTS 逻辑。

方舟字节码阅读技巧

在开始逐个分析各模块之前,先总结一下反编译输出中几种常见的代码模式和对应的 ArkTS 源码结构。

对于 async/await 模式,反编译输出中的典型形态是:

asyncfunctionenter = asyncfunctionenter();
suspendgenerator(asyncfunctionenter, asyncfunctionawaituncaught(asyncfunctionenter, someAsyncCall()));
resumegenerator = resumegenerator(asyncfunctionenter);
if ((1 == getresumemode(asyncfunctionenter) ? 1 : 0) != 0) {
    throw(resumegenerator);
}

这段代码对应的 ArkTS 源码其实就是:

let result = await someAsyncCall();

asyncfunctionawaituncaught 负责挂起当前协程等待 Promise 完成,resumegenerator 拿到 Promise 的结果值,getresumemode 检查 Promise 是 resolve 还是 reject——如果是 reject 就走 throw 分支。搞清楚这个模式之后,遇到类似的代码块就可以快速跳过这些模板代码,直接关注实际的业务逻辑。

对于闭包和变量捕获,newlexenvwithname 是关键指令。比如:

newlexenvwithname([2, "reject", 0, "resolve", 1], 2);
_lexenv_0_1_ = arg0;
_lexenv_0_0_ = arg1;

这表示创建了一个包含两个变量的词法环境,_lexenv_0_0_ 对应名为 resolve 的变量(槽位1),_lexenv_0_1_ 对应 reject(槽位0)。注意这里的映射关系:数组中的格式是 [总数, 名称, 槽位, 名称, 槽位, ...],而 _lexenv_X_Y_ 中的 X 表示词法环境的嵌套层级,Y 表示槽位索引。

分析反汇编结果

DatabaseUtil

package com.hmos.exam5.pkg/entry/ets/model;

public class DatabaseUtil {
    public Object pkgName@entry;
    public Object isCommonjs;
    public Object hasTopLevelAwait;
    public Object isSharedModule;
    public Object scopeNames;
    public Object moduleRecordIdx;

    public Object #*@3*#(Object functionObject, Object newTarget, DatabaseUtil this, Object arg0, Object arg1) {
        newlexenvwithname([2, "reject", 0, "resolve", 1], 2);
        _lexenv_0_1_ = arg0;
        _lexenv_0_0_ = arg1;
        asyncfunctionenter = asyncfunctionenter();
        try {
            ldlocalmodulevar = _module_0_;
            get = ldlocalmodulevar.get("s1");
            if (get == false) {
                _lexenv_0_0_(Error("Database not initialized"));
                return asyncfunctionresolve(null, asyncfunctionenter);
            }
            suspendgenerator(asyncfunctionenter, asyncfunctionawaituncaught(asyncfunctionenter, _module_5_(_lexenv_1_0_)));
            resumegenerator = resumegenerator(asyncfunctionenter);
            if ((1 == getresumemode(asyncfunctionenter) ? 1 : 0) != 0) {
                throw(resumegenerator);
            }
            ldlexvar = "SELECT * FROM user WHERE username = '" + _lexenv_1_1_ + "' AND password = '" + resumegenerator + "'";
            console.warn("[Insecure SQL]", ldlexvar);
            get.querySql(ldlexvar, [Object], #*@3**#);
            return asyncfunctionresolve(null, asyncfunctionenter);
        } catch (ExceptionI0 unused) {
            return asyncfunctionreject(asyncfunctionenter, asyncfunctionenter);
        }
    }

    public Object #*@3**#(Object functionObject, Object newTarget, DatabaseUtil this, Object arg0, Object arg1) {
        if (istrue(arg0) == null) {
            if (isfalse(istrue(arg1) == null ? 1 : 0) != null) {
                i = (arg1.rowCount > 0 ? 1 : 0);
                try {
                    arg1.close();
                } catch (ExceptionI0 unused) {
                }
                _lexenv_0_1_(i);
                return null;
            }
        }
        _lexenv_0_0_(arg0);
        return null;
    }

    public Object #~@0<#get(Object functionObject, Object newTarget, DatabaseUtil this, Object arg0) {
        return _lexenv_0_0_.stores[arg0];
    }

    public Object func_main_0(Object functionObject, Object newTarget, DatabaseUtil this) {
        newlexenvwithname([11, "uint8ArrayToHex", 0, "TOKEN_SALT", 1, "getDatabase", 2, "getUserQuerySql", 3, "queryUserResultSet", 4, "hasResult", 5, "moveToFirst", 6, "readUsername", 7, "readPasswordHash", 8, "buildToken", 9, "closeResultSet", 10], 11);
        _lexenv_0_9_ = #*#buildToken;
        _module_3_ = #*#checkLogin;
        _lexenv_0_10_ = #*#closeResultSet;
        _module_4_ = #*#generateTokenByUsername;
        _lexenv_0_2_ = #*#getDatabase;
        _lexenv_0_3_ = #*#getUserQuerySql;
        _lexenv_0_5_ = #*#hasResult;
        _lexenv_0_6_ = #*#moveToFirst;
        _lexenv_0_4_ = #*#queryUserResultSet;
        _lexenv_0_8_ = #*#readPasswordHash;
        _lexenv_0_7_ = #*#readUsername;
        _module_5_ = #*#sha256Hex;
        _lexenv_0_0_ = #*#uint8ArrayToHex;
        obj = createobjectwithbuffer(["name", "user.db", "securityLevel", 0]);
        obj.securityLevel = import { default as relationalStore } from "@ohos:data.relationalStore".SecurityLevel.S1;
        _module_1_ = obj;
        _module_2_ = "\nCREATE TABLE IF NOT EXISTS user (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  username TEXT NOT NULL UNIQUE,\n  password TEXT NOT NULL\n);\n";
        newlexenvwithname = newlexenvwithname([1, "DatabaseManager", 0], 1);
        try {
            obj2 = hole.#~@0=#DatabaseManager(Object2, Object3, hole, ["initAll", "com.hmos.exam5.pkg/entry/ets/model/DatabaseUtil.#~@0<#initAll", 1, "get", "com.hmos.exam5.pkg/entry/ets/model/DatabaseUtil.#~@0<#get", 1, 0]);
            _lexenv_0_0_ = obj2;
            obj3 = obj2.prototype;
            obj2.#~@0>#static_initializer();
            newlexenvwithname = obj2;
        } catch (ExceptionI0 unused) {
            poplexenv();
            throw(newlexenvwithname);
        }
        poplexenv();
        _module_0_ = newlexenvwithname;
        _lexenv_0_1_ = "hmos_ctf_2026";
        return null;
    }

    public Object #*#hasResult(Object functionObject, Object newTarget, DatabaseUtil this, Object arg0) {
        return (arg0.rowCount > 0 ? 1 : 0);
    }

    public Object #*#sha256Hex(Object functionObject, Object newTarget, DatabaseUtil this, Object arg0) {
        asyncfunctionenter = asyncfunctionenter();
        try {
            newobjrange = import { default as util } from "@ohos:util".TextEncoder();
            encodeInto = newobjrange.encodeInto(arg0);
            cryptoFramework = import { default as cryptoFramework } from "@ohos:security.cryptoFramework";
            createMd = cryptoFramework.createMd("SHA256");
            obj = createMd.updateSync;
            obj2 = createobjectwithbuffer(["data", 0]);
            obj2.data = encodeInto;
            obj(obj2);
            asyncfunctionenter = asyncfunctionresolve(_lexenv_0_0_(createMd.digestSync().data), asyncfunctionenter);
            return asyncfunctionenter;
        } catch (ExceptionI0 unused) {
            return asyncfunctionreject(asyncfunctionenter, asyncfunctionenter);
        }
    }

    public Object #~@0<@1*@2*#(Object functionObject, Object newTarget, DatabaseUtil this, Object arg0, Object arg1) {
        newlexenvwithname([2, "reject", 0, "resolve", 1], 2);
        _lexenv_0_1_ = arg0;
        _lexenv_0_0_ = arg1;
        relationalStore = import { default as relationalStore } from "@ohos:data.relationalStore";
        relationalStore.getRdbStore(_lexenv_2_0_, _lexenv_1_0_, #~@0<@1*@2**#);
        return null;
    }

    public Object #*#buildToken(Object functionObject, Object newTarget, DatabaseUtil this, Object arg0, Object arg1) {
        asyncfunctionenter = asyncfunctionenter();
        try {
            suspendgenerator(asyncfunctionenter, asyncfunctionawaituncaught(asyncfunctionenter, _module_5_(arg0 + arg1 + _lexenv_0_1_)));
            resumegenerator = resumegenerator(asyncfunctionenter);
            if ((1 == getresumemode(asyncfunctionenter) ? 1 : 0) != 0) {
                throw(resumegenerator);
            }
            asyncfunctionenter = asyncfunctionresolve(resumegenerator, asyncfunctionenter);
            return asyncfunctionenter;
        } catch (ExceptionI0 unused) {
            return asyncfunctionreject(asyncfunctionenter, asyncfunctionenter);
        }
    }

    public Object #*#checkLogin(Object functionObject, Object newTarget, DatabaseUtil this, Object arg0, Object arg1) {
        newlexenvwithname([2, "password", 0, "username", 1], 2);
        _lexenv_0_1_ = arg0;
        _lexenv_0_0_ = arg1;
        asyncfunctionenter = asyncfunctionenter();
        try {
            asyncfunctionenter = asyncfunctionresolve(Promise(#*@3*#), asyncfunctionenter);
            return asyncfunctionenter;
        } catch (ExceptionI0 unused) {
            return asyncfunctionreject(asyncfunctionenter, asyncfunctionenter);
        }
    }

    public Object #~@0<#initAll(Object functionObject, Object newTarget, DatabaseUtil this, Object arg0) {
        newlexenvwithname([1, "context", 0], 1);
        _lexenv_0_0_ = arg0;
        asyncfunctionenter = asyncfunctionenter();
        try {
            objArr = [Object];
            objArr[0] = #~@0<@1*#initStore(_module_1_);
            suspendgenerator(asyncfunctionenter, asyncfunctionawaituncaught(asyncfunctionenter, Promise.all(objArr)));
            resumegenerator = resumegenerator(asyncfunctionenter);
            if ((1 == getresumemode(asyncfunctionenter) ? 1 : 0) != 0) {
                throw(resumegenerator);
            }
            _lexenv_1_0_.stores["s1"] = resumegenerator[0];
            console.info("[DatabaseManager] All databases initialized.");
            asyncfunctionenter = asyncfunctionresolve(null, asyncfunctionenter);
            return asyncfunctionenter;
        } catch (ExceptionI0 unused) {
            return asyncfunctionreject(asyncfunctionenter, asyncfunctionenter);
        }
    }

    public Object #~@0<@1*@2**#(Object functionObject, Object newTarget, DatabaseUtil this, Object arg0, Object arg1) {
        newlexenvwithname([1, "db", 0], 1);
        _lexenv_0_0_ = arg1;
        if (istrue(arg0) == null) {
            if (isfalse(istrue(_lexenv_0_0_) == null ? 1 : 0) != null) {
                ldlexvar = _lexenv_0_0_;
                ldlexvar.executeSql(_module_2_, [Object], #~@0<@1*@2***#);
                return null;
            }
        }
        console.error("getRdbStore failed:", arg0);
        _lexenv_1_0_(arg0);
        return null;
    }

    public Object #*#getDatabase(Object functionObject, Object newTarget, DatabaseUtil this) {
        ldlocalmodulevar = _module_0_;
        return ldlocalmodulevar.get("s1");
    }

    public Object #*#moveToFirst(Object functionObject, Object newTarget, DatabaseUtil this, Object arg0) {
        return arg0.goToFirstRow();
    }

    public Object #~@0<@1*@2***#(Object functionObject, Object newTarget, DatabaseUtil this, Object arg0) {
        if (isfalse(arg0) == null) {
            _lexenv_1_0_(arg0);
            return null;
        }
        ldlexvar = _lexenv_0_0_;
        ldlexvar.executeSql("INSERT OR IGNORE INTO user (username, password) VALUES (?, ?)", createarraywithbuffer(["admin", "af0d3a523b93a558a63d07929efd58f4a1fad1b34348bdb06e547b1151863869"]), #~@0<@1*@2****#);
        return null;
    }

    public Object #*#readUsername(Object functionObject, Object newTarget, DatabaseUtil this, Object arg0) {
        return arg0.getString(arg0.getColumnIndex("username"));
    }

    public Object #~@0<@1*@2****#(Object functionObject, Object newTarget, DatabaseUtil this, Object arg0) {
        if (isfalse(arg0) == null) {
            _lexenv_1_0_(arg0);
            return null;
        }
        _lexenv_1_1_(_lexenv_0_0_);
        return null;
    }

    public Object #*#closeResultSet(Object functionObject, Object newTarget, DatabaseUtil this, Object arg0) {
        isfalse = isfalse(istrue(arg0) == null ? 1 : 0);
        if (isfalse == null) {
            return null;
        }
        try {
            arg0.close();
            return null;
        } catch (ExceptionI0 unused) {
            return null;
        }
    }

    public Object #*#getUserQuerySql(Object functionObject, Object newTarget, DatabaseUtil this, Object arg0) {
        return "SELECT username, password FROM user WHERE username = '" + arg0 + "' LIMIT 1";
    }

    public Object #*#uint8ArrayToHex(Object functionObject, Object newTarget, DatabaseUtil this, Object arg0) {
        obj = "";
        for (i = 0; (i < arg0.length ? 1 : 0) != 0; i = tonumer(i) + 1) {
            ldobjbyvalue = arg0[i];
            toString = ldobjbyvalue.toString(16);
            obj = (obj == true ? 1 : 0) + toString.padStart(2, "0");
        }
        return obj;
    }

    public Object #~@0<@1*#initStore(Object functionObject, Object newTarget, DatabaseUtil this, Object arg0) {
        newlexenvwithname([1, "config", 0], 1);
        _lexenv_0_0_ = arg0;
        return Promise(#~@0<@1*@2*#);
    }

    public Object #*#readPasswordHash(Object functionObject, Object newTarget, DatabaseUtil this, Object arg0) {
        return arg0.getString(arg0.getColumnIndex("password"));
    }

    public Object #*#queryUserResultSet(Object functionObject, Object newTarget, DatabaseUtil this, Object arg0) {
        asyncfunctionenter = asyncfunctionenter();
        try {
            callargsN = _lexenv_0_2_();
            if (callargsN == false) {
                console.error("Database not initialized");
                return asyncfunctionresolve(null, asyncfunctionenter);
            }
            callargsN2 = _lexenv_0_3_(arg0);
            console.info("[SQL] => " + callargsN2);
            suspendgenerator(asyncfunctionenter, asyncfunctionawaituncaught(asyncfunctionenter, callargsN.querySql(callargsN2)));
            resumegenerator = resumegenerator(asyncfunctionenter);
            if ((1 == getresumemode(asyncfunctionenter) ? 1 : 0) != 0) {
                throw(resumegenerator);
            }
            return asyncfunctionresolve(resumegenerator, asyncfunctionenter);
        } catch (ExceptionI0 unused) {
            return asyncfunctionreject(asyncfunctionenter, asyncfunctionenter);
        }
    }

    public Object #~@0=#DatabaseManager(Object functionObject, Object newTarget, DatabaseUtil this) {
        return this;
    }

    public Object #~@0>#static_initializer(Object functionObject, Object newTarget, DatabaseUtil this) {
        this.stores = createemptyobject();
        return null;
    }

    public Object #*#generateTokenByUsername(Object functionObject, Object newTarget, DatabaseUtil this, Object arg0) {
        asyncfunctionenter = asyncfunctionenter();
        try {
            try {
                try {
                    suspendgenerator(asyncfunctionenter, asyncfunctionawaituncaught(asyncfunctionenter, _lexenv_0_4_(arg0)));
                    resumegenerator = resumegenerator(asyncfunctionenter);
                    if ((1 == getresumemode(asyncfunctionenter) ? 1 : 0) != 0) {
                        throw(resumegenerator);
                    }
                    if (resumegenerator == false) {
                        _lexenv_0_10_(resumegenerator);
                        return asyncfunctionresolve("", asyncfunctionenter);
                    }
                    if (_lexenv_0_5_(resumegenerator) == false) {
                        console.error("用户不存在: " + arg0 + "");
                        _lexenv_0_10_(resumegenerator);
                        return asyncfunctionresolve("", asyncfunctionenter);
                    }
                    if (_lexenv_0_6_(resumegenerator) == false) {
                        console.error("读取用户失败: " + arg0 + "");
                        _lexenv_0_10_(resumegenerator);
                        return asyncfunctionresolve("", asyncfunctionenter);
                    }
                    suspendgenerator(asyncfunctionenter, asyncfunctionawaituncaught(asyncfunctionenter, _lexenv_0_9_(_lexenv_0_7_(resumegenerator), _lexenv_0_8_(resumegenerator))));
                    resumegenerator2 = resumegenerator(asyncfunctionenter);
                    if ((1 == getresumemode(asyncfunctionenter) ? 1 : 0) != 0) {
                        throw(resumegenerator2);
                    }
                    _lexenv_0_10_(resumegenerator);
                    return asyncfunctionresolve(resumegenerator2, asyncfunctionenter);
                } catch (ExceptionI0 unused) {
                    console.error("[generateTokenByUsername] failed");
                    _lexenv_0_10_(0);
                    return asyncfunctionresolve("", asyncfunctionenter);
                }
            } catch (ExceptionI0 unused2) {
                return asyncfunctionreject(null, asyncfunctionenter);
            }
        } catch (ExceptionI0 unused3) {
            if ((0 == 0 ? 1 : 0) != 0) {
                _lexenv_0_10_(0);
            }
            if ((0 != hole ? 1 : 0) != 0) {
                throw(0);
            }
            return asyncfunctionresolve(null, asyncfunctionenter);
        }
    }
}

DatabaseUtil 深入分析

模块初始化与变量映射

要读懂 DatabaseUtil 的反编译代码,首先需要理清 func_main_0 中的变量映射关系。这个方法是模块加载时的初始化入口,newlexenvwithname 创建的词法环境包含了11个槽位,每个槽位对应一个具名函数。根据 newlexenvwithname 的参数可以还原出完整的映射表:

_lexenv_0_0_  -> uint8ArrayToHex
_lexenv_0_1_  -> TOKEN_SALT = "hmos_ctf_2026"
_lexenv_0_2_  -> getDatabase
_lexenv_0_3_  -> getUserQuerySql
_lexenv_0_4_  -> queryUserResultSet
_lexenv_0_5_  -> hasResult
_lexenv_0_6_  -> moveToFirst
_lexenv_0_7_  -> readUsername
_lexenv_0_8_  -> readPasswordHash
_lexenv_0_9_  -> buildToken
_lexenv_0_10_ -> closeResultSet
_module_3_    -> checkLogin (导出)
_module_4_    -> generateTokenByUsername (导出)
_module_5_    -> sha256Hex

有了这张映射表,再回头看那些充满 _lexenv_X_Y_ 的反编译代码就清晰多了。

数据库初始化与预置凭据

在 #~@0<@1*@2***# 方法中可以看到数据库初始化完成后会执行一条 INSERT 语句:

INSERT OR IGNORE INTO user (username, password) VALUES (?, ?)

参数是硬编码的 admin 和 af0d3a523b93a558a63d07929efd58f4a1fad1b34348bdb06e547b1151863869。这意味着应用首次启动时会在本地 SQLite 数据库中插入一个管理员用户,密码以 SHA256 哈希的形式存储。

用户名:admin

密码哈希:af0d3a523b93a558a63d07929efd58f4a1fad1b34348bdb06e547b1151863869

这个密码哈希值是整个解密链的起始输入之一,后面构造 token 和 SM4 密钥都依赖它。

SQL注入问题

值得注意的是 #*@3*# 方法(即 checkLogin 内部的 Promise 回调)和 #*#getUserQuerySql 中都存在明显的 SQL 拼接问题。getUserQuerySql 直接将用户名拼接进 SQL 语句:

SELECT username, password FROM user WHERE username = '{arg0}' LIMIT 1

在 #*@3*# 中更加明显,直接把用户名和密码哈希拼进了 SQL:

SELECT * FROM user WHERE username = '{username}' AND password = '{passwordHash}'

代码里甚至还有一行 console.warn("[Insecure SQL]", ldlexvar) 的日志输出,说明出题者故意留下了这个 SQL 注入的线索。不过在这道题的解题过程中,SQL 注入并不是必需的——因为管理员的用户名和密码哈希都是硬编码在字节码里的,直接提取即可。但如果这是一个真实应用,这种 SQL 拼接方式就是一个严重的安全漏洞,攻击者可以通过构造恶意用户名绕过登录验证。

Token生成逻辑的还原

#*#buildToken:

suspendgenerator(..., _module_5_(arg0 + arg1 + _lexenv_0_1_));

登录成功后,系统在 AppStorage 里存入的身份凭证。

DatabaseUtil.buildToken 的反汇编核心是:

passwordHash + username + TOKEN_SALT
-> sha256Hex(...)

结合 generateTokenByUsername 里对 readUsername / readPasswordHash / buildToken 的调用顺序,可以还原出:

currentToken = sha256Hex(username + passwordHash + "hmos_ctf_2026")

generateTokenByUsername 的执行流程需要仔细跟踪。通过变量映射表展开,这个方法实际上做了以下事情:调用 queryUserResultSet(username) 查询用户记录,检查结果集是否非空(hasResult),移动游标到第一行(moveToFirst),然后分别读取 username 和 passwordHash 字段(readUsername + readPasswordHash),最后调用 buildToken(username, passwordHash) 计算 token。buildToken 内部调用 sha256Hex(arg0 + arg1 + TOKEN_SALT),也就是对 username + passwordHash + "hmos_ctf_2026" 这个字符串做 SHA256 哈希。

根据以上分析,可以还原出 generateTokenByUsername 的原始 ArkTS 源码大致如下:

async function generateTokenByUsername(username: string): Promise<string> {
    let resultSet = await queryUserResultSet(username);
    if (!resultSet) {
        closeResultSet(resultSet);
        return "";
    }
    if (!hasResult(resultSet)) {
        closeResultSet(resultSet);
        return "";
    }
    if (!moveToFirst(resultSet)) {
        closeResultSet(resultSet);
        return "";
    }
    let uname = readUsername(resultSet);
    let pwdHash = readPasswordHash(resultSet);
    let token = await buildToken(uname, pwdHash);
    closeResultSet(resultSet);
    return token;
}

async function buildToken(username: string, passwordHash: string): Promise<string> {
    return await sha256Hex(username + passwordHash + TOKEN_SALT);
}

对管理员用户代入后得到:

username      = admin
passwordHash  = af0d3a523b93a558a63d07929efd58f4a1fad1b34348bdb06e547b1151863869
currentToken  = fb809f9d941bb2dc8034978ee02cd35b688c2ba93be23b6d25d91fa7ef5fb518

然后再进入 Home 页的二次哈希:

sha256Hex(currentToken + "|admin|HMOS_CTF_2026")
= 51a8f50d751a48550f90b3c49439afbe...

取前 32 个十六进制字符作为 16 字节 SM4 key:

51a8f50d751a48550f90b3c49439afbe

SHA256 实现细节

sha256Hex 方法使用了鸿蒙的 @ohos:security.cryptoFramework 框架来计算 SHA256。具体流程是先通过 TextEncoder 将字符串编码为 Uint8Array,然后调用 cryptoFramework.createMd("SHA256") 创建摘要对象,用 updateSync 填入数据,最后用 digestSync() 获取摘要结果,再通过 uint8ArrayToHex 转换为十六进制字符串。这和 Web API 中的 crypto.subtle.digest 以及 Node.js 中的 crypto.createHash 思路一致,只是鸿蒙有自己的一套 API 封装。

FlagUtil

package com.hmos.exam5.pkg/entry/ets/model;

public class FlagUtil {
    public Object pkgName@entry;
    public Object isCommonjs;
    public Object hasTopLevelAwait;
    public Object isSharedModule;
    public Object scopeNames;
    public Object moduleRecordIdx;

    public Object func_main_0(Object functionObject, Object newTarget, FlagUtil this) {
        newlexenvwithname([1, "LOCAL_FLAG_CIPHER_HEX", 0], 1);
        _module_0_ = #*#bytesToHex;
        _module_1_ = #*#bytesToUtf8;
        _module_2_ = #*#genSm4KeyByData;
        _module_3_ = #*#hexToBytes;
        _module_4_ = #*#readLocalFlagCipher;
        _module_5_ = #*#sm4Decrypt;
        _module_6_ = #*#sm4Encrypt;
        _module_7_ = #*#utf8ToBytes;
        _lexenv_0_0_ = "\n5a52339fbdb9b11b330ed4ffd6f06b453e0d3fb96a624a71b16124065c2d9e3362fa1d5941b0995e559002b759cf91a9\n".replace(RegExp("\\s+", "g"), "");
        return null;
    }

    public Object #*#bytesToHex(Object functionObject, Object newTarget, FlagUtil this, Object arg0) {
        obj = "";
        for (i = 0; (i < arg0.length ? 1 : 0) != 0; i = tonumer(i) + 1) {
            ldobjbyvalue = arg0[i];
            toString = ldobjbyvalue.toString(16);
            obj = (obj == true ? 1 : 0) + toString.padStart(2, "0");
        }
        return obj;
    }

    public Object #*#hexToBytes(Object functionObject, Object newTarget, FlagUtil this, Object arg0) {
        if (arg0 == false) {
            throw(Error("hexToBytes: empty hex string"));
        }
        trim = arg0.trim();
        toLowerCase = trim.toLowerCase();
        if (isfalse(toLowerCase.startsWith("0x")) == null) {
            toLowerCase = toLowerCase.slice(2);
        }
        obj = toLowerCase;
        replace = obj.replace(RegExp("\\s+", "g"), "");
        if ((0 != (replace.length % 2) ? 1 : 0) != 0) {
            throw(Error(("hexToBytes: invalid hex length " + replace.length + "")));
        }
        newobjrange = RegExp("^[0-9a-f]+$");
        if (newobjrange.test(replace) == false) {
            throw(Error("hexToBytes: invalid hex string"));
        }
        newobjrange2 = Uint8Array((replace.length / 2));
        i = 0;
        while (true) {
            i2 = i;
            if ((i2 < replace.length ? 1 : 0) == 0) {
                return newobjrange2;
            }
            newobjrange2[i2 / 2] = parseInt(replace.substring(i2, i2 + 2), 16);
            i = i2 + 2;
        }
    }

    public Object #*#sm4Decrypt(Object functionObject, Object newTarget, FlagUtil this, Object arg0, Object arg1) {
        asyncfunctionenter = asyncfunctionenter();
        try {
            suspendgenerator(asyncfunctionenter, asyncfunctionawaituncaught(asyncfunctionenter, _module_2_(arg1)));
            resumegenerator = resumegenerator(asyncfunctionenter);
            if ((1 == getresumemode(asyncfunctionenter) ? 1 : 0) != 0) {
                throw(resumegenerator);
            }
            cryptoFramework = import { default as cryptoFramework } from "@ohos:security.cryptoFramework";
            createCipher = cryptoFramework.createCipher("SM4_128|ECB|PKCS7");
            obj = createobjectwithbuffer(["data", 0]);
            obj.data = arg0;
            suspendgenerator(asyncfunctionenter, asyncfunctionawaituncaught(asyncfunctionenter, createCipher.init(import { default as cryptoFramework } from "@ohos:security.cryptoFramework".CryptoMode.DECRYPT_MODE, resumegenerator, 0)));
            resumegenerator2 = resumegenerator(asyncfunctionenter);
            if ((1 == getresumemode(asyncfunctionenter) ? 1 : 0) != 0) {
                throw(resumegenerator2);
            }
            suspendgenerator(asyncfunctionenter, asyncfunctionawaituncaught(asyncfunctionenter, createCipher.doFinal(obj)));
            resumegenerator3 = resumegenerator(asyncfunctionenter);
            if ((1 == getresumemode(asyncfunctionenter) ? 1 : 0) != 0) {
                throw(resumegenerator3);
            }
            asyncfunctionenter = asyncfunctionresolve(resumegenerator3.data, asyncfunctionenter);
            return asyncfunctionenter;
        } catch (ExceptionI0 unused) {
            return asyncfunctionreject(asyncfunctionenter, asyncfunctionenter);
        }
    }

    public Object #*#sm4Encrypt(Object functionObject, Object newTarget, FlagUtil this, Object arg0, Object arg1) {
        asyncfunctionenter = asyncfunctionenter();
        try {
            suspendgenerator(asyncfunctionenter, asyncfunctionawaituncaught(asyncfunctionenter, _module_2_(arg1)));
            resumegenerator = resumegenerator(asyncfunctionenter);
            if ((1 == getresumemode(asyncfunctionenter) ? 1 : 0) != 0) {
                throw(resumegenerator);
            }
            cryptoFramework = import { default as cryptoFramework } from "@ohos:security.cryptoFramework";
            createCipher = cryptoFramework.createCipher("SM4_128|ECB|PKCS7");
            obj = createobjectwithbuffer(["data", 0]);
            obj.data = arg0;
            suspendgenerator(asyncfunctionenter, asyncfunctionawaituncaught(asyncfunctionenter, createCipher.init(import { default as cryptoFramework } from "@ohos:security.cryptoFramework".CryptoMode.ENCRYPT_MODE, resumegenerator, 0)));
            resumegenerator2 = resumegenerator(asyncfunctionenter);
            if ((1 == getresumemode(asyncfunctionenter) ? 1 : 0) != 0) {
                throw(resumegenerator2);
            }
            suspendgenerator(asyncfunctionenter, asyncfunctionawaituncaught(asyncfunctionenter, createCipher.doFinal(obj)));
            resumegenerator3 = resumegenerator(asyncfunctionenter);
            if ((1 == getresumemode(asyncfunctionenter) ? 1 : 0) != 0) {
                throw(resumegenerator3);
            }
            asyncfunctionenter = asyncfunctionresolve(resumegenerator3.data, asyncfunctionenter);
            return asyncfunctionenter;
        } catch (ExceptionI0 unused) {
            return asyncfunctionreject(asyncfunctionenter, asyncfunctionenter);
        }
    }

    public Object #*#bytesToUtf8(Object functionObject, Object newTarget, FlagUtil this, Object arg0) {
        buffer = import { default as buffer } from "@ohos:buffer";
        from = buffer.from(arg0);
        return from.toString("utf-8");
    }

    public Object #*#utf8ToBytes(Object functionObject, Object newTarget, FlagUtil this, Object arg0) {
        buffer = import { default as buffer } from "@ohos:buffer";
        return Uint8Array(buffer.from(arg0, "utf-8").buffer);
    }

    public Object #*#genSm4KeyByData(Object functionObject, Object newTarget, FlagUtil this, Object arg0) {
        asyncfunctionenter = asyncfunctionenter();
        try {
            if ((16 != arg0.length ? 1 : 0) != 0) {
                throw(Error(("genSm4KeyByData: invalid key length " + arg0.length + ", expected 16")));
            }
            obj = createobjectwithbuffer(["data", 0]);
            obj.data = arg0;
            cryptoFramework = import { default as cryptoFramework } from "@ohos:security.cryptoFramework";
            createSymKeyGenerator = cryptoFramework.createSymKeyGenerator("SM4_128");
            suspendgenerator(asyncfunctionenter, asyncfunctionawaituncaught(asyncfunctionenter, createSymKeyGenerator.convertKey(obj)));
            resumegenerator = resumegenerator(asyncfunctionenter);
            if ((1 == getresumemode(asyncfunctionenter) ? 1 : 0) != 0) {
                throw(resumegenerator);
            }
            asyncfunctionenter = asyncfunctionresolve(resumegenerator, asyncfunctionenter);
            return asyncfunctionenter;
        } catch (ExceptionI0 unused) {
            return asyncfunctionreject(asyncfunctionenter, asyncfunctionenter);
        }
    }

    public Object #*#readLocalFlagCipher(Object functionObject, Object newTarget, FlagUtil this) {
        return _module_3_(_lexenv_0_0_);
    }
}

FlagUtil 深入分析

密文存储

func_main_0 中可以直接找到 flag 密文,它以十六进制字符串的形式硬编码在模块初始化代码中,赋值给 LOCAL_FLAG_CIPHER_HEX(即 _lexenv_0_0_)。字符串两端的换行符通过 .replace(RegExp("\\s+", "g"), "") 去除空白字符后得到干净的密文:

5a52339fbdb9b11b330ed4ffd6f06b453e0d3fb96a624a71b16124065c2d9e3362fa1d5941b0995e559002b759cf91a9

这段密文总长96个十六进制字符,也就是48字节。SM4是128位分组密码,每个分组16字节,48字节恰好是3个完整分组。考虑到使用了PKCS7填充,实际的明文长度应该小于48字节,最后一个分组的末尾部分是填充数据。

SM4加密方案分析

从 sm4Decrypt 的反编译代码中可以提取出加密配置:cryptoFramework.createCipher("SM4_128|ECB|PKCS7")。这意味着使用的是 SM4 算法,128位密钥长度,ECB(Electronic Codebook)工作模式,PKCS7填充方案。

ECB模式是分组密码中最简单的工作模式,每个明文分组独立加密,不依赖前后分组的状态。这种模式的优点是实现简单、支持并行加解密,缺点是相同的明文分组会产生相同的密文分组,存在模式泄露的风险。不过对于CTF题目中这种短明文(flag字符串通常不超过50字节),ECB模式不会造成实际的安全问题。如果用CBC或CTR模式反而会增加一个IV参数的复杂度。

PKCS7填充的规则是:如果最后一个分组不足16字节,就用缺少的字节数来填充。比如明文最后剩了13字节,就需要填充3个字节,每个填充字节的值都是0x03。如果明文恰好是16的整数倍,还需要额外追加一整个分组的填充(16个0x10)。解密后需要根据最后一个字节的值去掉对应数量的填充字节。

genSm4KeyByData 方法负责将16字节的原始密钥数据转换为 cryptoFramework 能使用的 SymKey 对象。这里有一个重要的校验:arg0.length 必须等于16,否则会抛出异常。这确认了SM4密钥长度确实是16字节(128位),也就是32个十六进制字符。

还原出 FlagUtil 中核心方法的原始 ArkTS 代码:

const LOCAL_FLAG_CIPHER_HEX = "5a52339fbdb9b11b330ed4ffd6f06b453e0d3fb96a624a71b16124065c2d9e3362fa1d5941b0995e559002b759cf91a9";

function readLocalFlagCipher(): Uint8Array {
    return hexToBytes(LOCAL_FLAG_CIPHER_HEX);
}

async function sm4Decrypt(cipherData: Uint8Array, keyBytes: Uint8Array): Promise<Uint8Array> {
    let symKey = await genSm4KeyByData(keyBytes);
    let cipher = cryptoFramework.createCipher("SM4_128|ECB|PKCS7");
    let dataBlob: cryptoFramework.DataBlob = { data: cipherData };
    await cipher.init(cryptoFramework.CryptoMode.DECRYPT_MODE, symKey, null);
    let result = await cipher.doFinal(dataBlob);
    return result.data;
}

async function genSm4KeyByData(keyData: Uint8Array): Promise<cryptoFramework.SymKey> {
    if (keyData.length !== 16) {
        throw new Error("invalid key length");
    }
    let keyBlob: cryptoFramework.DataBlob = { data: keyData };
    let generator = cryptoFramework.createSymKeyGenerator("SM4_128");
    return await generator.convertKey(keyBlob);
}

page.Home

package com.hmos.exam5.pkg/entry/ets/pages;

public class Home {
    public Object pkgName@entry;
    public Object isCommonjs;
    public Object hasTopLevelAwait;
    public Object isSharedModule;
    public Object scopeNames;
    public Object moduleRecordIdx;

    public Object #*#(Object functionObject, Object newTarget, Home this) {
        return null;
    }

    public Object #*#^1(Object functionObject, Object newTarget, Home this) {
        return _lexenv_0_0_(null, createemptyobject());
    }

    public Object #~@0>@1*#(Object functionObject, Object newTarget, Home this) {
        ldlexvar = _lexenv_0_0_;
        ldlexvar.reloadState();
        return null;
    }

    public Object #~@0>@2*#(Object functionObject, Object newTarget, Home this, Object arg0, Object arg1) {
        Column.create();
        Column.width("100%");
        Column.height("100%");
        return null;
    }

    public Object #~@0>@2*#^1(Object functionObject, Object newTarget, Home this, Object arg0, Object arg1) {
        Text.create("当前用户: " + _lexenv_0_0_.currentUser + "");
        Text.fontSize(18);
        Text.margin(createobjectwithbuffer(["left", 10, "top", 10, "right", 10]));
        return null;
    }

    public Object #~@0>@2*#^2(Object functionObject, Object newTarget, Home this, Object arg0, Object arg1) {
        Text.create(_lexenv_0_0_.infoText);
        Text.fontSize(16);
        Text.margin(createobjectwithbuffer(["left", 10, "top", 6, "right", 10, "bottom", 10]));
        return null;
    }

    public Object #~@0>@2*#^3(Object functionObject, Object newTarget, Home this, Object arg0, Object arg1) {
        If.create();
        if (isfalse(_lexenv_0_0_.flagText) == null) {
            ldlexvar = _lexenv_0_0_;
            ldlexvar.ifElseBranchUpdateFunction(0, #~@0>@2*^3*#);
            return null;
        }
        ldlexvar2 = _lexenv_0_0_;
        ldlexvar2.ifElseBranchUpdateFunction(1, #~@0>@2*^3*#^1);
        return null;
    }

    public Object #~@0>@2*#^4(Object functionObject, Object newTarget, Home this, Object arg0, Object arg1) {
        obj = Web.create;
        obj2 = createobjectwithbuffer(["src", 0, "controller", 0]);
        obj3 = createobjectwithbuffer(["id", 0, "type", 30000, "params", 0, "bundleName", "com.hmos.exam5.pkg", "moduleName", "entry"]);
        obj3.params = createarraywithbuffer(["Home.html"]);
        obj2.src = obj3;
        obj2.controller = _lexenv_0_0_.controller;
        obj(obj2);
        Web.javaScriptAccess(1);
        obj4 = Web.javaScriptProxy;
        obj5 = createobjectwithbuffer(["object", 0, "name", "ctfBridge", "methodList", 0, "controller", 0]);
        obj5.object = _lexenv_0_0_.bridge;
        obj5.methodList = createarraywithbuffer(["saveUser", "refresh", "getCurrentUser", "getCurrentToken"]);
        obj5.controller = _lexenv_0_0_.controller;
        obj4(obj5);
        Web.onPageBegin(#~@0>@2*^4*#);
        Web.onPageEnd(#~@0>@2*^4*#^1);
        Web.width("100%");
        Web.layoutWeight(1);
        return null;
    }

    public Object #~@0>@2*#^5(Object functionObject, Object newTarget, Home this, Object arg0, Object arg1) {
        Button.createWithLabel("手动刷新状态");
        Button.width("100%");
        Button.height(42);
        Button.margin(10);
        Button.onClick(#~@0>@2*^5*#);
        return null;
    }

    public Object func_main_0(Object functionObject, Object newTarget, Home this) {
        newlexenvwithname([1, "HomePage", 0], 1);
        if (isIn("finalizeConstruction", ViewPU.prototype) == false) {
            Reflect.set(ViewPU.prototype, "finalizeConstruction", #*#);
        }
        obj = ViewPU.#~@0=#HomePage(Object2, Object3, ViewPU, ["setInitiallyProvidedValue", "com.hmos.exam5.pkg/entry/ets/pages/Home.#~@0>#setInitiallyProvidedValue", 1, "updateStateVars", "com.hmos.exam5.pkg/entry/ets/pages/Home.#~@0>#updateStateVars", 1, "purgeVariableDependenciesOnElmtId", "com.hmos.exam5.pkg/entry/ets/pages/Home.#~@0>#purgeVariableDependenciesOnElmtId", 1, "aboutToBeDeleted", "com.hmos.exam5.pkg/entry/ets/pages/Home.#~@0>#aboutToBeDeleted", 0, 4]);
        obj2 = obj.prototype;
        obj2["currentUser"].getter = obj2.#~@0>#currentUser;
        obj2["currentUser"].setter = obj2.#~@0>#currentUser^1;
        obj2["currentToken"].getter = obj2.#~@0>#currentToken;
        obj2["currentToken"].setter = obj2.#~@0>#currentToken^1;
        obj2["infoText"].getter = obj2.#~@0>#infoText;
        obj2["infoText"].setter = obj2.#~@0>#infoText^1;
        obj2["flagText"].getter = obj2.#~@0>#flagText;
        obj2["flagText"].setter = obj2.#~@0>#flagText^1;
        obj2["pageReady"].getter = obj2.#~@0>#pageReady;
        obj2["pageReady"].setter = obj2.#~@0>#pageReady^1;
        obj2.aboutToAppear = obj2.#~@0>#aboutToAppear;
        obj2.reloadState = obj2.#~@0>#reloadState;
        obj2.decryptLocalFlag = obj2.#~@0>#decryptLocalFlag;
        obj2.injectStateToH5 = obj2.#~@0>#injectStateToH5;
        obj2.initialRender = obj2.#~@0>#initialRender;
        obj2.rerender = obj2.#~@0>#rerender;
        obj.getEntryName = obj.#~@0<#getEntryName;
        _lexenv_0_0_ = obj;
        registerNamedRoute(#*#^1, "", createobjectwithbuffer(["bundleName", "com.hmos.exam5.pkg", "moduleName", "entry", "pagePath", "pages/Home", "pageFullPath", "entry/src/main/ets/pages/Home", "integratedHsp", "false", "moduleType", "followWithHap"]));
        return null;
    }

    public Object #~@0>@2*^3*#(Object functionObject, Object newTarget, Home this) {
        ldlexvar = _lexenv_0_0_;
        ldlexvar.observeComponentCreation2(#~@0>@2*^3**#, Text);
        Text.pop();
        return null;
    }

    public Object #~@0>@2*^4*#(Object functionObject, Object newTarget, Home this) {
        _lexenv_0_0_.pageReady = 0;
        console.info("[Home] onPageBegin");
        return null;
    }

    public Object #~@0>@2*^5*#(Object functionObject, Object newTarget, Home this) {
        ldlexvar = _lexenv_0_0_;
        ldlexvar.reloadState();
        return null;
    }

    public Object #~@0>@2*^3**#(Object functionObject, Object newTarget, Home this, Object arg0, Object arg1) {
        Text.create(_lexenv_0_0_.flagText);
        Text.fontSize(20);
        Text.fontColor(Color.Red);
        Text.margin(createobjectwithbuffer(["left", 10, "right", 10, "bottom", 10]));
        return null;
    }

    public Object #~@0=#HomePage(Object functionObject, Object newTarget, Home this, Object arg0, Object arg1, Object arg2, Object arg3, Object arg4, Object arg5) {
        obj = arg3;
        obj2 = arg4;
        if ((0 == obj ? 1 : 0) != 0) {
            obj = -1;
        }
        if ((0 == obj2 ? 1 : 0) != 0) {
            obj2 = null;
        }
        obj3 = super(arg0, arg2, obj, arg5);
        if (("function" == typeof(obj2) ? 1 : 0) != 0) {
            obj3.paramsGenerator_ = obj2;
        }
        obj3.controller = import { default as web_webview } from "@ohos:web.webview".WebviewController();
        obj3.bridge = import { CTFBridge } from "@bundle:com.hmos.exam5.pkg/entry/ets/model/CTFBridge"();
        obj3.__currentUser = ObservedPropertySimplePU("", obj3, "currentUser");
        obj3.__currentToken = ObservedPropertySimplePU("", obj3, "currentToken");
        obj3.__infoText = ObservedPropertySimplePU("欢迎来到 Home", obj3, "infoText");
        obj3.__flagText = ObservedPropertySimplePU("", obj3, "flagText");
        obj3.__pageReady = ObservedPropertySimplePU(null, obj3, "pageReady");
        obj3.lastInjectedState = "";
        obj3.setInitiallyProvidedValue(arg1);
        obj3.finalizeConstruction();
        return obj3;
    }

    public Object #~@0>#flagText(Object functionObject, Object newTarget, Home this) {
        obj = this.__flagText;
        return obj.get();
    }

    public Object #~@0>#infoText(Object functionObject, Object newTarget, Home this) {
        obj = this.__infoText;
        return obj.get();
    }

    public Object #~@0>#rerender(Object functionObject, Object newTarget, Home this) {
        this.updateDirtyElements();
        return null;
    }

    public Object #~@0>@2*^3*#^1(Object functionObject, Object newTarget, Home this) {
        return null;
    }

    public Object #~@0>@2*^4*#^1(Object functionObject, Object newTarget, Home this) {
        _lexenv_0_0_.pageReady = 1;
        console.info("[Home] onPageEnd");
        ldlexvar = _lexenv_0_0_;
        ldlexvar.injectStateToH5();
        return null;
    }

    public Object #~@0>#pageReady(Object functionObject, Object newTarget, Home this) {
        obj = this.__pageReady;
        return obj.get();
    }

    public Object #~@0>#flagText^1(Object functionObject, Object newTarget, Home this, Object arg0) {
        obj = this.__flagText;
        obj.set(arg0);
        return null;
    }

    public Object #~@0>#infoText^1(Object functionObject, Object newTarget, Home this, Object arg0) {
        obj = this.__infoText;
        obj.set(arg0);
        return null;
    }

    public Object #~@0>#currentUser(Object functionObject, Object newTarget, Home this) {
        obj = this.__currentUser;
        return obj.get();
    }

    public Object #~@0>#pageReady^1(Object functionObject, Object newTarget, Home this, Object arg0) {
        obj = this.__pageReady;
        obj.set(arg0);
        return null;
    }

    public Object #~@0>#reloadState(Object functionObject, Object newTarget, Home this) {
        asyncfunctionenter = asyncfunctionenter();
        try {
            get = AppStorage.get("currentUser");
            this.currentUser = ((0 == get ? 1 : 0) == 0 && (0 == get ? 1 : 0) == 0) ? get : "";
            get2 = AppStorage.get("currentToken");
            this.currentToken = ((0 == get2 ? 1 : 0) == 0 && (0 == get2 ? 1 : 0) == 0) ? get2 : "";
            console.info("[Home] currentUser=" + this.currentUser + ", currentToken=" + this.currentToken + "");
            if (isfalse(("admin" == this.currentUser ? 1 : 0)) == null && (asyncfunctionenter = isfalse(this.currentToken)) == null) {
                try {
                    suspendgenerator(asyncfunctionenter, asyncfunctionawaituncaught(asyncfunctionenter, this.decryptLocalFlag(this.currentToken)));
                    resumegenerator = resumegenerator(asyncfunctionenter);
                    if ((1 == getresumemode(asyncfunctionenter) ? 1 : 0) != 0) {
                        throw(resumegenerator);
                    }
                    this.flagText = resumegenerator;
                    asyncfunctionenter = "管理员模式���激活";
                    this.infoText = "管理员模式已激活";
                } catch (ExceptionI0 unused) {
                    this.flagText = "";
                    this.infoText = "token 错误或解密失败";
                }
            } else if (("admin" == this.currentUser ? 1 : 0) != 0) {
                this.flagText = "";
                this.infoText = "管理员模式,但尚未提供 token";
            } else {
                this.flagText = "";
                this.infoText = "普通用户页面";
            }
            if (isfalse(this.pageReady) == null) {
                this.injectStateToH5();
            }
            asyncfunctionenter = asyncfunctionresolve(null, asyncfunctionenter);
            return asyncfunctionenter;
        } catch (ExceptionI0 unused2) {
            return asyncfunctionreject(asyncfunctionenter, asyncfunctionenter);
        }
    }

    public Object #~@0<#getEntryName(Object functionObject, Object newTarget, Home this) {
        return "HomePage";
    }

    public Object #~@0>#currentToken(Object functionObject, Object newTarget, Home this) {
        obj = this.__currentToken;
        return obj.get();
    }

    public Object #~@0>#aboutToAppear(Object functionObject, Object newTarget, Home this) {
        newlexenvwithname([1, "this", 0], 1);
        _lexenv_0_0_ = this;
        obj = _lexenv_0_0_.bridge;
        obj.setController(_lexenv_0_0_.controller);
        obj2 = _lexenv_0_0_.bridge;
        obj2.setReloadHandler(#~@0>@1*#);
        ldlexvar = _lexenv_0_0_;
        ldlexvar.reloadState();
        return null;
    }

    public Object #~@0>#currentUser^1(Object functionObject, Object newTarget, Home this, Object arg0) {
        obj = this.__currentUser;
        obj.set(arg0);
        return null;
    }

    public Object #~@0>#initialRender(Object functionObject, Object newTarget, Home this) {
        newlexenvwithname([1, "this", 0], 1);
        _lexenv_0_0_ = this;
        ldlexvar = _lexenv_0_0_;
        ldlexvar.observeComponentCreation2(#~@0>@2*#, Column);
        ldlexvar2 = _lexenv_0_0_;
        ldlexvar2.observeComponentCreation2(#~@0>@2*#^1, Text);
        Text.pop();
        ldlexvar3 = _lexenv_0_0_;
        ldlexvar3.observeComponentCreation2(#~@0>@2*#^2, Text);
        Text.pop();
        ldlexvar4 = _lexenv_0_0_;
        ldlexvar4.observeComponentCreation2(#~@0>@2*#^3, If);
        If.pop();
        ldlexvar5 = _lexenv_0_0_;
        ldlexvar5.observeComponentCreation2(#~@0>@2*#^4, Web);
        ldlexvar6 = _lexenv_0_0_;
        ldlexvar6.observeComponentCreation2(#~@0>@2*#^5, Button);
        Button.pop();
        Column.pop();
        return null;
    }

    public Object #~@0>#currentToken^1(Object functionObject, Object newTarget, Home this, Object arg0) {
        obj = this.__currentToken;
        obj.set(arg0);
        return null;
    }

    public Object #~@0>#injectStateToH5(Object functionObject, Object newTarget, Home this) {
        obj = JSON.stringify;
        obj2 = createobjectwithbuffer(["currentUser", 0, "currentToken", 0, "infoText", 0, "flagText", 0]);
        obj2.currentUser = this.currentUser;
        obj2.currentToken = this.currentToken;
        obj2.infoText = this.infoText;
        obj2.flagText = this.flagText;
        callthisN = obj(obj2);
        if ((this.lastInjectedState == callthisN ? 1 : 0) != 0) {
            console.info("[Home] skip injectStateToH5, same state");
            return null;
        }
        this.lastInjectedState = callthisN;
        obj3 = this.currentUser;
        replace = obj3.replace(RegExp("\\\\", "g"), "\\\\");
        replace2 = replace.replace(RegExp("'", "g"), "\\'");
        obj4 = this.currentToken;
        replace3 = obj4.replace(RegExp("\\\\", "g"), "\\\\");
        replace4 = replace3.replace(RegExp("'", "g"), "\\'");
        obj5 = this.infoText;
        replace5 = obj5.replace(RegExp("\\\\", "g"), "\\\\");
        replace6 = replace5.replace(RegExp("'", "g"), "\\'");
        obj6 = this.flagText;
        replace7 = obj6.replace(RegExp("\\\\", "g"), "\\\\");
        replace8 = replace7.replace(RegExp("'", "g"), "\\'");
        i = "\n    try {\n      localStorage.setItem('currentUser', '" + replace2 + "');\n      localStorage.setItem('currentToken', '" + replace4 + "');\n      window.currentUser = '" + replace2 + "';\n      window.currentToken = '" + replace4 + "';\n      window.pageInfo = '" + replace6 + "';\n      window.flagText = '" + replace8 + "';\n\n      if (typeof window.onNativeStateUpdate === 'function') {\n        window.onNativeStateUpdate({\n          currentUser: '" + replace2 + "',\n          currentToken: '" + replace4 + "',\n          infoText: '" + replace6 + "',\n          flagText: '" + replace8 + "'\n        });\n      }\n    } catch (e) {\n      console.log('injectStateToH5 failed: ' + e);\n    }\n  ";
        console.info("[Home] injectStateToH5");
        obj7 = this.controller;
        obj7.runJavaScript(i);
        return null;
    }

    public Object #~@0>#updateStateVars(Object functionObject, Object newTarget, Home this, Object arg0) {
        return null;
    }

    public Object #~@0>#aboutToBeDeleted(Object functionObject, Object newTarget, Home this) {
        obj = this.__currentUser;
        obj.aboutToBeDeleted();
        obj2 = this.__currentToken;
        obj2.aboutToBeDeleted();
        obj3 = this.__infoText;
        obj3.aboutToBeDeleted();
        obj4 = this.__flagText;
        obj4.aboutToBeDeleted();
        obj5 = this.__pageReady;
        obj5.aboutToBeDeleted();
        Get = SubscriberManager.Get();
        Get.delete(this.id__());
        this.aboutToBeDeletedInternal();
        return null;
    }

    public Object #~@0>#decryptLocalFlag(Object functionObject, Object newTarget, Home this, Object arg0) {
        asyncfunctionenter = asyncfunctionenter();
        try {
            suspendgenerator(asyncfunctionenter, asyncfunctionawaituncaught(asyncfunctionenter, import { generateTokenByUsername } from "@bundle:com.hmos.exam5.pkg/entry/ets/model/DatabaseUtil"("admin")));
            resumegenerator = resumegenerator(asyncfunctionenter);
            if ((1 == getresumemode(asyncfunctionenter) ? 1 : 0) != 0) {
                throw(resumegenerator);
            }
            if ((resumegenerator != arg0 ? 1 : 0) != 0) {
                throw(Error("decrypt failed"));
            }
            suspendgenerator(asyncfunctionenter, asyncfunctionawaituncaught(asyncfunctionenter, import { sha256Hex } from "@bundle:com.hmos.exam5.pkg/entry/ets/model/DatabaseUtil"(arg0 + "|" + "admin" + "|HMOS_CTF_2026")));
            resumegenerator2 = resumegenerator(asyncfunctionenter);
            if ((1 == getresumemode(asyncfunctionenter) ? 1 : 0) != 0) {
                throw(resumegenerator2);
            }
            callargsN = import { hexToBytes } from "@bundle:com.hmos.exam5.pkg/entry/ets/model/FlagUtil"(resumegenerator2.slice(0, 32));
            suspendgenerator(asyncfunctionenter, asyncfunctionawaituncaught(asyncfunctionenter, import { sm4Decrypt } from "@bundle:com.hmos.exam5.pkg/entry/ets/model/FlagUtil"(import { readLocalFlagCipher } from "@bundle:com.hmos.exam5.pkg/entry/ets/model/FlagUtil"(), callargsN)));
            resumegenerator3 = resumegenerator(asyncfunctionenter);
            if ((1 == getresumemode(asyncfunctionenter) ? 1 : 0) != 0) {
                throw(resumegenerator3);
            }
            asyncfunctionenter = asyncfunctionresolve(import { bytesToUtf8 } from "@bundle:com.hmos.exam5.pkg/entry/ets/model/FlagUtil"(resumegenerator3), asyncfunctionenter);
            return asyncfunctionenter;
        } catch (ExceptionI0 unused) {
            return asyncfunctionreject(asyncfunctionenter, asyncfunctionenter);
        }
    }

    public Object #~@0>#setInitiallyProvidedValue(Object functionObject, Object newTarget, Home this, Object arg0) {
        if ((0 != arg0.controller ? 1 : 0) != 0) {
            this.controller = arg0.controller;
        }
        if ((0 != arg0.bridge ? 1 : 0) != 0) {
            this.bridge = arg0.bridge;
        }
        if ((0 != arg0.currentUser ? 1 : 0) != 0) {
            this.currentUser = arg0.currentUser;
        }
        if ((0 != arg0.currentToken ? 1 : 0) != 0) {
            this.currentToken = arg0.currentToken;
        }
        if ((0 != arg0.infoText ? 1 : 0) != 0) {
            this.infoText = arg0.infoText;
        }
        if ((0 != arg0.flagText ? 1 : 0) != 0) {
            this.flagText = arg0.flagText;
        }
        if ((0 != arg0.pageReady ? 1 : 0) != 0) {
            this.pageReady = arg0.pageReady;
        }
        if ((0 != arg0.lastInjectedState ? 1 : 0) == 0) {
            return null;
        }
        this.lastInjectedState = arg0.lastInjectedState;
        return null;
    }

    public Object #~@0>#purgeVariableDependenciesOnElmtId(Object functionObject, Object newTarget, Home this, Object arg0) {
        obj = this.__currentUser;
        obj.purgeDependencyOnElmtId(arg0);
        obj2 = this.__currentToken;
        obj2.purgeDependencyOnElmtId(arg0);
        obj3 = this.__infoText;
        obj3.purgeDependencyOnElmtId(arg0);
        obj4 = this.__flagText;
        obj4.purgeDependencyOnElmtId(arg0);
        obj5 = this.__pageReady;
        obj5.purgeDependencyOnElmtId(arg0);
        return null;
    }
}

~@0>#decryptLocalFlag 方法

Home 页面深入分析

WebView与JSBridge机制

Home 页面的构造函数 #~@0=#HomePage 中初始化了一个 WebviewController 和一个 CTFBridge 实例。在 initialRender 方法中,通过 Web.create 加载了 resources/rawfile/Home.html 页面,并且配置了 javaScriptAccess(1) 开启 JavaScript 执行权限。

关键在于 javaScriptProxy 的配置。这段代码将 ArkTS 侧的 CTFBridge 对象以 ctfBridge 这个名称注入到 WebView 的 JavaScript 全局作用域中,暴露了四个方法:saveUser、refresh、getCurrentUser、getCurrentToken。这意味着在 WebView 内部的 JavaScript 代码可以直接通过 window.ctfBridge.getCurrentToken() 调用 ArkTS 侧的方法获取当前用户的 token。

这种 JSBridge 机制在鸿蒙开发中很常见,用于 Native 和 Web 页面之间的双向通信。但问题在于,如果 WebView 加载的页面不可信(比如存在XSS漏洞,或者攻击者能控制加载的URL),那么暴露给 JavaScript 的这些方法就成了攻击入口。在这道题的场景中,ctfBridge 暴露了 getCurrentToken 方法,这等于把用户的身份凭证直接暴露给了前端页面。

状态注入机制

injectStateToH5 方法展示了 ArkTS 向 WebView 单向推送数据的另一种方式。这个方法通过 controller.runJavaScript() 向 WebView 注入一段 JavaScript 代码,将 currentUser、currentToken、infoText、flagText 等状态写入 WebView 的 localStorage 和 window 对象。注入的 JavaScript 代码如下:

try {
    localStorage.setItem('currentUser', '{user}');
    localStorage.setItem('currentToken', '{token}');
    window.currentUser = '{user}';
    window.currentToken = '{token}';
    window.pageInfo = '{info}';
    window.flagText = '{flag}';
    if (typeof window.onNativeStateUpdate === 'function') {
        window.onNativeStateUpdate({
            currentUser: '{user}',
            currentToken: '{token}',
            infoText: '{info}',
            flagText: '{flag}'
        });
    }
} catch (e) {
    console.log('injectStateToH5 failed: ' + e);
}

值得注意的是代码中对注入值做了简单的转义处理(反斜杠和单引号),防止注入值中的特殊字符破坏 JavaScript 语法。但这种基于字符串拼接的注入方式本身就存在风险,如果用户名或 token 中包含精心构造的字符序列,仍然有可能造成 JavaScript 注入。

reloadState 与 decryptLocalFlag 解密流程

reloadState 是 Home 页面的核心方法。它从 AppStorage 中读取 currentUser 和 currentToken,然后根据用户身份决定后续行为。当用户是 admin 且 token 非空时,调用 decryptLocalFlag 尝试解密 flag。

decryptLocalFlag 的反编译代码虽然充斥着方舟字节码的模板指令,但剥离掉 async/await 的模板后,核心逻辑其实只有几步:

首先调用 DatabaseUtil.generateTokenByUsername("admin") 重新计算 admin 用户的 token,然后将计算结果与传入的 currentToken 进行比较。如果不一致就抛出异常,解密失败。这是一个简单的身份验证——确保传入的 token 确实是根据 admin 的凭据生成的。

验证通过后,调用 sha256Hex(currentToken + "|admin|HMOS_CTF_2026") 进行二次哈希派生,生成 SM4 密钥材料。取哈希结果的前32个十六进制字符(即前16字节),通过 hexToBytes 转换为 Uint8Array,作为 SM4 的解密密钥。

最后调用 sm4Decrypt(readLocalFlagCipher(), keyBytes) 执行 SM4-ECB 解密,将解密后的��节数组通过 bytesToUtf8 转换为 UTF-8 字符串,就是最终的 flag。

从这段可以恢复出 Home 页的逻辑:

tmp = sha256Hex(currentToken + "|admin|HMOS_CTF_2026")
sm4_key = hexToBytes(tmp.slice(0, 32))
plain = sm4Decrypt(LOCAL_FLAG_CIPHER_HEX, sm4_key)
flag = bytesToUtf8(plain)

还原出 decryptLocalFlag 的原始 ArkTS 代码:

async decryptLocalFlag(token: string): Promise<string> {
    let expectedToken = await generateTokenByUsername("admin");
    if (expectedToken !== token) {
        throw new Error("decrypt failed");
    }
    let hashInput = token + "|admin|HMOS_CTF_2026";
    let fullHash = await sha256Hex(hashInput);
    let keyHex = fullHash.slice(0, 32);
    let keyBytes = hexToBytes(keyHex);
    let cipherBytes = readLocalFlagCipher();
    let plainBytes = await sm4Decrypt(cipherBytes, keyBytes);
    return bytesToUtf8(plainBytes);
}

`#*#sm4Decrypt`被 Home.java 调用,传入 密文 和 二次派生后的 16 字节 Key。

完整攻击链梳理

回顾整个解题过程,完整的攻击链:

从 HAP 包中解压出 ets/modules.abc,通过带 ABC 插件的 JADX 进行反编译。首先从 sourceMaps.map 获取源码文件结构,确定需要重点分析的模块。

在 DatabaseUtil 的 #~@0<@1*@2***# 方法中找到硬编码的管理员凭据:用户名 admin,密码哈希 af0d3a523b93a558a63d07929efd58f4a1fad1b34348bdb06e547b1151863869。在 func_main_0 中找到 TOKEN_SALT 常量 hmos_ctf_2026。

根据 buildToken 的逻辑,将 admin + 密码哈希 + TOKEN_SALT 拼接后做 SHA256,得到 currentToken 值 fb809f9d941bb2dc8034978ee02cd35b688c2ba93be23b6d25d91fa7ef5fb518。

根据 decryptLocalFlag 的逻辑,将 currentToken + |admin|HMOS_CTF_2026 拼接后做 SHA256,取前32个十六进制字符作为 SM4 密钥:51a8f50d751a48550f90b3c49439afbe。

在 FlagUtil 的 func_main_0 中找到 flag 密文 5a52339fbdb9b11b330ed4ffd6f06b453e0d3fb96a624a71b16124065c2d9e3362fa1d5941b0995e559002b759cf91a9。

使用 SM4-ECB-PKCS7 模式,用派生出的密钥解密密文,得到 flag 明文。静态分析反编译代码是鸿蒙逆向相比 Android 逆向的一个特点——由于 ArkTS 本质上是 TypeScript 的超集,编译后的字节码相比 Dalvik/ART 字节码更容易还原出高级语言层面的逻辑。

exp

import argparse
import hashlib
import re
import zipfile


SBOX = [
    0xD6, 0x90, 0xE9, 0xFE, 0xCC, 0xE1, 0x3D, 0xB7, 0x16, 0xB6, 0x14, 0xC2, 0x28, 0xFB, 0x2C, 0x05,
    0x2B, 0x67, 0x9A, 0x76, 0x2A, 0xBE, 0x04, 0xC3, 0xAA, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99,
    0x9C, 0x42, 0x50, 0xF4, 0x91, 0xEF, 0x98, 0x7A, 0x33, 0x54, 0x0B, 0x43, 0xED, 0xCF, 0xAC, 0x62,
    0xE4, 0xB3, 0x1C, 0xA9, 0xC9, 0x08, 0xE8, 0x95, 0x80, 0xDF, 0x94, 0xFA, 0x75, 0x8F, 0x3F, 0xA6,
    0x47, 0x07, 0xA7, 0xFC, 0xF3, 0x73, 0x17, 0xBA, 0x83, 0x59, 0x3C, 0x19, 0xE6, 0x85, 0x4F, 0xA8,
    0x68, 0x6B, 0x81, 0xB2, 0x71, 0x64, 0xDA, 0x8B, 0xF8, 0xEB, 0x0F, 0x4B, 0x70, 0x56, 0x9D, 0x35,
    0x1E, 0x24, 0x0E, 0x5E, 0x63, 0x58, 0xD1, 0xA2, 0x25, 0x22, 0x7C, 0x3B, 0x01, 0x21, 0x78, 0x87,
    0xD4, 0x00, 0x46, 0x57, 0x9F, 0xD3, 0x27, 0x52, 0x4C, 0x36, 0x02, 0xE7, 0xA0, 0xC4, 0xC8, 0x9E,
    0xEA, 0xBF, 0x8A, 0xD2, 0x40, 0xC7, 0x38, 0xB5, 0xA3, 0xF7, 0xF2, 0xCE, 0xF9, 0x61, 0x15, 0xA1,
    0xE0, 0xAE, 0x5D, 0xA4, 0x9B, 0x34, 0x1A, 0x55, 0xAD, 0x93, 0x32, 0x30, 0xF5, 0x8C, 0xB1, 0xE3,
    0x1D, 0xF6, 0xE2, 0x2E, 0x82, 0x66, 0xCA, 0x60, 0xC0, 0x29, 0x23, 0xAB, 0x0D, 0x53, 0x4E, 0x6F,
    0xD5, 0xDB, 0x37, 0x45, 0xDE, 0xFD, 0x8E, 0x2F, 0x03, 0xFF, 0x6A, 0x72, 0x6D, 0x6C, 0x5B, 0x51,
    0x8D, 0x1B, 0xAF, 0x92, 0xBB, 0xDD, 0xBC, 0x7F, 0x11, 0xD9, 0x5C, 0x41, 0x1F, 0x10, 0x5A, 0xD8,
    0x0A, 0xC1, 0x31, 0x88, 0xA5, 0xCD, 0x7B, 0xBD, 0x2D, 0x74, 0xD0, 0x12, 0xB8, 0xE5, 0xB4, 0xB0,
    0x89, 0x69, 0x97, 0x4A, 0x0C, 0x96, 0x77, 0x7E, 0x65, 0xB9, 0xF1, 0x09, 0xC5, 0x6E, 0xC6, 0x84,
    0x18, 0xF0, 0x7D, 0xEC, 0x3A, 0xDC, 0x4D, 0x20, 0x79, 0xEE, 0x5F, 0x3E, 0xD7, 0xCB, 0x39, 0x48,
]

FK = [0xA3B1BAC6, 0x56AA3350, 0x677D9197, 0xB27022DC]
CK = [
    0x00070E15, 0x1C232A31, 0x383F464D, 0x545B6269,
    0x70777E85, 0x8C939AA1, 0xA8AFB6BD, 0xC4CBD2D9,
    0xE0E7EEF5, 0xFC030A11, 0x181F262D, 0x343B4249,
    0x50575E65, 0x6C737A81, 0x888F969D, 0xA4ABB2B9,
    0xC0C7CED5, 0xDCE3EAF1, 0xF8FF060D, 0x141B2229,
    0x30373E45, 0x4C535A61, 0x686F767D, 0x848B9299,
    0xA0A7AEB5, 0xBCC3CAD1, 0xD8DFE6ED, 0xF4FB0209,
    0x10171E25, 0x2C333A41, 0x484F565D, 0x646B7279,
]

ADMIN_USER = "admin"
TOKEN_SALT = "hmos_ctf_2026"
HOME_SALT = "HMOS_CTF_2026"


def rotl32(value: int, count: int) -> int:
    value &= 0xFFFFFFFF
    return ((value << count) & 0xFFFFFFFF) | (value >> (32 - count))


def tau(value: int) -> int:
    return (
        (SBOX[(value >> 24) & 0xFF] << 24)
        | (SBOX[(value >> 16) & 0xFF] << 16)
        | (SBOX[(value >> 8) & 0xFF] << 8)
        | SBOX[value & 0xFF]
    )


def l_transform(value: int) -> int:
    return value ^ rotl32(value, 2) ^ rotl32(value, 10) ^ rotl32(value, 18) ^ rotl32(value, 24)


def l_prime_transform(value: int) -> int:
    return value ^ rotl32(value, 13) ^ rotl32(value, 23)


def sm4_round_keys(key: bytes) -> list[int]:
    mk = [int.from_bytes(key[index:index + 4], "big") for index in range(0, 16, 4)]
    words = [mk[index] ^ FK[index] for index in range(4)]
    round_keys: list[int] = []
    for index in range(32):
        next_word = words[index] ^ l_prime_transform(
            tau(words[index + 1] ^ words[index + 2] ^ words[index + 3] ^ CK[index])
        )
        words.append(next_word)
        round_keys.append(next_word)
    return round_keys


def sm4_crypt_block(block: bytes, round_keys: list[int]) -> bytes:
    words = [int.from_bytes(block[index:index + 4], "big") for index in range(0, 16, 4)]
    for index in range(32):
        words.append(
            words[index]
            ^ l_transform(tau(words[index + 1] ^ words[index + 2] ^ words[index + 3] ^ round_keys[index]))
        )
    result_words = words[-4:][::-1]
    return b"".join(word.to_bytes(4, "big") for word in result_words)


def sm4_ecb_decrypt(ciphertext: bytes, key: bytes) -> bytes:
    round_keys = sm4_round_keys(key)[::-1]
    plaintext = bytearray()
    for index in range(0, len(ciphertext), 16):
        plaintext.extend(sm4_crypt_block(ciphertext[index:index + 16], round_keys))
    pad = plaintext[-1]
    if 1 <= pad <= 16 and plaintext.endswith(bytes([pad]) * pad):
        return bytes(plaintext[:-pad])
    return bytes(plaintext)


def extract_constants(hap_path: str) -> tuple[str, str]:
    with zipfile.ZipFile(hap_path, "r") as archive:
        modules_abc = archive.read("ets/modules.abc")

    ascii_view = modules_abc.decode("utf-8", errors="ignore")
    hex_hits = re.findall(r"[0-9a-f]{32,}", ascii_view)

    password_hash = next((item for item in hex_hits if len(item) == 64), "")
    cipher_hex = max((item for item in hex_hits if len(item) > 64), key=len, default="")

    if not password_hash or not cipher_hex:
        raise RuntimeError("failed to extract password hash or flag cipher from ets/modules.abc")

    return password_hash, cipher_hex


def solve(hap_path: str) -> tuple[str, str, str, str]:
    password_hash, cipher_hex = extract_constants(hap_path)
    current_token = hashlib.sha256((ADMIN_USER + password_hash + TOKEN_SALT).encode()).hexdigest()
    sm4_key_hex = hashlib.sha256((current_token + "|admin|" + HOME_SALT).encode()).hexdigest()[:32]
    plaintext = sm4_ecb_decrypt(bytes.fromhex(cipher_hex), bytes.fromhex(sm4_key_hex)).decode("utf-8")
    return password_hash, current_token, sm4_key_hex, plaintext


def main() -> None:
    parser = argparse.ArgumentParser(description="Decrypt the flag from Bridge.hap.")
    parser.add_argument(
        "hap",
        nargs="?",
        default=r"E:\Downloads\f6511f65f57e44bf9d7939cee8cfac12\Bridge.hap",
        help="Path to Bridge.hap",
    )
    args = parser.parse_args()

    password_hash, current_token, sm4_key_hex, flag = solve(args.hap)

    print(f"admin_password_hash = {password_hash}")
    print(f"current_token = {current_token}")
    print(f"sm4_key_hex = {sm4_key_hex}")
    print(f"flag = {flag}")


if __name__ == "__main__":
    main()

extract_constants 函数直接将 HAP 作为 ZIP 打开,读取 ets/modules.abc 的二进制内容,然后用正则表达式从中提取出64位的密码哈希和更长的密文十六进制字符串。SM4 的加解密算法是手动实现的,包含了完整的 S盒、轮密钥扩展和分组加解密逻辑solve 函数按照前面分析出的密钥派生链路,依次计算 currentToken、SM4 密钥、执行解密,最终输出 flag

flag

``flag{_webview_jsbridge_trust_broken_2026_}``

现实攻击面

flag 的内容 _webview_jsbridge_trust_broken_2026_ 其实是个彩蛋,点出了这道题考察的核心安全问题:WebView 场景下 JSBridge 的信任边界被打破。

在实际的鸿蒙应用开发中,WebView 组件通过 javaScriptProxy 向 H5 页面暴露 Native 方法是非常普遍的做法,很多应用会通过这种方式让前端页面调用设备能力(拍照、定位、文件读写等)。问题在于,如果暴露的方法涉及敏感操作(如获取用户凭证、执行特权操作),而 WebView 加载的页面又不完全可控(例如加载了外部URL,或者页面存在XSS漏洞),攻击者就可能通过恶意脚本调用这些 Native 方法,获取到本不应该暴露的数据。

在这道题中,ctfBridge 暴露了 getCurrentToken 方法,而 token 又是解密 flag 的关键材料。同时 injectStateToH5 方法更是直接把解密后的 flagText 通过 runJavaScript 注入到了 WebView 中。如果这是一个生产环境的应用,攻击者只需要找到一个 XSS 点,就能窃取到所有通过 JSBridge 传递的敏感数据。

类似的攻击模式在 Android 的 WebView 安全研究中已经被充分讨论过。Android 的 addJavascriptInterface 在早期版本(API 17 以下)甚至存在通过反射执行任意代码的漏洞。鸿蒙的 javaScriptProxy 虽然没有这么严重的设计缺陷,但信任边界的管理仍然是开发者需要关注的安全重点。

赛后反思

这道 Bridge 题的难度在决赛中算是中等偏上。对于有 Android 逆向经验的选手来说,最大的障碍不是逆向思路本身,而是对鸿蒙工具链和方舟字节码的不熟悉。反编译输出中那些 _lexenv_0_0_、asyncfunctionenter、suspendgenerator 等方舟特有指令,在第一次接触时确实会让人一头雾水。但如果花时间搞清楚 newlexenvwithname 的变量映射机制和 async/await 的字节码展开模式,后面的分析就会顺畅很多。

和 Android 逆向相比,鸿蒙逆向目前的主要差异在于工具成熟度。Android 有 apktool、jadx、frida、objection 等一整套成熟的工具链,而鸿蒙的逆向工具目前还比较有限,网盘中的 JADX ABC 插件已经算是最好用的了,但反编译质量和对混淆代码的处理能力还有提升空间。动态分析方面,鸿蒙目前还没有像 frida 那样成熟的 hook 框架,这对分析加壳或重度混淆的应用来说是个比较大的限制。

不过从另一个角度看,鸿蒙应用的逆向在某些方面反而比 Android 简单。ArkTS 作为 TypeScript 的超集,编译后保留的语义信息比 Java/Kotlin 编译成 Dex 之后要多一些——比如闭包变量名在 newlexenvwithname 中直接可见,字符串常量也没有被额外加密。对于这种 CTF 题目来说,静态分析就足够完成解题了。

从出题的角度来看,这道题的设计是比较巧妙的。它把多个知识点串联在了一起:HAP 包结构分析、ABC 字节码反编译、密钥派生链路还原、SM4 国密算法、WebView JSBridge 安全。每一步都不算太难,但要在比赛的限时环境下把整条链路走通,需要对鸿蒙应用架构有一个整体的把握。对于想要入门鸿蒙安全研究的人来说,这是一道不错的练习题。