///|
/// RSA 公钥验签原语(M6-RSA-a,W6 公钥验签·仅 RSA)。
///
/// 仅实现 RSA **验签**(公钥操作),不实现签名/密钥生成/私钥。范围严格限于:
///   1. RSA 公钥验签原语:`sig^e mod n`,PKCS#1 v1.5 填充校验 + DigestInfo 比对;
///   2. 从 X.509 证书 SPKI 提取 RSA 公钥(模数 n、指数 e)。
///
/// 依赖:本包 `bigint.mbt` 的无符号大数模幂。算法仅 RSA(ECDSA 由 W6 裁决排除,
/// fail-closed)。SHA-256 / SHA-512 摘要由 `crypto.mbt` 提供。
///
/// 语义:验签成功 = 签名值在模幂后以 PKCS#1 v1.5 正确填充且 DigestInfo(含 OID 与
/// 摘要)逐字节一致。**不**做 CRT/私钥/侧信道(离线分析工具,非实时验签服务)。
/// 边界:模数 bit 长硬上限 8192(见 `rsa_max_modulus_bits`);超限一律 fail-closed,
/// 不进入模幂,避免攻击者可控的超大模数放大计算量(对齐 W2 内存有界口径)。

///|
/// RSA 公钥:模数 n(大数)+ 指数 e(大数)。仅验签用途。
priv struct RsaPublicKey {
  n : BigInt
  e : BigInt
}

///|
/// 模数 bit 长硬上限(对齐 W2 内存有界口径):2048/4096/8192 位均可用,超过 8192
/// 位则 fail-closed,不执行模幂。
let rsa_max_modulus_bits : Int32 = 8192

///|
/// 模数是否超过硬上限;超限时验签直接判失败(值化返回,不抛错)。
fn rsa_key_too_large(key : RsaPublicKey) -> Bool {
  big_bit_length(key.n) > rsa_max_modulus_bits
}

///|
/// 从 X.509 SPKI(SubjectPublicKeyInfo)DER 提取 RSA 公钥;非 RSA 或解析失败返回 None。
///
/// 结构:SEQUENCE { SEQUENCE{ OID, NULL } , BIT STRING{ 00, SEQUENCE{ INTEGER n, INTEGER e } } }。
fn rsa_public_key_from_spki(spki : Bytes) -> RsaPublicKey? {
  let len = spki.length()
  if len < 8 {
    return None
  }
  let outer = match der_read(spki, 0, len) {
    Some(t) => t
    None => return None
  }
  if outer.tag != 0x30 {
    return None
  }
  // AlgorithmIdentifier
  let alg = match der_read(spki, outer.body, outer.end) {
    Some(t) => t
    None => return None
  }
  if alg.tag != 0x30 {
    return None
  }
  // 定位 BIT STRING(alg 之后)
  let bit = match der_read(spki, alg.end, outer.end) {
    Some(t) => t
    None => return None
  }
  if bit.tag != 0x03 {
    return None
  }
  // BIT STRING 内容:首字节为未用位数(通常 0x00),其后为 DER 编码的 RSAPublicKey。
  if bit.body >= bit.end {
    return None
  }
  let rsa_seq = match der_read(spki, bit.body + 1, bit.end) {
    Some(t) => t
    None => return None
  }
  if rsa_seq.tag != 0x30 {
    return None
  }
  let n_tlv = match der_read(spki, rsa_seq.body, rsa_seq.end) {
    Some(t) => t
    None => return None
  }
  if n_tlv.tag != 0x02 {
    return None
  }
  let e_tlv = match der_read(spki, n_tlv.end, rsa_seq.end) {
    Some(t) => t
    None => return None
  }
  if e_tlv.tag != 0x02 {
    return None
  }
  let n = big_from_der_integer(spki, n_tlv.body, n_tlv.end)
  let e = big_from_der_integer(spki, e_tlv.body, e_tlv.end)
  if big_is_zero(n) || big_is_zero(e) {
    return None
  }
  Some({ n, e, })
}

///|
/// DER INTEGER(可能带一个前导 0x00 填充位)→ BigInt。
fn big_from_der_integer(b : Bytes, start : Int32, end : Int32) -> BigInt {
  let mut s = start
  // 正数补位:去掉单个前导 0x00(非零值时)。
  if end - s > 1 && b[s] == b'\x00' {
    s = s + 1
  }
  let arr : Array[Byte] = []
  for i = s; i < end; i = i + 1 {
    arr.push(b[i])
  }
  big_from_be_bytes(Bytes::from_array(arr[:]))
}

