KMP/CMP 鸿蒙社区 · 鸿蒙跨端实战项目 · 文件签印源码与 README
前言
对账单归档以后,有人发现一笔金额对不上。两份文件的名字一样,长度也一样,打开后只有一个数字不同。文件系统能告诉我们读到了多少字节,却回答不了哪份内容和签名产生时一致。即使把文件的哈希另存为一列,如果这列数据和文件一起被改写,收件方仍然缺少一个能单独验证的依据。
这个例子把问题缩到一行:同一份签名、同一把公钥,一份对账文本原封不动,另一份把金额的第一个字符从 1 改成 9。两份文件都能正常打开,都可以被业务代码解析成金额。只有验签能判断它们是否和签名对应。这样设计,是因为一段失败提示不能证明篡改检测有用:输入文件不存在、签名格式不对、设备不支持接口,都可能导致失败。原件通过、只改一个字节的副本不通过,才是这里要观察的结果。
跨端页面使用 Compose Multiplatform。密钥创建和签名由鸿蒙 Online Authentication Kit 的 DID 服务完成,验签使用系统密码框架。Kotlin 模块保管执行记录和两份文件的结论,鸿蒙适配器保管文件字节、密钥绑定及系统接口调用。页面拿到的是结果和阶段,不接触私钥,也不接收用于标识用户的字段。
两份文件
在 MatePad Edge 上打开「文件签印」,点一次「签名并比对」。页面左侧的原件显示金额 120.00,改动件显示 920.00;右侧依次显示生成密钥、绑定、查询、签名和验签。判定标准是原件通过、改动件失败,并且两行使用同一份签名。在模拟器中也可以打开页面并发起请求,运行至设备拒绝阶段,两个验签位仍显示待验证。

从点击到两行验签结果出现,可以同时看到哪些步骤已经完成。

改动件保留了原件的换行、币种和单号。这里的金额只是方便肉眼找到差异,用的是程序生成的演示文件。应用把原件和改动件分别写到自己的目录,再读回两份字节数组。签名使用读回的原件,验签各读一份。也就是说,画面里的对照不是把一个内存字符串换个颜色:两份文件都经过了同样的读写路径,差别只在那一字节。
运行中的「验签失败」有两种容易混淆的含义。改动件的红色结果意味着验签器已经正常工作并返回不通过,它是实验预期。若签名服务未启动、系统拒绝调用,或读取公钥时抛错,页面应当停在相应步骤,两行都保留「待验证」。把这两类情况分开以后,看到红色字样就知道是文件与签名不匹配,还是这轮压根没有得到可用证据。

这一轮怎么判定
原件和改动件的文件长度是相同的,签名长度则不参与判断。SM2 的签名以 ASN.1 结构返回,整数的编码长度并不固定;即使同一份内容重试,拿到的签名字节也不需要相同。日志中的签名长度只用于排查是否拿到了输出。更可靠的判定是:第一次使用公钥和原件验过,第二次用同一个公钥和同一份签名检查改动件,结果不通过。
| 检查项 | 送入的数据 | 判定依据 |
|---|---|---|
| 原件 | 原件字节、同一公钥、同一签名 | 验签接口返回通过 |
| 改动件 | 等长副本,仅改金额首字节,沿用公钥和签名 | 验签接口返回不通过 |
| 模拟器 | 同一宿主、同一份示例数据 | 返回 801;无签名结果,两行保持待验证 |
按阶段看日志时,先找到本次点击产生的起始行,再往后读。进入签名阶段只能说明查到了目标绑定;进入验签阶段才意味着收到了系统签名。最后一行同时记录两个布尔结果。把这三处信息连起来,就能排除一种常见误读:把系统接口返回了响应,当成整个文件校验已经完成。

这组对照没有测耗时,也没有从两次真假值推出安全级别。它回答的是同一份签名是否适用于当前两份文件。判断过程未比较不同机型,也未比较本地与服务端的速度。想复核时,两次验签所需的三个输入都能在代码里定位,不用依赖界面文案或人为标记。
还可以用反向试验帮助检查接线:让签名输入改成 920.00 的版本,仍用同一把公钥分别核对两份文件。此时应该轮到 920.00 通过,120.00 不通过。这是一个复查办法,本文记录的演示仍然只对原件签名。区分「做了哪个试验」与「还可以怎么查」很重要,尤其是把演示交给同事复现时,不能把未运行的验证步骤算进实测结果。另一个办法是在调试时记录两个文件的长度和首个不同的字节位置。这两个值足以核实是否改了一处,不必把真实对账单输出到终端。
从别名到签名
密钥别名出现在创建请求里,签名接口却收的是密钥 ID。这两个字段不能随手填成同一串字。示例先生成随机后缀,为本轮新建一个别名和一个示例 DID。生成密钥之后,通过导入接口绑定示例 DID、别名和签名时要用的 ID;再从系统查询绑定,用查回的结果调用签名。中间的查询多了一次接口往返,但能避免把应用以为已经写进去的记录,当成系统实际保存的结果。
这里用的是教学范围的示例标识。它只用于在应用内建立可查的密钥绑定,不表示某个用户的真实身份,也没有公开解析服务。拿到这样的标识,另一台设备不会凭空知道某个人是谁。要做跨系统的身份互认,还需要选定标识方法、处理解析和密钥轮换,以及按业务决定凭证由谁签发、由谁信任。本文只走鸿蒙设备上的生成、绑定、查询和签名路径,不把这条路径包装成一套身份认证系统。
生成请求只指定 SM2 和签名验签用途。示例创建的是应用专用测试密钥,按公开接口的约定不配置认证器,不触发用户认证。这个选择适用于验证签名与文件字节之间的关系,不意味着用户已经授权一笔对账业务。如果业务需要人在场、明确同意或验明身份,应按目标设备支持的认证方式重新设计并验收,不能拿这份演示替代。尤其是有人看见「DID」就默认有指纹确认,这是两件需要独立验证的事。
生命周期也从创建请求开始考虑。每轮使用新的别名和示例标识,避免和前一轮碰撞。只有导入成功才尝试删除本轮示例 DID,删除失败另外记日志;不为了清理而动应用里其他条目。生成成功但导入失败时,示例未取得一条成功绑定的记录,不能假定删除 DID 会把未绑定密钥一并移除。实际业务若长期运行,应根据业务场景管理密钥、设备侧条目上限和失败重试。反复生成密钥既不等于轮换策略,也不是定位失败的好办法。

