///|
/// 真验签通道:`Apk::verify_signatures`(W6 公钥验签,M6-RSA-a/b)。
///
/// 与 `signature_checks()`(历史契约)不同:本入口对签名**值**做 RSA PKCS#1 v1.5 公钥
/// 验签。`crypto_verified` 为 true 仅当签名值在模幂后填充正确且 DigestInfo 一致。
///
/// 语义防火墙(本包最重要的设计决策,硬性):
/// - `signature_checks()` 与 `SignatureCheck.signature_verified` **恒 false 永不改变**;
/// - 验签结论只走本模块的新类型 `SignatureVerification`;
/// - 不支持/未实现算法(ECDSA、DSA、RSA-PSS、v1 未接入分支)一律 fail-closed:
///   `crypto_verified` 恒 false,`detail` 说明原因,绝不误判为通过。
///
/// 范围(W6 已裁决 2026-11-18:仅 RSA 降级立项):v2/v3/v3.1 的 RSA PKCS#1 v1.5
/// 签名值验证(M6-RSA-a);v1 CMS SignedData 接入(M6-RSA-b)。

///|
/// 单个签名方案的验签结论(新类型,纯加法 API;旧类型语义不变)。
pub(all) struct SignatureVerification {
  scheme : SignatureScheme
  /// 签名结构是否可解析(v2/v3/v3.1:signer 序列结构合法;v1:PKCS#7/MANIFEST/.SF 齐全)。
  structure_ok : Bool
  /// 本地可验证的摘要是否一致(v2/v3/v3.1:APK 内容分块摘要;v1:清单条目 + .SF 摘要)。
  digest_ok : Bool
  /// **公钥验签**是否通过。仅 RSA PKCS#1 v1.5 可实现;ECDSA/DSA/未知恒 false(fail-closed)。
  crypto_verified : Bool
  /// 实际执行的算法标识(如 `"SHA256withRSA"` / `"SHA512withRSA"` / `"unsupported"`)。
  algo : String
  /// 人类可读结论 / 失败原因(诊断用,不参与判定)。
  detail : String
}

///|
/// 对每个已识别签名方案做**签名值**验签,返回新类型 `SignatureVerification` 列表。
///
/// 顺序与 `signature_checks()` 一致(v1 优先,v2/v3/v3.1 按块内顺序、按方案排序)。
/// 不抛错即表示结构可解析;单个方案验签失败记录在该方案 `crypto_verified=false` 中,
/// 不中断整体遍历。
pub fn Apk::verify_signatures(
  self : Apk,
) -> Array[SignatureVerification] raise ApkError {
  let out : Array[SignatureVerification] = []
  for rec in self.collect_signature_records() {
    match rec.scheme {
      SignatureScheme::V1 => out.push(self.verify_v1_crypto(rec))
      SignatureScheme::V2 | SignatureScheme::V3 | SignatureScheme::V31 =>
        out.push(self.verify_v2_crypto(rec))
    }
  }
  out
}

///|
/// v1 CMS signerInfo 验签(M6-RSA-b)。结构与摘要沿用 `verify_v1` 的既有结论;
/// 签名值走 `verify_v1_signer_info`(RSA PKCS#1 v1.5 over signedAttrs 或 content)。
fn Apk::verify_v1_crypto(self : Apk, rec : SigRecord) -> SignatureVerification {
  let base = self.verify_v1(rec)
  let sf_bytes = match rec.v1_sf {
    Some(n) => self.safe_entry(n)
    None => None
  }
  let pkcs7 = match rec.v1_block {
    Some(n) => self.safe_entry(n)
    None => None
  }
  let (crypto_verified, algo, detail) = match (sf_bytes, pkcs7) {
    (Some(sf), Some(der)) => verify_v1_signer_info(rec.certs, sf, der)
    _ =>
      (false, "unsupported", "v1 signerInfo: .SF or PKCS#7 block unavailable")
  }
  {
    scheme: rec.scheme,
    structure_ok: base.structure_ok,
    digest_ok: base.digest_ok,
    crypto_verified,
    algo,
    detail,
  }
}