///|
/// PKCS#1 v1.5 验签:`signature` 为等长模数的签名字节;`digest` 为摘要;`hash_name`
/// 为 `"SHA-256"` 或 `"SHA-512"`。返回公钥验签是否通过。
fn rsa_verify_pkcs1(
  key : RsaPublicKey,
  signature : Bytes,
  digest : Bytes,
  hash_name : String,
) -> Bool {
  if big_is_zero(key.n) || big_is_zero(key.e) {
    return false
  }
  if rsa_key_too_large(key) {
    return false
  }
  let modulus_bytes = big_to_be_bytes(key.n)
  let nbytes = modulus_bytes.length()
  // 签名必须正好等于模数长度(PKCS#1 要求)。
  if signature.length() != nbytes {
    return false
  }
  let sig_int = big_from_be_bytes(signature)
  if big_cmp(sig_int, key.n) >= 0 {
    return false
  }
  let m = big_mod_pow(sig_int, key.e, key.n)
  // EM = m 补齐为 k 字节大端。
  let m_bytes = big_to_be_bytes(m)
  let em = if m_bytes.length() < nbytes {
    let arr = Array::make(nbytes, b'\x00')
    let dst = nbytes - m_bytes.length()
    for i = 0; i < m_bytes.length(); i = i + 1 {
      arr[dst + i] = m_bytes[i]
    }
    Bytes::from_array(arr[:])
  } else {
    m_bytes
  }
  // DigestInfo 期望前缀(SHA-256 / SHA-512),含 OID 与 NULL 与长度字节。
  let prefix : Bytes = if hash_name == "SHA-256" {
    // 30 31 30 0d 06 09 60 86 48 01 65 03 04 02 01 05 00 04 20
    b"\x30\x31\x30\x0d\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x01\x05\x00\x04\x20"
  } else if hash_name == "SHA-512" {
    // 30 51 30 0d 06 09 60 86 48 01 65 03 04 02 03 05 00 04 40
    b"\x30\x51\x30\x0d\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x03\x05\x00\x04\x40"
  } else {
    return false
  }
  // 期望的 EM 尾部:prefix || digest,并前置固定头。
  let expected_len = 2 + prefix.length() + digest.length()
  if nbytes < expected_len + 1 {
    // 至少要有 00 01 FF* 00 与 DigestInfo
    return false
  }
  // 校验填充:EM[0]=00, EM[1]=01, 若干 0xFF, 00, 然后 prefix||digest。
  if em[0] != b'\x00' || em[1] != b'\x01' {
    return false
  }
  // 从 index 2 找 0x00 分隔符(0xFF 至少一个)。
  let mut sep = -1
  for i = 2; i < nbytes; i = i + 1 {
    if em[i] == b'\x00' {
      sep = i
      break
    }
    if em[i] != b'\xff' {
      // 分隔符前必须是全 0xFF
      return false
    }
  }
  if sep < 2 {
    return false
  }
  let body_start = sep + 1
  let body_len = nbytes - body_start
  if body_len != prefix.length() + digest.length() {
    return false
  }
  // 比对 prefix
  for i = 0; i < prefix.length(); i = i + 1 {
    if em[body_start + i] != prefix[i] {
      return false
    }
  }
  // 比对 digest
  for i = 0; i < digest.length(); i = i + 1 {
    if em[body_start + prefix.length() + i] != digest[i] {
      return false
    }
  }
  true
}