接口和限制可对照鸿蒙 DID API和数字身份开发指南。示例使用公开接口,不调用凭证导入接口,也不申请凭证管理所需权限。
验签看的是字节
金额从 120.00 改到 920.00 的位置在一个只含 ASCII 的样本里。字符串里的位置就是 UTF-8 字节下标。如果换成含中文的发票备注,字符位置和编码后的字节偏移通常不相同,就应在已编码的字节数组上查找目标序列或单独组织示例输入。不能把 Unicode 字符下标直接当作文件偏移,否则验证的可能根本不是以为修改的那一处。
文件读取也避免经过「文本读出来、转成对象、再序列化」的过程。哪怕解析后的数据完全一样,编辑器重写换行、增加文件开头的标记、调整键的顺序或删除末尾空格,都可能改掉底层字节。假如业务想允许这些格式变化,就要先约定规范化规则,并让签名方和验证方遵循同一规则。直接签文件时,规则反而清楚:读到什么字节,就验证什么字节。用哈希可辅助找差异,但不要把另算的一次哈希默默替换成签名约定。
适配器在调用异步系统接口前复制两份输入,以免调用方在等待期间继续改写数组。到了验签环节,原件、改动件分别新建一个验签器。两个验签器使用同一把公钥、同一份签名,只更新各自的内容。如果复用一份没有重新初始化的摘要状态,第二次计算可能把前一次输入算进去;这时得到的失败结果并不能说明单字节改动被检测到了。
公钥从 DID 密钥创建结果取得,经系统密码框架解析成可用于验签的公钥。这里不从文件名、签名长度或 DID 文本推测算法。SM2 和 SM3 的组合由示例配置明确给出,可对照华为的SM2 签名与验签指南。这次验签确实使用生成密钥时得到的公钥;生产环境里,验证方还必须独立确认那把公钥可信。攻击者若能同时替换文件、签名和公钥,单靠数学验签不会判断替换后的公钥来自谁。
DID 的签名入口对输入有字节数上限。示例把最大值写在库里,在进入系统服务前拒绝空数据、超过 4500 字节、长度不同或内容相同的对照输入。长度相同是本实验为了控制变量,不是验签算法对所有业务文件的要求。大文件如果采用摘要签名,应另外定义并记录摘要算法、输入格式、版本和验证约定,不能把这里只接受短输入的接口当作一个任意文件签名器。
跨端边界
应用宿主是最靠近设备的一层。它负责读写两份小文件,取得当前 Ability 的上下文,然后调用库里的鸿蒙适配器。没有把签名步骤散在按钮回调中:按钮只启动一轮任务,后面五个阶段由同一个适配器串起来。换一个 CMP 页面接入时,仍可用原来的适配器和共享状态;页面不用重新拼 DID 请求,也不需要知道 ASN.1 的编码细节。
桥上传的是本轮编号、阶段和结果。它不传输文件内容、密钥或任何用于识别用户的字段;连签名也只传长度。界面既然只要回答「原件和改动件分别如何」,就没有必要把签名字节和设备公钥跨层传一遍。如果以后需要导出签名包,应当另加一个明确的导出接口,在平台侧审查允许暴露的字段,并区分公开公钥与设备证明材料。
共享模块用一个递增编号串起开始、推进、完成和失败。新一轮把两行恢复成未验证;旧轮次的回调不允许写入本轮。阶段也必须向前走,不能在「生成密钥」直接把页面设成验签完成。宿主运行时禁用按钮,避免连续点击并发执行两次。两道约束各有用途:按钮控制用户交互,状态机管接收结果的顺序。即使未来入口换成自动重试,结果仍然要带上原轮次编号才能进入页面。

宽窗把文件对照和调用顺序放在同一排;窄窗则先读结果,再向下看步骤。两种布局的判定数据来自同一个状态对象。切换窗口宽度不应重新生成密钥,回到界面也不能把尚未开始的结果自动标成失败。这些约束比某个控件的配色更关键:页面在窄窗里即使只露出前两行,也不能让读者把空白或颜色当成判定结果。

