///|
/// Verity 签名块结构解析(W5 — 块识别 + 原始字节 + 声明字段)。
///
/// 边界:APK Signing Block 中 ID 0x42726577 的块在 AOSP 中用作对齐填充(padding),
/// 不承载结构化 verity 参数(fs-verity Merkle 树参数在 v4 .idsig 文件中)。
/// 本模块按开发文档 W5 方针实现:块识别 + 原始字节保存 + 尽力解析声明字段;
/// 树重算挂 `#skip` 显式缺口。
///
/// 非目标:不做 Merkle 树重算、不做 v4 .idsig 解析、不做安装语义。
///|
#derive(Debug)
/// Verity 签名块信息(APK Signing Block ID 0x42726577)。
pub(all) struct VerityInfo {
/// block_id = 0x42726577
block_id : UInt32
/// 块内声明的版本号(解析失败时为 0)。
version : Int32
/// 块内声明的哈希算法名称;unknown = 未识别 / 算法不在支持列表。
hash_algorithm : String
/// 块内声明的数据分块大小(字节);0 = 未声明。
block_size : Int32
/// 块内声明的盐值(小写 hex);空 = 未声明。
salt_hex : String
/// 块内声明的根哈希(小写 hex);空 = 未声明。
root_hash_hex : String
/// 块内声明的树尺寸(字节);0 = 未声明。
tree_size : UInt64
/// 是否已重算 Merkle 树并与声明一致。
/// 本模块不做树重算,恒为 false(#skip 缺口)。
tree_recomputed_ok : Bool
}
///|
pub extend VerityInfo with Debug::{to_repr}
///|
/// 读取 verity 签名块(ID 0x42726577)的结构信息;无该块返回 None。
///
/// 遍历 APK Signing Block 的 ID-value 对,找到 verity 块后尽力解析声明字段;
/// 所有解析失败以缺省值表示(不 raise、不 panic),由调用方决定如何使用。
/// 树重算恒不执行,`tree_recomputed_ok` 恒为 false。
pub fn Apk::verity(self : Apk) -> VerityInfo? raise ApkError {
let sb = match self.signing_block_off {
Some(o) => o.to_int()
None => return None
}
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)
let value_off = pos + 12
let value_len = pair_len.to_int() - 4
if id == VERITY_BLOCK_ID {
let raw = self.source[value_off:value_off + value_len].to_owned()
return Some(parse_verity_value(id, raw))
}
pos = pos + 8 + pair_len.to_int()
}
None
}
///|
/// Verity 块 ID(AOSP ApkSigningBlockUtils.VERITY_PADDING_BLOCK_ID)。
const VERITY_BLOCK_ID : UInt32 = 0x42726577
///|
/// 从 verity 块原始字节尽力解析声明字段;解析失败以缺省值表示。
fn parse_verity_value(block_id : UInt32, raw : Bytes) -> VerityInfo {
let len = raw.length()
let mut version = 0
let mut hash_algorithm = "unknown"
let mut block_size = 0
let mut salt_hex = ""
let mut root_hash_hex = ""
let mut tree_size : UInt64 = 0UL
// 尝试按简单顺序格式解析:
// u32 version | u32 hash_algo | u32 block_size | u32 salt_len | salt |
// u32 root_hash_len | root_hash | u64 tree_size
if len >= 4 {
version = le_u32(raw, 0).reinterpret_as_int()
}
if len >= 8 {
let algo_id = le_u32(raw, 4)
hash_algorithm = if algo_id == 1U {
"SHA-256"
} else if algo_id == 2U {
"SHA-512"
} else {
"unknown"
}
}
if len >= 12 {
block_size = le_u32(raw, 8).reinterpret_as_int()
}
let mut pos = 12
if pos + 4 <= len {
let salt_len = le_u32(raw, pos).reinterpret_as_int()
pos = pos + 4
if salt_len > 0 && salt_len <= 64 && pos + salt_len <= len {
salt_hex = bytes_to_hex(raw[pos:pos + salt_len])
pos = pos + salt_len
}
}
if pos + 4 <= len {
let rh_len = le_u32(raw, pos).reinterpret_as_int()
pos = pos + 4
if rh_len > 0 && rh_len <= 64 && pos + rh_len <= len {
root_hash_hex = bytes_to_hex(raw[pos:pos + rh_len])
pos = pos + rh_len
}
}
if pos + 8 <= len {
tree_size = le_u64(raw, pos)
}
{
block_id,
version,
hash_algorithm,
block_size,
salt_hex,
root_hash_hex,
tree_size,
tree_recomputed_ok: false,
}
}
///|
/// 字节切片 → 小写 hex 字符串。
fn bytes_to_hex(b : BytesView) -> String {
let out = StringBuilder(capacity=b.length() * 2)
for byte in b {
let v = byte.to_int()
let hi = (v >> 4) & 0xF
let lo = v & 0xF
let c_hi = if hi < 10 {
(48 + hi).unsafe_to_char()
} else {
(87 + hi).unsafe_to_char()
}
let c_lo = if lo < 10 {
(48 + lo).unsafe_to_char()
} else {
(87 + lo).unsafe_to_char()
}
out.write_char(c_hi)
out.write_char(c_lo)
}
out.to_string()
}