///|
/// RSA 验签(PSS,RFC 8017 §9.1.2 / EMSA-PSS-VERIFY),salt 长度 = 摘要长度。
///
/// 用于 Android APK Signature Scheme 的 0x0101(PSS+SHA-256)/ 0x0102(PSS+SHA-512)
/// 签名算法 ID。`msg_digest` 为待验数据的摘要(`H(M)`),而非消息本身。
///
/// 已知严格性限制:`salt_len` 硬编码等于 `h_len`(Android 签名口径),RFC 8017 允许
/// 其他 salt 长度(含 salt=0 与「按签名值自动探测」)。本库对非 hLen salt 的合法签名
/// 会判 `false`(fail-closed,不误判为通过);如需通用 PSS 需显式传入 salt 长度。
fn rsa_verify_pss(
  key : RsaPublicKey,
  signature : Bytes,
  msg_digest : Bytes,
  hash_name : String,
) -> Bool {
  if big_is_zero(key.n) || big_is_zero(key.e) {
    return false
  }
  if rsa_key_too_large(key) {
    return false
  }
  let h_len = msg_digest.length()
  if h_len == 0 {
    return false
  }
  let salt_len = h_len
  let modulus_bytes = big_to_be_bytes(key.n)
  let nbytes = modulus_bytes.length()
  if signature.length() != nbytes {
    return false
  }
  let sig_int = big_from_be_bytes(signature)
  if big_cmp(sig_int, key.n) >= 0 {
    return false
  }
  let m = big_mod_pow(sig_int, key.e, key.n)
  let m_bytes = big_to_be_bytes(m)
  // emBits = modBits - 1;emLen = ceil(emBits / 8)
  let mod_bits = big_bit_length(key.n)
  let em_bits = mod_bits - 1
  if em_bits <= 0 {
    return false
  }
  let em_len = (em_bits + 7) / 8
  if m_bytes.length() > em_len {
    return false
  }
  // EM = m 右对齐补齐为 emLen 字节(大端)。
  let em : Array[Byte] = Array::make(em_len, b'\x00')
  let dst = em_len - m_bytes.length()
  for i = 0; i < m_bytes.length(); i = i + 1 {
    em[dst + i] = m_bytes[i]
  }
  if em_len < h_len + salt_len + 2 {
    return false
  }
  if em[em_len - 1] != b'\xbc' {
    return false
  }
  let db_len = em_len - h_len - 1
  // maskedDB 最高位必须为 0(8*emLen - emBits 位)。
  let unused_bits = 8 * em_len - em_bits
  if unused_bits > 0 {
    let mask = (1 << (8 - unused_bits)) - 1
    if (em[0].to_int() & (0xFF - mask)) != 0 {
      return false
    }
  }
  // H = EM 中 maskedDB 之后的 hLen 字节(EM = maskedDB || H || 0xbc)
  let h : Array[Byte] = []
  for i = db_len; i < em_len - 1; i = i + 1 {
    h.push(em[i])
  }
  let h_bytes = Bytes::from_array(h[:])
  // dbMask = MGF1(H, dbLen)
  let db_mask = mgf1(h_bytes, db_len, hash_name)
  if db_mask.length() != db_len {
    return false
  }
  // DB = maskedDB XOR dbMask
  let db : Array[Byte] = []
  for i = 0; i < db_len; i = i + 1 {
    db.push((em[i].to_int() ^ db_mask[i].to_int()).to_byte())
  }
  if unused_bits > 0 {
    let mask = (1 << (8 - unused_bits)) - 1
    db[0] = (db[0].to_int() & mask).to_byte()
  }
  // DB = PS(全 0) || 0x01 || salt
  let ps_len = db_len - salt_len - 1
  if ps_len < 0 {
    return false
  }
  for i = 0; i < ps_len; i = i + 1 {
    if db[i] != b'\x00' {
      return false
    }
  }
  if db[ps_len] != b'\x01' {
    return false
  }
  // salt = DB 尾部 saltLen 字节
  let salt : Array[Byte] = []
  for i = ps_len + 1; i < db_len; i = i + 1 {
    salt.push(db[i])
  }
  // H' = Hash(0x00 * 8 || mHash || salt)
  let mp : Array[Byte] = []
  for i = 0; i < 8; i = i + 1 {
    mp.push(b'\x00')
  }
  for b in msg_digest {
    mp.push(b)
  }
  for b in salt {
    mp.push(b)
  }
  let hp = if hash_name == "SHA-256" {
    sha256(Bytes::from_array(mp[:]))
  } else if hash_name == "SHA-512" {
    sha512(Bytes::from_array(mp[:]))
  } else {
    return false
  }
  if hp.length() != h_len {
    return false
  }
  for i = 0; i < h_len; i = i + 1 {
    if hp[i] != h_bytes[i] {
      return false
    }
  }
  true
}

///|
/// MGF1 掩码生成(RFC 8017 附录 B.2.1):T = Hash(seed || I2OSP(counter, 4)) 拼接至 mask_len。
fn mgf1(seed : Bytes, mask_len : Int32, hash_name : String) -> Bytes {
  let out : Array[Byte] = []
  let mut counter = 0U
  while out.length() < mask_len {
    let block : Array[Byte] = []
    for b in seed {
      block.push(b)
    }
    block.push(((counter >> 24) & 0xFF).to_byte())
    block.push(((counter >> 16) & 0xFF).to_byte())
    block.push(((counter >> 8) & 0xFF).to_byte())
    block.push((counter & 0xFF).to_byte())
    let d = if hash_name == "SHA-256" {
      sha256(Bytes::from_array(block[:]))
    } else if hash_name == "SHA-512" {
      sha512(Bytes::from_array(block[:]))
    } else {
      b""
    }
    if d.length() == 0 {
      return b""
    }
    for b in d {
      if out.length() >= mask_len {
        break
      }
      out.push(b)
    }
    counter = counter + 1
  }
  Bytes::from_array(out[:])
}