在项目中,didSeal 包含共享状态和鸿蒙适配器,composeApp 负责 CMP 页面和 Kotlin 入口,example/ohos 是宿主示例。Gradle 把 ARM64 和 x86_64 的 Kotlin 原生库与头文件同步给宿主,并复制同一份鸿蒙适配器。读源码时从库目录进去比只看宿主里生成的副本清楚;改代码也应从源文件改起,下一次构建会重新同步。
从 801 查起
API 级别和设备能力是两道检查。工程的最低兼容、编译和目标均设为 API 26,因为这里直接调用从 API 26 开始的 DID 接口。系统能力查询可用于提前判断,但是返回支持不代表每个运行环境都能生成密钥。此处的 API 26 模拟器能启动页面,实际调用生成密钥时返回 801;真机上的相同请求可以继续到验签。把两者都只写成「API 26」会丢掉关键条件。
如果看到 801,先核实正在运行的目标设备,再确认是生成密钥、查询还是别的接口报错。这个错误还没走到原件与改动件的验签,改金额、换文件编码、改变验签算法,都无法使本轮产生签名。模拟器仍适合检查页面、错误分支和桥接状态。拿 JVM 的本地密钥做辅助测试也可以,但那只能验证共享逻辑或一般密码运算,不能算鸿蒙 DID 系统调用通过。
如果生成后报绑定错误,核对所填别名是不是本次应用生成的那一个,密钥用途是否是签名与验签,以及当前条目是否已经绑定其他标识。查询不到记录时,看看导入的标识和查询参数是否一致,是否要求返回密钥列表。查询只拿到标识并不等于取回了绑定,必须核对列表中的实际别名和 ID。绑定成功才开始排查签名输入和公钥导入,不要把几个阶段的报错归结为同一类问题。
若同一轮原件也验不过,先确认签名所用的输入确实是刚从磁盘读回来的原件,再确认公钥来自本轮生成结果。把文件重新编码、换用别轮生成的公钥或对 ASN.1 签名自行做未约定的格式转换,都会破坏对照。如果两份文件都验过,则先核对改动件确实与原件不同,验签函数没有重复拿到同一个输入。结果组合比单独看到某个 true 或 false 更能定位错误。
最后是对外展示的问题。样例把报错码保留下来,没有把失败包装成可用的结果;也不会在终端上打印文件内容、设备证明材料和完整标识。需要向维护方说明问题时,报告运行设备、系统版本、API 和失败阶段,外加最小的错误码就够开始复现。具体错误码可对照官方 DID 错误码。
还有一种容易被遗漏的情况:即使副本真的被改过,如果重新读取的是同一个文件,两条验签路径也可能都通过。读写测试因此要从两个不同的路径取得结果,而不是先把原件读进来,再把两条界面的文件名改成不同文字。示例在文件接口处检查写入和读取的字节数,碰到短读或写入失败就结束这一轮。把短读补零后继续送签,也许仍能获得合法签名,但签的是程序补出的内容,已经不是磁盘里要审查的那份文件了。
构建与复测
工程使用 DevEco Studio 6.1.1.300 的环境,构建由独立安装的 HarmonyOS API 26 命令行 SDK 完成。Kotlin/Native 鸿蒙版为 2.2.21-1.2.0,Compose Multiplatform 鸿蒙版与宿主包均为 1.9.2-1.2.0,Skiko 为 0.9.22.2-1.2.0。宿主的兼容、目标和编译版本均为 26,Gradle 构建同时生成平板和模拟器的原生库。
真机使用华为 MatePad Edge(QXS-W00),HarmonyOS 7.0.0,软件版本 7.0.0.111(SP16C00E111R6P5),API 26。真机在宽窗和悬浮窄窗中均完成签验对照。模拟器为 DevEco Emulator 26.0.0.402 的 Mate X7 配置(PHEMU-FD01,x86_64),HarmonyOS 7.0.0,镜像软件版本 7.0.0.107(SP8DEVC00E999R4P11),API 26。模拟器请求返回 801,两份文件仍显示待验证。



