//! 手写 RSA-2048 + RS256 签名/验签(roadmap v2)。 //! //! ## 为什么手写 //! //! 「零新增依赖 / vendor 离线可编译」是 v1 的硬约定。引入 `rsa` crate 意味着 //! 连带 vendor `num-bigint-dig` / `der` / `pkcs8` / `zeroize` 等十余个 crate; //! 而 RS256 的数学内核(Montgomery 模乘 + Miller-Rabin)约 400 行可控代码。 //! 本模块是模块内**唯一**的大数运算,不与外部共享。 //! //! ## 算法选型 //! //! * 模乘用 **Montgomery CIOS**(避免实现 Knuth D 长除法,且无除法分支); //! * 签名用 **CRT**(dp/dq/qi 两个 1024-bit 模幂 + 重组合)——IAP 会话路径 //! 每请求重签 access_token,CRT 比全长模幂快约 4 倍; //! * 素性用 **Miller-Rabin**(24 証人 + 小素数试除); //! * `dp / dq / qi` 用**二进制移位长除法**计算(仅 keygen 时用,性能无关)。 //! //! ## 密钥存储(对 roadmap 的偏离说明) //! //! roadmap 原文是 `OAUTH_JWK_DIR/active.pem`。手写 ASN.1/PEM 编解码的收益低, //! 实际存储为 `active.jwk.json`:分量(n/e/d/p/q/dp/dq/qi)全部 base64url, //! `kid` 为公钥 SHA-256 前 16 hex。轮换语义照 roadmap:私钥只保留 active 一把, //! 旧公钥文件(`*.pub.jwk.json`)保留在 JWKS 输出中直到旧令牌过期。 //! //! ## 安全红线 //! //! * 私钥文件在 `data_dir/jwks/` 下,**不进版本库**; //! * 验签只信任 JWT header 中白名单 `alg`(RS256/HS256),拒绝 `none`, //! 并按 header 中的 `kid` 选择密钥(缺省用 active)。 use serde_json::{Value, json}; use ipass_core::util; // =========================================================================== // BigUint:u32 小端 limbs 的最小实现 // =========================================================================== type Big = Vec; /// 大端字节流 → u32 小端 limbs:末字节为最低有效字节。 /// ( limbs[k] 的权重是 2^(32k),BE 第 i 字节距最低位偏移 = len-1-i ) fn be_to_limbs(bytes: &[u8]) -> Big { let n = bytes.len(); let mut out = vec![0u32; (n + 3) / 4]; for (i, &b) in bytes.iter().enumerate() { let pos = n - 1 - i; out[pos / 4] |= (b as u32) << (8 * (pos % 4)); } out } fn trim(mut a: Big) -> Big { while a.len() > 1 && *a.last().unwrap() == 0 { a.pop(); } a } fn cmp(a: &[u32], b: &[u32]) -> core::cmp::Ordering { let n = a.len().max(b.len()); for i in (0..n).rev() { let x = a.get(i).copied().unwrap_or(0); let y = b.get(i).copied().unwrap_or(0); match x.cmp(&y) { core::cmp::Ordering::Equal => continue, o => return o, } } core::cmp::Ordering::Equal } fn add(a: &[u32], b: &[u32]) -> Big { let n = a.len().max(b.len()) + 1; let mut out = Vec::with_capacity(n); let mut carry = 0u64; for i in 0..n { let s = a.get(i).copied().unwrap_or(0) as u64 + b.get(i).copied().unwrap_or(0) as u64 + carry; out.push(s as u32); carry = s >> 32; } trim(out) } fn sub(a: &[u32], b: &[u32]) -> Big { let mut out = Vec::with_capacity(a.len()); let mut borrow = 0i64; for i in 0..a.len() { let mut d = a[i] as i64 - b.get(i).copied().unwrap_or(0) as i64 - borrow; if d < 0 { d += 1 << 32; borrow = 1; } else { borrow = 0; } out.push(d as u32); } debug_assert_eq!(borrow, 0, "sub 下溢"); trim(out) } /// 学校簿乘法(u32 基)。只用于 keygen 与 CRT 重组合,非热路径。 fn mul(a: &[u32], b: &[u32]) -> Big { if a.iter().all(|&x| x == 0) || b.iter().all(|&x| x == 0) { return vec![0]; } let mut out = vec![0u32; a.len() + b.len()]; for (i, &x) in a.iter().enumerate() { let mut carry = 0u64; for (j, &y) in b.iter().enumerate() { let t = x as u64 * y as u64 + out[i + j] as u64 + carry; out[i + j] = t as u32; carry = t >> 32; } let mut k = i + b.len(); while carry > 0 { let t = out[k] as u64 + carry; out[k] = t as u32; carry = t >> 32; k += 1; } } trim(out) } /// 二进制移位长除法:`a mod m`(仅 keygen 使用:dp/dq/qinv 计算)。 fn mod_binary(a: &[u32], m: &[u32]) -> Big { debug_assert!(cmp(m, &[1]) != core::cmp::Ordering::Less); let mut r: Big = vec![0]; for bit in (0..(a.len() * 32)).rev() { // r = r << 1 | bit shl1(&mut r); if (a[bit / 32] >> (bit % 32)) & 1 == 1 { r[0] |= 1; } if cmp(&r, m) != core::cmp::Ordering::Less { r = sub(&r, m); } } r } fn shl1(a: &mut Big) { let mut carry = 0u32; for limb in a.iter_mut() { let nc = *limb >> 31; *limb = (*limb << 1) | carry; carry = nc; } if carry > 0 { a.push(carry); } } /// 模逆:`a^{-1} mod m`(gcd(a,m)=1)。系数全程保持在 [0, m): /// 不变式 `a·s ≡ r (mod m)` 只需模 m 成立,因此 s 的减法在模 m 内进行, /// 天然无负数——避开带符号大数实现。 fn mod_inv(a: &[u32], m: &[u32]) -> Option { let mut r0 = mod_binary(a, m); let mut r1 = m.to_vec(); let mut s0: Big = vec![1]; let mut s1: Big = vec![0]; while cmp(&r1, &[0]) == core::cmp::Ordering::Greater { let (q, rem) = divmod(&r0, &r1); r0 = r1; r1 = rem; // s_new = (s0 - q·s1) mod m let qs = mod_binary(&mul(&q, &s1), m); let s_new = if cmp(&s0, &qs) == core::cmp::Ordering::Less { sub(&add(&s0, m), &qs) } else { sub(&s0, &qs) }; s0 = s1; s1 = s_new; } if r0 == [1] { Some(s0) } else { None } } /// 扩展欧几里得:返回 `g = gcd(a, m)` 与 `x` 使 `a·x ≡ g (mod m)`。 /// 递归版,只用于 keygen(d、qinv)。 fn ext_gcd(a: &[u32], m: &[u32]) -> (Big, Big, Big) { // 迭代实现:保持 (old_r, r) 与 (old_s, s),t 序列不需要(只要 x mod m) let mut old_r = a.to_vec(); let mut r = m.to_vec(); let mut old_s: Big = vec![1]; let mut s: Big = vec![0]; while cmp(&r, &[0]) == core::cmp::Ordering::Greater { // q = old_r / r(二进制估商:反复减太慢,直接用逐位除法) let (q, rem) = divmod(&old_r, &r); old_r = r; r = rem; let t = sub(&old_s, &mul(&q, &s)); // t 可能暂为「负」,此处 a、m 均 > 0 且最终结果 mod m 为正; // 为避免实现带符号大数,用 mod m 的同余性质:先 mod m 再继续。 // 简化处理:q 通常很小(辗转相除商均值 ~φ),减法下溢概率极低; // 若下溢则结果等价于 mod 2^(32n),在最终 mod m 后仍同余(模 2^k 世界里 // 负数与加 2^k 同余,欧几里得的线性组合性质保持成立到 m < 2^(32k))。 old_s = core::mem::replace(&mut s, t); } (old_r, old_s, r) } /// 带商的除法(Knuth D 的简化版:二进制逐位)返回 `(q, r)`。仅 keygen 用。 fn divmod(a: &[u32], b: &[u32]) -> (Big, Big) { debug_assert!(cmp(b, &[0]) != core::cmp::Ordering::Equal); let mut q = vec![0u32; a.len()]; let mut r: Big = vec![0]; for bit in (0..(a.len() * 32)).rev() { shl1(&mut r); if (a[bit / 32] >> (bit % 32)) & 1 == 1 { if r.len() == 1 && r[0] == 0 { r[0] = 1; } else { r[0] |= 1; } } if cmp(&r, b) != core::cmp::Ordering::Less { r = sub(&r, b); q[bit / 32] |= 1 << (bit % 32); } } (trim(q), r) } // =========================================================================== // Montgomery 模乘(CIOS) // =========================================================================== /// 固定模数的 Montgomery 上下文 struct Mont { /// 模数(奇数),L 个 limbs n: Big, /// -n^{-1} mod 2^32 n0: u32, /// R^2 mod n(进 Montgomery 域用) r2: Big, /// R mod n(退出域用) r1: Big, /// 期望的 limbs 数 l: usize, } impl Mont { fn new(n: &[u32]) -> Mont { let mut n = trim(n.to_vec()); if n.len() == 1 && n[0] == 1 { n = vec![1]; // 不应发生;占位 } let l = n.len(); // n0inv:牛顿迭代求 n[0] 的逆 mod 2^32,再取负 let mut x = n[0]; // 奇数,必有逆 for _ in 0..4 { x = x.wrapping_mul(2u32.wrapping_sub(n[0].wrapping_mul(x))); } let n0 = x.wrapping_neg(); let mut mont = Mont { n, n0, r2: vec![0], r1: vec![0], l }; // R mod n:R = 2^(32L),从 1 开始翻倍 32L 次,每步条件减 n let mut r: Big = vec![1]; for _ in 0..(32 * l) { shl1(&mut r); if cmp(&r, &mont.n) != core::cmp::Ordering::Less { r = sub(&r, &mont.n); } } mont.r1 = trim(r.clone()); // R^2 mod n:继续翻倍 32L 次 let mut r2 = r; for _ in 0..(32 * l) { shl1(&mut r2); if cmp(&r2, &mont.n) != core::cmp::Ordering::Less { r2 = sub(&r2, &mont.n); } } mont.r2 = trim(r2); mont } /// CIOS 蒙哥马利乘:返回 `a·b·R^{-1} mod n`(a、b 为 Montgomery 域内值) fn mul(&self, a: &[u32], b: &[u32]) -> Big { let l = self.l; // CIOS 固定按 n 的 limb 数循环;操作数可能被 trim 短(如 0、1), // 统一补零到 l 位,避免越界。 let mut ap = a.to_vec(); ap.resize(l, 0); let mut bp = b.to_vec(); bp.resize(l, 0); let a: &[u32] = ≈ let b: &[u32] = &bp; let mut t = vec![0u64; l + 2]; for i in 0..l { // 第一遍:t += a[i] * b let mut carry = 0u64; let ai = a[i] as u64; for j in 0..l { let s = t[j] + ai * b[j] as u64 + carry; t[j] = s & 0xffff_ffff; carry = s >> 32; } let s = t[l] as u64 + carry; t[l] = s & 0xffff_ffff; t[l + 1] = (s >> 32) as u64; // 归约步:m = t[0] * n0 mod 2^32;t += m * n;整体右移一个 limb let m = (t[0] as u32).wrapping_mul(self.n0); carry = (m as u64 * self.n[0] as u64 + t[0]) >> 32; for j in 1..l { let s = t[j] + m as u64 * self.n[j] as u64 + carry; t[j - 1] = s & 0xffff_ffff; carry = s >> 32; } let s = t[l] as u64 + carry; t[l - 1] = s & 0xffff_ffff; t[l] = t[l + 1] + ((s >> 32) as u64); t[l + 1] = 0; } // 结果在 t[0..l];可能比 n 大一个 R,条件减一次 let mut out: Vec = t[..l].iter().map(|&x| x as u32).collect(); if t[l] != 0 || cmp(&out, &self.n) != core::cmp::Ordering::Less { out = sub(&out, &self.n); } trim(out) } /// 进入 Montgomery 域:`a → a·R mod n` fn to_mont(&self, a: &[u32]) -> Big { self.mul(&mod_binary(a, &self.n), &self.r2) } /// 退出 Montgomery 域:`a → a·R^{-1} mod n` fn from_mont(&self, a: &[u32]) -> Big { self.mul(a, &[1]) } } /// `a^e mod n`(Montgomery,e 为 u32 小端 limbs 的指数,如 d) fn powmod(base: &[u32], exp_le: &[u32], mont: &Mont) -> Big { let base_m = mont.to_mont(base); let mut result = mont.r1.clone(); // = 1 in Montgomery 域 let mut started = false; for i in (0..exp_le.len()).rev() { for bit in (0..32).rev() { if started { result = mont.mul(&result, &result); } if (exp_le[i] >> bit) & 1 == 1 { if started { result = mont.mul(&result, &base_m); } else { started = true; result = base_m.clone(); } } } } if !started { return vec![1]; // e == 0 } mont.from_mont(&result) } // =========================================================================== // Miller-Rabin 素性检测 // =========================================================================== const SMALL_PRIMES: [u32; 96] = [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, ]; fn is_probable_prime(cand: &[u32]) -> bool { // 小素数试除 for &p in &SMALL_PRIMES { if cmp(cand, &[p]) == core::cmp::Ordering::Equal { return true; } let (_, r) = divmod(cand, &[p]); if r == [0] { return false; } } // cand-1 = d·2^s let one: Big = vec![1]; let d = sub(cand, &one); let mut s = 0usize; let mut dd = d.clone(); while dd[0] & 1 == 0 { // 右移一位 let mut carry = 0u32; for limb in dd.iter_mut().rev() { let nc = *limb & 1; *limb = (*limb >> 1) | (carry << 31); carry = nc; } dd = trim(dd); s += 1; if dd == [0] { return false; // cand-1 全 0 → cand == 1,不是素数 } } let mont = Mont::new(cand); // 24 个固定証人(对 1024-bit:错误率 < 2^-48,与 OpenSSL 常用组合相当) for &w in [ 2u32, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, ] .iter() { let a = mod_binary(&vec![w], cand); if cmp(&a, &one) == core::cmp::Ordering::Equal || cmp(&a, &sub(cand, &one)) == core::cmp::Ordering::Equal { continue; } let mut x = powmod(&a, &dd_le(&d), &mont); // 初始即「合数」:只有平方链中碰到 n-1 才能洗清。 // 初值若为 false,s=1(n-1 = d·2,随机奇数 ~50% 概率)时循环零次 // 执行,会把这个证人也放行——这正是曾产出合数"素数"的 bug。 let mut composite = true; if x == one || cmp(&x, &sub(cand, &one)) == core::cmp::Ordering::Equal { continue; } for _ in 0..s.saturating_sub(1) { // x = x^2 mod cand(域内自乘) x = mont.mul(&x, &x); if cmp(&x, &sub(cand, &one)) == core::cmp::Ordering::Equal { composite = false; break; } if x == one { composite = true; break; } composite = true; } if composite { return false; } } true } /// 大端序转 u32 小端 limbs(powmod 的指数表示) fn dd_le(d_be_big: &Big) -> Big { d_be_big.clone() // Big 本身就是 u32 小端 limbs } // =========================================================================== // 密钥生成与序列化 // =========================================================================== fn rand_limbs(nbytes: usize) -> Big { let hex = util::rand_hex(nbytes); let mut out = vec![0u32; nbytes / 4]; for (i, limb) in out.iter_mut().enumerate() { let mut v = 0u32; for j in 0..4 { v |= (u8::from_str_radix(&hex[i * 8 + j * 2..i * 8 + j * 2 + 2], 16) .unwrap_or(0) as u32) << (j * 8); } *limb = v; } out } /// 生成指定位数的奇素数(top two bits set,保证 n 足位) fn gen_prime(bits: usize) -> Big { let nbytes = bits / 8; loop { let mut c = rand_limbs(nbytes); // 置最高两位与最低位:保证 n = p·q 达到 2048 bit 且 c 为奇数 let top = c.len() - 1; c[top] |= 0b1100_0000_0000_0000_0000_0000_0000_0000; c[0] |= 1; c = trim(c); if is_probable_prime(&c) { return c; } } } pub struct RsaKeypair { pub n: Big, pub e: u32, pub d: Big, pub p: Big, pub q: Big, pub dp: Big, pub dq: Big, pub qinv: Big, pub kid: String, } /// 生成 RSA-2048 密钥对。e 固定 65537。 pub fn generate() -> Result { let e: u32 = 65537; let one: Big = vec![1]; let e_big: Big = vec![e]; let (p, q) = loop { let p = gen_prime(1024); let q = gen_prime(1024); if cmp(&p, &q) == core::cmp::Ordering::Equal { continue; } // gcd(p-1, e) == 1 且 gcd(q-1, e) == 1(e = 65537 是素数,只需 p-1 不整除 e) let (_, r1) = divmod(&sub(&p, &one), &e_big); let (_, r2) = divmod(&sub(&q, &one), &e_big); if r1 != [0] && r2 != [0] { break (p, q); } }; let n = mul(&p, &q); if n.len() != 64 { return Err("模长不足 2048 位".to_owned()); } // φ(n) = (p-1)(q-1) let phi = mul(&sub(&p, &one), &sub(&q, &one)); // d = e^{-1} mod φ let Some(d) = mod_inv(&e_big, &phi) else { return Err("e 与 φ(n) 不互素".to_owned()); }; let dp = mod_binary(&d, &sub(&p, &one)); let dq = mod_binary(&d, &sub(&q, &one)); // qinv = q^{-1} mod p let qinv = mod_inv(&q, &p).ok_or("q 与 p 不互素".to_owned())?; let kid = util::sha256_hex(&to_be_bytes(&n))[..16].to_owned(); Ok(RsaKeypair { n, e, d, p, q, dp, dq, qinv, kid }) } fn to_be_bytes(a: &[u32]) -> Vec { let mut out = Vec::with_capacity(a.len() * 4); for limb in a.iter().rev() { out.extend_from_slice(&limb.to_be_bytes()); } // 去前导零 let first_nonzero = out.iter().position(|&b| b != 0).unwrap_or(out.len() - 1); out.drain(..first_nonzero); out } fn b64url_bytes(a: &[u32]) -> String { crate::oauth::oauth_b64_encode(&to_be_bytes(a)) } fn from_b64url(s: &str) -> Big { trim(be_to_limbs(&crate::oauth::oauth_b64_decode(s))) } /// 序列化为 JWK JSON(含私钥分量)。 pub fn to_jwk(k: &RsaKeypair) -> Value { json!({ "kty": "RSA", "alg": "RS256", "use": "sig", "kid": k.kid, "n": b64url_bytes(&k.n), "e": b64url_bytes(&[k.e]), "d": b64url_bytes(&k.d), "p": b64url_bytes(&k.p), "q": b64url_bytes(&k.q), "dp": b64url_bytes(&k.dp), "dq": b64url_bytes(&k.dq), "qi": b64url_bytes(&k.qinv), }) } /// 从 JWK JSON 解析。**公钥文件**(仅 n/e/kid)也可解析——私钥分量缺省为空, /// 只用于验签;签发路径必须用完整私钥(`has_private` 检查)。 pub fn from_jwk(v: &Value) -> Option { let get = |k: &str| -> Option { v.get(k).and_then(|x| x.as_str()).map(|s| s.to_owned()) }; Some(RsaKeypair { n: from_b64url(&get("n")?), e: from_b64url(&get("e")?).first().copied().unwrap_or(65537), d: get("d").map(|x| from_b64url(&x)).unwrap_or_default(), p: get("p").map(|x| from_b64url(&x)).unwrap_or_default(), q: get("q").map(|x| from_b64url(&x)).unwrap_or_default(), dp: get("dp").map(|x| from_b64url(&x)).unwrap_or_default(), dq: get("dq").map(|x| from_b64url(&x)).unwrap_or_default(), qinv: get("qi").map(|x| from_b64url(&x)).unwrap_or_default(), kid: get("kid").unwrap_or_default(), }) } impl RsaKeypair { /// 是否持有私钥分量(签发需要,验签不需要)。 pub fn has_private(&self) -> bool { !self.d.is_empty() } } // =========================================================================== // 签名(CRT)/ 验签 // =========================================================================== /// PKCS#1 v1.5 EMSA 编码:`0x00 01 FF..FF 00 || DigestInfo(SHA-256) || hash` fn emsa_pkcs1(t_len: usize, k: usize, digest: &[u8; 32]) -> Big { // SHA-256 的 DigestInfo DER 前缀(RFC 8017 注 1) const PREFIX: [u8; 19] = [ 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20, ]; let t_len_full = PREFIX.len() + 32; debug_assert_eq!(t_len_full, t_len); let mut em = vec![0u8; k]; em[0] = 0x00; em[1] = 0x01; for b in em[2..k - t_len_full - 1].iter_mut() { *b = 0xff; } em[k - t_len_full - 1] = 0x00; em[k - t_len_full..k - 32].copy_from_slice(&PREFIX); em[k - 32..].copy_from_slice(digest); // BE bytes → u32 LE limbs be_to_limbs(&em) } /// CRT 签名:`sig = m^d mod n`,拆为 p、q 两半。 pub fn sign_crt(digest: &[u8; 32], k: &RsaKeypair) -> Vec { let k_len = k.n.len(); let mont_p = Mont::new(&k.p); let mont_q = Mont::new(&k.q); let m = emsa_pkcs1(51, k_len * 4, digest); // m1 = m^dp mod p;m2 = m^dq mod q let m_p = mod_binary(&m, &k.p); let m_q = mod_binary(&m, &k.q); let m1 = powmod(&m_p, &k.dp, &mont_p); let m2 = powmod(&m_q, &k.dq, &mont_q); // Garner: h = qinv * (m1 - m2) mod p;注意 m1 可能 < m2 → 加 p 防下溢 let mut diff = sub(&m1, &m2); if cmp(&m1, &m2) == core::cmp::Ordering::Less { diff = sub(&add(&m1, &k.p), &m2); } // qinv、diff 均 < p → 在 Montgomery 域内乘 let qinv_m = mont_p.to_mont(&k.qinv); let h_m = mont_p.mul(&mont_p.to_mont(&diff), &qinv_m); let h = mont_p.from_mont(&h_m); // s = m2 + h * q let sig = add(&m2, &mul(&h, &k.q)); let sig = mod_binary(&sig, &k.n); // JWT/RS256 签名必须定长(模长字节数):短签名左补零 let sb = to_be_bytes(&sig); let mut out = vec![0u8; k_len * 4 - sb.len()]; out.extend_from_slice(&sb); out } /// 公钥验签:`m = sig^e mod n`,比对 EMSA 编码。 pub fn verify(sig_be: &[u8], n: &[u32], e: u32) -> Option<[u8; 32]> { if sig_be.len() != n.len() * 4 || sig_be.is_empty() { return None; } let sig = be_to_limbs(sig_be); if cmp(&sig, n) != core::cmp::Ordering::Less { return None; } let mont = Mont::new(n); let m = powmod(&sig, &[e], &mont); // to_be_bytes 会去前导零;EMSA 编码必须按模长定长(首字节 0x00),补齐 let emb = to_be_bytes(&m); let mut em = vec![0u8; n.len() * 4 - emb.len()]; em.extend_from_slice(&emb); const PREFIX: [u8; 19] = [ 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20, ]; // 结构:00 01 FF..FF 00 || PREFIX || hash32 if em.len() != n.len() * 4 || em[0] != 0x00 || em[1] != 0x01 { return None; } let t_start = em.len() - 51; for &b in &em[2..t_start - 1] { if b != 0xff { return None; } } if em[t_start - 1] != 0x00 || em[t_start..t_start + 19] != PREFIX { return None; } let mut out = [0u8; 32]; out.copy_from_slice(&em[em.len() - 32..]); Some(out) }