///|
/// fs-verity Merkle 根重算与 v2/v3/v3.1 声明摘要比对(W5-后续)。
///
/// 背景(已联网核实 AOSP):APK Signing Block 中 ID `0x42726577`(`VERITY_PADDING_BLOCK_ID`)
/// 仅作对齐填充,**不承载** root hash 或任何 verity 参数——故既有 `VerityInfo` 从该块读到的
/// `root_hash_hex` 恒为空、`tree_recomputed_ok` 恒 false 是正确的,该块无法承载比对。
/// 真实 fs-verity Merkle 根位于 v2/v3/v3.1 **signed data 的 verity 内容摘要**中:
/// 摘要算法 ID `0x0421`(RSA)/`0x0423`(ECDSA)/`0x0425`(DSA) 均映射到
/// `CONTENT_DIGEST_VERITY_CHUNKED_SHA256`,值为 40 字节 = root_hash[32] || source_len(int64 小端)。
///
/// 本模块新增加法 API:`Apk::verity_tree_check`(新 struct `VerityTreeCheck`),对 fs-verity
/// Merkle 根做真重算并与 v2/v3/v3.1 声明的 verity 摘要根比对。属纯加法,不动既有
/// `VerityInfo`/`Apk::verity`,不新增 `ApkError` 变体,不引入依赖。
///
/// 非目标:不做 v4 `.idsig` 解析、不做安装语义、不修改 APK。
///|
/// fs-verity Merkle 根重算结论(与 v2/v3/v3.1 声明摘要比对)。
///
/// `block_id` 恒为 0x42726577(标识这是 verity 能力,尽管该块本身不承载 root hash)。
/// `tree_recomputed_ok` 为 true 仅当「声明了 verity 摘要」且「重算根 == 声明根」;否则 false
/// (fail-closed)。`verity_tree_check()` 返回 `None` 表示该 APK 的 v2/v3/v3.1 中无 verity 摘要。
pub(all) struct VerityTreeCheck {
/// 恒 0x42726577(标识 verity 能力)。
block_id : UInt32
/// "SHA-256"(fs-verity 固定);声明存在但算法无法识别时为 "unknown"。
hash_algorithm : String
/// fs-verity 块大小,恒 4096。
block_size : Int32
/// 盐值 hex(fs-verity 固定 8 字节全零):恒 "0000000000000000"。
salt_hex : String
/// v2/v3/v3.1 声明 verity 摘要中提取的 32 字节根(小写 hex)。
declared_root_hash_hex : String
/// 对 fs-verity 源数据重算出的 32 字节根(小写 hex);重算失败时为空串。
recomputed_root_hash_hex : String
/// 重算根 == 声明根。有声明且比对一致才为 true,否则 false(fail-closed)。
tree_recomputed_ok : Bool
/// v2/v3/v3.1 verity 摘要中声明的 source_len。
source_len : UInt64
}
///|
/// 收集 v2/v3/v3.1 signer 的 verity 摘要记录。
///
/// 遍历 APK Signing Block 的 ID-value 对,对每个 v2/v3/v3.1 方案尝试解析 signer 的 digests 序列,
/// 挑出算法 ID 为 0x0421/0x0423/0x0425 且值为 40 字节的记录。单个 signer 解析失败跳过(值化),
/// 但结构性截断(pair 长度越界)仍按既有 `BadSigningBlock` 语义 raise(与 `Apk::verity` 一致)。
/// 返回顺序不保证(调用方只取第一个合法记录)。
fn Apk::collect_verity_digests(
self : Apk,
) -> Array[SignerDigest] raise ApkError {
let out : Array[SignerDigest] = []
let sb = match self.signing_block_off {
Some(o) => o.to_int()
None => return out
}
let size = le_u64(self.source, sb)
let pairs_start = sb + 8
let pairs_end = sb + size.to_int() - 16
let mut pos = pairs_start
while pos < pairs_end {
guard pos + 8 <= pairs_end else {
raise ApkError::BadSigningBlock(
pos, "truncated ID-value pair length in APK Signing Block",
)
}
let pair_len = le_u64(self.source, pos)
guard pair_len >= 4 && pair_len - 4 <= (pairs_end - pos - 8).to_uint64() else {
raise ApkError::BadSigningBlock(
pos, "ID-value pair overruns APK Signing Block",
)
}
let id = le_u32(self.source, pos + 8)
if id == SIG_ID_V2 || id == SIG_ID_V3 || id == SIG_ID_V31 {
let value_off = pos + 12
let value_len = pair_len.to_int() - 4
let sch = if id == SIG_ID_V2 {
SignatureScheme::V2
} else if id == SIG_ID_V3 {
SignatureScheme::V3
} else {
SignatureScheme::V31
}
let data : SignerData? = Some(
extract_signer_data(self.source, sch, value_off, value_len, pos),
) catch {
// 单个 signer 解析失败值化为 None(跳过该 signer),与 W5「解析失败一律值化」一致;
// 结构性 pair 越界仍由上方 guard 按既有 BadSigningBlock 语义 raise。
_ => None
}
match data {
Some(d) =>
for dd in d.digests {
if is_verity_digest_algorithm(dd.algorithm) &&
dd.digest.length() == 40 {
out.push(dd)
}
}
None => ()
}
}
pos = pos + 8 + pair_len.to_int()
}
out
}
///|
/// 判断摘要算法 ID 是否对应 fs-verity 内容摘要(AOSP `CONTENT_DIGEST_VERITY_CHUNKED_SHA256`)。
/// 注:这是「签名算法 ID 映射到 verity 内容摘要」的 ID(RSA/ECDSA/DSA 三档)。
fn is_verity_digest_algorithm(id : UInt32) -> Bool {
id == 0x0421U || id == 0x0423U || id == 0x0425U
}
///|
/// 构造 fs-verity 源数据:APK 全部字节扣除签名块区间 `[signingBlockOff, centralDirOffset)`,
/// 且 EOCD 的中央目录偏移字段(EOCD 内偏移 +16,4 字节小端)改写为 `signingBlockOff`。
/// 与 `content_digest` 的分块摘要不同(这是 Merkle 树的整源),不可复用错。
/// 源数据不可构造(无签名块 / 无 EOCD / 目录越界)返回 None。
fn Apk::verity_source_bytes(self : Apk) -> Bytes? {
let sb = match self.signing_block_off {
Some(v) => v.to_int()
None => return None
}
let eocd = match find_eocd(self.source) {
Some(o) => o
None => return None
}
let source = self.source
let cd_off = le_u32(source, eocd + 16).reinterpret_as_int()
let cd_size = le_u32(source, eocd + 12).reinterpret_as_int()
if cd_off < 0 || cd_size < 0 || cd_off + cd_size > eocd {
return None
}
let comment_len = le_u16(source, eocd + 20)
let eocd_len = 22 + comment_len
if eocd + eocd_len > source.length() {
return None
}
let buf : Array[Byte] = []
// 1) 签名块前的条目区 [0, sb)
for i = 0; i < sb; i = i + 1 {
buf.push(source[i])
}
// 2) 中央目录区 [cd_off, cd_off + cd_size)
for i = cd_off; i < cd_off + cd_size; i = i + 1 {
buf.push(source[i])
}
// 3) EOCD 副本,中央目录偏移字段改写为 sb
for i = 0; i < eocd_len; i = i + 1 {
buf.push(source[eocd + i])
}
let sb_u = sb.reinterpret_as_uint()
let base = buf.length() - eocd_len
buf[base + 16] = (sb_u & 0xFFU).reinterpret_as_int().to_byte()
buf[base + 17] = ((sb_u >> 8) & 0xFFU).reinterpret_as_int().to_byte()
buf[base + 18] = ((sb_u >> 16) & 0xFFU).reinterpret_as_int().to_byte()
buf[base + 19] = ((sb_u >> 24) & 0xFFU).reinterpret_as_int().to_byte()
Some(Bytes::from_array(buf[:]))
}
///|
/// fs-verity Merkle 根(apk-verity 变体,AOSP `VerityBuilder.generateApkVerityTree`)。
///
/// - 盐 = 8 字节全零,SHA-256,块大小 4096。
/// - 叶子层:源按 4096 分块,每块 `sha256(盐 || 零填充至4096的块)`;不满补零。
/// - 内部层:上一层 32 字节摘要串接后按 4096 分块,每块 `sha256(盐 || 零填充至4096)`;逐层向上直到该层 ≤4096 字节。
/// - 根:对最顶层(首个 ≤4096 字节的层)做 `sha256(盐 || 该层零填充块)`。
fn verity_root(source : Bytes, salt : Bytes, block_size : Int32) -> Bytes {
// 叶子层
let mut level : Array[Bytes] = []
let n = source.length()
let mut off = 0
while off < n {
let take = if n - off > block_size { block_size } else { n - off }
let block = zero_pad(source[off:off + take].to_owned(), block_size)
level.push(sha256(concat_salt(salt, block)))
off = off + block_size
}
// 内部层:直到当前层串接尺寸 ≤ block_size
while level.length() * 32 > block_size {
let concat = concat_bytes(level)
let m = concat.length()
let next : Array[Bytes] = []
let mut o = 0
while o < m {
let take = if m - o > block_size { block_size } else { m - o }
let block = zero_pad(concat[o:o + take].to_owned(), block_size)
next.push(sha256(concat_salt(salt, block)))
o = o + block_size
}
level = next
}
// 根:最顶层串接零填充
let top = zero_pad(concat_bytes(level), block_size)
sha256(concat_salt(salt, top))
}
///|
/// 对字节流做 fs-verity 根重算并与 v2/v3/v3.1 声明的 verity 摘要根比对。
///
/// - 收集 v2/v3/v3.1 signer 的 digests,找到 algorithm 为 0x0421/0x0423/0x0425 且值 40 字节的
/// 摘要(提取声明根与 source_len);无则返回 `None`。
/// - 有声明时构造 fs-verity 源并重算根,比对一致 `tree_recomputed_ok=true`。
/// - 解析失败一律值化(`tree_recomputed_ok=false`、字段缺省),不 panic、不新增错误变体。
pub fn Apk::verity_tree_check(self : Apk) -> VerityTreeCheck? raise ApkError {
let digests = self.collect_verity_digests()
let mut declared : (Bytes, UInt64)? = None
for d in digests {
if d.digest.length() == 40 {
declared = Some((d.digest[0:32].to_owned(), le_u64(d.digest, 32)))
break
}
}
match declared {
None => return None
Some((root_hash, source_len)) => {
let recomputed : Bytes? = match self.verity_source_bytes() {
Some(src) =>
Some(verity_root(src, b"\x00\x00\x00\x00\x00\x00\x00\x00", 4096))
None => None
}
let ok = match recomputed {
Some(r) => r == root_hash
None => false
}
Some({
block_id: VERITY_BLOCK_ID,
hash_algorithm: "SHA-256",
block_size: 4096,
salt_hex: "0000000000000000",
declared_root_hash_hex: bytes_to_hex(root_hash),
recomputed_root_hash_hex: match recomputed {
Some(r) => bytes_to_hex(r)
None => ""
},
tree_recomputed_ok: ok,
source_len,
})
}
}
}
///|
/// 盐 || 数据。
fn concat_salt(salt : Bytes, data : Bytes) -> Bytes {
let out : Array[Byte] = []
for x in salt {
out.push(x)
}
for x in data {
out.push(x)
}
Bytes::from_array(out[:])
}
///|
/// 零填充到 block_size(不足补零;已满原样返回)。
fn zero_pad(b : Bytes, block_size : Int32) -> Bytes {
if b.length() == block_size {
return b
}
let out : Array[Byte] = []
for x in b {
out.push(x)
}
while out.length() < block_size {
out.push(b'\x00')
}
Bytes::from_array(out[:])
}
///|
/// 串接一层摘要。
fn concat_bytes(level : Array[Bytes]) -> Bytes {
let out : Array[Byte] = []
for d in level {
for x in d {
out.push(x)
}
}
Bytes::from_array(out[:])
}