///|
/// v2/v3/v3.1 签名值验签(RSA PKCS#1 v1.5 / PSS 与 ECDSA)。
///
/// 签名覆盖的原始数据 = signer 的 **signed-data 内容字节**(digests + certificates +
/// [min/maxSDK] + attributes 的长度前缀序列化,不含其自身长度前缀),即 apksigner
/// 口径的 `dataToSign`。对每个 signature 记录按算法 ID 决定摘要算法并验签。
fn Apk::verify_v2_crypto(self : Apk, rec : SigRecord) -> SignatureVerification {
  let signers = self.try_extract_scheme_verify(rec)
  if signers is None {
    return {
      scheme: rec.scheme,
      structure_ok: false,
      digest_ok: false,
      crypto_verified: false,
      algo: "unsupported",
      detail: "signer structure could not be parsed for signature-value verification",
    }
  }
  let signers = signers.unwrap()
  // 摘要:沿用既有内容分块摘要判定。
  let digest_ok = match rec.digests {
    [] => false
    _ => {
      let mut ok = false
      for d in rec.digests {
        let name = content_digest_algorithm_name(d.algorithm)
        if name != "SHA-256" && name != "SHA-512" {
          continue
        }
        match self.content_digest(name) {
          Some(c) => if c == d.digest { ok = true }
          None => ()
        }
      }
      ok
    }
  }
  // 结构合法 = 至少一个 signer,且签名记录与公钥字段齐全。
  let structure_ok = signers.length() > 0
  // 逐个 signer 尝试 RSA / ECDSA 验签;任一签名通过即 crypto_verified=true。
  let (crypto_verified, algo, detail) = verify_v2_signers(signers)
  {
    scheme: rec.scheme,
    structure_ok,
    digest_ok,
    crypto_verified,
    algo,
    detail,
  }
}