安装时先按 README 完成 Gradle 同步与 OHPM 依赖安装,再用 Hvigor 构建 HAP。真机应使用授权到当前设备且与包名匹配的调试签名。打开页面后点「签名并比对」,在真机检查两行相反的结论,并核对日志中的签名和验签阶段。在模拟器上,复核错误码分支、两份文件仍是待验证、没有输出伪造签名。两类结果应分开记录。
想更换对照数据时,先保留当前样本做一轮回归,然后改写宿主中的文本和改动位置。不要在同一轮既换文件内容,又换密钥算法、输入编码和签名格式。改一处时失败原因通常很好追;一起改了四处,看到原件验不过也无法立刻知道是哪一处引入的。最后在界面与日志各看一次结果,确认显示的标签确实对应这轮的两个值。
把这个例子带进自己的应用时,也别直接把演示的单次签验流程接到所有文件上。服务端收件、离线传输和端侧归档,各自面对的信任条件不同。以端侧归档为例,应先说明签名和公钥各存在哪里、读者如何取得可信公钥,以及以后更换密钥时旧签名如何继续验。样例省去了这些业务规则,正好能把 DID 签名这一层单独跑明白;准备长期保存记录时,再把它们补齐。
总结
这次可复用的部分是一条很短的链路:用系统 DID 服务生成应用密钥,绑定并回读,签原件,再用同一个公钥和签名检查两份字节。原件通过,等长改动件失败,说明签名绑定到内容;模拟器上的 801 则说明 API 级别达标后仍需查设备能力。前者是验签结论,后者是环境结论,不能用其中一个替代另一个。
如果在自己的业务里加文件校验,建议先约定签的究竟是文件字节、规范化数据还是摘要,再确定公钥的信任来源及密钥如何管理。跨端界面只接收它要呈现的状态,系统专用接口留在平台适配器中。这样从一张对账文本换成别的短文件时,最先要改的是样本和签名约定,不必把界面、原生桥和鸿蒙适配层一起拆开重写。
完整代码
以下是库、宿主示例和原生桥的关键完整文件。构建顺序见上节;其余工程配置包括资源、模块清单、Gradle 包装器及依赖版本表。
鸿蒙签验适配器
didSeal/src/ohosMain/arkts/DidSealAdapter.ets
import { common } from '@kit.AbilityKit';
import { BusinessError } from '@kit.BasicServicesKit';
import { cryptoFramework } from '@kit.CryptoArchitectureKit';
import { did } from '@kit.OnlineAuthenticationKit';
export enum SealStep {
Key = 1, Bind = 2, Query = 3, Sign = 4, Verify = 5
}
export const MAX_SIGN_BYTES: number = 4500;
export class SealError extends Error {
readonly code: number;
constructor(code: number, message: string) {
super(message);
this.code = code;
}
}
export interface SealResult {
original: boolean;
modified: boolean;
signatureBytes: number;
}
export class DidSealAdapter {
static available(): boolean {
return canIUse('SystemCapability.Security.DID');
}
private static async verify(key: cryptoFramework.PubKey, bytes: Uint8Array,
signature: Uint8Array): Promise<boolean> {
// 每份内容分别初始化验签器,避免两份数据进入同一个摘要状态。
const verifier = cryptoFramework.createVerify('SM2_256|SM3');
await verifier.init(key);
await verifier.update({ data: bytes });
return verifier.verify(null, { data: signature });
}
async compare(context: common.UIAbilityContext, original: Uint8Array, modified: Uint8Array,
onStep: (step: SealStep) => void, onCleanupError: (code: number) => void): Promise<SealResult> {
if (!DidSealAdapter.available()) {
throw new SealError(801, 'DID is unavailable');
}
if (original.length === 0 || original.length > MAX_SIGN_BYTES || modified.length > MAX_SIGN_BYTES ||
original.length !== modified.length || original.every((byte: number, i: number) => byte === modified[i])) {
throw new SealError(-10, 'Provide different non-empty inputs of the same length, at most 4500 bytes');
}
// 对异步调用的输入拍快照,防止调用方在等待期间继续写入数组。
const signedInput = original.slice();
const changedInput = modified.slice();
const random = cryptoFramework.createRandom().generateRandomSync(12).data;
const nonce = Array.from(random).map((b: number) => b.toString(16).padStart(2, '0')).join('');
const alias = 'file_seal_' + nonce;
const subject = 'did:example:fileseal' + nonce;
const keyId = subject + '#file-signing';
let bound = false;
try {
// 仅为演示文件创建应用专用密钥,不开启用户身份认证。
const key = await did.generateKey(context, {
keyAlias: alias,
keyConfig: { algorithm: did.KeyAlgo.SM2, purposeList: [did.KeyPurpose.SIGN, did.KeyPurpose.VERIFY] },
extension: '{"systemPrompt":"none"}'
});
onStep(SealStep.Bind);
await did.importDid(context, { did: subject, didKeyList: [{ keyAlias: alias, keyId: keyId }] });
bound = true;
onStep(SealStep.Query);
const record = await did.queryDid(context, { did: subject, queryDidConfig: { requireDidKey: true } });
const stored = record.didKeyList?.find((item: did.DidKey): boolean => item.keyAlias === alias);
if (!stored || stored.keyId !== keyId) {
throw new SealError(-11, 'DID key binding did not match');
}
onStep(SealStep.Sign);
const proof = await did.sign(context, { keyId: stored.keyId, inData: signedInput });
onStep(SealStep.Verify);
const keys = await cryptoFramework.createAsyKeyGenerator('SM2_256').convertKey({ data: key.publicKey }, null);
return {
original: await DidSealAdapter.verify(keys.pubKey, signedInput, proof.outData),
modified: await DidSealAdapter.verify(keys.pubKey, changedInput, proof.outData),
signatureBytes: proof.outData.length
};
} finally {
// 只清理本轮成功导入的示例 DID。清理错误单独上报,保留主结果。
if (bound) {
try {
await did.deleteDid(context, subject);
} catch (error) {
onCleanupError((error as BusinessError).code ?? -1);
}
}
}
}
}
KMP 状态
didSeal/src/commonMain/kotlin/dev/didseal/core/SealRun.kt
package dev.didseal.core
enum class SealStage(val wire: Int) {
Ready(0), Key(1), Bind(2), Query(3), Sign(4), Verify(5), Complete(6), Failed(7);
companion object {
fun decode(wire: Int): SealStage? = entries.firstOrNull { it.wire == wire }
}
}
data class SealReport(
val ticket: Int = 0,
val api: Int = 0,
val size: Int = 0,
val stage: SealStage = SealStage.Ready,
val original: Boolean? = null,
val modified: Boolean? = null,
val signatureBytes: Int = 0,
val failedAt: SealStage? = null,
val code: Int? = null
)
/** 只记录界面需要的结果,DID 标识、密钥和文件内容均留在平台层。 */
class SealRun {
private var nextTicket = 0
var report = SealReport()
private set
fun reset() { report = SealReport() }
fun begin(api: Int, size: Int): SealReport {
report = SealReport(++nextTicket, api, size, SealStage.Key)
return report
}
fun advance(ticket: Int, wire: Int): SealReport? {
val stage = SealStage.decode(wire) ?: return null
if (ticket != report.ticket || stage.wire != report.stage.wire + 1 ||
stage.wire > SealStage.Verify.wire) return null
report = report.copy(stage = stage)
return report
}
fun finish(ticket: Int, original: Boolean, modified: Boolean, bytes: Int): SealReport? {
if (ticket != report.ticket || report.stage != SealStage.Verify || bytes <= 0) return null
report = report.copy(stage = SealStage.Complete, original = original, modified = modified, signatureBytes = bytes)
return report
}
fun fail(ticket: Int, code: Int): SealReport? {
if (ticket != report.ticket || report.stage.wire !in SealStage.Key.wire..SealStage.Verify.wire) return null
report = report.copy(stage = SealStage.Failed, failedAt = report.stage, code = code)
return report
}
}
示例页面
composeApp/src/commonMain/kotlin/dev/didseal/sample/SealBoard.kt
package dev.didseal.sample
import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import dev.didseal.core.SealReport
import dev.didseal.core.SealStage
private val Workspace = Color(0xFFEAF0F5)
private val Rail = Color(0xFF15263B)
private val Ink = Color(0xFF17263A)
private val Muted = Color(0xFF53667D)
private val Rule = Color(0xFFD6DFE8)
private val Blue = Color(0xFF225AC1)
private val Green = Color(0xFF10654D)
private val Red = Color(0xFF9F2D42)
private val Sheet = RoundedCornerShape(12.dp)
private val phases = listOf("生成应用密钥", "绑定示例 DID", "读取密钥绑定", "签署原件", "对照验签")
@Composable
fun SealBoard(report: SealReport) {
BoxWithConstraints(Modifier.fillMaxSize().background(Workspace), contentAlignment = Alignment.TopCenter) {
val wide = maxWidth >= 760.dp
Column(
Modifier.widthIn(max = 1180.dp).fillMaxWidth().verticalScroll(rememberScrollState())
.padding(horizontal = if (wide) 32.dp else 14.dp, vertical = 18.dp),
verticalArrangement = Arrangement.spacedBy(14.dp)
) {
Text("文件对照", color = Ink, fontSize = 24.sp, fontWeight = FontWeight.Bold)
VerificationSummary(report)
if (wide) {
Row(horizontalArrangement = Arrangement.spacedBy(16.dp)) {
DocumentComparison(report, Modifier.weight(2f))
AuditTrail(report, Modifier.weight(1f))
}
} else {
DocumentComparison(report, Modifier.fillMaxWidth())
AuditTrail(report, Modifier.fillMaxWidth())
}
}
}
}
@Composable
private fun VerificationSummary(report: SealReport) {
val verified = report.stage == SealStage.Complete && report.original == true && report.modified == false
val failed = report.stage == SealStage.Failed || (report.stage == SealStage.Complete && !verified)
val tone = if (verified) Green else if (failed) Red else Blue
val background = if (verified) Color(0xFFDDF5EA) else if (failed) Color(0xFFFBE5E8) else Color(0xFFE0EAFC)
val message = when (report.stage) {
SealStage.Ready -> "点击上方「签名并比对」开始。"
SealStage.Complete -> if (verified) "验签结果符合预期 · ${report.size} 字节输入 · ${report.signatureBytes} 字节签名"
else "验签组合不符合预期,请检查输入与签名。"
SealStage.Failed -> if (report.code == 801) "当前设备环境不支持 DID 调用(801)。"
else "系统或示例返回 ${report.code},本轮没有验签结论。"
else -> "正在运行 · API ${report.api}"
}
Text(message, Modifier.fillMaxWidth().background(background, Sheet).padding(14.dp),
color = tone, fontSize = 14.sp, fontWeight = FontWeight.SemiBold)
}
@Composable
private fun DocumentComparison(report: SealReport, modifier: Modifier) {
BoxWithConstraints(modifier) {
if (maxWidth >= 500.dp) {
Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {
DocumentSheet("原件", "receipt.txt", "120.00", report.original, false, Modifier.weight(1f))
DocumentSheet("改动件", "receipt-edited.txt", "920.00", report.modified, true, Modifier.weight(1f))
}
} else {
Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
DocumentSheet("原件", "receipt.txt", "120.00", report.original, false, Modifier.fillMaxWidth())
DocumentSheet("改动件", "receipt-edited.txt", "920.00", report.modified, true, Modifier.fillMaxWidth())
}
}
}
}
@Composable
private fun DocumentSheet(label: String, filename: String, amount: String, passed: Boolean?, changed: Boolean,
modifier: Modifier) {
val tone = when (passed) { true -> Green; false -> Red; null -> Muted }
val verdict = when (passed) { true -> "验签通过"; false -> "验签失败"; null -> "待验证" }
Column(modifier.background(Color.White, Sheet).border(1.dp, Rule, Sheet).padding(16.dp),
verticalArrangement = Arrangement.spacedBy(11.dp)) {
Text(label, color = Ink, fontSize = 17.sp, fontWeight = FontWeight.Bold)
Text(filename, color = Muted, fontFamily = FontFamily.Monospace, fontSize = 12.sp)
Column(Modifier.fillMaxWidth().background(Color(0xFFF4F7FA), RoundedCornerShape(6.dp)).padding(12.dp)) {
Text("receipt=DEMO-01", color = Muted, fontFamily = FontFamily.Monospace, fontSize = 12.sp)
Row {
Text("amount=", color = Muted, fontFamily = FontFamily.Monospace, fontSize = 13.sp)
Text(amount.take(1), color = if (changed) Red else Ink, fontFamily = FontFamily.Monospace,
fontSize = 13.sp, modifier = Modifier.background(if (changed) Color(0xFFFFE6A8) else Color.Transparent))
Text(amount.drop(1), color = Ink, fontFamily = FontFamily.Monospace, fontSize = 13.sp)
}
Text("currency=CNY", color = Muted, fontFamily = FontFamily.Monospace, fontSize = 12.sp)
}
Text(verdict, color = tone, fontSize = 14.sp, fontWeight = FontWeight.Bold)
}
}
@Composable
private fun AuditTrail(report: SealReport, modifier: Modifier) {
Column(modifier.background(Rail, Sheet).padding(16.dp),
verticalArrangement = Arrangement.spacedBy(12.dp)) {
Text("签验记录", color = Color.White, fontSize = 17.sp, fontWeight = FontWeight.Bold)
phases.forEachIndexed { index, label ->
val phase = index + 1
val reached = (report.failedAt ?: report.stage).wire
val status = when {
report.stage == SealStage.Failed && reached == phase -> "失败"
reached > phase -> "完成"
reached == phase -> "执行中"
else -> "待处理"
}
val tone = when (status) {
"失败" -> Color(0xFFFFA7B6)
"完成" -> Color(0xFF80DFB8)
"执行中" -> Color(0xFF91BEFF)
else -> Color(0xFFABC0D6)
}
Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(8.dp)) {
Text(phase.toString().padStart(2, '0'), color = tone, fontFamily = FontFamily.Monospace, fontSize = 11.sp)
Text(label, Modifier.weight(1f), color = Color.White, fontSize = 13.sp)
Text(status, color = tone, fontSize = 11.sp)
}
}
}
}
Kotlin 原生入口
composeApp/src/ohosMain/kotlin/dev/didseal/sample/Platform.kt
package dev.didseal.sample
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.ui.window.ComposeArkUIViewController
import dev.didseal.core.SealReport
import dev.didseal.core.SealRun
import kotlinx.cinterop.ExperimentalForeignApi
import kotlinx.coroutines.initMainHandler
import kotlin.experimental.ExperimentalNativeApi
import platform.ArkTS.ArkTS_Napi_NativeModule.napi_env
import platform.ArkTS.ArkTS_Napi_NativeModule.napi_value
private val run = SealRun()
private var report by mutableStateOf(SealReport())
@OptIn(ExperimentalNativeApi::class, ExperimentalForeignApi::class)
@CName("MainArkUIViewController")
fun MainArkUIViewController(env: napi_env): napi_value {
initMainHandler(env)
run.reset()
report = run.report
return ComposeArkUIViewController(env) { SealBoard(report) }
}
@OptIn(ExperimentalNativeApi::class)
@CName("SealBegin")
fun sealBegin(api: Int, size: Int): Int {
report = run.begin(api, size)
return report.ticket
}
@OptIn(ExperimentalNativeApi::class)
@CName("SealStepUpdate")
fun sealStep(ticket: Int, step: Int) {
run.advance(ticket, step)?.let { report = it }
}
@OptIn(ExperimentalNativeApi::class)
@CName("SealFinish")
fun sealFinish(ticket: Int, original: Int, modified: Int, bytes: Int) {
run.finish(ticket, original == 1, modified == 1, bytes)?.let { report = it }
}
@OptIn(ExperimentalNativeApi::class)
@CName("SealErrorUpdate")
fun sealError(ticket: Int, code: Int) {
run.fail(ticket, code)?.let { report = it }
}
ArkTS 宿主与文件读写
example/ohos/entry/src/main/ets/pages/Index.ets
import { common } from '@kit.AbilityKit';
import { util } from '@kit.ArkTS';
import { LengthMetrics } from '@kit.ArkUI';
import { BusinessError, deviceInfo } from '@kit.BasicServicesKit';
import { fileIo } from '@kit.CoreFileKit';
import { hilog } from '@kit.PerformanceAnalysisKit';
import { ArkUIViewController, Compose } from '@cpf-kmp-cmp/compose';
import nativeApi from 'libentry.so';
import { DidSealAdapter, SealError } from '../didseal/DidSealAdapter';
const DOMAIN = 0x012A;
const TAG = 'DidSeal';
const SAMPLE = 'receipt=DEMO-01\namount=120.00\ncurrency=CNY\n';
@Entry
@Component
struct Index {
private controller: ArkUIViewController | undefined = undefined;
private adapter: DidSealAdapter = new DidSealAdapter();
@State private busy: boolean = false;
aboutToAppear(): void {
this.controller = nativeApi.createController();
}
private writeThenRead(path: string, value: Uint8Array): Uint8Array {
const file = fileIo.openSync(path, fileIo.OpenMode.READ_WRITE | fileIo.OpenMode.CREATE | fileIo.OpenMode.TRUNC);
try {
const bytes = new ArrayBuffer(value.length);
new Uint8Array(bytes).set(value);
if (fileIo.writeSync(file.fd, bytes) !== value.length) {
throw new SealError(-20, 'Could not write the whole fixture');
}
const data = new ArrayBuffer(value.length);
if (fileIo.readSync(file.fd, data, { offset: 0 }) !== value.length) {
throw new SealError(-21, 'Could not read the whole fixture');
}
return new Uint8Array(data);
} finally {
fileIo.closeSync(file);
}
}
private async run(): Promise<void> {
if (this.busy) {
return;
}
this.busy = true;
const context = this.getUIContext().getHostContext() as common.UIAbilityContext;
const input = new util.TextEncoder().encodeInto(SAMPLE);
const ticket = nativeApi.begin(deviceInfo.sdkApiVersion, input.length);
hilog.info(DOMAIN, TAG, 'begin api=%{public}d bytes=%{public}d', deviceInfo.sdkApiVersion, input.length);
try {
const change = input.slice();
const offset = SAMPLE.indexOf('120.00');
change[offset] = 0x39;
const original = this.writeThenRead(context.filesDir + '/receipt.txt', input);
const modified = this.writeThenRead(context.filesDir + '/receipt-edited.txt', change);
const result = await this.adapter.compare(context, original, modified, (step) => {
nativeApi.step(ticket, step);
hilog.info(DOMAIN, TAG, 'step=%{public}d', step);
}, (code) => {
hilog.warn(DOMAIN, TAG, 'cleanup_error=%{public}d', code);
});
nativeApi.finish(ticket, result.original ? 1 : 0, result.modified ? 1 : 0, result.signatureBytes);
hilog.info(DOMAIN, TAG, 'verify original=%{public}d changed=%{public}d signature_bytes=%{public}d',
result.original ? 1 : 0, result.modified ? 1 : 0, result.signatureBytes);
} catch (error) {
const code = (error as BusinessError).code ?? -1;
nativeApi.fail(ticket, code);
hilog.warn(DOMAIN, TAG, 'error=%{public}d', code);
} finally {
this.busy = false;
}
}
build() {
Column() {
Flex({ wrap: FlexWrap.Wrap, space: { main: LengthMetrics.vp(16), cross: LengthMetrics.vp(14) },
alignItems: ItemAlign.Center, justifyContent: FlexAlign.SpaceBetween }) {
Row({ space: 12 }) {
Text('签').fontSize(18).fontWeight(FontWeight.Bold).fontColor('#FFFFFF')
.width(40).height(40).textAlign(TextAlign.Center).borderRadius(9).backgroundColor('#225AC1')
Column({ space: 3 }) {
Text('文件签印').fontSize(23).fontWeight(FontWeight.Bold).fontColor('#17263A')
Text('用同一份签名检查原件与改动件').fontSize(12).fontColor('#53667D')
}.alignItems(HorizontalAlign.Start)
}
Button(this.busy ? '验证中' : '签名并比对', { type: ButtonType.Normal })
.id('seal-run')
.enabled(!this.busy)
.borderRadius(10)
.backgroundColor('#225AC1')
.fontColor('#FFFFFF')
.fontWeight(FontWeight.Bold)
.height(44)
.padding({ left: 20, right: 20 })
.onClick(() => { this.run(); })
}
.width('100%')
.constraintSize({ maxWidth: 1180 })
.padding({ left: 16, right: 16, top: 10, bottom: 10 })
if (this.controller) {
Compose({ controller: this.controller, libraryName: 'entry' }).width('100%').layoutWeight(1)
}
}.height('100%').width('100%').backgroundColor('#FFFFFF')
}
}
N-API 桥
example/ohos/entry/src/main/cpp/napi_init.cpp
#include "libkn_api.h"
#include "napi/native_api.h"
#include <array>
#include <cstdint>
namespace {
template <size_t N>
bool ReadArgs(napi_env env, napi_callback_info info, std::array<int32_t, N>& values)
{
std::array<napi_value, N + 1> args;
size_t count = args.size();
if (napi_get_cb_info(env, info, &count, args.data(), nullptr, nullptr) == napi_ok && count == N) {
for (size_t index = 0; index < N; ++index) {
if (napi_get_value_int32(env, args[index], &values[index]) != napi_ok) break;
if (index + 1 == N) return true;
}
}
napi_throw_type_error(env, nullptr, "Expected numeric probe data");
return false;
}
napi_value CreateController(napi_env env, napi_callback_info)
{
return reinterpret_cast<napi_value>(MainArkUIViewController(env));
}
napi_value Begin(napi_env env, napi_callback_info info)
{
std::array<int32_t, 2> args;
if (!ReadArgs(env, info, args)) return nullptr;
napi_value result;
napi_create_int32(env, SealBegin(args[0], args[1]), &result);
return result;
}
napi_value Finish(napi_env env, napi_callback_info info)
{
std::array<int32_t, 4> args;
if (!ReadArgs(env, info, args)) return nullptr;
SealFinish(args[0], args[1], args[2], args[3]);
napi_value result;
napi_get_undefined(env, &result);
return result;
}
napi_value Step(napi_env env, napi_callback_info info)
{
std::array<int32_t, 2> args;
if (!ReadArgs(env, info, args)) return nullptr;
SealStepUpdate(args[0], args[1]);
napi_value result;
napi_get_undefined(env, &result);
return result;
}
napi_value Error(napi_env env, napi_callback_info info)
{
std::array<int32_t, 2> args;
if (!ReadArgs(env, info, args)) return nullptr;
SealErrorUpdate(args[0], args[1]);
napi_value result;
napi_get_undefined(env, &result);
return result;
}
napi_value Init(napi_env env, napi_value exports)
{
androidx_compose_ui_arkui_init(env, exports);
napi_property_descriptor methods[] = {
{"createController", nullptr, CreateController, nullptr, nullptr, nullptr, napi_default, nullptr},
{"begin", nullptr, Begin, nullptr, nullptr, nullptr, napi_default, nullptr},
{"finish", nullptr, Finish, nullptr, nullptr, nullptr, napi_default, nullptr},
{"step", nullptr, Step, nullptr, nullptr, nullptr, napi_default, nullptr},
{"fail", nullptr, Error, nullptr, nullptr, nullptr, napi_default, nullptr},
};
napi_define_properties(env, exports, sizeof(methods) / sizeof(methods[0]), methods);
return exports;
}
}
static napi_module module = {1, 0, nullptr, Init, "entry", nullptr, {0}};
extern "C" __attribute__((constructor)) void RegisterEntryModule()
{
napi_module_register(&module);
}
桥接声明
example/ohos/entry/src/main/cpp/types/libentry/Index.d.ts
import type { ArkUIViewController } from '@cpf-kmp-cmp/compose/src/main/cpp/types/libcompose_arkui_utils';
export const createController: () => ArkUIViewController;
export const begin: (api: number, size: number) => number;
export const step: (ticket: number, stage: number) => void;
export const finish: (ticket: number, original: number, modified: number, signatureBytes: number) => void;
export const fail: (ticket: number, code: number) => void;
库构建
didSeal/build.gradle.kts
plugins {
alias(libs.plugins.kotlinMultiplatform)
}
kotlin {
ohosArm64()
ohosX64()
}
示例构建与产物同步
composeApp/build.gradle.kts
import org.jetbrains.kotlin.gradle.plugin.mpp.NativeBuildType
plugins {
alias(libs.plugins.kotlinMultiplatform)
alias(libs.plugins.composeMultiplatform)
alias(libs.plugins.composeCompiler)
}
kotlin {
// 共享界面分别生成平板 ARM64 与模拟器 X64 动态库。
listOf(ohosArm64(), ohosX64()).forEach { target ->
target.binaries.sharedLib {
baseName = "kn"
if (buildType == NativeBuildType.RELEASE) {
optimized = false
}
export(libs.compose.multiplatform.export)
linkerOpts("-lz")
val backend = rootProject.findProperty("rendererBackend")?.toString() ?: "skia"
if (backend == "fusion-renderer") {
linkerOpts(
"-lnative_drawing", "-limage_source", "-lpixelmap", "-lpixelmap_ndk.z",
"-lnative_window", "-lace_napi.z", "-lhilog_ndk.z", "-lhitrace_ndk.z",
"-luv", "-lunwind", "-licu"
)
}
}
target.compilations.getByName("main") {
val resource by cinterops.creating {
defFile(file("src/ohosMain/cinterop/resource.def"))
includeDirs(file("src/ohosMain/cinterop/include"))
}
}
}
sourceSets {
commonMain.dependencies {
implementation(projects.didSeal)
implementation(compose.runtime)
implementation(compose.foundation)
implementation(compose.material)
implementation(compose.material3)
implementation(compose.ui)
implementation(compose.components.resources)
implementation(compose.components.uiToolingPreview)
implementation(libs.kotlinx.coroutines.core)
implementation(libs.atomicFu)
}
val ohosMain by creating {
dependsOn(commonMain.get())
dependencies {
api(libs.compose.multiplatform.export)
}
}
getByName("ohosArm64Main").dependsOn(ohosMain)
getByName("ohosX64Main").dependsOn(ohosMain)
}
}
// 成套复制动态库与头文件,鸿蒙宿主不依赖 Android 或 iOS SDK。
arrayOf("debug", "release").forEach { type ->
val capitalized = type.replaceFirstChar { it.uppercase() }
tasks.register<Copy>("publish${capitalized}BinariesToHarmonyApp") {
group = "harmony"
dependsOn("link${capitalized}SharedOhosArm64", "link${capitalized}SharedOhosX64")
duplicatesStrategy = DuplicatesStrategy.INCLUDE
into(rootProject.file("example/ohos"))
from("build/bin/ohosArm64/${type}Shared/libkn_api.h") {
into("entry/src/main/cpp/include/arm64-v8a/")
}
from("build/bin/ohosArm64/${type}Shared/libkn.so") {
into("entry/libs/arm64-v8a/")
}
from("build/bin/ohosX64/${type}Shared/libkn_api.h") {
into("entry/src/main/cpp/include/x86_64/")
}
from("build/bin/ohosX64/${type}Shared/libkn.so") {
into("entry/libs/x86_64/")
}
val resourcePackage = "${rootProject.name}.${project.name.lowercase()}.generated.resources"
from("src/commonMain/composeResources") {
into("entry/src/main/resources/rawfile/composeResources/$resourcePackage/")
}
from(rootProject.file("didSeal/src/ohosMain/arkts/DidSealAdapter.ets")) {
into("entry/src/main/ets/didseal/")
}
}
}
HarmonyOS 工程 API 配置
example/ohos/build-profile.json5
{
"app": {
"signingConfigs": [],
"products": [
{
"name": "default",
"compatibleSdkVersion": "26.0.0",
"targetSdkVersion": "26.0.0",
"compileSdkVersion": "26.0.0",
"runtimeOS": "HarmonyOS",
"buildOption": {
"nativeCompiler": "BiSheng",
"strictMode": {
"caseSensitiveCheck": true,
"useNormalizedOHMUrl": true
}
}
}
],
"buildModeSet": [
{
"name": "debug",
},
{
"name": "release"
}
]
},
"modules": [
{
"name": "entry",
"srcPath": "./entry",
"targets": [
{
"name": "default",
"applyToProducts": [
"default"
]
}
]
}
]
}
5



被折叠的 条评论
为什么被折叠?