///|
/// 对一组 signer 做签名值验签:先按 RSA SPKI 解析,失败再按 EC SPKI 解析。
///
/// RSA:算法 ID 0x0101/0x0102 = RSA-PSS(SHA-256/512),0x0103/0x0104 = PKCS#1 v1.5。
/// ECDSA:0x0201 = SHA256withECDSA、0x0202 = SHA512withECDSA(无 PSS 变体),
/// 签名值为 DER `SEQUENCE{INTEGER r, INTEGER s}`。两者都无法识别时 fail-closed。
fn verify_v2_signers(
  signers : Array[SignerVerifyData],
) -> (Bool, String, String) {
  let mut crypto_verified = false
  let mut algo = "unsupported"
  let mut detail = "no verifiable RSA signature"
  for s in signers {
    match rsa_public_key_from_spki(s.public_key) {
      Some(k) =>
        if rsa_key_too_large(k) {
          // 模数超 8192 位:fail-closed,且不进入模幂(DoS 面收敛)。
          detail = "key too large"
        } else {
          for (alg_id, sig_bytes) in s.signatures {
            // Android 签名算法 ID:0x0101/0x0102 = RSA-PSS(SHA-256/512),
            // 0x0103/0x0104 = RSA-PKCS#1 v1.5(SHA-256/512);其余不支持。
            let (hash_name, digest, pss) = match alg_id {
              0x0101U => ("SHA-256", sha256(s.signed_data), true)
              0x0102U => ("SHA-512", sha512(s.signed_data), true)
              0x0103U => ("SHA-256", sha256(s.signed_data), false)
              0x0104U => ("SHA-512", sha512(s.signed_data), false)
              _ => ("", b"", false)
            }
            let verified = if hash_name == "" {
              false
            } else if pss {
              rsa_verify_pss(k, sig_bytes, digest, hash_name)
            } else {
              rsa_verify_pkcs1(k, sig_bytes, digest, hash_name)
            }
            if verified {
              crypto_verified = true
              algo = if pss {
                if hash_name == "SHA-256" {
                  "SHA256withRSA/PSS"
                } else {
                  "SHA512withRSA/PSS"
                }
              } else if hash_name == "SHA-256" {
                "SHA256withRSA"
              } else {
                "SHA512withRSA"
              }
              detail = if pss {
                "RSA PSS signature verified over signed data"
              } else {
                "RSA PKCS#1 v1.5 signature verified over signed data"
              }
            } else {
              detail = "signature failed verification or unsupported algorithm"
            }
          }
        }
      None =>
        match ec_public_key_from_spki(s.public_key) {
          None => detail = "public key is not a parseable RSA or EC SPKI"
          Some((curve, qx, qy)) =>
            match ec_params(curve) {
              None => detail = "unsupported EC curve"
              Some(params) =>
                for (alg_id, sig_bytes) in s.signatures {
                  // ECDSA 无 PSS 版本:0x0201 只对应 SHA-256、0x0202 只对应 SHA-512。
                  let (hash_name, digest) = match alg_id {
                    0x0201U => ("SHA-256", sha256(s.signed_data))
                    0x0202U => ("SHA-512", sha512(s.signed_data))
                    _ => ("", b"")
                  }
                  if hash_name == "" {
                    detail = "signature failed verification or unsupported algorithm"
                    continue
                  }
                  match ec_sig_from_der(sig_bytes) {
                    None => detail = "ECDSA signature value is not valid DER"
                    Some((r, sig_s)) =>
                      if ec_ecdsa_verify(
                          params,
                          qx,
                          qy,
                          ec_hash_to_e(digest, params.n),
                          r,
                          sig_s,
                        ) {
                        crypto_verified = true
                        algo = if hash_name == "SHA-256" {
                          "SHA256withECDSA"
                        } else {
                          "SHA512withECDSA"
                        }
                        detail = "ECDSA signature verified over signed data"
                      } else {
                        detail = "ECDSA signature failed verification"
                      }
                  }
                }
            }
        }
    }
  }
  (crypto_verified, algo, detail)
}

///|
/// 提取签名方案的各 signer 验签数据;结构异常(raise)时返回 None(fail-closed)。
fn Apk::try_extract_scheme_verify(
  self : Apk,
  rec : SigRecord,
) -> Array[SignerVerifyData]? {
  let mut out : Array[SignerVerifyData]? = None
  try {
    out = Some(
      extract_scheme_verify(
        self.source,
        rec.value_off,
        rec.value_len,
        rec.value_off,
        rec.scheme,
      ),
    )
  } catch {
    _ => ()
  } noraise {
    _ => ()
  }
  out
}

///|
/// 单个 signer 的验签所需数据。
priv struct SignerVerifyData {
  signed_data : Bytes
  signatures : Array[(UInt32, Bytes)]
  public_key : Bytes
}

///|
/// 从签名方案 value 中提取每个 signer 的 signed-data 原始字节、签名记录与公钥 SPKI。
///
/// 布局与 `extract_signer_data` 相同,但额外取:
///   v2  signer = signed_data(长度前缀) + signatures(长度前缀序列) + public_key(长度前缀)。
///   v3/3.1 signer = signed_data + uint32 minSdk + uint32 maxSdk + signatures + public_key。
/// signatures = u32 序列长 { u32 记录长 u32 算法ID u32 签名长 签名 }*。
/// signed-data 内容字节即签名覆盖对象(不含其自身长度前缀)。
fn extract_scheme_verify(
  source : Bytes,
  value_off : Int32,
  value_len : Int32,
  pair_off : Int32,
  scheme : SignatureScheme,
) -> Array[SignerVerifyData] raise ApkError {
  let out : Array[SignerVerifyData] = []
  let end = value_off + value_len
  let mut pos = value_off
  guard pos + 4 <= end else {
    raise ApkError::BadSigningBlock(pair_off, "signer sequence length missing")
  }
  let seq_len = le_u32(source, pos)
  guard seq_len <= (end - pos - 4).reinterpret_as_uint() else {
    raise ApkError::BadSigningBlock(
      pair_off, "signer sequence overruns signature scheme value",
    )
  }
  let seq_end = pos + 4 + seq_len.reinterpret_as_int()
  pos = pos + 4
  while pos < seq_end {
    guard pos + 4 <= seq_end else {
      raise ApkError::BadSigningBlock(pair_off, "signer length missing")
    }
    let signer_len = le_u32(source, pos)
    guard signer_len <= (seq_end - pos - 4).reinterpret_as_uint() else {
      raise ApkError::BadSigningBlock(
        pair_off, "signer overruns signer sequence",
      )
    }
    let signer_end = pos + 4 + signer_len.reinterpret_as_int()
    let mut sp = pos + 4
    // signed_data
    guard sp + 4 <= signer_end else {
      raise ApkError::BadSigningBlock(pair_off, "signed data length missing")
    }
    let sd_len = le_u32(source, sp)
    guard sd_len <= (signer_end - sp - 4).reinterpret_as_uint() else {
      raise ApkError::BadSigningBlock(pair_off, "signed data overruns signer")
    }
    let sd_content = sp + 4
    let sd_end = sd_content + sd_len.reinterpret_as_int()
    let signed_data = source[sd_content:sd_end].to_owned()
    sp = sd_end
    // v3 / v3.1:signed_data 之后是 minSdk / maxSdk 两个裸 uint32。
    if scheme is SignatureScheme::V3 || scheme is SignatureScheme::V31 {
      guard sp + 8 <= signer_end else {
        raise ApkError::BadSigningBlock(pair_off, "v3 min/max SDK missing")
      }
      sp = sp + 8
    }
    // signatures(长度前缀序列)
    guard sp + 4 <= signer_end else {
      raise ApkError::BadSigningBlock(pair_off, "signatures length missing")
    }
    let sigs_len = le_u32(source, sp)
    guard sigs_len <= (signer_end - sp - 4).reinterpret_as_uint() else {
      raise ApkError::BadSigningBlock(pair_off, "signatures overrun signer")
    }
    let sigs_end = sp + 4 + sigs_len.reinterpret_as_int()
    sp = sp + 4
    let signatures : Array[(UInt32, Bytes)] = []
    while sp < sigs_end {
      guard sp + 4 <= sigs_end else {
        raise ApkError::BadSigningBlock(
          pair_off, "signature record length missing",
        )
      }
      let rec_len = le_u32(source, sp)
      guard rec_len >= 8 && rec_len <= (sigs_end - sp - 4).reinterpret_as_uint() else {
        raise ApkError::BadSigningBlock(
          pair_off, "signature record overruns signatures",
        )
      }
      let alg_id = le_u32(source, sp + 4)
      let sig_len = le_u32(source, sp + 8)
      guard sig_len <= rec_len - 8 else {
        raise ApkError::BadSigningBlock(pair_off, "signature overruns record")
      }
      signatures.push(
        (
          alg_id,
          source[sp + 12:sp + 12 + sig_len.reinterpret_as_int()].to_owned(),
        ),
      )
      sp = sp + 4 + rec_len.reinterpret_as_int()
    }
    sp = sigs_end
    // public_key(长度前缀)
    guard sp + 4 <= signer_end else {
      raise ApkError::BadSigningBlock(pair_off, "public key length missing")
    }
    let pk_len = le_u32(source, sp)
    guard pk_len <= (signer_end - sp - 4).reinterpret_as_uint() else {
      raise ApkError::BadSigningBlock(pair_off, "public key overruns signer")
    }
    let public_key = source[sp + 4:sp + 4 + pk_len.reinterpret_as_int()].to_owned()
    sp = sp + 4 + pk_len.reinterpret_as_int()
    out.push({ signed_data, signatures, public_key, })
    pos = signer_end
  }
  out
}